@cartanova/qgrid-cli 2.5.5 → 2.5.7

package/bundle/src/application/qgrid/qgrid.types.ts

@@ -100,40 +100,29 @@ export const QgridToolResultInput = z.object({
 });
 export type QgridToolResultInput = z.infer<typeof QgridToolResultInput>;
 
-export const QueryInput = z
-  .looseObject({
-    system: z.string().optional(),
-    prompt: z.string(),
-    input: z.array(QgridInputPart).optional(),
-    model: z.string().optional(),
-    timeout: QueryTimeoutMs.optional(),
-    jsonSchema: z.string().optional(),
-    tools: z.array(QgridTool).optional(),
-    effort: z.string().optional(),
-    verbosity: Verbosity.optional(),
-    reasoningSummary: ReasoningSummary.optional(),
-    serviceTier: ServiceTier.optional(),
-    history: z.string().optional(),
-    projectName: z.string().optional(),
-    // 호환용 필드. 서버 lifecycle 판단에는 사용하지 않는다.
-    isStep: z.boolean().optional(),
-    // 생략하면 로깅한다. false는 request log 쓰기만 끄고 dispatch/thread는 유지한다.
-    logger: z.boolean().optional(),
-    runContext: QgridRunContext.optional(),
-    toolResults: z.array(QgridToolResultInput).optional(),
-    // codex 내장 image_generation tool 을 켠다(OpenAI 경로 전용, opt-in, non-stream).
-    imageGeneration: z.boolean().optional(),
-    // qgrid 가격 추정 및 Codex 이미지 요청 힌트. 이미지 모델은 gpt-image-2 로 고정 가정한다.
-    imageGenerationOptions: ImageGenerationOptions.optional(),
-  })
-  .superRefine((value, ctx) => {
-    if (!Object.hasOwn(value, "logMode")) return;
-    ctx.addIssue({
-      code: "custom",
-      path: ["logMode"],
-      message: "logMode is no longer supported; use logger: false to disable request logging",
-    });
-  });
+export const QueryInput = z.looseObject({
+  system: z.string().optional(),
+  prompt: z.string(),
+  input: z.array(QgridInputPart).optional(),
+  model: z.string().optional(),
+  timeout: QueryTimeoutMs.optional(),
+  jsonSchema: z.string().optional(),
+  tools: z.array(QgridTool).optional(),
+  effort: z.string().optional(),
+  verbosity: Verbosity.optional(),
+  reasoningSummary: ReasoningSummary.optional(),
+  serviceTier: ServiceTier.optional(),
+  history: z.string().optional(),
+  projectName: z.string().optional(),
+  // 생략하면 로깅한다. false는 request log 쓰기만 끄고 dispatch/thread는 유지한다.
+  logger: z.boolean().optional(),
+  runContext: QgridRunContext.optional(),
+  toolResults: z.array(QgridToolResultInput).optional(),
+  // codex 내장 image_generation tool 을 켠다(OpenAI 경로 전용, opt-in, non-stream).
+  imageGeneration: z.boolean().optional(),
+  // qgrid 가격 추정 및 Codex 이미지 요청 힌트. 이미지 모델은 gpt-image-2 로 고정 가정한다.
+  imageGenerationOptions: ImageGenerationOptions.optional(),
+});
 export type QueryInput = z.infer<typeof QueryInput>;
 
 export const ModelFallback = z.object({
@@ -273,17 +262,6 @@ export type FinishRunInput = z.infer<typeof FinishRunInput>;
 
 // ─── Token Management ───
 
-export const AddTokenInput = z.object({
-  token: z.string(),
-  name: z.string(),
-});
-export type AddTokenInput = z.infer<typeof AddTokenInput>;
-
-export const RemoveTokenInput = z.object({
-  token: z.string(),
-});
-export type RemoveTokenInput = z.infer<typeof RemoveTokenInput>;
-
 export const TokenStats = z.object({
   token: z.string(),
   name: z.string(),

package/bundle/src/application/qgrid/tool-emulation-schema.test.ts

@@ -31,27 +31,48 @@ describe("buildToolCallSchema", () => {
       expect.stringContaining("Do not invoke listed client tools as native Claude Code tools"),
     );
     expect(schema).toHaveProperty(
-      ["properties", "action", "description"],
-      expect.stringContaining("tool_call"),
-    );
-    expect(schema).toHaveProperty(
-      ["properties", "toolCalls", "description"],
+      ["properties", "result", "anyOf", 1, "description"],
       expect.stringContaining("Do not call these tools as native"),
     );
     expect(schema).toHaveProperty(
-      ["properties", "toolCalls", "anyOf", 0, "items", "properties", "toolName", "description"],
+      [
+        "properties",
+        "result",
+        "anyOf",
+        1,
+        "properties",
+        "toolCalls",
+        "items",
+        "properties",
+        "toolName",
+        "description",
+      ],
       expect.stringContaining("getWeather"),
     );
   });
 
-  it("preserves the legacy string answer shape when no user schema is supplied", () => {
+  it("makes degenerate combinations grammatically impossible", () => {
     const schema = buildToolCallSchema(tools);
 
     expect(schema).not.toHaveProperty("$defs");
-    expect(schema).toHaveProperty("properties.answer.anyOf", [
-      { type: "string" },
-      { type: "null" },
-    ]);
+    // answer 변형: answer 는 비 null string 필수, toolCalls 는 null 고정.
+    expect(schema).toHaveProperty(["properties", "result", "anyOf", 0, "properties", "answer"], {
+      type: "string",
+    });
+    expect(schema).toHaveProperty(["properties", "result", "anyOf", 0, "properties", "toolCalls"], {
+      type: "null",
+    });
+    // tool_call 변형: toolCalls 1개 이상 필수, answer 는 null 고정.
+    expect(schema).toHaveProperty(
+      ["properties", "result", "anyOf", 1, "properties", "toolCalls", "minItems"],
+      1,
+    );
+    expect(schema).toHaveProperty(["properties", "result", "anyOf", 1, "properties", "answer"], {
+      type: "null",
+    });
+    // OpenAI structured outputs 제약: 루트는 object, union 은 result property 아래 중첩.
+    expect(schema).toHaveProperty("type", "object");
+    expect(schema).toHaveProperty("required", ["result"]);
   });
 
   it("namespaces a user schema and references it from answer", () => {
@@ -61,10 +82,9 @@ describe("buildToolCallSchema", () => {
     };
     const schema = buildToolCallSchema(tools, userSchema);
 
-    expect(schema).toHaveProperty("properties.answer.anyOf", [
-      { $ref: "#/$defs/__qgrid_user_output" },
-      { type: "null" },
-    ]);
+    expect(schema).toHaveProperty(["properties", "result", "anyOf", 0, "properties", "answer"], {
+      $ref: "#/$defs/__qgrid_user_output",
+    });
     expect(schema).toHaveProperty(userPath(), userSchema);
   });
 

package/bundle/src/application/qgrid/tool-emulation-schema.ts

@@ -34,6 +34,12 @@ export class ToolSchemaCompositionError extends Error {
   }
 }
 
+// envelope 는 result 한 겹 아래에 discriminated union 을 둔다. 두 변형을 문법 수준에서
+// 상호배타로 만들어(answer 변형은 answer 비null 필수, tool_call 변형은 toolCalls 1개 이상)
+// `action:"answer", answer:null` 같은 퇴화 조합을 원천 차단한다 — 평평한 스키마 시절
+// 이 조합이 constrained decoding 을 통과해 13.5k 건의 오염 응답을 만든 실사고가 근거.
+// union 을 result property 안에 중첩하는 이유: OpenAI structured outputs 는 루트가
+// object 여야 하고 top-level anyOf 를 거부한다. 중첩 anyOf 와 minItems 는 지원된다.
 export function buildToolCallSchema(tools: QgridTool[], answerSchema?: JsonValue): JsonValue {
   const toolDescriptions = tools
     .map((tool) => {
@@ -48,48 +54,59 @@ export function buildToolCallSchema(tools: QgridTool[], answerSchema?: JsonValue
   return {
     type: "object",
     description:
-      "Use this schema only through StructuredOutput. Do not invoke listed client tools as native Claude Code tools. To request client-side tool execution, set action to tool_call and include toolCalls. Use action answer only when no further client tool result is needed.",
+      "Use this schema only through StructuredOutput. Do not invoke listed client tools as native Claude Code tools. To request client-side tool execution, set result.action to tool_call and include result.toolCalls. Use action answer only when no further client tool result is needed.",
     properties: {
-      action: {
-        type: "string",
-        enum: ["answer", "tool_call"],
-        description:
-          "Use tool_call to request client-side tool execution through this structured output. Use answer only for a final answer.",
-      },
-      answer: {
-        anyOf: [
-          normalizedAnswerSchema === undefined ? { type: "string" } : { $ref: USER_OUTPUT_REF },
-          { type: "null" },
-        ],
-      },
-      toolCalls: {
-        description:
-          "Client-side tool calls requested through structured output. Do not call these tools as native Claude Code tools.",
+      result: {
         anyOf: [
           {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                toolName: {
-                  type: "string",
-                  enum: tools.map((tool) => tool.name),
-                  description: `Client-side tool name to request through structured output. Do not call this as a native Claude Code tool.\n${toolDescriptions}`,
-                },
-                args: {
-                  type: "string",
-                  description: "Tool arguments as a JSON string for the client-side tool.",
+            type: "object",
+            description: "Final answer. Use only when no further client tool result is needed.",
+            properties: {
+              action: { type: "string", enum: ["answer"] },
+              answer:
+                normalizedAnswerSchema === undefined
+                  ? { type: "string" }
+                  : { $ref: USER_OUTPUT_REF },
+              toolCalls: { type: "null" },
+            },
+            required: ["action", "answer", "toolCalls"],
+            additionalProperties: false,
+          },
+          {
+            type: "object",
+            description:
+              "Request client-side tool execution through this structured output. Do not call these tools as native Claude Code tools.",
+            properties: {
+              action: { type: "string", enum: ["tool_call"] },
+              answer: { type: "null" },
+              toolCalls: {
+                type: "array",
+                minItems: 1,
+                items: {
+                  type: "object",
+                  properties: {
+                    toolName: {
+                      type: "string",
+                      enum: tools.map((tool) => tool.name),
+                      description: `Client-side tool name to request through structured output. Do not call this as a native Claude Code tool.\n${toolDescriptions}`,
+                    },
+                    args: {
+                      type: "string",
+                      description: "Tool arguments as a JSON string for the client-side tool.",
+                    },
+                  },
+                  required: ["toolName", "args"],
+                  additionalProperties: false,
                 },
               },
-              required: ["toolName", "args"],
-              additionalProperties: false,
             },
+            required: ["action", "answer", "toolCalls"],
+            additionalProperties: false,
           },
-          { type: "null" },
         ],
       },
     },
-    required: ["action", "answer", "toolCalls"],
+    required: ["result"],
     additionalProperties: false,
     ...(normalizedAnswerSchema === undefined
       ? {}

package/bundle/src/application/qgrid/tool-emulation.test.ts

@@ -24,11 +24,10 @@ describe("applyToolCallEmulation image parts", () => {
   const img = { data: "iVBORw0KGgoBAgM", revisedPrompt: "a red circle" };
 
   it("appends an image part after text when images are present (no tools)", () => {
-    const out = applyToolCallEmulation(
-      { ...baseResult, text: "here is your image" },
-      undefined,
-      { images: [img] },
-    );
+    const out = applyToolCallEmulation({ ...baseResult, text: "here is your image" }, undefined, {
+      images: [img],
+      answerKind: "text",
+    });
     expect(out.content).toEqual([
       { type: "text", text: "here is your image" },
       { type: "image", data: "iVBORw0KGgoBAgM", revisedPrompt: "a red circle" },
@@ -38,23 +37,22 @@ describe("applyToolCallEmulation image parts", () => {
   });
 
   it("appends multiple images preserving order", () => {
-    const out = applyToolCallEmulation(
-      { ...baseResult, text: "here is your image" },
-      undefined,
-      {
-        images: [
-          { data: "iVBORw0KGgoAAA", revisedPrompt: "one" },
-          { data: "iVBORw0KGgoBBB", revisedPrompt: "two" },
-        ],
-      },
-    );
+    const out = applyToolCallEmulation({ ...baseResult, text: "here is your image" }, undefined, {
+      answerKind: "text",
+      images: [
+        { data: "iVBORw0KGgoAAA", revisedPrompt: "one" },
+        { data: "iVBORw0KGgoBBB", revisedPrompt: "two" },
+      ],
+    });
     const images = out.content.filter((c) => c.type === "image");
     expect(images).toHaveLength(2);
     expect(images.map((c) => (c.type === "image" ? c.revisedPrompt : null))).toEqual(["one", "two"]);
   });
 
   it("leaves content unchanged when no images are passed (regression guard)", () => {
-    const out = applyToolCallEmulation({ ...baseResult, text: "here is your image" });
+    const out = applyToolCallEmulation({ ...baseResult, text: "here is your image" }, undefined, {
+      answerKind: "text",
+    });
     expect(out.content).toEqual([{ type: "text", text: "here is your image" }]);
   });
 });
@@ -71,22 +69,14 @@ describe("applyToolCallEmulation envelope validation", () => {
     },
   ];
 
-  function applyEnvelope(
-    envelope: unknown,
-    answerMode: "legacy" | "structured" = "structured",
-  ) {
-    return applyToolCallEmulation(
-      { ...baseResult, text: JSON.stringify(envelope) },
-      tools,
-      { answerMode },
-    );
+  function applyEnvelope(result: unknown, answerKind: "text" | "json" = "json") {
+    return applyToolCallEmulation({ ...baseResult, text: JSON.stringify({ result }) }, tools, {
+      answerKind,
+    });
   }
 
-  it("preserves a legacy tools-only string answer", () => {
-    const out = applyEnvelope(
-      { action: "answer", answer: "done", toolCalls: null },
-      "legacy",
-    );
+  it("returns a text answer verbatim without JSON quoting", () => {
+    const out = applyEnvelope({ action: "answer", answer: "done", toolCalls: null }, "text");
 
     expect(out.text).toBe("done");
     expect(out.content).toEqual([{ type: "text", text: "done" }]);
@@ -99,7 +89,7 @@ describe("applyToolCallEmulation envelope validation", () => {
     ["scalar", '"scalar"'],
     [42, "42"],
     [false, "false"],
-  ])("serializes structured answer %j as JSON text", (answer, expected) => {
+  ])("serializes json answer %j as JSON text", (answer, expected) => {
     const out = applyEnvelope({ action: "answer", answer, toolCalls: null });
 
     expect(out.text).toBe(expected);
@@ -107,61 +97,17 @@ describe("applyToolCallEmulation envelope validation", () => {
     expect(out.finishReason).toBe("stop");
   });
 
-  it("preserves prototype-sensitive keys in a structured answer", () => {
+  it("preserves prototype-sensitive keys in a json answer", () => {
     const out = applyToolCallEmulation(
       {
         ...baseResult,
-        text: String.raw`{"action":"answer","answer":{"__proto__":"kept","nested":{"__proto__":1}},"toolCalls":null}`,
+        text: String.raw`{"result":{"action":"answer","answer":{"__proto__":"kept","nested":{"__proto__":1}},"toolCalls":null}}`,
       },
       tools,
-      { answerMode: "structured" },
+      { answerKind: "json" },
     );
 
-    expect(out.text).toBe(
-      String.raw`{"__proto__":"kept","nested":{"__proto__":1}}`,
-    );
-  });
-
-  it("accepts null or empty toolCalls on a structured answer branch", () => {
-    for (const envelope of [
-      { action: "answer", answer: { ok: true }, toolCalls: null },
-      { action: "answer", answer: { ok: true }, toolCalls: [] },
-    ]) {
-      expect(applyEnvelope(envelope).text).toBe('{"ok":true}');
-    }
-  });
-
-  it("keeps absent toolCalls compatible on a legacy answer branch", () => {
-    expect(applyEnvelope({ action: "answer", answer: "done" }, "legacy").text).toBe("done");
-  });
-
-  it.each([
-    [{ action: "answer", answer: null, toolCalls: null }, undefined],
-    [{ action: "answer", toolCalls: [] }, undefined],
-    [{ action: "unexpected", answer: "fallback answer", toolCalls: null }, "fallback answer"],
-    [{ answer: "", toolCalls: null }, ""],
-    [42, undefined],
-  ])("preserves tolerant legacy final-answer fallback for %j", (envelope, expected) => {
-    const outerText = JSON.stringify(envelope);
-    const out = applyToolCallEmulation(
-      { ...baseResult, text: outerText },
-      tools,
-      { answerMode: "legacy" },
-    );
-
-    expect(out.text).toBe(expected ?? outerText);
-    expect(out.finishReason).toBe("stop");
-  });
-
-  it.each([
-    { action: "tool_call", answer: null, toolCalls: null },
-    { action: "tool_call", answer: null },
-    { action: "tool_call", answer: null, toolCalls: [] },
-  ])("preserves tolerant legacy empty tool_call envelopes: %j", (envelope) => {
-    const out = applyEnvelope(envelope, "legacy");
-
-    expect(out.content).toEqual([]);
-    expect(out.finishReason).toBe("tool-calls");
+    expect(out.text).toBe(String.raw`{"__proto__":"kept","nested":{"__proto__":1}}`);
   });
 
   it("maps a coherent non-empty tool_call branch", () => {
@@ -181,56 +127,70 @@ describe("applyToolCallEmulation envelope validation", () => {
     expect(out.finishReason).toBe("tool-calls");
   });
 
+  // 퇴화 조합 전수 거부 — 과거 관용 디코더가 이들을 조용히 통과시켜 envelope 원문이
+  // 최종 답변으로 흘러나간 실사고(2026-07 medpath 13.5k 건)가 있었다. 관용 폴백 금지.
   it.each([
-    { action: "answer", answer: null, toolCalls: null },
-    { action: "answer", answer: "done", toolCalls: [{}] },
-    { action: "tool_call", answer: "mixed", toolCalls: [{}] },
-    { action: "tool_call", answer: null, toolCalls: [] },
-    { action: "tool_call", answer: null, toolCalls: [{ toolName: "lookup" }] },
-    { action: "unexpected", answer: "done", toolCalls: null },
-    ["not", "an", "object"],
-    { action: "answer", answer: { ok: true } },
-    { action: "answer", answer: { ok: true }, toolCalls: null, extra: true },
-    {
-      action: "tool_call",
-      answer: null,
-      toolCalls: [{ toolName: "lookup", args: "{}", extra: true }],
-    },
-  ])("rejects incoherent structured envelope %j", (envelope) => {
-    expect(() => applyEnvelope(envelope)).toThrowError(ToolCallEmulationError);
-  });
-
-  it("rejects unknown tools after decoding a structured tool call", () => {
-    expect(() =>
-      applyEnvelope({
+    [{ action: "answer", answer: null, toolCalls: null }],
+    [{ action: "answer", toolCalls: [] }],
+    [{ action: "answer", answer: "done", toolCalls: [] }],
+    [{ action: "unexpected", answer: "done", toolCalls: null }],
+    [{ answer: "done", toolCalls: null }],
+    [{ action: "tool_call", answer: null, toolCalls: null }],
+    [{ action: "tool_call", answer: null, toolCalls: [] }],
+    [{ action: "tool_call", answer: "mixed", toolCalls: [{ toolName: "lookup", args: "{}" }] }],
+    [{ action: "tool_call", answer: null, toolCalls: [{ toolName: "lookup" }] }],
+    [{ action: "answer", answer: { ok: true }, toolCalls: null, extra: true }],
+    [
+      {
         action: "tool_call",
         answer: null,
-        toolCalls: [{ toolName: "missing", args: "{}" }],
-      }),
-    ).toThrowError(/unknown emulated tool/);
+        toolCalls: [{ toolName: "lookup", args: "{}", extra: true }],
+      },
+    ],
+    [42],
+    [["not", "an", "object"]],
+  ])("rejects degenerate envelope %j in json mode", (result) => {
+    expect(() => applyEnvelope(result)).toThrowError(ToolCallEmulationError);
   });
 
-  it("does not apply the structured decoder to legacy responses", () => {
-    const answer = { ok: true };
-    const out = applyEnvelope(
-      { action: "answer", answer, toolCalls: [{ ignored: true }] },
-      "legacy",
-    );
-
-    expect(out.text).toEqual(answer);
+  it.each([
+    [{ action: "answer", answer: null, toolCalls: null }],
+    [{ action: "answer", answer: { ok: true }, toolCalls: null }],
+    [{ action: "tool_call", answer: null, toolCalls: [] }],
+  ])("rejects degenerate envelope %j in text mode too", (result) => {
+    expect(() => applyEnvelope(result, "text")).toThrowError(ToolCallEmulationError);
   });
 
-  it("fails malformed outer JSON explicitly in structured mode", () => {
+  it("rejects an envelope missing the result wrapper", () => {
     expect(() =>
       applyToolCallEmulation(
-        { ...baseResult, text: "not-json" },
+        { ...baseResult, text: '{"action":"answer","answer":"done","toolCalls":null}' },
         tools,
-        { answerMode: "structured" },
+        { answerKind: "text" },
       ),
     ).toThrowError(ToolCallEmulationError);
   });
 
-  it("rejects a deeply nested structured envelope without overflowing the stack", () => {
+  it("rejects unknown tools after decoding a tool call", () => {
+    expect(() =>
+      applyEnvelope({
+        action: "tool_call",
+        answer: null,
+        toolCalls: [{ toolName: "missing", args: "{}" }],
+      }),
+    ).toThrowError(/unknown emulated tool/);
+  });
+
+  it.each(["text", "json"] as const)(
+    "fails malformed outer JSON explicitly in %s mode (no text rescue)",
+    (answerKind) => {
+      expect(() =>
+        applyToolCallEmulation({ ...baseResult, text: "not-json" }, tools, { answerKind }),
+      ).toThrowError(ToolCallEmulationError);
+    },
+  );
+
+  it("rejects a deeply nested envelope without overflowing the stack", () => {
     let answer: unknown = 0;
     for (let depth = 0; depth < CALLER_SCHEMA_LIMITS.maxDepth + 5; depth += 1) {
       answer = [answer];
@@ -238,7 +198,7 @@ describe("applyToolCallEmulation envelope validation", () => {
 
     try {
       applyEnvelope({ action: "answer", answer, toolCalls: null });
-      throw new Error("expected the structured envelope to be rejected");
+      throw new Error("expected the envelope to be rejected");
     } catch (error) {
       expect(error).toBeInstanceOf(ToolCallEmulationError);
       expect(error).not.toBeInstanceOf(RangeError);
@@ -246,50 +206,40 @@ describe("applyToolCallEmulation envelope validation", () => {
     }
   });
 
-  it("rejects structured envelopes above the node budget", () => {
+  it("rejects envelopes above the node budget", () => {
     expect(() =>
       applyEnvelope({
         action: "answer",
         answer: Array.from({ length: CALLER_SCHEMA_LIMITS.maxNodes }, () => 0),
         toolCalls: null,
       }),
-    ).toThrowError(/structured-output envelope exceeds node limit/);
+    ).toThrowError(/exceeds node limit/);
   });
 
-  it("rejects structured envelopes above the UTF-8 byte budget before parsing", () => {
+  it("rejects envelopes above the UTF-8 byte budget before parsing", () => {
     const text = JSON.stringify({
-      action: "answer",
-      answer: "x".repeat(CALLER_SCHEMA_LIMITS.maxUtf8Bytes),
-      toolCalls: null,
+      result: {
+        action: "answer",
+        answer: "x".repeat(CALLER_SCHEMA_LIMITS.maxUtf8Bytes),
+        toolCalls: null,
+      },
     });
 
     expect(() =>
-      applyToolCallEmulation(
-        { ...baseResult, text },
-        tools,
-        { answerMode: "structured" },
-      ),
-    ).toThrowError(/structured-output envelope exceeds UTF-8 byte limit/);
-  });
-
-  it("preserves malformed outer JSON fallback in legacy mode", () => {
-    const out = applyToolCallEmulation({ ...baseResult, text: "not-json" }, tools);
-
-    expect(out.text).toBe("not-json");
-    expect(out.content).toEqual([{ type: "text", text: "not-json" }]);
-    expect(out.finishReason).toBe("stop");
+      applyToolCallEmulation({ ...baseResult, text }, tools, { answerKind: "json" }),
+    ).toThrowError(/exceeds UTF-8 byte limit/);
   });
 
-  it("preserves images after a structured final answer", () => {
+  it("preserves images after a json final answer", () => {
     const out = applyToolCallEmulation(
       {
         ...baseResult,
-        text: '{"action":"answer","answer":{"ok":true},"toolCalls":null}',
+        text: '{"result":{"action":"answer","answer":{"ok":true},"toolCalls":null}}',
       },
       tools,
       {
         images: [{ data: "image-data", revisedPrompt: "revised" }],
-        answerMode: "structured",
+        answerKind: "json",
       },
     );
 
@@ -300,13 +250,11 @@ describe("applyToolCallEmulation envelope validation", () => {
   });
 
   it.each([
-    '{"action":"answer","answer":1e400,"toolCalls":null}',
-    '{"action":"answer","answer":{"nested":1e400},"toolCalls":null}',
+    '{"result":{"action":"answer","answer":1e400,"toolCalls":null}}',
+    '{"result":{"action":"answer","answer":{"nested":1e400},"toolCalls":null}}',
   ])("rejects non-finite JSON numbers: %s", (text) => {
     expect(() =>
-      applyToolCallEmulation({ ...baseResult, text }, tools, {
-        answerMode: "structured",
-      }),
+      applyToolCallEmulation({ ...baseResult, text }, tools, { answerKind: "json" }),
     ).toThrowError(/answer must be valid JSON/);
   });
 });