@cartanova/qgrid-cli 2.10.5 → 2.10.7

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

@@ -43,6 +43,7 @@ export const requestLogSubsetQueries = {
       image_cost_usd: "request_logs.image_cost_usd",
       image_cost_method: "request_logs.image_cost_method",
       effort: "request_logs.effort",
+      service_tier: "request_logs.service_tier",
       history: "request_logs.history",
       tools: "request_logs.tools",
       status: "request_logs.status",
@@ -75,6 +76,7 @@ export const requestLogSubsetQueries = {
       image_cost_usd: "request_logs.image_cost_usd",
       image_cost_method: "request_logs.image_cost_method",
       effort: "request_logs.effort",
+      service_tier: "request_logs.service_tier",
       status: "request_logs.status",
       response_json_ok: "request_logs.response_json_ok",
       tool_call_count: "request_logs.tool_call_count",

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

@@ -167,6 +167,7 @@ export const RequestLogBaseSchema = z.object({
   cost_source: z.string().max(20).nullable(),
   image_cost_usd: z.int().nullable(),
   image_cost_method: z.string().max(100).nullable(),
+  service_tier: z.string().max(20).nullable(),
   effort: z.string().max(10).nullable(),
   history: HistoryItems.nullable(),
   tools: ToolDefinitions.nullable(),
@@ -201,6 +202,7 @@ export type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {
     "cost_source",
     "image_cost_usd",
     "image_cost_method",
+    "service_tier",
     "effort",
     "history",
     "tools",
@@ -405,6 +407,7 @@ export const RequestLogSubsetA = z.object({
   image_cost_usd: z.int().nullable(),
   image_cost_method: z.string().max(100).nullable(),
   effort: z.string().max(10).nullable(),
+  service_tier: z.string().max(20).nullable(),
   history: HistoryItems.nullable(),
   tools: ToolDefinitions.nullable(),
   status: RequestLogStatus,
@@ -436,6 +439,7 @@ export const RequestLogSubsetP = z.object({
   image_cost_usd: z.int().nullable(),
   image_cost_method: z.string().max(100).nullable(),
   effort: z.string().max(10).nullable(),
+  service_tier: z.string().max(20).nullable(),
   status: RequestLogStatus,
   response_json_ok: z.boolean().nullable(),
   tool_call_count: z.int(),

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

@@ -230,8 +230,9 @@ const entityLabels = {
   "entity.RequestLog.ttft_ms": "first gen TTFT(ms)",
   "entity.RequestLog.cost_usd": "API 비용",
   "entity.RequestLog.cost_source": "비용 출처(provider/pricing_table/mixed)",
-  "entity.RequestLog.image_cost_usd": "이미지 생성 추정 비용",
-  "entity.RequestLog.image_cost_method": "이미지 비용 추정 방식",
+  "entity.RequestLog.image_cost_usd": "이미지 생성 비용",
+  "entity.RequestLog.image_cost_method": "이미지 비용 계산 방식",
+  "entity.RequestLog.service_tier": "Requested OpenAI service tier",
   "entity.RequestLog.effort": "effort level",
   "entity.RequestLog.history": "inject_items 히스토리",
   "entity.RequestLog.tools": "요청에 장착된 tool 정의 목록",

package/bundle/src/migrations/20261016155350_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.string("service_tier", 20).nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // rollback - add
+    table.dropColumns("service_tier");
+  });
+}

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

@@ -3,6 +3,34 @@ import { describe, expect, it } from "vitest";
 import { calculateCostUsd, getModelCosts } from "./model-cost";
 
 describe("calculateCostUsd", () => {
+  it.each([
+    ["gpt-6-astra", 2.6],
+    ["gpt-6.1-sol", 0.5],
+    ["gpt-6-sol", 0.52],
+    ["gpt-6-luna", 0.026],
+    ["gpt-5.6-sol", 1.04],
+    ["gpt-5.6-terra", 0.56],
+    ["gpt-5.6-luna", 0.056],
+  ])("prices %s fast input, cached input, cache writes and output", (model, expected) => {
+    expect(calculateCostUsd(`openai/${model}`, {
+      inputTokens: 160_000, cachedInputTokens: 100_000,
+      cacheCreationInputTokens: 40_000, outputTokens: 10_000,
+    }, "fast")).toBeCloseTo(expected, 10);
+  });
+
+  it("combines Fast API rates with long-context rates, not subscription usage multipliers", () => {
+    expect(calculateCostUsd("openai/gpt-6.1-sol", {
+      inputTokens: 300_000, cachedInputTokens: 200_000, outputTokens: 10_000,
+    }, "fast")).toBeCloseTo(1.18, 10);
+  });
+
+  it("keeps standard pricing for omitted/flex tiers and Anthropic", () => {
+    const usage = { inputTokens: 1_000, outputTokens: 1_000 };
+    expect(calculateCostUsd("gpt-6.1-sol", usage)).toBeCloseTo(0.012, 10);
+    expect(calculateCostUsd("gpt-6.1-sol", usage, "flex")).toBeCloseTo(0.012, 10);
+    expect(calculateCostUsd("claude-sonnet-5-5", usage, "fast")).toBeCloseTo(0.012, 10);
+  });
+
   it.each([
     [272_000, 2.77],
     [272_001, 5.51502],

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

@@ -237,6 +237,19 @@ export function getModelCosts(model: string): ModelCosts {
   return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;
 }
 
+// Verified Fast API rates for the currently served Codex models (2026-10-16).
+// Applies to all token categories and long context; not the 2.5x subscription quota multiplier.
+// https://developers.openai.com/api/docs/pricing
+const OPENAI_FAST_MULTIPLIERS: Record<string, number> = {
+  "gpt-6-astra": 2,
+  "gpt-6.1-sol": 2,
+  "gpt-6-sol": 2,
+  "gpt-6-luna": 2,
+  "gpt-5.6-sol": 2,
+  "gpt-5.6-terra": 2,
+  "gpt-5.6-luna": 2,
+};
+
 export function calculateCostUsd(
   model: string,
   usage: {
@@ -247,6 +260,7 @@ export function calculateCostUsd(
     cacheCreationInputTokens5m?: number;
     cacheCreationInputTokens1h?: number;
   },
+  serviceTier?: string,
 ): number {
   const costs = getModelCosts(model);
   const cachedInput = usage.cachedInputTokens ?? 0;
@@ -281,12 +295,15 @@ export function calculateCostUsd(
     (isLongContext ? lc.inputMultiplier : 1);
   const outputRate = costs.outputTokens * (isLongContext ? lc.outputMultiplier : 1);
 
-  return (
+  const standardCost =
     (nonCachedInput / 1_000_000) * inputRate +
     (usage.outputTokens / 1_000_000) * outputRate +
     (cachedInput / 1_000_000) * cachedRate +
     (unclassifiedCacheCreationInput / 1_000_000) * cacheCreationFallbackRate +
     (classifiedCacheCreationInput5m / 1_000_000) * cacheCreation5mRate +
-    (classifiedCacheCreationInput1h / 1_000_000) * cacheCreation1hRate
+    (classifiedCacheCreationInput1h / 1_000_000) * cacheCreation1hRate;
+  const normalizedModel = model.split("/").pop() ?? model;
+  return (
+    standardCost * (serviceTier === "fast" ? (OPENAI_FAST_MULTIPLIERS[normalizedModel] ?? 1) : 1)
   );
 }

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

@@ -27,7 +27,7 @@ describe("OpenAI Codex backend protocol", () => {
     } })).toMatchObject({ generation: { route: "codex-responses", size: "841x1870" } });
   });
   it("distinguishes partial function items from completed arguments", () => {
-    const item = { type: "function_call", call_id: "call", name: "generate_transparent_image", arguments: "{}" };
+    const item = { type: "function_call", call_id: "call", name: "generate_image", arguments: "{}" };
     expect(normalizeOpenAIEvent({ type: "response.output_item.added", item })).toEqual({ type: "output-item", item, completed: false });
     expect(normalizeOpenAIEvent({ type: "response.output_item.done", item })).toEqual({ type: "output-item", item, completed: true });
   });
@@ -149,4 +149,26 @@ describe("OpenAI Codex backend protocol", () => {
       }),
     ).toEqual({ type: "image", id: "img", base64: "aGVsbG8=", mimeType: "image/png", revisedPrompt: "better", generation: { route: "codex-responses" } });
   });
+
+  it("preserves zero image-tool usage without treating it as missing", () => {
+    const usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+    expect(normalizeOpenAIEvent({ type: "response.completed", response: {
+      id: "r", tool_usage: { image_gen: usage },
+    } })).toEqual({
+      type: "completed", responseId: "r",
+      imageGeneration: { route: "codex-responses", usage },
+    });
+  });
+
+  it.each([undefined, null, {}, { input_tokens: "4", output_tokens: 1, total_tokens: 5 }, { input_tokens: -1, output_tokens: 1, total_tokens: 0 }])(
+    "ignores missing or malformed image-tool usage: %j", (usage) => {
+      expect(normalizeOpenAIEvent({ type: "response.completed", response: {
+        id: "r", tool_usage: { image_gen: usage },
+        tools: [{ type: "image_generation", model: "gpt-image-2-codex", size: "auto", quality: "auto" }],
+      } })).toEqual({
+        type: "completed", responseId: "r",
+        imageGeneration: { route: "codex-responses", model: "gpt-image-2-codex" },
+      });
+    },
+  );
 });

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

@@ -1,6 +1,6 @@
 import os from "node:os";
 
-import { type ImageGenerationMetadata } from "../../../application/qgrid/qgrid.types";
+import { ImageGenerationMetadata } from "../../../application/qgrid/qgrid.types";
 import { type OpenAIEffort } from "../common/effort";
 
 export const CHATGPT_CODEX_RESPONSES_URL =
@@ -180,7 +180,13 @@ export type OpenAINormalizedEvent =
       generation?: ImageGenerationMetadata;
     }
   | { type: "output-item"; item: OpenAIResponseItem; completed?: boolean }
-  | { type: "completed"; responseId: string; usage?: OpenAIUsage; model?: string }
+  | {
+      type: "completed";
+      responseId: string;
+      usage?: OpenAIUsage;
+      model?: string;
+      imageGeneration?: ImageGenerationMetadata;
+    }
   | { type: "error"; error: OpenAIProtocolError };
 
 export class OpenAIProtocolError extends Error {
@@ -286,11 +292,27 @@ export function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | unde
   }
   if (type === "response.completed") {
     const response = (event.response ?? {}) as Record<string, unknown>;
+    const toolUsage = response.tool_usage as Record<string, unknown> | undefined;
+    const parsedImageUsage = ImageGenerationMetadata.shape.usage.safeParse(toolUsage?.image_gen);
+    const imageUsage = parsedImageUsage.success ? parsedImageUsage.data : undefined;
+    const imageTool = Array.isArray(response.tools)
+      ? response.tools.find((tool) => tool?.type === "image_generation")
+      : undefined;
+    const imageModel = typeof imageTool?.model === "string" ? imageTool.model : undefined;
     return {
       type: "completed",
       responseId: String(response.id ?? ""),
       ...(response.usage ? { usage: usageFrom(response.usage) } : {}),
       ...(typeof response.model === "string" ? { model: response.model } : {}),
+      ...(imageUsage || imageModel
+        ? {
+            imageGeneration: {
+              route: "codex-responses" as const,
+              ...(imageModel ? { model: imageModel } : {}),
+              ...(imageUsage ? { usage: imageUsage } : {}),
+            },
+          }
+        : {}),
     };
   }
   if (type === "error" || type === "response.failed" || type === "response.incomplete") {

package/bundle/src/utils/providers/openai/openai-direct-client.test.ts

@@ -29,6 +29,21 @@ async function collect<T>(iterable: AsyncIterable<T>): Promise<T[]> {
 }
 
 describe("OpenAI direct HTTPS client", () => {
+  it.each([true, { background: "opaque" }])("keeps chat-model images on Responses (%j)", async (imageGeneration) => {
+    const fetchMock = vi.fn<typeof fetch>(async () =>
+      sse({ type: "response.completed", response: { id: "hosted-image" } }),
+    );
+    const client = new OpenAIDirectClient({
+      credentials: { accessToken: "access", accountId: "acct" }, fetch: fetchMock,
+    });
+    await collect(client.responses({ model: "gpt-6-luna", history: [], imageGeneration }));
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock.mock.calls[0]?.[0]).toBe(CHATGPT_CODEX_RESPONSES_URL);
+    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toMatchObject({
+      model: "gpt-6-luna", tools: [expect.objectContaining({ type: "image_generation" })],
+    });
+  });
+
   it("posts the pinned body and Codex identity without live calls", async () => {
     const fetchMock = vi.fn<typeof fetch>(async () =>
       sse(

package/bundle/src/utils/providers/openai/openai-direct-client.ts

@@ -450,8 +450,9 @@ export class OpenAIDirectClient {
 
   responses(options: OpenAIResponsesOptions, signal?: AbortSignal): OpenAIEventStream {
     if (
-      typeof options.imageGeneration === "object" &&
-      options.imageGeneration.background === "transparent"
+      options.model === "gpt-image-2" ||
+      (typeof options.imageGeneration === "object" &&
+        options.imageGeneration.background === "transparent")
     ) {
       return this.standaloneImages(options, signal);
     }
@@ -498,10 +499,19 @@ export class OpenAIDirectClient {
         continue;
       }
       if (!response.ok) throw await responseError(response);
-      const images = await readStandaloneImageResponse(response);
+      const images = await readStandaloneImageResponse(
+        response,
+        typeof options.imageGeneration === "object" &&
+          options.imageGeneration.background === "transparent",
+      );
       signal?.throwIfAborted();
       yield* images;
-      yield { type: "completed", responseId: requestId, model: "gpt-image-2" };
+      const firstImage = images[0];
+      yield {
+        type: "completed",
+        responseId: requestId,
+        model: firstImage?.type === "image" ? firstImage.generation?.model : "gpt-image-2",
+      };
       return;
     }
   }