@cartanova/qgrid-cli 2.9.0 → 2.9.2

package/bundle/src/utils/providers/common/effort.ts

@@ -0,0 +1,53 @@
+import { getLogger } from "@logtape/logtape";
+
+import { openaiModelMaxEffort } from "./model-cost";
+
+const logger = getLogger(["qgrid", "effort"]);
+
+/**
+ * provider 별 reasoning effort 어휘.
+ *
+ * SDK 가 보낸 effort 문자열을 그대로 provider 에 넘기지 않는다. provider 마다 받는 값이 다르고,
+ * 모르는 값을 받았을 때의 반응도 다르다(Codex 백엔드는 400 이 예상되고, Claude Code 는 경고만
+ * 남기고 모델 기본 effort 로 실행한다). 각 provider dispatcher 가 요청을 만들 때 여기서 판정해,
+ * 맞지 않는 값은 오류 없이 버리고 "미지정" 과 같게 취급한다.
+ */
+
+// Codex 구독 백엔드 모델 카탈로그(~/.codex/models_cache.json) 의 supported_reasoning_levels 합집합.
+// 공개 OpenAI API 의 `none`/`minimal` 은 이 경로에 없다. 모델별 상한은 model-cost.ts 의 카탈로그에 있다.
+export const OPENAI_EFFORTS = ["low", "medium", "high", "xhigh", "max", "ultra"] as const;
+export type OpenAIEffort = (typeof OPENAI_EFFORTS)[number];
+
+// Claude Code `--effort` 허용값. 모델별 상한(xhigh_effort / max_effort capability)은 Claude Code 가
+// 스스로 처리하므로 qgrid 는 provider 집합만 검사한다.
+export const ANTHROPIC_EFFORTS = ["low", "medium", "high", "xhigh", "max"] as const;
+export type AnthropicEffort = (typeof ANTHROPIC_EFFORTS)[number];
+
+// 어휘 안에 있고 상한(있다면) 이하인 값만 통과시킨다. 나머지는 debug 로그 후 미지정.
+function resolveWithin<T extends string>(
+  levels: readonly T[],
+  effort: string | undefined,
+  max: T | undefined,
+  target: string,
+): T | undefined {
+  if (effort === undefined) return undefined;
+  const rank = levels.indexOf(effort as T);
+  if (rank < 0) {
+    logger.debug(`ignoring effort "${effort}" for ${target}: not in ${levels.join("/")}`);
+    return undefined;
+  }
+  if (max !== undefined && rank > levels.indexOf(max)) {
+    logger.debug(`ignoring effort "${effort}" for ${target}: model supports up to "${max}"`);
+    return undefined;
+  }
+  return effort as T;
+}
+
+/** canonical OpenAI model(`openai/` prefix 제거 후) 기준으로 effort 를 판정한다. */
+export function resolveOpenAIEffort(model: string, effort?: string): OpenAIEffort | undefined {
+  return resolveWithin(OPENAI_EFFORTS, effort, openaiModelMaxEffort(model), `openai/${model}`);
+}
+
+export function resolveAnthropicEffort(effort?: string): AnthropicEffort | undefined {
+  return resolveWithin(ANTHROPIC_EFFORTS, effort, undefined, "anthropic");
+}

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

@@ -10,6 +10,8 @@
  * @see https://platform.claude.com/docs/en/about-claude/pricing
  */
 
+import { type OpenAIEffort } from "./effort";
+
 export interface ModelCosts {
   inputTokens: number;
   outputTokens: number;
@@ -45,13 +47,19 @@ const LONG_CONTEXT_272K: NonNullable<ModelCosts["longContext"]> = {
   outputMultiplier: 1.5,
 };
 
-const OPENAI_COSTS: Record<string, ModelCosts> = {
+// OpenAI 모델 카탈로그. 단가와 함께 Codex 백엔드가 모델별로 받는 최대 reasoning effort 를 한 곳에 둔다.
+// maxEffort 출처: ~/.codex/models_cache.json 의 supported_reasoning_levels (2026-09-02 확인).
+// 미기재 모델은 xhigh 까지만 받는다.
+type OpenAIModelSpec = ModelCosts & { maxEffort?: OpenAIEffort };
+
+const OPENAI_COSTS: Record<string, OpenAIModelSpec> = {
   // 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
   "gpt-5.6-sol": {
+    maxEffort: "ultra",
     inputTokens: 5,
     outputTokens: 30,
     cachedInputTokens: 0.5,
@@ -59,6 +67,7 @@ const OPENAI_COSTS: Record<string, ModelCosts> = {
     longContext: LONG_CONTEXT_272K,
   },
   "gpt-5.6-terra": {
+    maxEffort: "ultra",
     inputTokens: 2.5,
     outputTokens: 15,
     cachedInputTokens: 0.25,
@@ -66,6 +75,7 @@ const OPENAI_COSTS: Record<string, ModelCosts> = {
     longContext: LONG_CONTEXT_272K,
   },
   "gpt-5.6-luna": {
+    maxEffort: "max",
     inputTokens: 1,
     outputTokens: 6,
     cachedInputTokens: 0.1,
@@ -148,6 +158,11 @@ const ANTHROPIC_COSTS: Record<string, ModelCosts> = {
 // @see https://help.openai.com/en/articles/20001106-codex-rate-card
 const DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };
 
+/** Codex 백엔드가 이 모델에 허용하는 최대 effort. 카탈로그에 없는 모델은 xhigh 까지다. */
+export function openaiModelMaxEffort(model: string): OpenAIEffort {
+  return OPENAI_COSTS[model]?.maxEffort ?? "xhigh";
+}
+
 export function getModelCosts(model: string): ModelCosts {
   const normalizedModel = (model.split("/").pop() ?? model).replace(/\[1m\]$/i, "");
   return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;

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

@@ -1,5 +1,7 @@
 import os from "node:os";
 
+import { type OpenAIEffort } from "../common/effort";
+
 export const CHATGPT_CODEX_RESPONSES_URL =
   "https://chatgpt.com/backend-api/codex/responses" as const;
 
@@ -58,7 +60,7 @@ export interface OpenAIResponsesOptions {
   toolChoice?: string | OpenAIResponseItem;
   parallelToolCalls?: boolean;
   reasoning?: {
-    effort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+    effort?: OpenAIEffort;
     summary?: "auto" | "concise" | "detailed";
   };
   verbosity?: "low" | "medium" | "high";

package/bundle/src/utils/providers/openai/openai-dispatcher.test.ts

@@ -416,3 +416,23 @@ describe("OpenAIDispatcher direct runtime", () => {
     await expect(blocked.generate(request())).rejects.toThrow("NO_OPENAI_WORKERS");
   });
 });
+
+describe("effort 어휘 해석 (Codex 카탈로그 기준)", () => {
+  async function mappedEffortFor(model: string, effort: string): Promise<unknown> {
+    let mapped: OpenAIResponsesOptions | undefined;
+    const d = dispatcher((options) => {
+      mapped = options;
+      return events({ type: "completed", responseId: "r1" });
+    });
+    await d.onTokenAdded(7, "primary", credentials, null, 1);
+    await d.generate(request({ model, effort }));
+    return mapped?.reasoning?.effort;
+  }
+
+  it("모델이 지원하는 값은 그대로 보내고, 상한 초과·공개 API 어휘는 reasoning 에서 빼 백엔드 기본값을 쓴다", async () => {
+    await expect(mappedEffortFor("gpt-5.6-terra", "ultra")).resolves.toBe("ultra");
+    await expect(mappedEffortFor("gpt-5.5", "xhigh")).resolves.toBe("xhigh");
+    await expect(mappedEffortFor("gpt-5.5", "max")).resolves.toBeUndefined();
+    await expect(mappedEffortFor("gpt-5.6-terra", "minimal")).resolves.toBeUndefined();
+  });
+});

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

@@ -3,6 +3,7 @@ import { getLogger } from "@logtape/logtape";
 import { QuotaThresholdExceededError } from "../../../application/qgrid/qgrid.types";
 import { TokenModel } from "../../../application/token/token.model";
 import { type OpenAICredentials } from "../../../application/token/token.types";
+import { resolveOpenAIEffort } from "../common/effort";
 import {
   type GenerateRequest,
   type GenerateResult,
@@ -97,11 +98,11 @@ function inputItems(req: GenerateRequest): OpenAIResponseItem[] {
 function asReasoning(req: GenerateRequest): OpenAIResponsesOptions["reasoning"] | undefined {
   const summary =
     req.reasoningSummary && req.reasoningSummary !== "none" ? req.reasoningSummary : undefined;
-  if (!req.effort && !summary) return undefined;
+  // Codex 어휘·모델 상한 밖의 effort 는 여기서 조용히 버린다(백엔드 기본값 적용).
+  const effort = resolveOpenAIEffort(req.model ?? "", req.effort);
+  if (!effort && !summary) return undefined;
   return {
-    ...(req.effort
-      ? { effort: req.effort as NonNullable<OpenAIResponsesOptions["reasoning"]>["effort"] }
-      : {}),
+    ...(effort ? { effort } : {}),
     ...(summary
       ? {
           summary: summary as NonNullable<OpenAIResponsesOptions["reasoning"]>["summary"],