@cartanova/qgrid-cli 2.7.1 → 2.7.3

package/bundle/src/application/qgrid/conv-routing.test.ts

@@ -113,4 +113,71 @@ describe("decideConvRouting", () => {
     });
     expect(decision.coldInput[0]).not.toMatchObject({ type: "text", text: "" });
   });
+
+  it("direct OpenAI는 epoch=-1 좌표를 opaque cache affinity로 해석하고 전체 history를 유지한다", () => {
+    const cacheAffinityKey = "a".repeat(64);
+    const model = "openai/gpt-5.5";
+    const decision = decideConvRouting(
+      input({
+        prompt: "next",
+        model,
+        system: "same",
+        history: JSON.stringify([{ role: "user", content: "first" }]),
+        cacheAffinityKey,
+        runContext: {
+          threadCoord: {
+            workerId: 17,
+            threadId: cacheAffinityKey,
+            epoch: -1,
+            systemHash: systemHash("same", model),
+          },
+        },
+      }),
+      { directOpenAI: true, modelNamespace: model },
+    );
+
+    expect(decision.reuse).toBeUndefined();
+    expect(decision.reuseInput).toBeUndefined();
+    expect(decision.coldHistory).toEqual([{ role: "user", content: "first" }]);
+    expect(decision.coldInput).toEqual([{ type: "text", text: "next", text_elements: [] }]);
+    expect(decision.promptCacheKey).toBe(cacheAffinityKey);
+    expect(decision.preferredTokenId).toBe(17);
+  });
+
+  it("direct OpenAI rejects legacy or mismatched coords but keeps the request affinity key", () => {
+    const cacheAffinityKey = "b".repeat(64);
+    const decision = decideConvRouting(
+      input({
+        model: "openai/gpt-5.5",
+        cacheAffinityKey,
+        runContext: {
+          threadCoord: {
+            workerId: 4,
+            threadId: "legacy-thread",
+            epoch: 3,
+            systemHash: systemHash(undefined, "openai/gpt-5.5"),
+          },
+        },
+      }),
+      { directOpenAI: true, modelNamespace: "openai/gpt-5.5" },
+    );
+
+    expect(decision.promptCacheKey).toBe(cacheAffinityKey);
+    expect(decision.preferredTokenId).toBeUndefined();
+    expect(decision.reuse).toBeUndefined();
+  });
+
+  it("system hash separates model namespaces", () => {
+    expect(systemHash("same", "openai/gpt-5.5")).not.toBe(systemHash("same", "openai/gpt-5.4"));
+  });
+
+  it("direct OpenAI 요청에 affinity key 가 없으면 cache key 를 만들지 않는다", () => {
+    const decision = decideConvRouting(input({ model: "openai/gpt-5.5" }), {
+      directOpenAI: true,
+      modelNamespace: "openai/gpt-5.5",
+    });
+
+    expect(decision.promptCacheKey).toBeUndefined();
+    expect(decision.preferredTokenId).toBeUndefined();
+  });
 });

package/bundle/src/application/qgrid/conv-routing.ts

@@ -1,5 +1,5 @@
 /**
- * conv-routing — conversation(=codex thread) 재사용을 위한 thread 좌표 검증/구성.
+ * conv-routing — 대화 연속성(cache affinity) 좌표 검증/구성.
  *
  * 목표: thread(=conversation_id=prompt_cache_key)를 재사용해 OpenAI prompt caching 적중.
  * - 후속 turn: 기존 thread 에 delta(마지막 user / tool 결과)만 보냄 (history inject 없음).
@@ -10,19 +10,18 @@
  */
 import { createHash } from "node:crypto";
 
-import { type JsonValue } from "../../codex-protocol/serde_json/JsonValue";
-import { type UserInput } from "../../codex-protocol/v2/UserInput";
 import { type ReuseThreadCoord } from "../../utils/providers/common/provider-dispatcher";
+import { type JsonValue, type UserInput } from "../../utils/providers/common/provider-types";
 import { type QgridThreadCoord, type QueryInput, type QgridToolResultInput } from "./qgrid.types";
 
-export function systemHash(system?: string): string {
+export function systemHash(system?: string, modelNamespace?: string): string {
   return createHash("sha256")
-    .update(system ?? "")
+    .update(modelNamespace === undefined ? (system ?? "") : `${modelNamespace}\0${system ?? ""}`)
     .digest("hex")
     .slice(0, 16);
 }
 
-// tool 결과를 다음 turn 의 input text 로 변환 (codex turn/start.input 은 UserInput 만 받음).
+// tool 결과를 다음 turn 의 input text 로 변환 (provider 입력은 UserInput 만 받음).
 function toolResultsToText(toolResults: QgridToolResultInput[]): string {
   const lines = toolResults.map((tr) => {
     const name = tr.toolName ? ` (${tr.toolName})` : "";
@@ -43,14 +42,28 @@ export interface ConvDecision {
   coldHistory?: Array<JsonValue>;
   // 이 요청 시점의 system 해시 (응답에서 thread 좌표 발급 시 사용).
   systemHash: string;
+  // Direct-provider cache affinity. Presence marks the epoch=-1 coordinate semantics.
+  promptCacheKey?: string;
+  preferredTokenId?: number;
+}
+
+export interface ConvRoutingOptions {
+  directOpenAI?: boolean;
+  modelNamespace?: string;
 }
 
 // thread 좌표 + 들어온 요청으로 "재사용 가능한가"를 판정하고, reuse/cold 양쪽 payload 를 구성한다.
 // dispatcher 단의 epoch/worker 생존 검증은 여기서 못 하므로(상태 없음) reuse 좌표 + 두 payload 를
 // 모두 넘기고, dispatcher 의 acquireReuseWorker 결과에 따라 reuse(delta) 또는 cold(전체) 를 고른다.
 // 양쪽을 다 들고 가야 reuse 가 실패로 폴백돼도 전체 history 로 문맥을 복구할 수 있다.
-export function decideConvRouting(input: QueryInput): ConvDecision {
-  const sysHash = systemHash(input.system);
+export function decideConvRouting(
+  input: QueryInput,
+  options: ConvRoutingOptions = {},
+): ConvDecision {
+  const sysHash = systemHash(
+    input.system,
+    options.directOpenAI ? (options.modelNamespace ?? input.model ?? "openai") : undefined,
+  );
   const history: Array<JsonValue> | undefined = input.history
     ? (JSON.parse(input.history) as Array<JsonValue>)
     : undefined;
@@ -58,21 +71,33 @@ export function decideConvRouting(input: QueryInput): ConvDecision {
   const coord = input.runContext?.threadCoord;
 
   // 재사용 자격: 좌표 존재 + system 동일. sessionKey 격리 + systemHash 로 대화 동일성이
-  // 보장되고, 공통 prefix 는 codex 가 prompt_cache_key 고정으로 알아서 캐시한다.
-  const eligible = coord !== undefined && coord.systemHash === sysHash;
+  // 보장되고, 공통 prefix 는 백엔드가 prompt_cache_key 고정으로 알아서 캐시한다.
+  const directCoordEligible =
+    options.directOpenAI === true &&
+    coord?.epoch === -1 &&
+    coord.systemHash === sysHash &&
+    input.cacheAffinityKey !== undefined &&
+    coord.threadId === input.cacheAffinityKey;
+  const legacyReuseEligible =
+    options.directOpenAI !== true && coord !== undefined && coord.systemHash === sysHash;
+  // affinity 를 요청하지 않은 one-shot 요청에 임의 키를 붙이면 transport 가 그 소켓을
+  // affinity 소켓으로 오인해 재사용되지 않을 연결을 계속 붙들어 둔다 → 키를 비워 둔다.
+  const cacheKey = options.directOpenAI ? input.cacheAffinityKey : undefined;
 
   return {
     reuse:
-      eligible && coord
+      legacyReuseEligible && coord
         ? { workerId: coord.workerId, threadId: coord.threadId, epoch: coord.epoch }
         : undefined,
     // 재사용 turn 은 delta(마지막 user/tool 결과)만 — thread 가 이미 이전 turn 들을 누적.
-    reuseInput: eligible ? buildDeltaInput(input) : undefined,
+    reuseInput: legacyReuseEligible ? buildDeltaInput(input) : undefined,
     // 첫 turn / 폴백: 전체 prompt + history inject. tool 결과 follow-up 이 cold 로 떨어져도
     // 실행 user 줄에는 "이 결과로 계속 답하라"는 continuation 이 들어가야 한다.
     coldInput: buildDeltaInput(input),
     coldHistory: history,
     systemHash: sysHash,
+    promptCacheKey: cacheKey,
+    preferredTokenId: directCoordEligible ? coord.workerId : undefined,
   };
 }
 
@@ -101,7 +126,16 @@ function buildDeltaInput(input: QueryInput): Array<UserInput> {
 export function issueConvContext(
   threadCoord: ReuseThreadCoord,
   decision: ConvDecision,
+  preferredTokenId = threadCoord.workerId,
 ): QgridThreadCoord {
+  if (decision.promptCacheKey) {
+    return {
+      workerId: preferredTokenId,
+      threadId: decision.promptCacheKey,
+      epoch: -1,
+      systemHash: decision.systemHash,
+    };
+  }
   return {
     workerId: threadCoord.workerId,
     threadId: threadCoord.threadId,

package/bundle/src/application/qgrid/qgrid-oauth-redirect.test.ts

@@ -4,11 +4,14 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { CONSOLE_CALLBACK_URL } from "./oauth";
 import { QgridFrame } from "./qgrid.frame";
 
-const { exchangeMock, tokenSaveMock, tokenDelMock, findByAccountMock } = vi.hoisted(() => ({
+const { exchangeMock, openAIExchangeMock, tokenSaveMock, tokenDelMock, findByAccountMock, notifyMock } =
+  vi.hoisted(() => ({
   exchangeMock: vi.fn(),
+  openAIExchangeMock: vi.fn(),
   tokenSaveMock: vi.fn(async () => [1]),
   tokenDelMock: vi.fn(async () => 1),
   findByAccountMock: vi.fn(async () => []),
+  notifyMock: vi.fn(),
 }));
 
 // oauthStart 는 PKCE 상태를 cache 에 저장한다 — Map 스텁으로 왕복만 지원한다.
@@ -32,6 +35,11 @@ vi.mock("./oauth", async (importOriginal) => ({
   exchangeCodeForTokens: exchangeMock,
 }));
 
+vi.mock("../../utils/providers/openai/openai-oauth", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../../utils/providers/openai/openai-oauth")>()),
+  exchangeOpenAICode: openAIExchangeMock,
+}));
+
 vi.mock("../token/token.model", () => ({
   TokenModel: {
     save: tokenSaveMock,
@@ -56,7 +64,7 @@ vi.mock("../token/token.model", () => ({
 // isolate:false 워커의 token-death 전용 테스트로 새지 않게 실제 모듈 로드를 막는다.
 vi.mock("./token-death", () => ({
   deactivateAuthDeadToken: vi.fn(),
-  notifyTokenAdded: vi.fn(),
+  notifyTokenAdded: notifyMock,
 }));
 
 function authUrlParam(authUrl: string, key: string): string | null {
@@ -104,6 +112,14 @@ describe("QgridFrame.oauthStart redirect resolution", () => {
     expect(authUrlParam(authUrl, "redirect_uri")).toBe(CONSOLE_CALLBACK_URL);
   });
 
+  it("uses the redirect flow for a loopback Host header with a port", async () => {
+    mockHttpContext({ host: "localhost:44900" });
+
+    const { authUrl, mode } = await QgridFrame.oauthStart("tok");
+    expect(mode).toBe("redirect");
+    expect(authUrlParam(authUrl, "redirect_uri")).toBe("http://localhost:44900/callback");
+  });
+
   it("falls back to the localhost redirect flow without an HTTP context", async () => {
     vi.spyOn(Sonamu, "getContext").mockImplementation(() => {
       throw new Error("no context");
@@ -168,3 +184,77 @@ describe("QgridFrame.oauthComplete code flow", () => {
     expect(exchangeMock).not.toHaveBeenCalled();
   });
 });
+
+describe("QgridFrame direct OpenAI OAuth", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    openAIExchangeMock.mockReset();
+    tokenSaveMock.mockClear();
+    tokenDelMock.mockClear();
+    findByAccountMock.mockClear().mockResolvedValue([]);
+    notifyMock.mockClear();
+  });
+
+  it("uses the pinned loopback callback despite hostile forwarding headers", async () => {
+    mockHttpContext({ origin: "https://qgrid.example.com" });
+
+    const result = await QgridFrame.oauthStartOpenAI("openai-token");
+    const url = new URL(result.authUrl);
+    expect(result.mode).toBe("redirect");
+    expect(url.origin + url.pathname).toBe("https://auth.openai.com/oauth/authorize");
+    expect(url.searchParams.get("redirect_uri")).toBe("http://localhost:44900/auth/callback");
+    expect(url.searchParams.get("state")).toBeTruthy();
+    expect(url.searchParams.get("code_challenge_method")).toBe("S256");
+  });
+
+  it("exchanges an OpenAI callback, replaces the duplicate account, and notifies", async () => {
+    mockHttpContext({ origin: "https://qgrid.example.com" });
+    const { authUrl } = await QgridFrame.oauthStartOpenAI("openai-token");
+    const state = authUrlParam(authUrl, "state")!;
+    findByAccountMock.mockResolvedValueOnce([{ id: 9, active: true }] as never);
+    openAIExchangeMock.mockResolvedValueOnce({
+      accessToken: "access",
+      refreshToken: "refresh",
+      idToken: "id",
+      accessTokenExpiresAt: 123,
+      idTokenExpiresAt: 456,
+      accountId: "account-1",
+      planType: "pro",
+    });
+    const reply = { redirect: vi.fn() };
+
+    await QgridFrame.handleOAuthCallback("the-code", state, reply as never);
+
+    expect(openAIExchangeMock).toHaveBeenCalledWith(
+      "the-code",
+      expect.any(String),
+      "http://localhost:44900/auth/callback",
+    );
+    expect(tokenDelMock).toHaveBeenCalledOnce();
+    expect(tokenSaveMock).toHaveBeenCalledWith([
+      {
+        provider: "openai",
+        credentials: expect.objectContaining({ accountId: "account-1", planType: "pro" }),
+        name: "openai-token",
+      },
+    ]);
+    expect(notifyMock).toHaveBeenCalledWith("openai-token", "openai");
+    expect(reply.redirect).toHaveBeenCalledWith("/?oauth=success&name=openai-token");
+  });
+
+  it("consumes OpenAI state before a failed exchange", async () => {
+    mockHttpContext({ origin: "https://qgrid.example.com" });
+    const { authUrl } = await QgridFrame.oauthStartOpenAI("openai-token");
+    const state = authUrlParam(authUrl, "state")!;
+    openAIExchangeMock.mockRejectedValueOnce(new Error("exchange rejected"));
+    const firstReply = { redirect: vi.fn() };
+    const secondReply = { redirect: vi.fn() };
+
+    await QgridFrame.handleOAuthCallback("bad-code", state, firstReply as never);
+    await QgridFrame.handleOAuthCallback("bad-code", state, secondReply as never);
+
+    expect(firstReply.redirect).toHaveBeenCalledWith("/?oauth=error&reason=exchange_failed");
+    expect(secondReply.redirect).toHaveBeenCalledWith("/?oauth=error&reason=invalid_state");
+    expect(openAIExchangeMock).toHaveBeenCalledOnce();
+  });
+});

package/bundle/src/application/qgrid/qgrid-run-lifecycle.test.ts

@@ -51,6 +51,7 @@ function queryOutput(overrides: Partial<QueryOutput> = {}): QueryOutput {
     usage: {
       input_tokens: 5,
       output_tokens: 7,
+      reasoning_tokens: 0,
       cache_creation_input_tokens: 0,
       cache_read_input_tokens: 0,
     },
@@ -117,6 +118,7 @@ describe("qgrid run lifecycle start", () => {
       project_name: "project",
       history: [{ type: "message", role: "user", content: "earlier" }],
       is_image_generation: undefined,
+      json_schema: null,
     });
   });
 
@@ -601,6 +603,7 @@ describe("qgrid run lifecycle TTFT", () => {
         usage: {
           input_tokens: 100_000,
           output_tokens: 20,
+          reasoning_tokens: 0,
           cache_read_input_tokens: 10_000,
           cache_creation_input_tokens: 80_000,
           cache_creation_5m_input_tokens: 30_000,

package/bundle/src/application/qgrid/qgrid-run-lifecycle.ts

@@ -87,6 +87,15 @@ function filterHistoryForStorage(rawHistory: string | undefined): unknown {
   }
 }
 
+function isParseableJson(text: string): boolean {
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export type RunLifecycleResult = {
   runContext?: QgridRunContext;
 };
@@ -127,6 +136,7 @@ export async function beforeQuery(args: QueryInput): Promise<{
       history: filterHistoryForStorage(args.history),
       tools: args.tools?.length ? args.tools : undefined,
       is_image_generation: args.imageGeneration,
+      json_schema: args.jsonSchema ?? null,
     });
   }
 
@@ -208,9 +218,13 @@ export async function afterQuery(
 
       // finishReason === "stop" → run 종료 (전체 step usage 합산)
       const agg = await RequestLogModel.aggregateStepUsage(requestLogId);
+      const responseText = formatResponseForLog(result);
       await RequestLogModel.finishRun(requestLogId, {
         status: "succeeded",
-        response: formatResponseForLog(result),
+        response: responseText,
+        // structured 요청만 판정한다. deti 배치의 broken JSON 류를 목록에서 바로
+        // 구별하기 위한 기록이며, 비structured 요청은 null 로 남는다.
+        response_json_ok: args.jsonSchema ? isParseableJson(responseText) : null,
         token_name: result.tokenName,
         input_tokens: agg.input_tokens,
         output_tokens: agg.output_tokens,

package/bundle/src/application/qgrid/qgrid.dispatcher.test.ts

@@ -5,6 +5,7 @@ import {
   type GenerateResult,
   type GenerateStreamCallbacks,
 } from "../../utils/providers/common/provider-dispatcher";
+import { systemHash } from "./conv-routing";
 import { buildStrictOutputSchema, QgridDispatcherClass } from "./qgrid.dispatcher";
 import { type QueryOutput } from "./qgrid.types";
 
@@ -176,7 +177,7 @@ describe("QgridDispatcherClass", () => {
     expect(onError).toHaveBeenCalledWith(serverError);
   });
 
-  it("OpenAI query 는 reuse/reuseInput 을 provider 로 계속 전달한다", async () => {
+  it("OpenAI query 는 thread reuse 대신 full-history cache affinity 를 전달한다", async () => {
     const dispatcher = new QgridDispatcherClass();
     const generate = vi.fn(async (_req: GenerateRequest) => providerResult({ model: "gpt-5.5" }));
     dispatcher.openaiDispatcher = { generate } as never;
@@ -185,19 +186,48 @@ describe("QgridDispatcherClass", () => {
       prompt: "next",
       model: "openai/gpt-5.5",
       system: "same-system",
+      history: JSON.stringify([{ role: "user", content: "first" }]),
+      cacheAffinityKey: "a".repeat(64),
       runContext: {
         threadCoord: {
           workerId: 1,
-          threadId: "thread-1",
-          epoch: 0,
-          systemHash: "800ddd9ba811b821",
+          threadId: "a".repeat(64),
+          epoch: -1,
+          systemHash: systemHash("same-system", "openai/gpt-5.5"),
         },
       },
     });
 
     const req = generate.mock.calls[0]![0];
-    expect(req.reuse).toEqual({ workerId: 1, threadId: "thread-1", epoch: 0 });
-    expect(req.reuseInput).toEqual([{ type: "text", text: "next", text_elements: [] }]);
+    expect(req).not.toHaveProperty("reuse");
+    expect(req).not.toHaveProperty("reuseInput");
+    expect(req.coldHistory).toEqual([{ role: "user", content: "first" }]);
+    expect(req.coldInput).toEqual([{ type: "text", text: "next", text_elements: [] }]);
+    expect(req.promptCacheKey).toBe("a".repeat(64));
+    expect(req.preferredTokenId).toBe(1);
+  });
+
+  it("OpenAI response issues a four-field epoch=-1 affinity coord", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    dispatcher.openaiDispatcher = {
+      generate: vi.fn(async () =>
+        providerResult({ threadCoord: { workerId: 137, threadId: "ignored", epoch: -1 } }),
+      ),
+    } as never;
+
+    const result = await dispatcher.query({
+      prompt: "first",
+      model: "openai/gpt-5.5",
+      system: "system",
+      cacheAffinityKey: "c".repeat(64),
+    });
+
+    expect(result.runContext?.threadCoord).toEqual({
+      workerId: 137,
+      threadId: "c".repeat(64),
+      epoch: -1,
+      systemHash: expect.any(String),
+    });
   });
 
   it("Anthropic query 는 reuse/reuseInput 을 provider 로 전달하지 않는다", async () => {

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

@@ -9,7 +9,6 @@
 
 import { InternalServerErrorException, ServiceUnavailableException } from "sonamu";
 
-import { type JsonValue } from "../../codex-protocol/serde_json/JsonValue";
 import { SD } from "../../i18n/sd.generated";
 import { type AnthropicDispatcher } from "../../utils/providers/anthropic/anthropic-dispatcher";
 import { createFenceStripTransform } from "../../utils/providers/anthropic/fence-strip";
@@ -19,6 +18,7 @@ import {
   type GenerateResult,
   type StreamCallbacks,
 } from "../../utils/providers/common/provider-dispatcher";
+import { type JsonValue } from "../../utils/providers/common/provider-types";
 import {
   parseAndValidateCallerSchemas,
   serializeAndValidateDispatchSchema,
@@ -115,7 +115,10 @@ export class QgridDispatcherClass {
     if (route.provider === "openai") {
       if (!this.openaiDispatcher) throw this.notReadyError("openai");
 
-      const decision = decideConvRouting(input);
+      const decision = decideConvRouting(input, {
+        directOpenAI: true,
+        modelNamespace: `openai/${route.model}`,
+      });
       const result = await this.openaiDispatcher.generate({
         model: route.model,
         systemPrompt: input.system,
@@ -124,10 +127,11 @@ export class QgridDispatcherClass {
         verbosity: input.verbosity,
         reasoningSummary: input.reasoningSummary,
         serviceTier: input.serviceTier,
+        timeoutMs: input.timeout,
         coldInput: decision.coldInput,
         coldHistory: decision.coldHistory,
-        reuse: decision.reuse,
-        reuseInput: decision.reuseInput,
+        promptCacheKey: input.imageGeneration ? undefined : decision.promptCacheKey,
+        preferredTokenId: input.imageGeneration ? undefined : decision.preferredTokenId,
         abortSignal,
         imageGeneration: input.imageGeneration,
         imageGenerationOptions: input.imageGenerationOptions,
@@ -137,7 +141,7 @@ export class QgridDispatcherClass {
       // sessionKey 소비자의 warm 좌표를 죽은 좌표로 덮어써 다음 텍스트 turn 이 cold 로 떨어진다.
       const coord = input.imageGeneration
         ? undefined
-        : issueConvContext(result.threadCoord, decision);
+        : issueConvContext(result.threadCoord, decision, result.threadCoord.workerId);
 
       return applyToolCallEmulation(toEmulationResult(result), input.tools, {
         threadCoord: coord,
@@ -186,7 +190,10 @@ export class QgridDispatcherClass {
     if (route.provider === "openai") {
       if (!this.openaiDispatcher) throw this.notReadyError("openai");
 
-      const decision = decideConvRouting(input);
+      const decision = decideConvRouting(input, {
+        directOpenAI: true,
+        modelNamespace: `openai/${route.model}`,
+      });
       await this.openaiDispatcher.generateStream(
         {
           model: route.model,
@@ -196,10 +203,11 @@ export class QgridDispatcherClass {
           verbosity: input.verbosity,
           reasoningSummary: input.reasoningSummary,
           serviceTier: input.serviceTier,
+          timeoutMs: input.timeout,
           coldInput: decision.coldInput,
           coldHistory: decision.coldHistory,
-          reuse: decision.reuse,
-          reuseInput: decision.reuseInput,
+          promptCacheKey: decision.promptCacheKey,
+          preferredTokenId: decision.preferredTokenId,
           abortSignal,
           // 이미지 플래그를 전달해야 generateStream 의 non-stream 전용 거부(R2)가 발동한다.
           imageGeneration: input.imageGeneration,
@@ -212,7 +220,11 @@ export class QgridDispatcherClass {
           onComplete: (turnResult) => {
             cb.onComplete(
               applyToolCallEmulation(toEmulationResult(turnResult), input.tools, {
-                threadCoord: issueConvContext(turnResult.threadCoord, decision),
+                threadCoord: issueConvContext(
+                  turnResult.threadCoord,
+                  decision,
+                  turnResult.threadCoord.workerId,
+                ),
                 answerKind,
               }),
             );
@@ -357,6 +369,7 @@ function toEmulationResult(
     usage: {
       input_tokens: result.usage.inputTokens,
       output_tokens: result.usage.outputTokens,
+      reasoning_tokens: result.usage.reasoningOutputTokens,
       cache_creation_input_tokens: result.usage.cacheCreationInputTokens ?? 0,
       cache_creation_5m_input_tokens: result.usage.cacheCreationInputTokens5m,
       cache_creation_1h_input_tokens: result.usage.cacheCreationInputTokens1h,