在上一篇關於 Microsoft Agent Framework 系列教學文章 "MFA014 - 多模態輸入（圖片）" 中，我們學會了使用 Microsoft Agent Framework 建立能夠處理圖片輸入的 AI 代理。讓模型接收到多模態的資料，在這裡使用的圖片，這裡的圖片將會是冰箱的照片。透過這個練習，我們了解了如何讓 AI 代理分析圖片內容並給出建議。
在完成這篇文章的練習之後，你將能夠使用 Microsoft Agent Framework 建立一個能夠處理多輪對話的 AI 代理，並了解 Responses API 與 Chat Completions 代理在多輪對話中的差異。所謂的 Chat Completion API 則是每輪都需要將完整對話歷史送給模型，服務端不會保存對話狀態。而對於 Responses API，服務端會保存對話狀態，因此每輪不需要重送完整對話歷史，且能保留上一輪的推論摘要。那麼對於使用者而言，面對問題需求的時候，該如何挑選適合的代理，就可以根據是否需要服務端保存對話歷史以及對訊息數與 Token 使用量的考量來決定。
接下來看看如何做到這樣的效果。
- 開啟 Visual Studio 2026
- 選擇「建立新專案」
- 在 [建立新的專案] 視窗中，在右方清單內，找到並選擇「主控台應用程式」 項目
- 然後點擊右下方「下一步」按鈕
- 此時將會看到 [設定新的專案] 對話窗
- 在該對話窗的 [專案名稱] 欄位中，輸入專案名稱，例如 "csResponsesAgent"
- 然後點擊右下方「下一步」按鈕
- 接著會看到 [其他資訊] 對話窗
- 在這個對話窗內，確認使用底下的選項
- 架構：.NET 10.0 (或更新版本)
- 勾選 不要使用最上層陳述式 (這是我的個人習慣)
- 然後點擊右下方「建立」按鈕
- 現在，已經完成了這個 Console 主控台 專案的建立
要完成這個第一次接觸 Microsoft Agent Framework 練習專案，需要安裝以下幾個 NuGet 套件：
這個套件是微軟官方為 .NET 整合 AI 服務所提供的擴充套件，專門用於與 OpenAI 進行整合。它實現了 IChatClient 與 IEmbeddingGenerator 核心抽象介面，讓開發人員能以一致的程式碼，輕鬆串接 OpenAI 或相容的 API 端點（例如 Azure OpenAI、GitHub Models 等）。
- 滑鼠右擊 [csResponsesAgent] 專案節點
- 點選彈出功能表的 [管理 NuGet 套件] 項
- 在 [瀏覽] 索引標籤中，搜尋並且安裝底下的 NuGet 套件
- Microsoft.Extensions.AI
關於這個小節的內容，將會在這個系列每篇文章中都會用到，因此，可以參考 MFA001 Microsoft Agent Framework 初次體驗開發出 AI 代理 文章中的 [宣告 API 端點與 Key 環境變數] 說明內容，若這裡提到的環境變數已經建立好了，則可以跳過這個小節內容。
為了要完成這個需求 : 如何用 Azure OpenAI 的 gpt-5.6-luna 聊天模型建立一個簡單 AI 代理，並產生一篇與鵝有關的詩。 因此，我們需要修改 Program.cs 程式碼，這時需要完成底下的操作。
- 在專案內，找到並且開啟 [Program.cs] 檔案
- 使用底下程式碼內容來取代 [Program.cs] 檔案的內容
#pragma warning disable OPENAI001 // OpenAI SDK 2.14 的 ResponsesClient 仍標記為實驗性 API
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;
using OpenAI;
using OpenAI.Chat;
using OpenAI.Responses;
using System.ClientModel;
using System.Text;
using ChatMessage = Microsoft.Extensions.AI.ChatMessage; // OpenAI.Chat 也有 ChatMessage，這裡指定用 MEAI 的
namespace csResponsesAgent;
internal class Program
{
private const string Instructions = "你是邏輯老師，請用繁體中文作答，先給結論再用三句話內說明理由。";
// 同一道邏輯題：三種情境都問它，數字才有比較基礎
// 刻意選一題「需要想一下」的題目：推論太短（約 200 token 以內）時，服務端常常不回推論摘要
private const string Puzzle =
"有四個盒子，標籤分別是「蘋果」「橘子」「香蕉」「混合」，但四個標籤全部貼錯了。" +
"你只能從其中一個盒子拿出一顆水果來看（不能看盒子裡面），" +
"能不能保證推出四個盒子的正確內容？請說明。";
// 第二輪追問：故意不重述規則，只有記得上一輪的代理才答得出來
private const string FollowUp = "那如果只有三個盒子（蘋果、橘子、混合），規則都一樣，應該從哪個盒子拿？";
// 由聊天用戶端中介層記錄：這一輪「實際送出」幾則訊息、帶出去的對話 id 是什麼
private static int lastSentMessages;
private static string? lastSentConversationId;
static async Task Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
var apiKey = Environment.GetEnvironmentVariable("AzureOpenAI_Key");
var endpoint = Environment.GetEnvironmentVariable("AzureOpenAI_Endpoint");
var model = "gpt-5.6-luna";
if (string.IsNullOrWhiteSpace(apiKey) || string.IsNullOrWhiteSpace(endpoint))
{
Console.WriteLine("請先設定環境變數 AzureOpenAI_Key 與 AzureOpenAI_Endpoint 後再執行。");
return;
}
// ── Responses API 代理：ResponsesClient + AsAIAgent()（Microsoft.Agents.AI.OpenAI 提供的擴充方法）
AIAgent responsesAgent =
new ResponsesClient(
new ApiKeyCredential(apiKey),
new ResponsesClientOptions { Endpoint = new Uri(endpoint) })
.AsAIAgent(
model: model,
instructions: Instructions,
name: "邏輯老師（Responses）",
clientFactory: client => client.AsBuilder().Use(CountMessages, null).Build());
// ── Chat Completions 代理：就是 MFA001～MFA003 用的 ChatClient，只是改用同一個套件的 AsAIAgent() 建立
AIAgent chatAgent =
new ChatClient(
model,
new ApiKeyCredential(apiKey),
new OpenAIClientOptions { Endpoint = new Uri(endpoint) })
.AsAIAgent(
instructions: Instructions,
name: "邏輯老師（Chat Completions）",
clientFactory: client => client.AsBuilder().Use(CountMessages, null).Build());
Console.WriteLine($"使用的模型：{model}");
Console.WriteLine($"邏輯題：{Puzzle}");
// ── 示範一：設定 reasoning effort 與推論摘要，同一道題比較 Low 與 High
Header("示範一：Responses API ＋ 推論摘要（同一道題，effort = Low vs High）");
foreach (var effort in new[] { ReasoningEffort.Low, ReasoningEffort.High })
{
Section($"reasoning effort = {effort}");
AgentResponse response = await responsesAgent.RunAsync(Puzzle, options: ReasoningRunOptions(effort));
PrintReasoningAndAnswer(response);
PrintUsage(response.Usage);
}
// ── 示範二：服務端保存對話（Responses API）
Header("示範二：服務端保存對話（Responses API，只傳上一輪的 response id）");
var responsesTurns = await RunTwoTurnsAsync(responsesAgent);
// ── 示範三：本機保存對話（Chat Completions，MFA003 的作法）
Header("示範三：對照組 Chat Completions（每一輪都把整段歷史重送）");
var chatTurns = await RunTwoTurnsAsync(chatAgent);
// ── 對照小結：只看第二輪（追問那一輪）
Header("對照小結：第二輪（追問）");
Row("實際送出的訊息數", $"{responsesTurns[1].SentMessages} 則", $"{chatTurns[1].SentMessages} 則");
Row("帶出的對話 id", responsesTurns[1].SentConversationId is null ? "（無）" : "上一輪的 response id", chatTurns[1].SentConversationId ?? "（無）");
Row("輸入 token（其中快取）", $"{responsesTurns[1].InputTokens}（{responsesTurns[1].CachedTokens}）", $"{chatTurns[1].InputTokens}（{chatTurns[1].CachedTokens}）");
Row("推論 token", $"{responsesTurns[1].ReasoningTokens}", $"{chatTurns[1].ReasoningTokens}");
Row("兩輪中拿到推論摘要", responsesTurns.Any(t => t.HasSummary) ? "是" : "否", chatTurns.Any(t => t.HasSummary) ? "是" : "否");
Row("對話歷史存在哪裡", "OpenAI 服務端", "本機 AgentSession");
// 這是最容易誤會的地方：「不重送歷史」省的是傳輸量和自己管理歷史的工作，不是 token
Console.WriteLine();
Console.WriteLine(" 觀察：Responses 第二輪只送 1 則訊息，但服務端會把上一輪的完整內容（含推論項目）接回上下文，");
Console.WriteLine(" 所以輸入 token 照樣計費，甚至可能比 Chat Completions 多；Chat Completions 重送的只有看得見的文字，");
Console.WriteLine(" 上一輪的推論內容直接丟掉。（提示快取要前綴超過約 1,024 token 才會命中，這個範例太短所以是 0）");
}
// 兩種 API 都用 MEAI 的 ChatOptions.Reasoning 設定：Effort 是推論力道，Output = Summary 是要求回傳推論摘要
private static ChatClientAgentRunOptions ReasoningRunOptions(ReasoningEffort effort) =>
new(new ChatOptions
{
Reasoning = new ReasoningOptions { Effort = effort, Output = ReasoningOutput.Summary }
});
private static async Task<List<TurnStat>> RunTwoTurnsAsync(AIAgent agent)
{
AgentSession session = await agent.CreateSessionAsync();
var turns = new List<TurnStat>();
foreach (var (title, question) in new[] { ("第一輪：原題", Puzzle), ("第二輪：追問（不重述題目）", FollowUp) })
{
Section(title);
AgentResponse response = await agent.RunAsync(question, session, ReasoningRunOptions(ReasoningEffort.Low));
PrintReasoningAndAnswer(response);
// Responses API 存在服務端時，ConversationId 就是這一輪的 response id；Chat Completions 則一直是 null
var conversationId = (session as ChatClientAgentSession)?.ConversationId;
Console.WriteLine($" 實際送出訊息數：{lastSentMessages} 則");
Console.WriteLine($" 帶出的對話 id ：{lastSentConversationId ?? "（無）"}");
Console.WriteLine($" 回來後 session.ConversationId：{conversationId ?? "（無，歷史存在本機 session）"}");
PrintUsage(response.Usage);
turns.Add(new TurnStat(
lastSentMessages,
lastSentConversationId,
response.Usage?.InputTokenCount ?? 0,
response.Usage?.CachedInputTokenCount ?? 0,
response.Usage?.ReasoningTokenCount ?? 0,
GetReasoningSummary(response).Length > 0));
}
return turns;
}
// 聊天用戶端中介層：記下這一輪真正送到 API 的訊息數，以及帶出去的對話 id（Responses 的 previous_response_id）
private static Task<ChatResponse> CountMessages(
IEnumerable<ChatMessage> messages, ChatOptions? options, IChatClient innerClient, CancellationToken cancellationToken)
{
var list = messages.ToList();
lastSentMessages = list.Count;
lastSentConversationId = options?.ConversationId;
return innerClient.GetResponseAsync(list, options, cancellationToken);
}
// 推論摘要放在回應訊息裡的 TextReasoningContent；答案則是一般的 TextContent（response.Text）
private static string GetReasoningSummary(AgentResponse response) =>
string.Join(Environment.NewLine, response.Messages
.SelectMany(message => message.Contents)
.OfType<TextReasoningContent>()
.Select(reasoning => reasoning.Text)
.Where(text => !string.IsNullOrWhiteSpace(text)));
private static void PrintReasoningAndAnswer(AgentResponse response)
{
var summary = GetReasoningSummary(response);
Console.WriteLine(" [推論摘要]");
Console.WriteLine(summary.Length > 0
? Indent(summary)
: " （沒有收到推論摘要：Chat Completions 不提供；Responses 則在推論太短時會省略）");
Console.WriteLine(" [答案]");
Console.WriteLine(Indent(response.Text));
}
private static void PrintUsage(UsageDetails? usage)
{
Console.WriteLine(
$" token：輸入 {usage?.InputTokenCount}（快取 {usage?.CachedInputTokenCount ?? 0}）" +
$"／輸出 {usage?.OutputTokenCount}（其中推論 {usage?.ReasoningTokenCount ?? 0}）" +
$"／總計 {usage?.TotalTokenCount}");
}
private static string Indent(string text) =>
string.Join(Environment.NewLine, text.Split('\n').Select(line => " " + line.TrimEnd('\r')));
private static void Header(string title)
{
Console.WriteLine();
Console.WriteLine(new string('=', 70));
Console.WriteLine($" {title}");
Console.WriteLine(new string('=', 70));
}
private static void Section(string title)
{
Console.WriteLine();
Console.WriteLine($"【{title}】");
}
private static void Row(string label, string responses, string chat) =>
Console.WriteLine($" {label}：Responses = {responses}｜Chat Completions = {chat}");
}
internal sealed record TurnStat(
int SentMessages,
string? SentConversationId,
long InputTokens,
long CachedTokens,
long ReasoningTokens,
bool HasSummary);在上面的範例程式碼中，將會展示如何使用 Responses API 代理與 Chat Completions 代理，並比較它們在處理同一個邏輯題時的行為差異。為什麼會想要這麼來比較呢?因為，這裡提供兩種類型的 API，當我們遇到問題的時候，究竟要如何選擇採用哪種 API 呢?透過這個範例，我們可以觀察到兩者在訊息傳遞、對話管理以及推論摘要上的差異，進而做出更適合的選擇。
這個程式一開始將會讀取 API Key 與服務端點的數據，使用 ResponsesClient 類別 (這個類別定義在 OpenAI.Responses 命名空間中) 來建立一個 AIAgent 代理物件，變數名稱為 responsesAgent，這將會是一個採用 Responses API 代理，也就是採用 ResponsesClient + AsAIAgent()（Microsoft.Agents.AI.OpenAI 提供的擴充方法），這裡使用的系統提示詞為 "你是邏輯老師，請用繁體中文作答，先給結論再用三句話內說明理由。"
第二個 AIAgent 物件，變數名稱為 chatAgent，將會是一個採用 Chat Completions 代理(定義在 OpenAI.Chat 命名空間中)，也就是使用 ChatClient + AsAIAgent() 建立，系統提示詞同樣為 "你是邏輯老師，請用繁體中文作答，先給結論再用三句話內說明理由。"
現在來針對定義在 Puzzle 這個字串的邏輯題，將其內容設為："有四個盒子，標籤分別是「蘋果」「橘子」「香蕉」「混合」，但四個標籤全部貼錯了。你只能從其中一個盒子拿出一顆水果來看（不能看盒子裡面），能不能保證推出四個盒子的正確內容？請說明。"，並將其傳遞給 responsesAgent 與 chatAgent 進行推論。單就這裡提出的提示詞而言，兩個代理都應該能夠給出正確的推論結果。但是，兩者在訊息傳遞、對話管理以及推論摘要上的行為可能會有所不同，這正是我們想要觀察的重點。
首先將會要來測試理解 API，這裡會分別對 responsesAgent 物件，傳入 ReasoningEffort.Low, ReasoningEffort.High 這兩個參數，ReasoningEffort 這個型別將會用來控制代理在推論時的努力程度，Low 代表低推理努力，High 代表高推理努力。這裡使用的程式碼將會為 await responsesAgent.RunAsync(Puzzle, options: ReasoningRunOptions(effort)); , 當執行完成後便會得到 AgentResult 物件，裡面包含了代理的推論結果以及相關的訊息傳遞與對話管理資訊。PrintReasoningAndAnswer 方法將會用來輸出推論過程與最終答案。在此方法內，將會呼叫 GetReasoningSummary 方法，這個方法透過 Linq 對訊息傳遞的內容進行分析，並整理出推論摘要，方便我們觀察代理在不同努力程度下的推理行為。GetReasoningSummary 方法執行結果將會儲存到 summary 物件內，也就是一段字串內容，代表了推論摘要
**Explaining the puzzle setup**
I’m considering a standard puzzle with three labeled boxes: apple, orange, and mixed, but they’re all incorrectly labeled. Typical strategies involve drawing from the mixed box to find the correct fruit, but here there are four types with three fruit kinds, which complicates things. It seems like one sample isn’t enough to solve this, and I should clarify using counterexamples to support that idea while keeping the explanation concise and clear.
上面的推論摘要之中文意思將會為：
**謎題設定說明**
我正在考慮一個標準的謎題，其中包含三個標有“蘋果”、“橙子”和“混合”的盒子，但它們的標籤都貼錯了。通常的解題策略是從「混合」盒子中抽取水果來找到正確的水果，但這裡卻有四種盒子，每種盒子裡又有三種水果，這使得問題變得複雜。似乎僅憑一個例子不足以解決這個問題，我應該用反例來闡明我的觀點，同時保持解釋的簡潔明了。
這次的推論結果將會儲存在 response.Text 這個屬性內
**結論：不能保證推出四個盒子的正確內容。**
應從標籤「混合」的盒子取水果，因為它不可能是混合盒，若取到蘋果，只能確定該盒是純蘋果，但其餘三盒仍可能有多種符合「全錯」的排列，例如「蘋果標籤盒」可為混合或橘子盒。
因此一次取樣所得資訊不足以唯一確定四個盒子的內容。
對於採用 ReasoningEffort.Low 方式來進行推論的使用摘要如下
token：輸入 118（快取 0）／輸出 418（其中推論 295）／總計 536
底下將會為採用 ReasoningEffort.High 的推論過程
(為什麼要採用兩種不同的推論努力程度來解題？ReasoningEffort.Low 代表快速、簡單的推論，可能忽略一些細節；ReasoningEffort.High 則代表更深入、全面的推論，會考慮更多可能性。透過比較兩種不同的推論努力程度，可以觀察代理在不同情境下的表現差異。)
【reasoning effort = High】
[推論摘要]
**Solving the labeling puzzle**
I need to find a solution involving boxes labeled incorrectly with their contents. The mixed-labeled box will help identify what’s inside, which will then allow me to label the others correctly. If I draw an apple from the mixed box, I can eliminate that as a possibility for the remaining boxes, given the constraints of labeling. For instance, if I label one box correctly, I can’t have the others labeled correctly. I’ll explore all possible arrangements next.**Analyzing the box labeling puzzle**
I’m trying to determine if the arrangement A-box B, O-box M, and B-box O is valid. Drawing from the mixed box could help identify one pure box, but it might not uniquely solve the problem with three remaining boxes. To answer the user’s question about guaranteeing the correct contents of four boxes, I need to explain clearly that it’s not possible with just one draw from the mixed box. I have to demonstrate this effectively in three sentences.**Examining labeling strategies**
I need to illustrate that no strategy guarantees accurate labeling, although drawing from the mixed-labeled box seems to be the best option. If I draw an apple, I can identify the mixed box but face ambiguity with two potential assignments. To clarify, I'll label the boxes as Apple A, Orange O, Banana B, and Mixed M. If I draw an apple from M, the remaining contents could suggest two valid assignments for the other labels, which complicates things further.
[答案]
**不能保證推出四個盒子的正確內容。**例如從「混合」盒取出蘋果，可知該盒是純蘋果；但剩下仍可能是「蘋果標籤盒＝混合、橘子標籤盒＝香蕉、香蕉標籤盒＝橘子」，也可能是「蘋果標籤盒＝香蕉、橘子標籤盒＝混合、香蕉標籤盒＝橘子」，兩者都符合所有標籤貼錯，因此一次取樣不足以唯一判定。
token：輸入 118（快取 0）／輸出 652（其中推論 516）／總計 770
從上面的 Low & High 的執行結果可以看出，ReasoningEffort.Low 的推論較為簡單快速，但可能忽略一些細節，例如：無法完整展示所有可能的盒子排列，對於保證正確標籤的推論不夠全面。而 ReasoningEffort.High 則提供了更完整的分析，考慮了多種可能性，能更清楚地說明為什麼無法保證推出四個盒子的正確內容。
接下來將會展示服務端保存對話（Responses API），這裡的目的將會是示範如何在同一個對話中，依序向代理提出多個問題，並追蹤每輪的訊息與用量。在此將會呼叫 RunTwoTurnsAsync 方法，在這個方法內，將會於傳入 responsesAgent 的 AIAgent 物件，呼叫 CreateSessionAsync 方法，取得一個 AgentSession 物件，接下來會使用同一個 AgentSession，依序向代理提出兩個問題，並記錄每輪的傳送與用量資訊：
- 依序詢問 Puzzle 原題和 FollowUp 追問；追問刻意不重述前題，藉此測試代理能否記住上下文。
- 每輪印出推論摘要、答案、實際送出的訊息數、對話 ID，以及 token 用量。
- 把這些數據整理成 TurnStat，最後回傳兩輪的統計清單。 這個方法本身不比較兩種 API；Main 會分別用 Responses API 代理和 Chat Completions 代理呼叫它，再比較兩者的結果。
另外一個將會是呼叫 RunTwoTurnsAsync 方法，但傳入的是 Chat Completions 代理，也就是 chatAgent 這個物件，這裡將會把每一輪的完整對話歷史重送給代理，藉此比較兩種代理在同一個對話中的表現差異。
當這兩輪呼叫完成 RunTwoTurnsAsync 之後，將會分別把結果存入 responsesResult 和 chatResult 兩個變數，之後可以比較兩者在同一個對話中的表現差異。底下將會為實際輸出內容
======================================================================
對照小結：第二輪（追問）
======================================================================
實際送出的訊息數：Responses = 1 則｜Chat Completions = 3 則
帶出的對話 id：Responses = 上一輪的 response id｜Chat Completions = （無）
輸入 token（其中快取）：Responses = 347（0）｜Chat Completions = 242（0）
推論 token：Responses = 0｜Chat Completions = 22
兩輪中拿到推論摘要：Responses = 是｜Chat Completions = 否
對話歷史存在哪裡：Responses = OpenAI 服務端｜Chat Completions = 本機 AgentSession
觀察：Responses 第二輪只送 1 則訊息，但服務端會把上一輪的完整內容（含推論項目）接回上下文，
所以輸入 token 照樣計費，甚至可能比 Chat Completions 多；Chat Completions 重送的只有看得見的文字，
上一輪的推論內容直接丟掉。（提示快取要前綴超過約 1,024 token 才會命中，這個範例太短所以是 0）
觀察上面的對照小結：第二輪（追問）可以發現，Responses API 只送出一則訊息，但服務端會自動帶入上一輪的完整對話歷史，因此能保留推論摘要；而 Chat Completions 代理則需要每輪重送完整對話歷史，導致訊息數增加，且無法保留上一輪的推論內容。這也說明了兩種代理在處理多輪對話時的差異：Responses API 依賴服務端保存對話，Chat Completions 則依賴本機管理對話歷史。對於 Token 使用量而言，Responses API 可能因為帶入完整對話歷史而增加輸入 token，但仍能減少訊息數；Chat Completions 則每輪都需重送完整對話歷史，訊息數增加，且無法保留推論摘要。
現在來看看這個範例程式碼的執行結果。
- 在 Visual Studio 2026 下，按下 F5 鍵執行程式，將會看到程式輸出的結果。
使用的模型：gpt-5.6-luna
邏輯題：有四個盒子，標籤分別是「蘋果」「橘子」「香蕉」「混合」，但四個標籤全部貼錯了。你只能從其中一個盒子拿出一顆水果來看（不能看盒子裡面），能不能保證推出四個盒子的正確內容？請說明。
======================================================================
示範一：Responses API ＋ 推論摘要（同一道題，effort = Low vs High）
======================================================================
【reasoning effort = Low】
[推論摘要]
**Explaining the puzzle setup**
I’m considering a standard puzzle with three labeled boxes: apple, orange, and mixed, but they’re all incorrectly labeled. Typical strategies involve drawing from the mixed box to find the correct fruit, but here there are four types with three fruit kinds, which complicates things. It seems like one sample isn’t enough to solve this, and I should clarify using counterexamples to support that idea while keeping the explanation concise and clear.
[答案]
**結論：不能保證推出四個盒子的正確內容。**
應從標籤「混合」的盒子取水果，因為它不可能是混合盒，若取到蘋果，只能確定該盒是純蘋果，但其餘三盒仍可能有多種符合「全錯」的排列，例如「蘋果標籤盒」可為混合或橘子盒。
因此一次取樣所得資訊不足以唯一確定四個盒子的內容。
token：輸入 118（快取 0）／輸出 418（其中推論 295）／總計 536
【reasoning effort = High】
[推論摘要]
**Solving the labeling puzzle**
I need to find a solution involving boxes labeled incorrectly with their contents. The mixed-labeled box will help identify what’s inside, which will then allow me to label the others correctly. If I draw an apple from the mixed box, I can eliminate that as a possibility for the remaining boxes, given the constraints of labeling. For instance, if I label one box correctly, I can’t have the others labeled correctly. I’ll explore all possible arrangements next.**Analyzing the box labeling puzzle**
I’m trying to determine if the arrangement A-box B, O-box M, and B-box O is valid. Drawing from the mixed box could help identify one pure box, but it might not uniquely solve the problem with three remaining boxes. To answer the user’s question about guaranteeing the correct contents of four boxes, I need to explain clearly that it’s not possible with just one draw from the mixed box. I have to demonstrate this effectively in three sentences.**Examining labeling strategies**
I need to illustrate that no strategy guarantees accurate labeling, although drawing from the mixed-labeled box seems to be the best option. If I draw an apple, I can identify the mixed box but face ambiguity with two potential assignments. To clarify, I'll label the boxes as Apple A, Orange O, Banana B, and Mixed M. If I draw an apple from M, the remaining contents could suggest two valid assignments for the other labels, which complicates things further.
[答案]
**不能保證推出四個盒子的正確內容。**例如從「混合」盒取出蘋果，可知該盒是純蘋果；但剩下仍可能是「蘋果標籤盒＝混合、橘子標籤盒＝香蕉、香蕉標籤盒＝橘子」，也可能是「蘋果標籤盒＝香蕉、橘子標籤盒＝混合、香蕉標籤盒＝橘子」，兩者都符合所有標籤貼錯，因此一次取樣不足以唯一判定。
token：輸入 118（快取 0）／輸出 652（其中推論 516）／總計 770
======================================================================
示範二：服務端保存對話（Responses API，只傳上一輪的 response id）
======================================================================
【第一輪：原題】
[推論摘要]
**Explaining a classic puzzle**
I need to answer in traditional Chinese, starting with a clear conclusion followed by an explanation of three sentences maximum. The puzzle involves labeling where the contents are pure apple, orange, banana, or a mixed fruit, all with wrong labels. The strategy is to draw from the box labeled mixed, as it cannot contain mixed fruit, allowing identification of the true contents of the other boxes too.
[答案]
可以保證。先從標示「混合」的盒子取一顆，因標籤全錯，它不可能是混合盒，因此看到的水果即可確定該盒是對應的單一水果盒；再依「其餘標籤全錯」的條件，排除已知內容，唯一確定另外三盒的正確配置。
實際送出訊息數：1 則
帶出的對話 id ：（無）
回來後 session.ConversationId：resp_09570987efccb64b006af16ce2a45c8193bf29d2ab8c90fe24
token：輸入 118（快取 0）／輸出 172（其中推論 81）／總計 290
【第二輪：追問（不重述題目）】
[推論摘要]
（沒有收到推論摘要：Chat Completions 不提供；Responses 則在推論太短時會省略）
[答案]
應從標示「混合」的盒子拿。因為標籤全錯，該盒必定是純蘋果或純橘子；若拿到蘋果，它就是蘋果盒，標示「橘子」的盒子只能是混合盒，剩下的是橘子盒（拿到橘子時反之亦然）。
實際送出訊息數：1 則
帶出的對話 id ：resp_09570987efccb64b006af16ce2a45c8193bf29d2ab8c90fe24
回來後 session.ConversationId：resp_09570987efccb64b006af16d266f98819398624f4df0d0cb1b
token：輸入 331（快取 0）／輸出 89（其中推論 0）／總計 420
======================================================================
示範三：對照組 Chat Completions（每一輪都把整段歷史重送）
======================================================================
【第一輪：原題】
[推論摘要]
（沒有收到推論摘要：Chat Completions 不提供；Responses 則在推論太短時會省略）
[答案]
**不能保證推出四個盒子的正確內容。**
例如從「混合」盒取出蘋果，只能確定該盒是「蘋果」，但其餘仍可能是「蘋果標籤＝橘子、橘子標籤＝香蕉、香蕉標籤＝混合」，也可能是「蘋果標籤＝混合、橘子標籤＝香蕉、香蕉標籤＝橘子」，兩者都符合所有標籤貼錯。
因此一次取出一顆水果的資訊不足以唯一確定四盒內容。
實際送出訊息數：1 則
帶出的對話 id ：（無）
回來後 session.ConversationId：（無，歷史存在本機 session）
token：輸入 118（快取 0）／輸出 660（其中推論 512）／總計 778
【第二輪：追問（不重述題目）】
[推論摘要]
（沒有收到推論摘要：Chat Completions 不提供；Responses 則在推論太短時會省略）
[答案]
**應該從標籤為「混合」的盒子拿一顆水果。**
因為所有標籤都錯，「混合」盒不可能是混合；若拿出蘋果，它就是蘋果盒，接著標籤「橘子」的盒只能是混合，標籤「蘋果」的盒則是橘子。
若拿出橘子，推理對調即可，因此一定能推出三盒內容。
實際送出訊息數：3 則
帶出的對話 id ：（無）
回來後 session.ConversationId：（無，歷史存在本機 session）
token：輸入 307（快取 0）／輸出 177（其中推論 58）／總計 484
======================================================================
對照小結：第二輪（追問）
======================================================================
實際送出的訊息數：Responses = 1 則｜Chat Completions = 3 則
帶出的對話 id：Responses = 上一輪的 response id｜Chat Completions = （無）
輸入 token（其中快取）：Responses = 331（0）｜Chat Completions = 307（0）
推論 token：Responses = 0｜Chat Completions = 58
兩輪中拿到推論摘要：Responses = 是｜Chat Completions = 否
對話歷史存在哪裡：Responses = OpenAI 服務端｜Chat Completions = 本機 AgentSession
觀察：Responses 第二輪只送 1 則訊息，但服務端會把上一輪的完整內容（含推論項目）接回上下文，
所以輸入 token 照樣計費，甚至可能比 Chat Completions 多；Chat Completions 重送的只有看得見的文字，
上一輪的推論內容直接丟掉。（提示快取要前綴超過約 1,024 token 才會命中，這個範例太短所以是 0）