@cartanova/qgrid-cli 2.7.0 → 2.7.2

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" });
+  });
+});

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

@@ -0,0 +1,255 @@
+import os from "node:os";
+
+export const CHATGPT_CODEX_RESPONSES_URL =
+  "https://chatgpt.com/backend-api/codex/responses" as const;
+
+export const CODEX_CLI_ORIGINATOR = "codex_cli_rs" as const;
+export const CODEX_CLI_VERSION = "0.147.0" as const;
+
+export interface CodexUserAgentPlatform {
+  osType: string;
+  osVersion: string;
+  architecture: string;
+  terminal: string;
+}
+
+function codexPlatform(): CodexUserAgentPlatform {
+  const names: Partial<Record<NodeJS.Platform, string>> = {
+    darwin: "Mac OS",
+    linux: "Linux",
+    win32: "Windows",
+  };
+  const terminal = process.env.TERM_PROGRAM;
+  const terminalVersion = process.env.TERM_PROGRAM_VERSION;
+  return {
+    osType: names[process.platform] ?? process.platform,
+    osVersion: os.release(),
+    architecture: process.arch,
+    terminal: terminal ? `${terminal}${terminalVersion ? `/${terminalVersion}` : ""}` : "unknown",
+  };
+}
+
+/** Matches the platform/terminal suffix emitted by the pinned Rust Codex CLI. */
+export function codexCliUserAgent(platform: CodexUserAgentPlatform = codexPlatform()): string {
+  return `codex_cli_rs/${CODEX_CLI_VERSION} (${platform.osType} ${platform.osVersion}; ${platform.architecture}) ${platform.terminal}`;
+}
+
+export type JsonValue =
+  | null
+  | boolean
+  | number
+  | string
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+/** Raw Responses API items. Keeping these opaque preserves the complete conversation history. */
+export type OpenAIResponseItem = Record<string, unknown>;
+
+export interface OpenAIOutputSchema {
+  name?: string;
+  schema: JsonValue;
+}
+
+export interface OpenAIResponsesOptions {
+  model: string;
+  instructions?: string;
+  history: readonly OpenAIResponseItem[];
+  tools?: readonly OpenAIResponseItem[];
+  toolChoice?: string | OpenAIResponseItem;
+  parallelToolCalls?: boolean;
+  reasoning?: {
+    effort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    summary?: "auto" | "concise" | "detailed";
+  };
+  verbosity?: "low" | "medium" | "high";
+  serviceTier?: string;
+  promptCacheKey?: string;
+  outputSchema?: OpenAIOutputSchema;
+  imageGeneration?: boolean | OpenAIResponseItem;
+}
+
+export interface OpenAIResponsesRequest {
+  model: string;
+  instructions?: string;
+  input: OpenAIResponseItem[];
+  tools?: OpenAIResponseItem[];
+  tool_choice: string | OpenAIResponseItem;
+  parallel_tool_calls: boolean;
+  reasoning: OpenAIResponsesOptions["reasoning"] | null;
+  store: false;
+  stream: true;
+  include: string[];
+  service_tier?: string;
+  prompt_cache_key?: string;
+  text?: {
+    verbosity?: "low" | "medium" | "high";
+    format?: {
+      type: "json_schema";
+      strict: true;
+      schema: JsonValue;
+      name: string;
+    };
+  };
+}
+
+export function buildOpenAIResponsesRequest(
+  options: OpenAIResponsesOptions,
+): OpenAIResponsesRequest {
+  const tools = options.tools ? [...options.tools] : [];
+  if (options.imageGeneration) {
+    tools.push(
+      options.imageGeneration === true
+        ? { type: "image_generation" }
+        : { type: "image_generation", ...options.imageGeneration },
+    );
+  }
+
+  const text =
+    options.verbosity || options.outputSchema
+      ? {
+          ...(options.verbosity ? { verbosity: options.verbosity } : {}),
+          ...(options.outputSchema
+            ? {
+                format: {
+                  type: "json_schema" as const,
+                  strict: true as const,
+                  schema: options.outputSchema.schema,
+                  name: options.outputSchema.name ?? "codex_output_schema",
+                },
+              }
+            : {}),
+        }
+      : undefined;
+
+  return {
+    model: options.model,
+    ...(options.instructions ? { instructions: options.instructions } : {}),
+    // Copy the array, not its items: raw items must arrive byte-for-byte equivalent.
+    input: [...options.history],
+    ...(tools.length ? { tools } : {}),
+    tool_choice: options.toolChoice ?? "auto",
+    parallel_tool_calls: options.parallelToolCalls ?? true,
+    reasoning: options.reasoning ?? null,
+    store: false,
+    stream: true,
+    include: ["reasoning.encrypted_content"],
+    ...(options.serviceTier ? { service_tier: options.serviceTier } : {}),
+    ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),
+    ...(text ? { text } : {}),
+  };
+}
+
+export function buildCodexIdentityHeaders(
+  accessToken: string,
+  accountId: string,
+  correlation?: { sessionId?: string; threadId?: string; clientRequestId?: string },
+): Record<string, string> {
+  return {
+    Accept: "text/event-stream",
+    Authorization: `Bearer ${accessToken}`,
+    "ChatGPT-Account-ID": accountId,
+    "Content-Type": "application/json",
+    originator: CODEX_CLI_ORIGINATOR,
+    "User-Agent": codexCliUserAgent(),
+    ...(correlation?.sessionId ? { "session-id": correlation.sessionId } : {}),
+    ...(correlation?.threadId ? { "thread-id": correlation.threadId } : {}),
+    ...(correlation?.clientRequestId ? { "x-client-request-id": correlation.clientRequestId } : {}),
+  };
+}
+
+export interface OpenAIUsage {
+  inputTokens: number;
+  cachedInputTokens: number;
+  outputTokens: number;
+  reasoningTokens: number;
+  totalTokens: number;
+}
+
+export type OpenAINormalizedEvent =
+  | { type: "created"; responseId?: string }
+  | { type: "text-delta"; text: string }
+  | { type: "image"; id?: string; base64: string; mimeType: "image/png"; revisedPrompt?: string }
+  | { type: "output-item"; item: OpenAIResponseItem }
+  | { type: "completed"; responseId: string; usage?: OpenAIUsage; model?: string }
+  | { type: "error"; error: OpenAIProtocolError };
+
+export class OpenAIProtocolError extends Error {
+  constructor(
+    message: string,
+    public readonly code?: string,
+    public readonly status?: number,
+    public readonly retryAfterMs?: number,
+  ) {
+    super(message);
+    this.name = "OpenAIProtocolError";
+  }
+}
+
+function usageFrom(value: unknown): OpenAIUsage | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const usage = value as Record<string, unknown>;
+  const inputDetails = (usage.input_tokens_details ?? {}) as Record<string, unknown>;
+  const outputDetails = (usage.output_tokens_details ?? {}) as Record<string, unknown>;
+  return {
+    inputTokens: Number(usage.input_tokens ?? 0),
+    cachedInputTokens: Number(inputDetails.cached_tokens ?? 0),
+    outputTokens: Number(usage.output_tokens ?? 0),
+    reasoningTokens: Number(outputDetails.reasoning_tokens ?? 0),
+    totalTokens: Number(usage.total_tokens ?? 0),
+  };
+}
+
+export function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | undefined {
+  if (!raw || typeof raw !== "object") return undefined;
+  const event = raw as Record<string, unknown>;
+  const type = String(event.type ?? "");
+  if (type === "response.created") {
+    const response = event.response as Record<string, unknown> | undefined;
+    return { type: "created", ...(response?.id ? { responseId: String(response.id) } : {}) };
+  }
+  if (type === "response.output_text.delta" && typeof event.delta === "string") {
+    return { type: "text-delta", text: event.delta };
+  }
+  if (
+    (type === "response.output_item.added" || type === "response.output_item.done") &&
+    event.item &&
+    typeof event.item === "object"
+  ) {
+    const item = event.item as OpenAIResponseItem;
+    if (item.type === "image_generation_call" && typeof item.result === "string") {
+      return {
+        type: "image",
+        ...(typeof item.id === "string" ? { id: item.id } : {}),
+        base64: item.result,
+        mimeType: "image/png",
+        ...(typeof item.revised_prompt === "string"
+          ? { revisedPrompt: item.revised_prompt }
+          : typeof item.revisedPrompt === "string"
+            ? { revisedPrompt: item.revisedPrompt }
+            : {}),
+      };
+    }
+    return { type: "output-item", item };
+  }
+  if (type === "response.completed") {
+    const response = (event.response ?? {}) as Record<string, unknown>;
+    return {
+      type: "completed",
+      responseId: String(response.id ?? ""),
+      ...(response.usage ? { usage: usageFrom(response.usage) } : {}),
+      ...(typeof response.model === "string" ? { model: response.model } : {}),
+    };
+  }
+  if (type === "error" || type === "response.failed" || type === "response.incomplete") {
+    const source = (event.error ?? event.response ?? event) as Record<string, unknown>;
+    const nested = (source.error ?? source) as Record<string, unknown>;
+    return {
+      type: "error",
+      error: new OpenAIProtocolError(
+        String(nested.message ?? `OpenAI stream ended with ${type}`),
+        typeof nested.code === "string" ? nested.code : undefined,
+      ),
+    };
+  }
+  return undefined;
+}

package/bundle/src/utils/providers/openai/openai-constants.ts

@@ -1,5 +1,7 @@
 export const OPENAI_ISSUER = "https://auth.openai.com";
 export const OPENAI_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+export const OPENAI_AUTHORIZE_URL = `${OPENAI_ISSUER}/oauth/authorize`;
 export const OPENAI_TOKEN_URL = `${OPENAI_ISSUER}/oauth/token`;
 export const OPENAI_SCOPES =
   "openid profile email offline_access api.connectors.read api.connectors.invoke";
+export const OPENAI_ORIGINATOR = "codex_cli_rs";