@cartanova/qgrid-cli 2.1.0 → 2.2.0

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

@@ -1,7 +1,12 @@
 import { getLogger } from "@logtape/logtape";
 
 import { type JsonValue } from "../../codex-protocol/serde_json/JsonValue";
-import { type QgridContent, type QgridTool, type QueryOutput } from "./qgrid.types";
+import {
+  type QgridContent,
+  type QgridThreadCoord,
+  type QgridTool,
+  type QueryOutput,
+} from "./qgrid.types";
 
 const logger = getLogger(["qgrid", "tool-emulation"]);
 
@@ -52,12 +57,16 @@ export function buildToolCallSchema(tools: QgridTool[]): JsonValue {
 }
 
 export function applyToolCallEmulation(
-  result: Omit<QueryOutput, "content" | "finishReason">,
+  result: Omit<QueryOutput, "content" | "finishReason" | "runContext">,
   tools?: QgridTool[],
+  threadCoord?: QgridThreadCoord,
 ): QueryOutput {
+  // thread 재사용 좌표를 runContext 로 실어 올린다 (auto 모드는 requestLogId 없이 threadCoord 만).
+  const runContext = threadCoord ? { threadCoord } : undefined;
+
   if (!tools?.length) {
     const content: QgridContent[] = [{ type: "text", text: result.text }];
-    return { ...result, content, finishReason: "stop" };
+    return { ...result, content, finishReason: "stop", runContext };
   }
 
   let parsed: ToolCallResponse;
@@ -65,7 +74,12 @@ export function applyToolCallEmulation(
     parsed = JSON.parse(result.text) as ToolCallResponse;
   } catch (e) {
     logger.warn(`tool-call emulation parse failed, falling back to text: ${(e as Error).message}`);
-    return { ...result, content: [{ type: "text", text: result.text }], finishReason: "stop" };
+    return {
+      ...result,
+      content: [{ type: "text", text: result.text }],
+      finishReason: "stop",
+      runContext,
+    };
   }
 
   if (parsed.action === "tool_call") {
@@ -82,7 +96,7 @@ export function applyToolCallEmulation(
         input: toolCall.args,
       };
     });
-    return { ...result, content, finishReason: "tool-calls" };
+    return { ...result, content, finishReason: "tool-calls", runContext };
   }
 
   const text = parsed.answer ?? result.text;
@@ -91,5 +105,6 @@ export function applyToolCallEmulation(
     text,
     content: [{ type: "text", text }],
     finishReason: "stop",
+    runContext,
   };
 }

package/bundle/src/application/sonamu.generated.http

@@ -227,7 +227,13 @@ Content-Type: application/json
     "isStep": false,
     "logMode": "auto",
     "runContext": {
-      "requestLogId": 0
+      "requestLogId": 0,
+      "threadCoord": {
+        "workerId": 0,
+        "threadId": "THREADID",
+        "epoch": 0,
+        "systemHash": "SYSTEMHASH"
+      }
     },
     "toolResults": [
       {
@@ -268,7 +274,13 @@ Content-Type: application/json
     "isStep": false,
     "logMode": "auto",
     "runContext": {
-      "requestLogId": 0
+      "requestLogId": 0,
+      "threadCoord": {
+        "workerId": 0,
+        "threadId": "THREADID",
+        "epoch": 0,
+        "systemHash": "SYSTEMHASH"
+      }
     },
     "toolResults": [
       {

package/bundle/src/utils/providers/common/provider-dispatcher.ts

@@ -8,17 +8,32 @@ import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
 import { type TokenUsageBreakdown } from "../../../codex-protocol/v2/TokenUsageBreakdown";
 import { type UserInput } from "../../../codex-protocol/v2/UserInput";
 
+// thread 재사용 라우팅 좌표. 상위(qgrid.dispatcher)에서 conv 핸들 검증을 통과한 경우에만 전달.
+// dispatcher 는 이 좌표가 가리키는 worker 의 기존 thread 에 turn 만 실행한다.
+export interface ReuseThreadCoord {
+  workerId: number;
+  threadId: string;
+  epoch: number;
+}
+
 export interface GenerateRequest {
   model: string;
-  input: Array<UserInput>;
   systemPrompt?: string;
   outputSchema?: JsonValue;
   effort?: string;
   verbosity?: string;
   reasoningSummary?: string;
   serviceTier?: string;
-  history?: Array<JsonValue>;
   abortSignal?: AbortSignal;
+  // 첫 turn / 재사용 폴백 시 보낼 input — 전체 prompt. 항상 설정.
+  coldInput: Array<UserInput>;
+  // 첫 turn / 폴백 시 inject 할 전체 history.
+  coldHistory?: Array<JsonValue>;
+  // 재사용 좌표 + delta input. 둘은 한 쌍 — 검증 통과 시에만 설정한다.
+  // dispatcher 가 worker/thread 생존을 재검증해 성공하면 reuseInput(delta)을, 실패하면
+  // coldInput + coldHistory 로 폴백한다(전체 history 로 문맥 복구).
+  reuse?: ReuseThreadCoord;
+  reuseInput?: Array<UserInput>;
 }
 
 export interface GenerateResult {
@@ -27,6 +42,18 @@ export interface GenerateResult {
   usage: TokenUsageBreakdown;
   durationMs: number;
   model: string;
+  // 이번 turn 이 사용한 thread 좌표. 상위가 conv 핸들을 발급/갱신하는 데 쓴다.
+  threadCoord: ReuseThreadCoord;
+}
+
+// 상위(qgrid.dispatcher)로 가는 스트림 콜백. onComplete 는 non-stream 의 GenerateResult 와
+// 동일 shape(tokenName/threadCoord 포함)를 받아, 두 경로가 같은 일급 타입을 공유한다.
+export interface GenerateStreamCallbacks {
+  onDelta: (text: string) => void;
+  onComplete: (result: GenerateResult) => void;
+  onError: (error: Error) => void;
+  onThreadId?: (threadId: string) => void;
+  onTurnId?: (turnId: string) => void;
 }
 
 export interface ProviderDispatcher {

package/bundle/src/utils/providers/openai/codex-worker.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { CodexAppServerWorker, type StreamCallbacks } from "./codex-worker";
+
+function createWorkerWithFakeRpc() {
+  const worker = new CodexAppServerWorker({
+    tokenId: 1,
+    tokenName: "token",
+    accessToken: "access",
+    accountId: "account",
+  });
+  const handlers = new Map<string, (params: never) => void>();
+  const rpc = {
+    onNotification(method: string, handler: (params: never) => void) {
+      handlers.set(method, handler);
+    },
+  };
+  (
+    worker as unknown as {
+      rpc: typeof rpc;
+    }
+  ).rpc = rpc;
+  return { worker, handlers };
+}
+
+function createWorkerWithRequestSpy() {
+  const worker = new CodexAppServerWorker({
+    tokenId: 1,
+    tokenName: "token",
+    accessToken: "access",
+    accountId: "account",
+  });
+  const request = vi.fn(async (method: string, _params?: unknown) => {
+    if (method === "thread/start") {
+      return { thread: { id: "thread-1" }, model: "gpt-test" };
+    }
+    if (method === "turn/start") {
+      return { turn: { id: "turn-1" } };
+    }
+    throw new Error(`unexpected request: ${method}`);
+  });
+  (
+    worker as unknown as {
+      rpc: { request: typeof request };
+      ready: boolean;
+    }
+  ).rpc = { request };
+  (
+    worker as unknown as {
+      ready: boolean;
+    }
+  ).ready = true;
+  return { worker, request };
+}
+
+describe("CodexAppServerWorker active turn cleanup", () => {
+  it("rejects a non-streaming turn when the worker process exits", async () => {
+    const { worker } = createWorkerWithFakeRpc();
+    const promise = (
+      worker as unknown as {
+        consumeTurnNotifications(threadId: string, model: string): Promise<unknown>;
+      }
+    ).consumeTurnNotifications("thread-1", "gpt-test");
+
+    (
+      worker as unknown as {
+        failActiveTurn(error: Error): void;
+      }
+    ).failActiveTurn(new Error("codex worker exited while turn was running"));
+
+    await expect(promise).rejects.toThrow("codex worker exited while turn was running");
+  });
+
+  it("notifies stream callbacks when the worker process exits", async () => {
+    const { worker } = createWorkerWithFakeRpc();
+    const callbacks: StreamCallbacks = {
+      onDelta: vi.fn(),
+      onComplete: vi.fn(),
+      onError: vi.fn(),
+    };
+    const promise = (
+      worker as unknown as {
+        consumeStreamNotifications(
+          threadId: string,
+          model: string,
+          cb: StreamCallbacks,
+        ): Promise<void>;
+      }
+    ).consumeStreamNotifications("thread-1", "gpt-test", callbacks);
+
+    (
+      worker as unknown as {
+        failActiveTurn(error: Error): void;
+      }
+    ).failActiveTurn(new Error("codex worker exited while turn was running"));
+
+    await expect(promise).rejects.toThrow("codex worker exited while turn was running");
+    expect(callbacks.onError).toHaveBeenCalledWith(
+      expect.objectContaining({ message: "codex worker exited while turn was running" }),
+    );
+  });
+});
+
+describe("CodexAppServerWorker prompt prefix", () => {
+  it("uses the same base instructions with and without an output schema", async () => {
+    type WorkerInternals = {
+      createThread(req: unknown): Promise<{ threadId: string; model: string }>;
+      startTurnOnThread(threadId: string, req: unknown): Promise<{ turnId: string }>;
+    };
+
+    const textWorker = createWorkerWithRequestSpy();
+    {
+      const w = textWorker.worker as unknown as WorkerInternals;
+      const req = {
+        input: [{ type: "text", text: "hello", text_elements: [] }],
+        developerInstructions: "fixed system prompt",
+      };
+      const { threadId } = await w.createThread(req);
+      await w.startTurnOnThread(threadId, req);
+    }
+
+    const schemaWorker = createWorkerWithRequestSpy();
+    const outputSchema = {
+      type: "object",
+      additionalProperties: false,
+      properties: { answer: { type: "string" } },
+      required: ["answer"],
+    };
+    {
+      const w = schemaWorker.worker as unknown as WorkerInternals;
+      const req = {
+        input: [{ type: "text", text: "hello", text_elements: [] }],
+        developerInstructions: "fixed system prompt",
+        outputSchema,
+      };
+      const { threadId } = await w.createThread(req);
+      await w.startTurnOnThread(threadId, req);
+    }
+
+    const textThreadStart = textWorker.request.mock.calls.find(
+      ([method]) => method === "thread/start",
+    )?.[1] as { baseInstructions?: string; developerInstructions?: string } | undefined;
+    const schemaThreadStart = schemaWorker.request.mock.calls.find(
+      ([method]) => method === "thread/start",
+    )?.[1] as { baseInstructions?: string; developerInstructions?: string } | undefined;
+    expect(textThreadStart).toEqual(
+      expect.objectContaining({
+        baseInstructions: schemaThreadStart?.baseInstructions,
+        developerInstructions: "fixed system prompt",
+      }),
+    );
+    expect(schemaThreadStart).toEqual(
+      expect.objectContaining({
+        developerInstructions: "fixed system prompt",
+      }),
+    );
+
+    const schemaTurnStart = schemaWorker.request.mock.calls.find(
+      ([method]) => method === "turn/start",
+    )?.[1];
+    expect(schemaTurnStart).toEqual(expect.objectContaining({ outputSchema }));
+  });
+});