@cartanova/qgrid-ai-sdk 0.1.0

package/e2e/e2e-logger.ts

@@ -0,0 +1,112 @@
+/**
+ * @cartanova/qgrid-ai-sdk Logger E2E Test
+ *
+ * TelemetryIntegration 기반 logger가 실서버에 run lifecycle을 기록하는지 검증.
+ * qgrid 서버(localhost:44900)가 떠 있어야 합니다.
+ *
+ * 사용법: pnpm --filter @cartanova/qgrid-ai-sdk e2e:logger
+ */
+import { generateText, stepCountIs, tool } from "ai";
+import { z } from "zod";
+
+import { createQgridLogger, qgrid } from "../src/index";
+
+const SERVER = process.env.QGRID_URL ?? "http://localhost:44900";
+const MODEL = (process.env.QGRID_MODEL ?? "openai/gpt-5.5") as Parameters<typeof qgrid>[0];
+
+let passed = 0;
+let failed = 0;
+
+async function test(name: string, fn: () => Promise<void>) {
+  try {
+    await fn();
+    passed++;
+    console.log(`  ✓ ${name}`);
+  } catch (e) {
+    failed++;
+    console.error(`  ✗ ${name}`);
+    console.error(`    ${(e as Error).message}`);
+  }
+}
+
+function assert(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new Error(message);
+}
+
+const WEATHER_DB: Record<string, { temperature: number; condition: string }> = {
+  Seoul: { temperature: 22, condition: "sunny" },
+  Busan: { temperature: 26, condition: "partly cloudy" },
+};
+
+async function main() {
+  console.log(`\n@cartanova/qgrid-ai-sdk Logger E2E (server: ${SERVER}, model: ${MODEL})\n`);
+
+  // 1. 단순 텍스트 + logger
+  await test("logger: simple text generation", async () => {
+    const logger = createQgridLogger({
+      serverUrl: SERVER,
+      projectName: "e2e-logger",
+      tokenName: "e2e-test",
+    });
+
+    const result = await generateText({
+      model: qgrid(MODEL),
+      prompt: 'Say exactly: "logger-ok"',
+      experimental_telemetry: { integrations: [logger] },
+    });
+
+    assert(result.text.length > 0, "empty response");
+    console.log(`    text="${result.text.slice(0, 50)}"`);
+
+    // 대기 후 DB 검증
+    await new Promise((r) => setTimeout(r, 1500));
+
+    const logRes = await fetch(
+      `${SERVER}/api/requestLog/findMany?subset=A&rawParams%5Bnum%5D=1&rawParams%5Bpage%5D=1&rawParams%5BorderBy%5D=id-desc`,
+    );
+    const logData = (await logRes.json()) as { rows: Array<Record<string, unknown>> };
+    const log = logData.rows[0];
+
+    // qgrid provider가 이미 lifecycle을 관리하므로 logger는 skip해야 함
+    // 하지만 단순 호출이라 qgrid provider의 runState도 생성 안 됨 (tools 없음)
+    // 이 경우 둘 다 기록하지 않거나, qgrid provider만 기록
+    console.log(`    latest log id=${log?.id}, status=${log?.status}`);
+  });
+
+  // 2. tool calling + logger (qgrid provider 사용 — logger가 skip하는지 검증)
+  await test("logger: skips when qgrid provider is used", async () => {
+    const errors: Error[] = [];
+    const logger = createQgridLogger({
+      serverUrl: SERVER,
+      projectName: "e2e-logger",
+      onLogError: (err) => errors.push(err),
+    });
+
+    const result = await generateText({
+      model: qgrid(MODEL),
+      prompt: "What is the weather in Seoul? Use the getWeather tool.",
+      tools: {
+        getWeather: tool({
+          description: "Get weather for a city",
+          inputSchema: z.object({ city: z.string() }),
+          execute: async ({ city }) => WEATHER_DB[city] ?? { temperature: 0, condition: "unknown" },
+        }),
+      },
+      stopWhen: stepCountIs(3),
+      experimental_telemetry: { integrations: [logger] },
+    });
+
+    assert(result.text.length > 0, "empty response");
+    assert(errors.length === 0, `logger errors: ${errors.map((e) => e.message).join(", ")}`);
+    console.log(`    text="${result.text.slice(0, 80)}"`);
+    console.log(`    logger skipped (qgrid provider detected)`);
+  });
+
+  console.log(`\n  ${passed} passed, ${failed} failed\n`);
+  if (failed > 0) process.exit(1);
+}
+
+main().catch((e) => {
+  console.error("E2E failed:", e);
+  process.exit(1);
+});

package/e2e/e2e.ts

@@ -0,0 +1,217 @@
+/**
+ * @cartanova/qgrid-ai-sdk E2E Test Suite
+ *
+ * 실제 qgrid 서버(localhost:44900)에 요청을 보내는 통합 테스트.
+ * 서버가 떠 있어야 합니다.
+ *
+ * 사용법: pnpm --filter @cartanova/qgrid-ai-sdk e2e
+ */
+import { generateText, stepCountIs, tool } from "ai";
+import { z } from "zod";
+
+import { qgrid } from "../src/index";
+
+const SERVER = process.env.QGRID_URL ?? "http://localhost:44900";
+const MODEL = (process.env.QGRID_MODEL ?? "openai/gpt-5.5") as Parameters<typeof qgrid>[0];
+
+// ── Test runner ────────────────────────────────────────────────────
+
+let passed = 0;
+let failed = 0;
+
+async function test(name: string, fn: () => Promise<void>) {
+  try {
+    await fn();
+    passed++;
+    console.log(`  ✓ ${name}`);
+  } catch (e) {
+    failed++;
+    console.error(`  ✗ ${name}`);
+    console.error(`    ${(e as Error).message}`);
+  }
+}
+
+function assert(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new Error(message);
+}
+
+// ── Mock data ──────────────────────────────────────────────────────
+
+const WEATHER_DB: Record<string, { temperature: number; condition: string }> = {
+  Seoul: { temperature: 22, condition: "sunny" },
+  Busan: { temperature: 26, condition: "partly cloudy" },
+  Daegu: { temperature: 28, condition: "hot" },
+  Jeju: { temperature: 24, condition: "rainy" },
+};
+
+const RESTAURANT_DB: Record<
+  string,
+  Array<{ id: string; name: string; cuisine: string; rating: number }>
+> = {
+  Daegu: [
+    { id: "r6", name: "대구 막창", cuisine: "BBQ", rating: 4.4 },
+    { id: "r7", name: "안지랑 곱창", cuisine: "Korean", rating: 4.7 },
+  ],
+  Busan: [
+    { id: "r3", name: "해운대 회센터", cuisine: "Seafood", rating: 4.7 },
+    { id: "r4", name: "서면 돼지국밥", cuisine: "Korean", rating: 4.9 },
+  ],
+};
+
+// ── Tests ──────────────────────────────────────────────────────────
+
+async function main() {
+  console.log(`\n@cartanova/qgrid-ai-sdk E2E (server: ${SERVER}, model: ${MODEL})\n`);
+
+  // 1. 단순 텍스트
+  await test("simple text generation", async () => {
+    const result = await generateText({
+      model: qgrid(MODEL),
+      prompt: 'Respond with exactly: "hello-e2e"',
+    });
+    assert(result.text.length > 0, "empty response");
+    assert(result.finishReason === "stop", `unexpected finishReason: ${result.finishReason}`);
+    assert(result.usage?.inputTokens, "missing input token usage");
+    console.log(`    text="${result.text.slice(0, 80)}"`);
+  });
+
+  // 2. system prompt
+  await test("system prompt", async () => {
+    const result = await generateText({
+      model: qgrid(MODEL),
+      system: "You must reply in exactly one word.",
+      prompt: "What color is the sky?",
+    });
+    assert(result.text.length > 0, "empty response");
+    console.log(`    text="${result.text.slice(0, 80)}"`);
+  });
+
+  // 3. single tool call
+  await test("single tool call", async () => {
+    const result = await generateText({
+      model: qgrid(MODEL),
+      prompt: "What is the weather in Seoul? Use the getWeather tool.",
+      tools: {
+        getWeather: tool({
+          description: "Get current weather for a city",
+          inputSchema: z.object({ city: z.string() }),
+          execute: async ({ city }) => WEATHER_DB[city] ?? { temperature: 0, condition: "unknown" },
+        }),
+      },
+      stopWhen: stepCountIs(3),
+    });
+    assert(result.steps.length >= 2, `expected at least 2 steps, got ${result.steps.length}`);
+    assert(result.steps[0].toolCalls.length > 0, "step 0 should have tool calls");
+    assert(result.finishReason === "stop", `unexpected finishReason: ${result.finishReason}`);
+    assert(result.text.length > 0, "empty final text");
+    console.log(`    steps=${result.steps.length}, text="${result.text.slice(0, 80)}"`);
+  });
+
+  // 4. multi-tool, multi-step
+  await test("multi-tool multi-step", async () => {
+    const result = await generateText({
+      model: qgrid(MODEL),
+      prompt:
+        "Step 1: Use the getWeather tool for Seoul, Busan, and Daegu. Step 2: Identify the warmest city. Step 3: Use the searchRestaurants tool for that warmest city. Then give a final summary.",
+      tools: {
+        getWeather: tool({
+          description: "Get weather for a city (English name: Seoul, Busan, Daegu, Jeju)",
+          inputSchema: z.object({ city: z.string() }),
+          execute: async ({ city }) => WEATHER_DB[city] ?? { temperature: 0, condition: "unknown" },
+        }),
+        searchRestaurants: tool({
+          description: "Search restaurants in a city",
+          inputSchema: z.object({ city: z.string() }),
+          execute: async ({ city }) => RESTAURANT_DB[city] ?? [],
+        }),
+      },
+      stopWhen: stepCountIs(5),
+    });
+
+    const allToolCalls = result.steps.flatMap((s) => s.toolCalls);
+    const weatherCalls = allToolCalls.filter((tc) => tc.toolName === "getWeather");
+    const restaurantCalls = allToolCalls.filter((tc) => tc.toolName === "searchRestaurants");
+    const toolNames = [...new Set(allToolCalls.map((tc) => tc.toolName))];
+
+    assert(
+      allToolCalls.length >= 2,
+      `expected at least 2 total tool calls, got ${allToolCalls.length}`,
+    );
+    assert(
+      weatherCalls.length >= 2,
+      `expected at least 2 getWeather calls, got ${weatherCalls.length}`,
+    );
+    assert(result.steps.length >= 2, `expected at least 2 steps, got ${result.steps.length}`);
+    assert(result.finishReason === "stop", `unexpected finishReason: ${result.finishReason}`);
+    console.log(
+      `    steps=${result.steps.length}, tools=${toolNames.join(",")}, weatherCalls=${weatherCalls.length}, restaurantCalls=${restaurantCalls.length}`,
+    );
+    console.log(`    text="${result.text.slice(0, 100)}"`);
+  });
+
+  // 5. auto lifecycle — run이 DB에 기록되었는지 검증
+  await test("auto lifecycle (createRun → appendStep → finishRun)", async () => {
+    const result = await generateText({
+      model: qgrid(MODEL),
+      prompt: "What is the weather in Busan? Use the getWeather tool.",
+      tools: {
+        getWeather: tool({
+          description: "Get weather for a city",
+          inputSchema: z.object({ city: z.string() }),
+          execute: async ({ city }) => WEATHER_DB[city] ?? { temperature: 0, condition: "unknown" },
+        }),
+      },
+      stopWhen: stepCountIs(3),
+    });
+    assert(result.finishReason === "stop", `unexpected finishReason: ${result.finishReason}`);
+
+    // fire-and-forget appendStep 완료 대기
+    await new Promise((r) => setTimeout(r, 1500));
+
+    // 가장 최근 request_log 조회
+    const logRes = await fetch(
+      `${SERVER}/api/requestLog/findMany?subset=A&rawParams%5Bnum%5D=1&rawParams%5Bpage%5D=1&rawParams%5BorderBy%5D=id-desc`,
+    );
+    const logData = (await logRes.json()) as { rows: Array<Record<string, unknown>> };
+    const log = logData.rows[0];
+    assert(log, "no request_log found");
+    assert(log.status === "succeeded", `expected status=succeeded, got ${log.status}`);
+    assert((log.input_tokens as number) > 0, "input_tokens should be > 0");
+    assert(
+      (log.tool_call_count as number) >= 1,
+      `expected tool_call_count >= 1, got ${log.tool_call_count}`,
+    );
+    assert((log.response as string)?.length > 0, "response should not be empty");
+
+    // steps 검증
+    const stepsRes = await fetch(
+      `${SERVER}/api/requestLogStep/findMany?subset=A&rawParams%5Bnum%5D=50&rawParams%5Bpage%5D=1&rawParams%5Brequest_log_id%5D=${log.id}&rawParams%5BorderBy%5D=id-asc`,
+    );
+    const stepsData = (await stepsRes.json()) as {
+      rows: Array<Record<string, unknown>>;
+      total: number;
+    };
+    const generateSteps = stepsData.rows.filter((s) => s.type === "generate");
+    const toolSteps = stepsData.rows.filter((s) => s.type === "tool_call");
+
+    assert(
+      generateSteps.length >= 2,
+      `expected at least 2 generate steps, got ${generateSteps.length}`,
+    );
+    assert(toolSteps.length >= 1, `expected at least 1 tool_call step, got ${toolSteps.length}`);
+
+    console.log(
+      `    requestLogId=${log.id}, status=${log.status}, tool_call_count=${log.tool_call_count}, steps=${stepsData.total}`,
+    );
+  });
+
+  // ── Summary ──────────────────────────────────────────────────────
+
+  console.log(`\n  ${passed} passed, ${failed} failed\n`);
+  if (failed > 0) process.exit(1);
+}
+
+main().catch((e) => {
+  console.error("E2E failed:", e);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@cartanova/qgrid-ai-sdk",
+  "version": "0.1.0",
+  "description": "AI SDK LanguageModelV3 provider for qgrid",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsdown && mv dist/index-*.d.ts dist/index.d.ts",
+    "test": "vitest run",
+    "e2e": "tsx e2e/e2e.ts",
+    "e2e:logger": "tsx e2e/e2e-logger.ts"
+  },
+  "devDependencies": {
+    "@ai-sdk/provider": "catalog:",
+    "ai": "catalog:",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "peerDependencies": {
+    "@ai-sdk/provider": "^3.0.0",
+    "ai": "^6.0.0"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,338 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { qgrid } from "./index";
+
+const usage = {
+  input_tokens: 10,
+  output_tokens: 5,
+  cache_creation_input_tokens: 0,
+  cache_read_input_tokens: 3,
+};
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+function tool() {
+  return {
+    type: "function",
+    name: "getWeather",
+    description: "Get weather",
+    inputSchema: {
+      type: "object",
+      properties: { city: { type: "string" } },
+      required: ["city"],
+    },
+  };
+}
+
+function toolPrompt(callIds: string[]) {
+  return [
+    { role: "user", content: [{ type: "text", text: "weather" }] },
+    ...callIds.flatMap((callId) => [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: callId,
+            toolName: "getWeather",
+            input: { city: callId },
+          },
+        ],
+      },
+      {
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: callId,
+            output: { temperature: callId },
+          },
+        ],
+      },
+    ]),
+  ];
+}
+
+function sseDone(data: unknown) {
+  const encoder = new TextEncoder();
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(encoder.encode(`event: done\ndata: ${JSON.stringify(data)}\n\n`));
+      controller.close();
+    },
+  });
+}
+
+describe("qgrid AI SDK provider", () => {
+  it("sends tools and maps tool-call response", async () => {
+    let queryBody: unknown;
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async (url: string, init?: RequestInit) => {
+        const body = JSON.parse(String(init?.body));
+        if (url.includes("/query")) {
+          queryBody = body;
+          return new Response(
+            JSON.stringify({
+              text: "",
+              content: [
+                {
+                  type: "tool-call",
+                  toolCallId: "call_weather",
+                  toolName: "getWeather",
+                  input: JSON.stringify({ city: "Seoul" }),
+                },
+              ],
+              finishReason: "tool-calls",
+              model: "gpt-5.5",
+              usage,
+              durationMs: 100,
+              costUsd: 0.01,
+              runContext: { requestLogId: 1 },
+            }),
+            { status: 200, headers: { "content-type": "application/json" } },
+          );
+        }
+        return new Response("{}", { status: 200 });
+      }),
+    );
+
+    const result = await qgrid("openai/gpt-5.5").doGenerate({
+      prompt: [{ role: "user", content: [{ type: "text", text: "weather" }] }],
+      tools: [tool()],
+    } as never);
+
+    expect(queryBody).toMatchObject({
+      args: {
+        prompt: "weather",
+        logMode: "run",
+        tools: [{ name: "getWeather", description: "Get weather" }],
+      },
+    });
+    expect(result.finishReason).toEqual({ unified: "tool-calls", raw: "tool_call" });
+    expect(result.content).toEqual([
+      {
+        type: "tool-call",
+        toolCallId: "call_weather",
+        toolName: "getWeather",
+        input: JSON.stringify({ city: "Seoul" }),
+      },
+    ]);
+  });
+
+  it("sends runContext and toolResults on tool-call follow-up", async () => {
+    const calls: Array<{ url: string; body: Record<string, unknown> }> = [];
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async (url: string, init?: RequestInit) => {
+        const body = JSON.parse(String(init?.body));
+        calls.push({ url, body });
+
+        if (url.includes("/query")) {
+          const prompt = body.args.prompt as string;
+          if (prompt === "weather") {
+            return new Response(
+              JSON.stringify({
+                text: "",
+                content: [
+                  {
+                    type: "tool-call",
+                    toolCallId: "call_1",
+                    toolName: "getWeather",
+                    input: '{"city":"Seoul"}',
+                  },
+                ],
+                finishReason: "tool-calls",
+                model: "gpt-5.5",
+                usage,
+                durationMs: 100,
+                costUsd: 0.01,
+                runContext: { requestLogId: 42 },
+              }),
+              { status: 200, headers: { "content-type": "application/json" } },
+            );
+          }
+          // follow-up (stop)
+          return new Response(
+            JSON.stringify({
+              text: "Seoul is 22°C",
+              content: [{ type: "text", text: "Seoul is 22°C" }],
+              finishReason: "stop",
+              model: "gpt-5.5",
+              usage,
+              durationMs: 80,
+              costUsd: 0.005,
+            }),
+            { status: 200, headers: { "content-type": "application/json" } },
+          );
+        }
+        return new Response("{}", { status: 200 });
+      }),
+    );
+
+    const model = qgrid("openai/gpt-5.5");
+
+    // 턴 1: tool-calls
+    await model.doGenerate({
+      prompt: [{ role: "user", content: [{ type: "text", text: "weather" }] }],
+      tools: [tool()],
+    } as never);
+
+    // 턴 2: follow-up with tool result
+    const result = await model.doGenerate({
+      prompt: toolPrompt(["call_1"]),
+      tools: [tool()],
+    } as never);
+
+    // follow-up 호출에 runContext + toolResults가 포함되어야 함
+    const followUpQuery = calls.filter((c) => c.url.includes("/query"))[1];
+    expect(followUpQuery?.body.args).toMatchObject({
+      logMode: "run",
+      runContext: { requestLogId: 42 },
+      toolResults: [{ toolCallId: "call_1" }],
+    });
+
+    // SDK는 직접 createRun/appendStep/finishRun 호출 안 함
+    expect(calls.filter((c) => c.url.includes("/createRun"))).toHaveLength(0);
+    expect(calls.filter((c) => c.url.includes("/appendStep"))).toHaveLength(0);
+    expect(calls.filter((c) => c.url.includes("/finishRun"))).toHaveLength(0);
+
+    expect(result.content).toEqual([{ type: "text", text: "Seoul is 22°C" }]);
+  });
+
+  it("does not send logMode for non-tool doGenerate", async () => {
+    let queryBody: unknown;
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async (url: string, init?: RequestInit) => {
+        const body = JSON.parse(String(init?.body));
+        if (url.includes("/query")) {
+          queryBody = body;
+          return new Response(
+            JSON.stringify({
+              text: "hello",
+              content: [{ type: "text", text: "hello" }],
+              finishReason: "stop",
+              model: "gpt-5.5",
+              usage,
+              durationMs: 50,
+              costUsd: 0.001,
+            }),
+            { status: 200, headers: { "content-type": "application/json" } },
+          );
+        }
+        return new Response("{}", { status: 200 });
+      }),
+    );
+
+    await qgrid("openai/gpt-5.5").doGenerate({
+      prompt: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+    } as never);
+
+    // logMode가 없어야 함 (서버 auto 경로)
+    expect((queryBody as Record<string, unknown>).args).not.toHaveProperty("logMode");
+  });
+
+  it("sends logMode:'run' for all doStream calls", async () => {
+    const calls: Array<{ url: string; body: Record<string, unknown> }> = [];
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async (url: string, init?: RequestInit) => {
+        const body = init?.body ? JSON.parse(String(init.body)) : {};
+        calls.push({ url, body });
+
+        if (url.includes("/prepareStream")) {
+          return new Response(JSON.stringify({ streamId: "s1" }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+          });
+        }
+        if (url.includes("/queryStream")) {
+          return new Response(
+            sseDone({
+              text: "streamed",
+              content: [{ type: "text", text: "streamed" }],
+              finishReason: "stop",
+              model: "gpt-5.5",
+              usage,
+              durationMs: 100,
+              costUsd: 0.01,
+            }),
+            { status: 200 },
+          );
+        }
+        return new Response("{}", { status: 200 });
+      }),
+    );
+
+    const result = await qgrid("openai/gpt-5.5").doStream({
+      prompt: [{ role: "user", content: [{ type: "text", text: "hello" }] }],
+    } as never);
+    for await (const _part of result.stream) {
+      // drain
+    }
+
+    const prepareCall = calls.find((c) => c.url.includes("/prepareStream"));
+    expect(prepareCall?.body.args).toMatchObject({ logMode: "run" });
+
+    // SDK는 직접 lifecycle 호출 안 함
+    expect(calls.filter((c) => c.url.includes("/createRun"))).toHaveLength(0);
+    expect(calls.filter((c) => c.url.includes("/finishRun"))).toHaveLength(0);
+  });
+
+  it("clears client run state when prompt does not match pending tool calls", async () => {
+    const calls: Array<{ url: string; body: Record<string, unknown> }> = [];
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async (url: string, init?: RequestInit) => {
+        const body = JSON.parse(String(init?.body));
+        calls.push({ url, body });
+
+        if (url.includes("/query")) {
+          return new Response(
+            JSON.stringify({
+              text: "",
+              content: [
+                {
+                  type: "tool-call",
+                  toolCallId: "call_1",
+                  toolName: "getWeather",
+                  input: '{"city":"Seoul"}',
+                },
+              ],
+              finishReason: "tool-calls",
+              model: "gpt-5.5",
+              usage,
+              durationMs: 100,
+              costUsd: 0.01,
+              runContext: { requestLogId: 1 },
+            }),
+            { status: 200, headers: { "content-type": "application/json" } },
+          );
+        }
+        return new Response("{}", { status: 200 });
+      }),
+    );
+
+    const model = qgrid("openai/gpt-5.5");
+    await model.doGenerate({
+      prompt: [{ role: "user", content: [{ type: "text", text: "weather" }] }],
+      tools: [tool()],
+    } as never);
+
+    // 다른 prompt로 호출 (tool result 없음) → overlap, runContext 안 보냄
+    await model.doGenerate({
+      prompt: [{ role: "user", content: [{ type: "text", text: "different" }] }],
+      tools: [tool()],
+    } as never);
+
+    const secondQuery = calls.filter((c) => c.url.includes("/query"))[1];
+    expect(secondQuery?.body.args).not.toHaveProperty("runContext");
+    expect(secondQuery?.body.args).toMatchObject({ logMode: "run" });
+  });
+});