@cartanova/qgrid-cli 2.4.8 → 2.4.9

package/bundle/src/migrations/20260722174410_alter_request_logs_alter3.ts

@@ -0,0 +1,19 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // alter column
+    table.string("model_name", 255).nullable().alter();
+    // alter column
+    table.string("requested_model_name", 255).nullable().alter();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // rollback - alter column
+    table.string("model_name", 50).nullable().alter();
+    // rollback - alter column
+    table.string("requested_model_name", 50).nullable().alter();
+  });
+}

package/bundle/src/migrations/20260722174411_alter_request_log_steps_alter3.ts

@@ -0,0 +1,19 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_log_steps", (table) => {
+    // alter column
+    table.string("model_name", 255).nullable().alter();
+    // alter column
+    table.string("requested_model_name", 255).nullable().alter();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_log_steps", (table) => {
+    // rollback - alter column
+    table.string("model_name", 50).nullable().alter();
+    // rollback - alter column
+    table.string("requested_model_name", 50).nullable().alter();
+  });
+}

package/bundle/src/sonamu.config.ts

@@ -3,7 +3,6 @@ import path from "path";
 import { getConsoleSink } from "@logtape/logtape";
 import { getLogger } from "@logtape/logtape";
 import { getPrettyFormatter } from "@logtape/pretty";
-import dotenv from "dotenv";
 import { CachePresets, defineConfig } from "sonamu";
 import { drivers as cacheDrivers, store } from "sonamu/cache";
 
@@ -15,23 +14,20 @@ import { ensureTokensTrigger } from "./application/qgrid/token-trigger-setup";
 import { AnthropicDispatcher } from "./utils/providers/anthropic/anthropic-dispatcher";
 import { OpenAIDispatcher } from "./utils/providers/openai/openai-dispatcher";
 
-dotenv.config({ path: path.join(import.meta.dirname, "../.env") });
-
 const host = process.env.HOST ?? "localhost";
 const port = Number(process.env.PORT ?? 44900);
 
 const connConfig = {
-  host: process.env.QGRID_DB_HOST ?? "localhost",
-  port: Number(process.env.QGRID_DB_PORT ?? 5432),
-  user: process.env.QGRID_DB_USER ?? "postgres",
-  password: process.env.QGRID_DB_PASSWORD ?? "postgres",
-  database: process.env.QGRID_DB_NAME ?? "qgrid",
+  host: process.env.SONAMU_DB_HOST ?? "localhost",
+  port: Number(process.env.SONAMU_DB_PORT ?? 5432),
+  user: process.env.SONAMU_DB_USER ?? "postgres",
+  password: process.env.SONAMU_DB_PASSWORD ?? "postgres",
+  database: process.env.SONAMU_DB_NAME ?? "qgrid",
 };
 
 export default defineConfig({
   projectName: process.env.PROJECT_NAME ?? "Qgrid",
   database: {
-    name: "qgrid",
     defaultOptions: {
       connection: {
         ...connConfig,
@@ -39,20 +35,6 @@ export default defineConfig({
         keepAliveInitialDelayMillis: 10000,
       },
     },
-    environments: {
-      fixture: {
-        connection: {
-          ...connConfig,
-          database: process.env.QGRID_DB_NAME,
-        },
-      },
-      test: {
-        connection: {
-          ...connConfig,
-          database: process.env.QGRID_DB_NAME,
-        },
-      },
-    },
   },
   api: {
     dir: "api",

package/bundle/src/testing/global.ts

@@ -77,10 +77,10 @@ export async function dropWorkerDatabases(
 
 function createAdminClient(): Client {
   return new Client({
-    host: process.env.QGRID_DB_HOST ?? "localhost",
-    port: Number(process.env.QGRID_DB_PORT ?? 5432),
-    user: process.env.QGRID_DB_USER ?? "postgres",
-    password: process.env.QGRID_DB_PASSWORD ?? "postgres",
+    host: process.env.SONAMU_DB_HOST ?? "localhost",
+    port: Number(process.env.SONAMU_DB_PORT ?? 5432),
+    user: process.env.SONAMU_DB_USER ?? "postgres",
+    password: process.env.SONAMU_DB_PASSWORD ?? "postgres",
     database: "postgres",
     application_name: "qgrid-vitest-global-setup",
   });
@@ -132,7 +132,7 @@ export async function provisionWorkerDatabases(
 
 export async function setup(project?: VitestProject): Promise<() => Promise<void>> {
   const runDatabase = process.env.QGRID_TEST_RUN_DB;
-  if (!runDatabase || process.env.QGRID_DB_NAME !== runDatabase) {
+  if (!runDatabase || process.env.SONAMU_DB_NAME !== runDatabase) {
     throw new Error("Vitest test database name was not configured consistently");
   }
   const maxWorkers = resolveMaxWorkers(project);

package/bundle/src/testing/test-database-name.test.ts

@@ -6,25 +6,25 @@ import {
 } from "./test-database-name";
 
 const originalRunDatabase = process.env.QGRID_TEST_RUN_DB;
-const originalDatabase = process.env.QGRID_DB_NAME;
+const originalSonamuDatabase = process.env.SONAMU_DB_NAME;
 
 describe("test run database name", () => {
   afterEach(() => {
     if (originalRunDatabase === undefined) delete process.env.QGRID_TEST_RUN_DB;
     else process.env.QGRID_TEST_RUN_DB = originalRunDatabase;
-    if (originalDatabase === undefined) delete process.env.QGRID_DB_NAME;
-    else process.env.QGRID_DB_NAME = originalDatabase;
+    if (originalSonamuDatabase === undefined) delete process.env.SONAMU_DB_NAME;
+    else process.env.SONAMU_DB_NAME = originalSonamuDatabase;
   });
 
   it("uses one run-unique basename for setup and Sonamu workers", () => {
     delete process.env.QGRID_TEST_RUN_DB;
-    process.env.QGRID_DB_NAME = "qgrid";
+    process.env.SONAMU_DB_NAME = "qgrid";
 
     const runDatabase = configureTestRunDatabaseName();
 
     expect(runDatabase).toMatch(/^qgrid_test_[A-Za-z0-9_]+$/);
     expect(process.env.QGRID_TEST_RUN_DB).toBe(runDatabase);
-    expect(process.env.QGRID_DB_NAME).toBe(runDatabase);
+    expect(process.env.SONAMU_DB_NAME).toBe(runDatabase);
   });
 
   it("adds controller-specific entropy when processes share a prefix", () => {

package/bundle/src/testing/test-database-name.ts

@@ -10,12 +10,13 @@ export function createTestRunDatabaseName(prefix: string, entropy: string): stri
 }
 
 export function configureTestRunDatabaseName(): string {
-  if (configuredRunDatabase) return configuredRunDatabase;
-  const prefix = process.env.QGRID_TEST_RUN_DB ?? "qgrid_test";
-  const entropy = `${process.pid}_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
-  const runDatabase = createTestRunDatabaseName(prefix, entropy);
-  configuredRunDatabase = runDatabase;
-  process.env.QGRID_TEST_RUN_DB = runDatabase;
-  process.env.QGRID_DB_NAME = runDatabase;
-  return runDatabase;
+  if (!configuredRunDatabase) {
+    const prefix = process.env.QGRID_TEST_RUN_DB ?? "qgrid_test";
+    const entropy = `${process.pid}_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+    configuredRunDatabase = createTestRunDatabaseName(prefix, entropy);
+  }
+
+  process.env.QGRID_TEST_RUN_DB = configuredRunDatabase;
+  process.env.SONAMU_DB_NAME = configuredRunDatabase;
+  return configuredRunDatabase;
 }

package/bundle/src/utils/providers/anthropic/anthropic-constants.test.ts

@@ -6,8 +6,8 @@ import {
   canonicalAnthropicModel,
   hasOneMillionSuffix,
   needsCli1mSuffix,
-  requiresAdaptiveThinking,
   supports1MContext,
+  usesAdaptiveThinking,
 } from "./anthropic-constants";
 
 describe("canonicalAnthropicModel", () => {
@@ -29,6 +29,7 @@ describe("canonicalAnthropicModel", () => {
 describe("Anthropic 1M context policy", () => {
   it("지원 모델은 실측 확인된 exact set 만 true", () => {
     expect(supports1MContext("claude-fable-5")).toBe(true);
+    expect(supports1MContext("claude-opus-5")).toBe(true);
     expect(supports1MContext("claude-sonnet-5")).toBe(true);
     expect(supports1MContext("claude-sonnet-4-6")).toBe(true);
     expect(supports1MContext("claude-opus-4-6")).toBe(true);
@@ -42,6 +43,7 @@ describe("Anthropic 1M context policy", () => {
 
   it("CLI suffix 필요 모델과 기본 1M 모델을 분리한다", () => {
     expect(needsCli1mSuffix("claude-fable-5")).toBe(false);
+    expect(needsCli1mSuffix("claude-opus-5")).toBe(false);
     expect(needsCli1mSuffix("claude-sonnet-5")).toBe(false);
     expect(needsCli1mSuffix("claude-sonnet-4-6")).toBe(true);
     expect(needsCli1mSuffix("claude-opus-4-6")).toBe(true);
@@ -66,10 +68,12 @@ describe("Anthropic 1M context policy", () => {
 });
 
 describe("Anthropic thinking policy", () => {
-  it("Fable 5 만 always-on adaptive thinking 으로 실행한다", () => {
-    expect(requiresAdaptiveThinking("claude-fable-5")).toBe(true);
-    expect(requiresAdaptiveThinking("anthropic/claude-fable-5")).toBe(true);
-    expect(requiresAdaptiveThinking("claude-sonnet-5")).toBe(false);
-    expect(requiresAdaptiveThinking("claude-opus-4-8")).toBe(false);
+  it("Fable 5 와 Opus 5 는 adaptive thinking 을 보존한다", () => {
+    expect(usesAdaptiveThinking("claude-fable-5")).toBe(true);
+    expect(usesAdaptiveThinking("anthropic/claude-fable-5")).toBe(true);
+    expect(usesAdaptiveThinking("claude-opus-5")).toBe(true);
+    expect(usesAdaptiveThinking("anthropic/claude-opus-5")).toBe(true);
+    expect(usesAdaptiveThinking("claude-sonnet-5")).toBe(false);
+    expect(usesAdaptiveThinking("claude-opus-4-8")).toBe(false);
   });
 });

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

@@ -46,6 +46,7 @@ export function hasOneMillionSuffix(model?: string): boolean {
 // 고정한다. opus-4-7 은 실측 전까지 미포함. 새 모델 추가 시 공식 사양과 실제 CLI 동작을 확인한다.
 const ONE_MILLION_CONTEXT_MODELS = new Set([
   "claude-fable-5",
+  "claude-opus-5",
   "claude-sonnet-5",
   "claude-sonnet-4-6",
   "claude-opus-4-6",
@@ -53,7 +54,10 @@ const ONE_MILLION_CONTEXT_MODELS = new Set([
 ]);
 
 const CLI_ONE_MILLION_SUFFIX_MODELS = new Set(["claude-sonnet-4-6", "claude-opus-4-6"]);
-const ALWAYS_ADAPTIVE_THINKING_MODELS = new Set(["claude-fable-5"]);
+// Fable 5 는 adaptive thinking 이 유일한 모드다. Opus 5 는 disabled 를 high 이하에서 지원하지만,
+// 공식 기본값·권장 동작인 adaptive thinking 을 유지한다. qgrid 기본 effort=low 가 비용/지연 제어를
+// 맡으며, 이 정책은 disabled+xhigh/max 400 오류와 disabled 시 tool/XML 출력 오염도 피한다.
+const ADAPTIVE_THINKING_MODELS = new Set(["claude-fable-5", "claude-opus-5"]);
 
 // 불변 계약: suffix 가 필요한 모델은 반드시 1M 지원 모델의 부분집합이어야 한다. 역방향 불일치(suffix
 // 대상인데 지원 집합엔 없음)면 needsCli1mSuffix=true·supports1MContext=false 가 동시에 나서
@@ -73,10 +77,10 @@ export function needsCli1mSuffix(model?: string): boolean {
   return CLI_ONE_MILLION_SUFFIX_MODELS.has(canonicalAnthropicModel(model));
 }
 
-// Fable 5 는 adaptive thinking 이 유일한 thinking mode 이므로 disabled 로 실행할 수 없다.
-// 나머지 모델은 qgrid 의 기존 저비용/비추론 경로를 그대로 유지한다.
-export function requiresAdaptiveThinking(model?: string): boolean {
-  return ALWAYS_ADAPTIVE_THINKING_MODELS.has(canonicalAnthropicModel(model));
+// qgrid 가 adaptive thinking 을 보존하는 모델인지 판별한다. 나머지 모델은 기존
+// 저비용/비추론 경로를 유지한다.
+export function usesAdaptiveThinking(model?: string): boolean {
+  return ADAPTIVE_THINKING_MODELS.has(canonicalAnthropicModel(model));
 }
 
 export function assertSupportedOneMillionSuffix(model?: string): void {

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

@@ -133,9 +133,11 @@ describe("buildClaudeArgs (멀티턴/격리/structured)", () => {
     expect(oneMillionEnv(false)).toEqual({ CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" });
   });
 
-  it("thinkingEnv: Fable 은 always-on adaptive thinking 을 보존하고 나머지는 비활성화", () => {
+  it("thinkingEnv: Fable 5/Opus 5 는 adaptive thinking 을 보존하고 나머지는 비활성화", () => {
     expect(thinkingEnv("claude-fable-5")).toEqual({});
     expect(thinkingEnv("anthropic/claude-fable-5")).toEqual({});
+    expect(thinkingEnv("claude-opus-5")).toEqual({});
+    expect(thinkingEnv("anthropic/claude-opus-5")).toEqual({});
     expect(thinkingEnv("claude-opus-4-8")).toEqual({
       CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
       MAX_THINKING_TOKENS: "0",
@@ -224,11 +226,11 @@ describe("buildClaudeArgs (멀티턴/격리/structured)", () => {
 
   it("1M 기본 지원 모델은 CLI --model 에 suffix 를 붙이지 않는다", () => {
     const args = buildClaudeArgs({
-      model: "claude-opus-4-8",
+      model: "claude-opus-5",
       sessionId: "u",
       needsOneMillionSuffix: false,
     });
-    expect(args[args.indexOf("--model") + 1]).toBe("claude-opus-4-8");
+    expect(args[args.indexOf("--model") + 1]).toBe("claude-opus-5");
   });
 
   it("Fable 5 는 항상 켜진 adaptive thinking 을 끄지 않고 effort 만 전달한다", () => {
@@ -242,6 +244,19 @@ describe("buildClaudeArgs (멀티턴/격리/structured)", () => {
     expect(args[args.indexOf("--effort") + 1]).toBe("low");
   });
 
+  it("Opus 5 는 adaptive thinking 을 보존해 xhigh/max effort 조합도 거부되지 않게 한다", () => {
+    for (const effort of ["xhigh", "max"]) {
+      const args = buildClaudeArgs({
+        model: "claude-opus-5",
+        sessionId: "u",
+        effort,
+      });
+      expect(args[args.indexOf("--model") + 1]).toBe("claude-opus-5");
+      expect(args).not.toContain("--thinking");
+      expect(args[args.indexOf("--effort") + 1]).toBe(effort);
+    }
+  });
+
   it("기존 Anthropic 모델은 thinking disabled 계약을 유지한다", () => {
     const args = buildClaudeArgs({ model: "claude-opus-4-8", sessionId: "u" });
     expect(args[args.indexOf("--thinking") + 1]).toBe("disabled");

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

@@ -30,8 +30,8 @@ import {
   assertSupportedOneMillionSuffix,
   canonicalAnthropicModel,
   needsCli1mSuffix,
-  requiresAdaptiveThinking,
   supports1MContext,
+  usesAdaptiveThinking,
 } from "./anthropic-constants";
 import {
   buildStreamJsonInput,
@@ -150,7 +150,7 @@ export function thinkingEnv(model: string): {
   CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING?: "1";
   MAX_THINKING_TOKENS?: "0";
 } {
-  return requiresAdaptiveThinking(model)
+  return usesAdaptiveThinking(model)
     ? {}
     : {
         CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
@@ -224,8 +224,8 @@ export function buildClaudeArgs(opts: {
     // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.
     // 크기에 따라 --system-prompt(작음) / --system-prompt-file(큼)로 분기(systemArgs).
     ...systemArgs,
-    // Fable 5 는 adaptive thinking 이 항상 켜져 있어 disabled 를 거부한다.
-    ...(requiresAdaptiveThinking(opts.model) ? [] : ["--thinking", "disabled"]),
+    // Fable 5 는 adaptive thinking 이 필수이고, Opus 5 는 공식 기본 adaptive 동작을 보존한다.
+    ...(usesAdaptiveThinking(opts.model) ? [] : ["--thinking", "disabled"]),
     "--effort",
     opts.effort ?? ANTHROPIC_DEFAULT_EFFORT,
     "--disable-slash-commands",

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

@@ -42,6 +42,7 @@ describe("calculateCostUsd", () => {
     ["claude-opus-4-6", 5, 25, 0.5, 10],
     ["claude-opus-4-7", 5, 25, 0.5, 10],
     ["claude-opus-4-8", 5, 25, 0.5, 10],
+    ["claude-opus-5", 5, 25, 0.5, 10],
   ])(
     "%s official Anthropic rates for 5m/1h cache writes",
     (model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens) => {

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

@@ -130,6 +130,7 @@ const ANTHROPIC_COSTS: Record<string, ModelCosts> = {
   "claude-opus-4-6": anthropicCosts(5, 25),
   "claude-opus-4-7": anthropicCosts(5, 25),
   "claude-opus-4-8": anthropicCosts(5, 25),
+  "claude-opus-5": anthropicCosts(5, 25),
 };
 
 // Anthropic 공식 introductory pricing: 2026-08-31까지 $2/$10, 이후 $3/$15.