@cartanova/qgrid-cli 2.7.1 → 2.7.2

package/bundle/src/application/setting/setting.entity.json

@@ -18,7 +18,7 @@
       "name": "key",
       "type": "string",
       "length": 100,
-      "desc": "설정 키 (예: openai.maxWorkersPerToken)",
+      "desc": "설정 키 (예: slack.enabled)",
       "toFilter": true
     },
     {

package/bundle/src/application/setting/setting.store.ts

@@ -5,7 +5,7 @@
  * `ecosystem.config.json` 으로 값을 주입하는데, DB 만 보게 만들면 배포 직후 설정이 전부
  * 기본값으로 떨어진다.
  *
- * 설정은 요청 경로(워커 스케일링, 알림 전송)에서 읽히므로 매번 DB 를 때리지 않고 메모리에
+ * 설정은 요청 경로(permit 해석, 알림 전송)에서 읽히므로 매번 DB 를 때리지 않고 메모리에
  * 둔다. `immediate` 변경도 현재 API 프로세스에만 즉시 반영된다. 인스턴스가 여러 개면 다른
  * 인스턴스의 캐시는 갱신되지 않으며, 이 범위에서는 프로세스 간 전파를 두지 않는다.
  */

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

@@ -226,6 +226,7 @@ GET {{baseUrl}}/api/requestLog/findMany
 	&rawParams[model_name]=
 	&rawParams[project_name_is_null]=false
 	&rawParams[project_name_is_not_null]=false
+	&rawParams[response_json_broken]=false
 Content-Type: application/json
 
 ###
@@ -261,16 +262,25 @@ Content-Type: application/json
       "effort": null,
       "history": null,
       "tools": null,
+      "json_schema": null,
       "status": "running",
       "error_message": null,
+      "response_json_ok": null,
       "tool_call_count": 0,
-      "is_image_generation": false
+      "is_image_generation": false,
+      "is_structured": false
     }
   ]
 }
 
 ###
 
+GET {{baseUrl}}/api/requestLog/responseTypeTs
+	?id=0
+Content-Type: application/json
+
+###
+
 POST {{baseUrl}}/api/requestLog/del
 Content-Type: application/json
 
@@ -314,6 +324,7 @@ Content-Type: application/json
     "serviceTier": "fast",
     "history": "HISTORY",
     "projectName": "PROJECTNAME",
+    "cacheAffinityKey": "CACHEAFFINITYKEY",
     "logger": false,
     "runContext": {
       "requestLogId": 0,
@@ -374,6 +385,7 @@ Content-Type: application/json
     "serviceTier": "fast",
     "history": "HISTORY",
     "projectName": "PROJECTNAME",
+    "cacheAffinityKey": "CACHEAFFINITYKEY",
     "logger": false,
     "runContext": {
       "requestLogId": 0,
@@ -508,6 +520,7 @@ GET {{baseUrl}}/api/qgrid/totalCost
 	&params[model_name]=
 	&params[project_name_is_null]=false
 	&params[project_name_is_not_null]=false
+	&params[response_json_broken]=false
 Content-Type: application/json
 
 ###
@@ -617,4 +630,10 @@ Content-Type: application/json
 
 GET {{baseUrl}}/api/monit/monitInfo
 	?
+Content-Type: application/json
+
+###
+
+GET {{baseUrl}}/api/monit/monitStats
+	?
 Content-Type: application/json

package/bundle/src/application/sonamu.generated.sso.ts

@@ -46,9 +46,11 @@ export const requestLogSubsetQueries = {
       history: "request_logs.history",
       tools: "request_logs.tools",
       status: "request_logs.status",
+      response_json_ok: "request_logs.response_json_ok",
       error_message: "request_logs.error_message",
       tool_call_count: "request_logs.tool_call_count",
       is_image_generation: "request_logs.is_image_generation",
+      is_structured: "request_logs.is_structured",
     });
   },
   P: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {
@@ -74,8 +76,10 @@ export const requestLogSubsetQueries = {
       image_cost_method: "request_logs.image_cost_method",
       effort: "request_logs.effort",
       status: "request_logs.status",
+      response_json_ok: "request_logs.response_json_ok",
       tool_call_count: "request_logs.tool_call_count",
       is_image_generation: "request_logs.is_image_generation",
+      is_structured: "request_logs.is_structured",
     });
   },
   C: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {

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

@@ -170,10 +170,13 @@ export const RequestLogBaseSchema = z.object({
   effort: z.string().max(10).nullable(),
   history: HistoryItems.nullable(),
   tools: ToolDefinitions.nullable(),
+  json_schema: z.string().nullable(),
   status: RequestLogStatus,
   error_message: z.string().nullable(),
+  response_json_ok: z.boolean().nullable(),
   tool_call_count: z.int(),
   is_image_generation: z.boolean(),
+  is_structured: z.boolean(),
 });
 export type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {
   readonly __hasDefault__: readonly [
@@ -201,10 +204,13 @@ export type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {
     "effort",
     "history",
     "tools",
+    "json_schema",
     "status",
     "error_message",
+    "response_json_ok",
     "tool_call_count",
     "is_image_generation",
+    "is_structured",
     "id",
   ];
 };
@@ -398,9 +404,11 @@ export const RequestLogSubsetA = z.object({
   history: HistoryItems.nullable(),
   tools: ToolDefinitions.nullable(),
   status: RequestLogStatus,
+  response_json_ok: z.boolean().nullable(),
   error_message: z.string().nullable(),
   tool_call_count: z.int(),
   is_image_generation: z.boolean(),
+  is_structured: z.boolean(),
 });
 export type RequestLogSubsetA = z.infer<typeof RequestLogSubsetA>;
 export const RequestLogSubsetP = z.object({
@@ -425,8 +433,10 @@ export const RequestLogSubsetP = z.object({
   image_cost_method: z.string().max(100).nullable(),
   effort: z.string().max(10).nullable(),
   status: RequestLogStatus,
+  response_json_ok: z.boolean().nullable(),
   tool_call_count: z.int(),
   is_image_generation: z.boolean(),
+  is_structured: z.boolean(),
 });
 export type RequestLogSubsetP = z.infer<typeof RequestLogSubsetP>;
 export const RequestLogSubsetC = z.object({

package/bundle/src/i18n/sd.generated.ts

@@ -235,10 +235,15 @@ const entityLabels = {
   "entity.RequestLog.effort": "effort level",
   "entity.RequestLog.history": "inject_items 히스토리",
   "entity.RequestLog.tools": "요청에 장착된 tool 정의 목록",
+  "entity.RequestLog.json_schema":
+    "structured output 요청의 JSON Schema 원문 (detail 의 response 타입 표시용)",
   "entity.RequestLog.status": "실행 상태",
   "entity.RequestLog.error_message": "에러 메시지",
+  "entity.RequestLog.response_json_ok":
+    "structured(jsonSchema) 요청의 응답 JSON 파싱 성공 여부. 비structured 요청은 null",
   "entity.RequestLog.tool_call_count": "tool call 횟수",
   "entity.RequestLog.is_image_generation": "이미지 생성 turn 여부 (quota 귀속용)",
+  "entity.RequestLog.is_structured": "structured output(jsonSchema) 요청 여부 (목록 구분 표시용)",
   "enum.RequestLogOrderBy.id-desc": "ID최신순",
   "enum.RequestLogOrderBy.id-asc": "ID오래된순",
   "enum.RequestLogOrderBy.created_at-desc": "등록일시최신순",
@@ -300,7 +305,7 @@ const entityLabels = {
   "entity.Setting": "Setting",
   "entity.Setting.id": "ID",
   "entity.Setting.created_at": "등록일시",
-  "entity.Setting.key": "설정 키 (예: openai.maxWorkersPerToken)",
+  "entity.Setting.key": "설정 키 (예: slack.enabled)",
   "entity.Setting.value": "설정 값 (문자열 저장, 앱에서 파싱·검증)",
   "entity.Setting.updated_at": "최종 수정일시",
   "enum.SettingOrderBy.key-asc": "키순",

package/bundle/src/migrations/20260814130113_alter_request_logs_add1_alter1.ts

@@ -0,0 +1,15 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // add
+    table.boolean("response_json_ok").nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // rollback - add
+    table.dropColumns("response_json_ok");
+  });
+}

package/bundle/src/migrations/20260814131051_alter_request_logs_add1_alter1.ts

@@ -0,0 +1,15 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // add
+    table.text("json_schema").nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // rollback - add
+    table.dropColumns("json_schema");
+  });
+}

package/bundle/src/migrations/20260814134846_alter_request_logs_add1_alter1.ts

@@ -0,0 +1,15 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // add
+    table.boolean("is_structured").notNullable().defaultTo(knex.raw("false"));
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // rollback - add
+    table.dropColumns("is_structured");
+  });
+}

package/bundle/src/migrations/20260814140759_alter_request_logs_alter1.ts

@@ -0,0 +1,13 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(
+    `CREATE INDEX request_logs_created_at_index ON request_logs USING btree(created_at ASC NULLS LAST);`,
+  );
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    table.dropIndex(["created_at"], "request_logs_created_at_index");
+  });
+}

package/bundle/src/sonamu.config.ts

@@ -3,6 +3,7 @@ import path from "path";
 import { getConsoleSink } from "@logtape/logtape";
 import { getLogger } from "@logtape/logtape";
 import { getPrettyFormatter } from "@logtape/pretty";
+import { type FastifyReply, type FastifyRequest } from "fastify";
 import { CachePresets, defineConfig } from "sonamu";
 import { drivers as cacheDrivers, store } from "sonamu/cache";
 
@@ -98,23 +99,19 @@ export default defineConfig({
         prefix: "/api/public",
       },
       custom: (server) => {
-        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트
-        server.get("/callback", async (request, reply) => {
+        const oauthCallback = async (request: FastifyRequest, reply: FastifyReply) => {
           const { code, state } = request.query as { code?: string; state?: string };
           if (!code || !state) {
             return reply.redirect("/?oauth=error&reason=missing_params");
           }
           try {
             return QgridFrame.handleOAuthCallback(code, state, reply);
-          } catch (e) {
-            return reply.redirect(
-              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,
-            );
+          } catch {
+            return reply.redirect("/?oauth=error&reason=callback_failed");
           }
-        });
-
-        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림
-        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인
+        };
+        server.get("/callback", oauthCallback);
+        server.get("/auth/callback", oauthCallback);
       },
     },
     apiConfig: {
@@ -219,12 +216,11 @@ export default defineConfig({
         startExpiredTokenReminder();
 
         const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;
-        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;
-        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;
+        const openaiCount = QgridDispatcher.openaiDispatcher?.tokenCount ?? 0;
 
         log.info(`listening on http://${host}:${port}`);
         log.info(`anthropic: ${anthropicCount} tokens ready`);
-        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);
+        log.info(`openai: ${openaiCount} tokens ready`);
         log.info(
           `subscriber: ${started ? "LISTEN active" : "degraded"}${triggerReady ? "" : ", trigger failed"}`,
         );

package/bundle/src/utils/providers/anthropic/anthropic-dispatcher.ts

@@ -93,6 +93,12 @@ export class AnthropicDispatcher implements ProviderDispatcher {
     return this.tokenPool.size;
   }
 
+  // 지금 실행 중인 Claude Code 프로세스 수 — fresh-spawn 이라 이게 곧 동시 요청 수다.
+  private inFlightCount = 0;
+  get inFlight(): number {
+    return this.inFlightCount;
+  }
+
   // Monit 표시용 — 풀에 있는 토큰 이름 스냅샷 (이름순 정렬)
   get tokenNames(): string[] {
     return [...this.tokenPool.values()].map((token) => token.name).toSorted();
@@ -273,12 +279,21 @@ export class AnthropicDispatcher implements ProviderDispatcher {
   }
 
   // generate/generateStream 공통 실행. onDelta 는 스트림이면 점진 방출, 비스트림이면 no-op.
-  private async run(
+  private async run(...args: Parameters<AnthropicDispatcher["runInner"]>): Promise<GenerateResult> {
+    this.inFlightCount++;
+    try {
+      return await this.runInner(...args);
+    } finally {
+      this.inFlightCount--;
+    }
+  }
+
+  private async runInner(
     req: GenerateRequest,
     onDelta: (t: string) => void,
     opts?: { includePartialMessages?: boolean },
   ): Promise<GenerateResult> {
-    // 이미지 생성은 OpenAI(codex) 경로 전용. Anthropic 라우팅에 이미지 플래그가
+    // 이미지 생성은 OpenAI 경로 전용. Anthropic 라우팅에 이미지 플래그가
     // 도달하면 조용히 텍스트로 폴백하지 않고 명시적으로 거부한다.
     if (req.imageGeneration) {
       throw new Error("image generation is not supported on the Anthropic route");

package/bundle/src/utils/providers/anthropic/claude-session.ts

@@ -18,9 +18,7 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
 
-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";
+import { type JsonValue, type TokenUsageBreakdown, type UserInput } from "../common/provider-types";
 import {
   ARGV_SAFE_MAX_UTF8_BYTES,
   assertAnthropicSchemaArgvSize,

package/bundle/src/utils/providers/anthropic/stream-json-adapter.test.ts

@@ -1,7 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
-import { type UserInput } from "../../../codex-protocol/v2/UserInput";
+import { type JsonValue, type UserInput } from "../common/provider-types";
 import {
   buildStreamJsonInput,
   type ClaudeStreamJsonState,

package/bundle/src/utils/providers/anthropic/stream-json-adapter.ts

@@ -8,12 +8,11 @@
  * The only executable user line is the current input.
  */
 
-import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
-import { type UserInput } from "../../../codex-protocol/v2/UserInput";
 import {
   type ModelFallback,
   type ProviderTokenUsageBreakdown,
 } from "../common/provider-dispatcher";
+import { type JsonValue, type UserInput } from "../common/provider-types";
 import { stripFences } from "./fence-strip";
 
 // ── 입력 어댑터 ────────────────────────────────────────────────────
@@ -38,7 +37,7 @@ function textBlock(text: string): Array<{ type: "text"; text: string }> {
   return [{ type: "text", text }];
 }
 
-// codex ResponseItem(coldHistory item) 최소 shape.
+// OpenAI Responses item(coldHistory item) 최소 shape.
 // extractPromptAndHistory(ai-sdk/utils.ts) 가 만드는 형식:
 //   { type:"message", role:"user", content:[{type:"input_text", text}] }
 //   { type:"message", role:"assistant", content:[{type:"output_text", text}] }

package/bundle/src/utils/providers/common/model-cost.ts

@@ -4,7 +4,7 @@
  * claude code 와 동일 패턴: 클라이언트에서 가격 테이블로 직접 계산.
  * 가격 단위: USD per 1M tokens.
  *
- * OpenAI 모델 목록: codex app-server model/list RPC 로 실측 (2026-05-18)
+ * OpenAI 모델 목록은 OpenAI 모델 문서와 현재 지원 목록을 기준으로 관리한다.
  *
  * @see https://platform.openai.com/docs/pricing
  * @see https://platform.claude.com/docs/en/about-claude/pricing
@@ -30,7 +30,7 @@ export interface ModelCosts {
   };
 }
 
-// ── OpenAI — codex app-server 에서 사용 가능한 모델 ─────────────────
+// ── OpenAI ─────────────────────────────────────────────────────────
 //
 // 가격 출처: https://developers.openai.com/api/docs/models (2026-07-18 확인)
 // 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함
@@ -46,13 +46,8 @@ const LONG_CONTEXT_272K: NonNullable<ModelCosts["longContext"]> = {
 };
 
 const OPENAI_COSTS: Record<string, ModelCosts> = {
-  // GPT-5.6 Sol, Terra, Luna. OpenAI native API 는 1.05M context / 128K max output 이지만,
-  // qgrid 의 codex app-server 경로는 context_window=372K (max_context_window 도 372K,
-  // effective 95% ≈ 353K) 로 제한된다 — codex 0.144.1 models_cache 실측 (2026-07-10).
-  // cache write 는 uncached input 의 1.25x 로 과금되지만, codex app-server usage
-  // (TokenUsageBreakdown) 에 cache write 토큰 필드가 없어 현재 OpenAI 실행 경로의
-  // cost 계산에서는 항상 0 으로 잡힌다 → 그만큼 과소집계. 단가는 외부 logger/manual
-  // usage 입력과 향후 프로토콜 확장을 위해 유지한다.
+  // GPT-5.6 Sol, Terra, Luna. cache write 단가는 외부 logger/manual usage 입력을 위해
+  // 유지한다. 현재 OpenAI 응답 usage 에 cache write 토큰 필드가 없으면 비용은 0으로 계산된다.
   // @see https://developers.openai.com/api/docs/models/gpt-5.6-sol
   // @see https://developers.openai.com/api/docs/models/gpt-5.6-terra
   // @see https://developers.openai.com/api/docs/models/gpt-5.6-luna

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

@@ -5,12 +5,9 @@
  */
 
 import { type ImageGenerationOptions } from "../../../application/qgrid/qgrid.types";
-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";
+import { type JsonValue, type TokenUsageBreakdown, type UserInput } from "./provider-types";
 
-// qgrid provider 내부 표준 usage. codex-protocol 의 TokenUsageBreakdown 은 생성 파일이므로
-// provider 전용 cache write 세부 필드는 여기서 확장해 보존한다.
+// qgrid provider 내부 표준 usage. provider 전용 cache write 세부 필드는 여기서 확장해 보존한다.
 export type ProviderTokenUsageBreakdown = TokenUsageBreakdown & {
   cacheCreationInputTokens?: number;
   cacheCreationInputTokens5m?: number;
@@ -25,7 +22,7 @@ export interface ReuseThreadCoord {
   epoch: number;
 }
 
-// provider-무관 이미지 결과. OpenAI(codex) 경로에서만 채워지며, 상위(qgrid.dispatcher)가
+// provider-무관 이미지 결과. OpenAI 경로에서만 채워지며, 상위(qgrid.dispatcher)가
 // content 파트로 전파한다. Anthropic 경로는 이 필드를 채우지 않는다.
 export interface GeneratedImage {
   data: string; // base64 PNG
@@ -55,19 +52,24 @@ export interface GenerateRequest {
   verbosity?: string;
   reasoningSummary?: string;
   serviceTier?: string;
-  // provider 실행 제한(ms). 현재 Anthropic Claude session 타이머가 사용한다.
+  // provider 실행 제한(ms). Queue selection 이후의 active provider request 전체에 적용한다.
   timeoutMs?: number;
   abortSignal?: AbortSignal;
   // 첫 turn / 재사용 폴백 시 보낼 input — 전체 prompt. 항상 설정.
   coldInput: Array<UserInput>;
   // 첫 turn / 폴백 시 inject 할 전체 history.
   coldHistory?: Array<JsonValue>;
+  // Provider-neutral cache affinity hints. Direct OpenAI currently receives these while still
+  // replaying coldInput + coldHistory on every turn; a dispatcher may use them for token choice
+  // and prompt-cache routing without relying on a process-local worker/thread.
+  promptCacheKey?: string;
+  preferredTokenId?: number;
   // 재사용 좌표 + delta input. 둘은 한 쌍 — 검증 통과 시에만 설정한다.
   // dispatcher 가 worker/thread 생존을 재검증해 성공하면 reuseInput(delta)을, 실패하면
   // coldInput + coldHistory 로 폴백한다(전체 history 로 문맥 복구).
   reuse?: ReuseThreadCoord;
   reuseInput?: Array<UserInput>;
-  // codex 내장 image_generation tool 을 켠다(OpenAI 경로 전용, opt-in).
+  // OpenAI image_generation tool 을 켠다(OpenAI 경로 전용, opt-in).
   // 이 플래그가 있으면 dispatcher 는 항상 cold thread 로 실행하고 재사용 라우팅을 건너뛴다.
   imageGeneration?: boolean;
   imageGenerationOptions?: ImageGenerationOptions;

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

@@ -0,0 +1,48 @@
+export type JsonValue =
+  | number
+  | string
+  | boolean
+  | JsonValue[]
+  | { [key: string]: JsonValue | undefined }
+  | null;
+
+export type UserInput =
+  | { type: "text"; text: string; text_elements: TextElement[] }
+  | { type: "image"; url: string }
+  | { type: "localImage"; path: string }
+  | { type: "skill"; name: string; path: string }
+  | { type: "mention"; name: string; path: string };
+
+export type TextElement = {
+  byteRange: { start: number; end: number };
+  placeholder: string | null;
+};
+
+export type TokenUsageBreakdown = {
+  totalTokens: number;
+  inputTokens: number;
+  cachedInputTokens: number;
+  outputTokens: number;
+  reasoningOutputTokens: number;
+};
+
+export type QuotaRateLimitWindow = {
+  usedPercent: number;
+  windowDurationMins: number | null;
+  resetsAt: number | null;
+};
+
+export type QuotaRateLimitSnapshot = {
+  limitId: string | null;
+  limitName: string | null;
+  primary: QuotaRateLimitWindow | null;
+  secondary: QuotaRateLimitWindow | null;
+  credits: JsonValue;
+  planType: string | null;
+  rateLimitReachedType: string | null;
+};
+
+export type QuotaRateLimits = {
+  rateLimits: QuotaRateLimitSnapshot;
+  rateLimitsByLimitId: { [key: string]: QuotaRateLimitSnapshot | undefined } | null;
+};

package/bundle/src/utils/providers/common/schema-validation.ts

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 
-import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
+import { type JsonValue } from "./provider-types";
 
 /**
  * Caller-provided schemas are serialized, copied, and recursively normalized before dispatch.

package/bundle/src/utils/providers/openai/openai-backend-protocol.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  buildCodexIdentityHeaders,
+  buildOpenAIResponsesRequest,
+  codexCliUserAgent,
+  normalizeOpenAIEvent,
+} from "./openai-backend-protocol";
+
+describe("OpenAI Codex backend protocol", () => {
+  it("preserves raw history and pins Responses controls", () => {
+    const history = [{ type: "message", role: "user", content: [{ type: "input_text", text: "hi" }] }];
+    const request = buildOpenAIResponsesRequest({
+      model: "gpt-5.2-codex",
+      history,
+      reasoning: { effort: "high", summary: "auto" },
+      verbosity: "low",
+      serviceTier: "priority",
+      promptCacheKey: "thread-1",
+      outputSchema: { schema: { type: "object", additionalProperties: false } },
+      imageGeneration: true,
+    });
+
+    expect(request).toEqual({
+      model: "gpt-5.2-codex",
+      input: history,
+      tools: [{ type: "image_generation" }],
+      tool_choice: "auto",
+      parallel_tool_calls: true,
+      reasoning: { effort: "high", summary: "auto" },
+      store: false,
+      stream: true,
+      include: ["reasoning.encrypted_content"],
+      service_tier: "priority",
+      prompt_cache_key: "thread-1",
+      text: {
+        verbosity: "low",
+        format: {
+          type: "json_schema",
+          strict: true,
+          schema: { type: "object", additionalProperties: false },
+          name: "codex_output_schema",
+        },
+      },
+    });
+    expect(request.input[0]).toBe(history[0]);
+  });
+
+  it("matches the pinned Codex user-agent shape with injected platform data", () => {
+    expect(
+      codexCliUserAgent({
+        osType: "Mac OS",
+        osVersion: "15.4.1",
+        architecture: "arm64",
+        terminal: "vscode/1.99.0",
+      }),
+    ).toBe("codex_cli_rs/0.147.0 (Mac OS 15.4.1; arm64) vscode/1.99.0");
+  });
+
+  it("builds ChatGPT and Codex CLI identity headers", () => {
+    const headers = buildCodexIdentityHeaders("token", "acct", {
+      sessionId: "session",
+      threadId: "thread",
+      clientRequestId: "request",
+    });
+    expect(headers).toEqual({
+      Accept: "text/event-stream",
+      Authorization: "Bearer token",
+      "ChatGPT-Account-ID": "acct",
+      "Content-Type": "application/json",
+      originator: "codex_cli_rs",
+      "User-Agent": expect.stringMatching(/^codex_cli_rs\/0\.147\.0 \(.+; .+\) .+$/),
+      "session-id": "session",
+      "thread-id": "thread",
+      "x-client-request-id": "request",
+    });
+  });
+
+  it("normalizes usage and generated images", () => {
+    expect(
+      normalizeOpenAIEvent({
+        type: "response.completed",
+        response: {
+          id: "r1",
+          usage: {
+            input_tokens: 4,
+            input_tokens_details: { cached_tokens: 2 },
+            output_tokens: 3,
+            output_tokens_details: { reasoning_tokens: 1 },
+            total_tokens: 7,
+          },
+        },
+      }),
+    ).toEqual({
+      type: "completed",
+      responseId: "r1",
+      usage: { inputTokens: 4, cachedInputTokens: 2, outputTokens: 3, reasoningTokens: 1, totalTokens: 7 },
+    });
+    expect(
+      normalizeOpenAIEvent({
+        type: "response.output_item.done",
+        item: { type: "image_generation_call", id: "img", result: "aGVsbG8=", revised_prompt: "better" },
+      }),
+    ).toEqual({ type: "image", id: "img", base64: "aGVsbG8=", mimeType: "image/png", revisedPrompt: "better" });
+  });
+});