@cartanova/qgrid-cli 2.10.10 → 2.11.1

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

@@ -8,11 +8,20 @@
  * The only executable user line is the current input.
  */
 
+import { z } from "zod";
+
 import {
   type ModelFallback,
   type ProviderTokenUsageBreakdown,
 } from "../common/provider-dispatcher";
-import { type JsonValue, type UserInput } from "../common/provider-types";
+import {
+  isJsonObject,
+  type JsonObject,
+  jsonNumber,
+  jsonString,
+  type JsonValue,
+  type UserInput,
+} from "../common/provider-types";
 import { stripFences } from "./fence-strip";
 
 // ── 입력 어댑터 ────────────────────────────────────────────────────
@@ -27,10 +36,7 @@ export interface ClaudeStreamJsonLine {
 }
 
 function userInputToText(input: Array<UserInput>): string {
-  return input
-    .filter((i): i is Extract<UserInput, { type: "text" }> => i.type === "text")
-    .map((i) => i.text)
-    .join("\n");
+  return input.flatMap((i) => (i.type === "text" ? [i.text] : [])).join("\n");
 }
 
 function textBlock(text: string): Array<{ type: "text"; text: string }> {
@@ -43,19 +49,22 @@ function textBlock(text: string): Array<{ type: "text"; text: string }> {
 //   { type:"message", role:"assistant", content:[{type:"output_text", text}] }
 //   { type:"function_call", name, arguments, call_id }
 //   { type:"function_call_output", call_id, output }
-type ResponseItem = { [key: string]: JsonValue | undefined };
+type ResponseItem = JsonObject;
 
 function asObject(v: JsonValue | undefined): ResponseItem | null {
-  return typeof v === "object" && v !== null && !Array.isArray(v) ? (v as ResponseItem) : null;
+  return isJsonObject(v) ? v : null;
 }
 
 function responseItemText(item: ResponseItem): string {
   const content = item.content;
+
   if (!Array.isArray(content)) return "";
+
   return content
     .map((c) => {
       const obj = asObject(c);
-      return obj && typeof obj.text === "string" ? obj.text : "";
+
+      return (obj && jsonString(obj.text)) ?? "";
     })
     .filter(Boolean)
     .join("\n");
@@ -63,8 +72,10 @@ function responseItemText(item: ResponseItem): string {
 
 function flattenColdHistory(coldHistory: Array<JsonValue>): string {
   const parts: Array<string> = [];
+
   for (const raw of coldHistory) {
     const item = asObject(raw);
+
     if (!item) continue;
 
     if (item.type === "message" && item.role === "assistant") {
@@ -72,16 +83,17 @@ function flattenColdHistory(coldHistory: Array<JsonValue>): string {
     } else if (item.type === "message" && item.role === "user") {
       parts.push(`User: ${responseItemText(item)}`);
     } else if (item.type === "function_call") {
-      const name = typeof item.name === "string" ? item.name : "";
-      const args =
-        typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {});
+      const name = jsonString(item.name) ?? "";
+      const args = jsonString(item.arguments) ?? JSON.stringify(item.arguments ?? {});
+
       parts.push(`Tool call: ${name}(${args})`);
     } else if (item.type === "function_call_output") {
-      const output =
-        typeof item.output === "string" ? item.output : JSON.stringify(item.output ?? "");
+      const output = jsonString(item.output) ?? JSON.stringify(item.output ?? "");
+
       parts.push(`Tool result: ${output}`);
     }
   }
+
   return parts.join("\n");
 }
 
@@ -93,6 +105,7 @@ export function buildStreamJsonInput(opts: {
 
   if (opts.coldHistory && opts.coldHistory.length > 0) {
     const flattened = flattenColdHistory(opts.coldHistory);
+
     if (flattened) {
       lines.push({
         type: "assistant",
@@ -120,20 +133,21 @@ export function serializeStreamJsonInput(lines: Array<ClaudeStreamJsonLine>): st
 //
 // Claude stdout(JSONL)을 qgrid deltas + final result 로 변환한다.
 
-interface ClaudeUsage {
-  input_tokens?: number;
-  output_tokens?: number;
-  cache_creation_input_tokens?: number;
-  cache_read_input_tokens?: number;
-  cache_creation?: {
-    ephemeral_5m_input_tokens?: number;
-    ephemeral_1h_input_tokens?: number;
-  };
-  iterations?: Array<{
-    type?: string;
-    model?: string;
-  }>;
-}
+// Usage fields are read only when they hold numbers; anything else counts as absent.
+const optionalCount = z.number().optional().catch(undefined);
+
+const ClaudeUsage = z.object({
+  input_tokens: optionalCount,
+  output_tokens: optionalCount,
+  cache_creation_input_tokens: optionalCount,
+  cache_read_input_tokens: optionalCount,
+  cache_creation: z
+    .object({ ephemeral_5m_input_tokens: optionalCount, ephemeral_1h_input_tokens: optionalCount })
+    .optional()
+    .catch(undefined),
+});
+
+type ClaudeUsage = z.infer<typeof ClaudeUsage>;
 
 export interface ClaudeStreamResult {
   text: string;
@@ -183,26 +197,34 @@ function toUsageBreakdown(u: ClaudeUsage): ProviderTokenUsageBreakdown {
   const totalInput = input + cacheCreate + cacheRead;
   const cacheCreate5m = u.cache_creation?.ephemeral_5m_input_tokens;
   const cacheCreate1h = u.cache_creation?.ephemeral_1h_input_tokens;
-  return {
+
+  const usage: ProviderTokenUsageBreakdown = {
     totalTokens: totalInput + output,
     inputTokens: totalInput,
     cachedInputTokens: cacheRead,
     cacheCreationInputTokens: cacheCreate,
-    ...(typeof cacheCreate5m === "number" ? { cacheCreationInputTokens5m: cacheCreate5m } : {}),
-    ...(typeof cacheCreate1h === "number" ? { cacheCreationInputTokens1h: cacheCreate1h } : {}),
     outputTokens: output,
     reasoningOutputTokens: 0,
   };
+
+  if (cacheCreate5m !== undefined) usage.cacheCreationInputTokens5m = cacheCreate5m;
+
+  if (cacheCreate1h !== undefined) usage.cacheCreationInputTokens1h = cacheCreate1h;
+
+  return usage;
 }
 
 function structuredOutputToolUseText(j: ResponseItem): string | undefined {
   const message = asObject(j.message);
   const content = message?.content;
+
   if (!Array.isArray(content)) return undefined;
 
   for (const raw of content) {
     const block = asObject(raw);
+
     if (!block) continue;
+
     if (
       block.type === "tool_use" &&
       block.name === "StructuredOutput" &&
@@ -211,37 +233,43 @@ function structuredOutputToolUseText(j: ResponseItem): string | undefined {
       return JSON.stringify(block.input);
     }
   }
+
   return undefined;
 }
 
 function canonicalEventModel(model: string): string {
   const withoutProvider = model.startsWith("anthropic/") ? model.slice("anthropic/".length) : model;
+
   return withoutProvider.replace(/\[1m\]$/, "");
 }
 
 function optionalString(value: JsonValue | undefined): string | undefined {
-  return typeof value === "string" && value.length > 0 ? value : undefined;
+  return jsonString(value) || undefined;
 }
 
 function recordFallback(state: ClaudeStreamJsonState | undefined, fallback: ModelFallback): void {
   if (!state) return;
+
   const normalized: ModelFallback = {
     ...fallback,
     fromModel: canonicalEventModel(fallback.fromModel),
     toModel: canonicalEventModel(fallback.toModel),
   };
+
   const existing = state.modelFallbacks?.find(
     (item) =>
       item.trigger === normalized.trigger &&
       item.fromModel === normalized.fromModel &&
       item.toModel === normalized.toModel,
   );
+
   if (existing) {
     existing.category ??= normalized.category;
     existing.explanation ??= normalized.explanation;
   } else {
     (state.modelFallbacks ??= []).push(normalized);
   }
+
   state.servedModel = normalized.toModel;
   state.refusalWithoutFallback = false;
 }
@@ -253,13 +281,17 @@ function updateRoutingFromUsage(
   if (!state || !usage || !Array.isArray(usage.iterations)) return;
 
   let previousModel: string | undefined;
+
   for (const raw of usage.iterations) {
     const iteration = asObject(raw);
+
     if (!iteration) continue;
     const model = optionalString(iteration.model);
     const type = optionalString(iteration.type);
+
     if (!model) continue;
     const canonicalModel = canonicalEventModel(model);
+
     if (type === "fallback_message" && previousModel) {
       recordFallback(state, {
         trigger: "refusal",
@@ -267,6 +299,7 @@ function updateRoutingFromUsage(
         toModel: canonicalModel,
       });
     }
+
     previousModel = canonicalModel;
     state.servedModel = canonicalModel;
   }
@@ -279,10 +312,13 @@ function updateRoutingFromMessage(
   if (!state || !message) return;
   const model = optionalString(message.model);
   const canonicalModel = model ? canonicalEventModel(model) : undefined;
+
   if (canonicalModel) state.servedModel = canonicalModel;
   const stopReason = optionalString(message.stop_reason);
+
   if (stopReason) {
     state.stopReason = stopReason;
+
     if (stopReason === "refusal") state.refusalWithoutFallback = true;
     else if (state.modelFallbacks?.some((fallback) => fallback.toModel === canonicalModel)) {
       state.refusalWithoutFallback = false;
@@ -290,12 +326,14 @@ function updateRoutingFromMessage(
   }
 
   const stopDetails = asObject(message.stop_details);
+
   if (stopDetails?.type === "refusal" || stopReason === "refusal") {
     state.refusal = {
       category: optionalString(stopDetails?.category),
       explanation: optionalString(stopDetails?.explanation),
     };
   }
+
   updateRoutingFromUsage(asObject(message.usage), state);
 }
 
@@ -308,49 +346,63 @@ export function handleStreamJsonLine(
   const structuredOutput = opts?.structuredOutput ?? false;
   const state = opts?.state;
   const trimmed = line.trim();
+
   if (!trimmed) return null;
 
-  let j: { [key: string]: JsonValue | undefined };
+  let parsed: JsonValue;
+
   try {
-    j = JSON.parse(trimmed) as { [key: string]: JsonValue | undefined };
+    // JSON.parse without a reviver yields only JSON values.
+    parsed = JSON.parse(trimmed);
   } catch {
     return null;
   }
 
+  // Every Claude stream-json line is an object; other JSON values carry no event.
+  const j = asObject(parsed) ?? {};
+
   if (j.type === "stream_event") {
     const event = asObject(j.event);
+
     if (event?.type === "message_start") {
       updateRoutingFromMessage(asObject(event.message), state);
     } else if (event?.type === "message_delta") {
       const delta = asObject(event.delta);
       const stopReason = optionalString(delta?.stop_reason);
+
       if (state && stopReason) {
         state.stopReason = stopReason;
+
         if (stopReason === "refusal") state.refusalWithoutFallback = true;
       }
     }
+
     if (event && event.type === "content_block_delta") {
       const delta = asObject(event.delta);
+
       if (delta) {
         if (structuredOutput) {
-          if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
-            onDelta(delta.partial_json);
-          }
+          const partialJson = jsonString(delta.partial_json);
+
+          if (delta.type === "input_json_delta" && partialJson !== undefined) onDelta(partialJson);
         } else {
-          if (delta.type === "text_delta" && typeof delta.text === "string") {
-            onDelta(delta.text);
-          }
+          const deltaText = jsonString(delta.text);
+
+          if (delta.type === "text_delta" && deltaText !== undefined) onDelta(deltaText);
         }
       }
     }
+
     return null;
   }
 
   if (j.type === "system") {
     const subtype = optionalString(j.subtype);
+
     if (subtype === "model_refusal_fallback") {
       const fromModel = optionalString(j.originalModel) ?? optionalString(j.original_model);
       const toModel = optionalString(j.fallbackModel) ?? optionalString(j.fallback_model);
+
       if (fromModel && toModel) {
         recordFallback(state, {
           trigger: "refusal",
@@ -370,6 +422,7 @@ export function handleStreamJsonLine(
       }
     } else if (subtype === "model_refusal_no_fallback" && state) {
       const originalModel = optionalString(j.originalModel) ?? optionalString(j.original_model);
+
       if (originalModel) state.servedModel = canonicalEventModel(originalModel);
       state.stopReason = "refusal";
       state.refusalWithoutFallback = true;
@@ -386,27 +439,34 @@ export function handleStreamJsonLine(
           optionalString(j.refusal_explanation),
       };
     }
+
     return null;
   }
 
   if (j.type === "assistant") {
     updateRoutingFromMessage(asObject(j.message), state);
+
     if (structuredOutput && state && state.structuredOutputText === undefined) {
       const text = structuredOutputToolUseText(j);
+
       if (text !== undefined) state.structuredOutputText = text;
     }
+
     return null;
   }
 
   if (j.type === "result") {
-    const subtype = typeof j.subtype === "string" ? j.subtype : undefined;
-    const terminalReason = typeof j.terminal_reason === "string" ? j.terminal_reason : undefined;
+    const subtype = jsonString(j.subtype);
+    const terminalReason = jsonString(j.terminal_reason);
+
     const resultSucceeded =
       j.is_error !== true &&
       terminalReason !== "model_error" &&
       (subtype === undefined || subtype === "success");
+
     let text: string;
     const preservedStructuredOutput = structuredOutput ? state?.structuredOutputText : undefined;
+
     // Claude Code는 StructuredOutput 스키마 검증 실패 후 내부 재시도를 할 수 있다. assistant
     // 이벤트의 첫 tool input은 거절된 시도일 수 있으므로, 성공 result가 제공한 최종 검증값을
     // 우선한다. 첫 입력 보존값은 max_turns/retry 초과처럼 성공 result가 없는 진단 경로용이다.
@@ -417,21 +477,26 @@ export function handleStreamJsonLine(
     } else if (j.structured_output !== undefined) {
       text = JSON.stringify(j.structured_output);
     } else {
-      text = stripFences(typeof j.result === "string" ? j.result : "");
+      text = stripFences(jsonString(j.result) ?? "");
     }
 
     const rawUsage = asObject(j.usage) ?? {};
     updateRoutingFromUsage(rawUsage, state);
     const resultModel = optionalString(j.model);
+
     if (state && resultModel && !state.servedModel) {
       state.servedModel = canonicalEventModel(resultModel);
     }
+
     const resultStopReason = optionalString(j.stop_reason);
+
     if (state && resultStopReason) {
       state.stopReason = resultStopReason;
+
       if (resultStopReason === "refusal") state.refusalWithoutFallback = true;
     }
-    const usage = toUsageBreakdown(rawUsage as ClaudeUsage);
+
+    const usage = toUsageBreakdown(ClaudeUsage.parse(rawUsage));
     const quotaExhausted = text.startsWith("You've hit");
 
     // SON-495: 비정상 종료(error_max_structured_output_retries 등)는 정직하게 에러로 처리한다.
@@ -450,8 +515,8 @@ export function handleStreamJsonLine(
     return {
       text,
       usage,
-      durationMs: typeof j.duration_ms === "number" ? j.duration_ms : 0,
-      costUsd: typeof j.total_cost_usd === "number" ? j.total_cost_usd : 0,
+      durationMs: jsonNumber(j.duration_ms) ?? 0,
+      costUsd: jsonNumber(j.total_cost_usd) ?? 0,
       quotaExhausted,
       isError,
       subtype,

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

@@ -13,7 +13,15 @@ export function getRefreshToken(creds: TokenCredentials): string | undefined {
 }
 
 export function getExpiresAt(creds: TokenCredentials): number {
+  // Grok credentials (authMode "oauth") store RFC 3339; an unparseable value reads as expired.
+  if ("authMode" in creds) {
+    const parsed = Date.parse(creds.expiresAt);
+
+    return Number.isNaN(parsed) ? 0 : parsed;
+  }
+
   if ("expiresAt" in creds) return creds.expiresAt;
+
   return creds.accessTokenExpiresAt;
 }
 

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

@@ -16,11 +16,13 @@ const logger = getLogger(["qgrid", "effort"]);
 // Codex 구독 백엔드 모델 카탈로그(~/.codex/models_cache.json) 의 supported_reasoning_levels 합집합.
 // Public effort options exclude none/minimal. thinking:false maps to wire-level none separately.
 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 로그 후 미지정.
@@ -31,16 +33,21 @@ function resolveWithin<T extends string>(
   target: string,
 ): T | undefined {
   if (effort === undefined) return undefined;
-  const rank = levels.indexOf(effort as T);
+  const rank = levels.findIndex((level) => level === effort);
+
   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;
+
+  return levels[rank];
 }
 
 /** canonical OpenAI model(`openai/` prefix 제거 후) 기준으로 effort 를 판정한다. */

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

@@ -1,6 +1,53 @@
 import { describe, expect, it } from "vitest";
 
-import { calculateCostUsd, getModelCosts } from "./model-cost";
+import {
+  calculateCostUsd,
+  getModelCosts,
+  grokImageCost,
+  grokReportedCost,
+  usdFromGrokTicks,
+} from "./model-cost";
+
+describe("Grok cost", () => {
+  it("converts provider ticks at 1e-10 USD", () => {
+    expect(usdFromGrokTicks(500_000_000)).toBe(0.05);
+    expect(usdFromGrokTicks(33_760_000)).toBeCloseTo(0.003376, 12);
+  });
+
+  it.each(["grok-4.7", "grok-4.6", "grok-4.5", "grok/grok-4.7"])(
+    "prices %s from the catalog ticks when the provider omitted the cost",
+    (model) => {
+      expect(getModelCosts(model)).toEqual({ inputTokens: 2, cachedInputTokens: 0.5, outputTokens: 6 });
+      // 1M input of which 400k cached, 100k output: 0.6*2 + 0.4*0.5 + 0.1*6.
+      expect(
+        calculateCostUsd(model, {
+          inputTokens: 1_000_000,
+          cachedInputTokens: 400_000,
+          outputTokens: 100_000,
+        }),
+      ).toBeCloseTo(2.0, 10);
+    },
+  );
+
+  it("prefers reported image ticks and falls back to the catalog per-image price", () => {
+    expect(grokImageCost("grok/grok-imagine-image-quality", 2, 700_000_000)).toEqual({
+      costUsd: 0.07,
+      costSource: "provider",
+      ticks: 700_000_000,
+    });
+    expect(grokImageCost("grok-imagine-image-quality", 2)).toEqual({
+      costUsd: 0.1,
+      costSource: "pricing_table",
+      ticks: 1_000_000_000,
+    });
+    expect(grokImageCost("grok-imagine-image-unknown", 1)).toBeUndefined();
+  });
+
+  it("reports video/voice cost only when xAI reported it", () => {
+    expect(grokReportedCost(undefined)).toBeUndefined();
+    expect(grokReportedCost(0)).toEqual({ costUsd: 0, costSource: "provider", ticks: 0 });
+  });
+});
 
 describe("calculateCostUsd", () => {
   it.each([