@cartanova/qgrid-ai-sdk 2.4.8 → 2.5.0

package/README.ko.md

@@ -162,6 +162,7 @@ const { text } = await generateText({
 
 | 옵션 | 값 | 적용 범위 | 설명 |
 |---|---|---|---|
+| `logger` | `boolean` | 공통 | qgrid request log 저장 여부. 기본값은 `true`. `false`로 설정해도 client tool 실행과 multi-step 연결은 계속 동작 |
 | `sessionKey` | `string` | OpenAI 전용 | 멀티턴 대화 식별자. 같은 key는 같은 codex thread로 라우팅되어 prompt cache 적중 ([아래](#멀티턴-prompt-cache-sessionkey) 참조) |
 | `effort` | `"none"` \| `"minimal"` \| `"low"` \| `"medium"` \| `"high"` \| `"xhigh"` \| `"max"` | 공통 (지원 값은 모델별 상이, 예: `"max"`는 GPT-5.6+) | reasoning 모델의 추론 깊이. 기본값은 config의 `defaultEffort` (`"low"`) |
 | `verbosity` | `"low"` \| `"medium"` \| `"high"` | OpenAI 전용 | 응답 텍스트의 상세도 |
@@ -263,6 +264,29 @@ createQgridLogger({
 
 모든 설정은 optional (serverUrl 제외). 기본값이 있으므로 `serverUrl`만 넣으면 동작합니다.
 
+특정 generation을 request log 저장에서 제외하려면 `providerOptions.qgrid.logger`를
+`false`로 설정하세요. qgrid provider 호출과 `createQgridLogger`가 관찰하는 외부 provider
+호출에 모두 적용되며, tool 실행과 multi-step 연결은 계속 정상 동작합니다.
+
+```typescript
+import { type QgridProviderOptions } from "@cartanova/qgrid-ai-sdk";
+
+const { text } = await generateText({
+  model: google("gemini-3-flash"),
+  prompt: "이 요청은 저장하지 마",
+  providerOptions: {
+    qgrid: { logger: false } satisfies QgridProviderOptions,
+  },
+  experimental_telemetry: createQgridLogger({ serverUrl: "http://localhost:44900" }),
+});
+```
+
+외부 provider request log의 모델 이름은 `provider/modelId` 형식으로 저장됩니다. provider가
+AI SDK response metadata로 실제 serving 모델을 다르게 보고하면 step과 final log에는
+관찰된 serving 모델을 저장하고 requested model은 별도로 유지합니다. AI SDK runtime의
+`response.modelId`는 변경하지 않습니다. `openai.responses`는 `openai`로,
+`anthropic.messages`는 `anthropic`으로 적재하는 등 AI SDK adapter suffix는 base provider로 정규화합니다.
+
 ### qgrid provider와 함께 사용
 
 `qgrid()` provider는 자체 lifecycle이 있으므로 logger가 자동으로 suppress됩니다. 같은 코드에서 qgrid provider와 다른 provider를 섞어 써도 이중 기록되지 않습니다.
@@ -295,6 +319,7 @@ type QgridSupportedModel =
   | "anthropic/claude-opus-4-6"
   | "anthropic/claude-opus-4-7"
   | "anthropic/claude-opus-4-8"
+  | "anthropic/claude-opus-5"
 ```
 
 ### GPT-5.6 사양
@@ -307,7 +332,9 @@ type QgridSupportedModel =
 
 세 모델 모두 `max` reasoning effort를 지원합니다. OpenAI native API 사양은 1.05M context / 128K 최대 출력이지만, qgrid는 codex app-server 구독 경로로 실행되어 세 모델 모두 context window가 372K(95% effective, 실사용 입력 약 353K)로 보고되며 설정으로 올릴 수 없습니다. 입력이 272K tokens를 넘으면 요청 전체에 input 2x, output 1.5x 장문 컨텍스트 할증이 적용되며, cache write는 uncached input 단가의 1.25x입니다.
 
-`anthropic/claude-fable-5`는 1M context와 128K 최대 출력을 지원합니다. 1M tokens당 표준 단가는 input $10, cache read $1, 5분 cache write $12.50, 1시간 cache write $20, output $50입니다. qgrid는 Claude 응답의 5분/1시간 cache creation breakdown을 보존해 TTL별 단가를 각각 적용하며, breakdown이 없는 구버전 응답에서만 Claude Code가 subscription OAuth 경로에 자동 적용하는 1시간 TTL 단가로 fallback합니다. Fable은 adaptive thinking이 항상 켜져 있어야 하므로 qgrid는 이 모델에서만 adaptive thinking을 보존하고, 기존 Anthropic 모델은 계속 thinking을 비활성화합니다.
+`anthropic/claude-fable-5`는 1M context와 128K 최대 출력을 지원합니다. 1M tokens당 표준 단가는 input $10, cache read $1, 5분 cache write $12.50, 1시간 cache write $20, output $50입니다. qgrid는 Claude 응답의 5분/1시간 cache creation breakdown을 보존해 TTL별 단가를 각각 적용하며, breakdown이 없는 구버전 응답에서만 Claude Code가 subscription OAuth 경로에 자동 적용하는 1시간 TTL 단가로 fallback합니다. Fable은 adaptive thinking이 항상 켜져 있어야 하므로 qgrid는 이 모델의 adaptive thinking을 보존합니다.
+
+`anthropic/claude-opus-5`는 기본 1M context와 128K 최대 출력을 지원합니다. 1M tokens당 단가는 input $5, cache read $0.50, 5분 cache write $6.25, 1시간 cache write $10, output $25입니다. qgrid는 Opus 5의 기본 adaptive thinking 동작을 유지하고 `effort`로 추론 깊이를 조절합니다. 따라서 `xhigh` 또는 `max` effort에서 허용되지 않는 `thinking: disabled` 조합도 만들지 않습니다.
 
 Claude Code는 Fable의 safety refusal을 Opus 4.8로 자동 재시도할 수 있습니다. 이 경우 AI SDK 응답의 `response.modelId`와 `providerMetadata.qgrid.model`은 실제 serving 모델인 Opus를 가리킵니다. `providerMetadata.qgrid.requestedModel`은 Fable로 유지되고, `providerMetadata.qgrid.modelFallbacks`에 refusal fallback 이력이 담깁니다. 같은 metadata에서 `costSource`와 5분/1시간 cache-write 토큰 분해도 확인할 수 있습니다.
 

package/README.md

@@ -162,6 +162,7 @@ const { text } = await generateText({
 
 | Option | Values | Applies to | Description |
 |---|---|---|---|
+| `logger` | `boolean` | both providers | qgrid request logging. Defaults to `true`; `false` disables request-log persistence for this generation without disabling client tools or multi-step continuation |
 | `sessionKey` | `string` | OpenAI only | Multi-turn conversation identifier. The same key routes to the same codex thread for prompt-cache hits (see [below](#multi-turn-prompt-cache-sessionkey)) |
 | `effort` | `"none"` \| `"minimal"` \| `"low"` \| `"medium"` \| `"high"` \| `"xhigh"` \| `"max"` | both providers (supported values are model-dependent, e.g. `"max"` is GPT-5.6+) | Reasoning depth. Defaults to the config's `defaultEffort` (`"low"`) |
 | `verbosity` | `"low"` \| `"medium"` \| `"high"` | OpenAI only | Response text verbosity |
@@ -263,6 +264,29 @@ createQgridLogger({
 
 Everything except `serverUrl` is optional. With defaults in place, passing only `serverUrl` works.
 
+To opt one generation out of request logging, set `providerOptions.qgrid.logger` to `false`.
+The same option works for qgrid-provider calls and for external-provider calls observed by
+`createQgridLogger`; tool execution and multi-step continuation still work normally.
+
+```typescript
+import { type QgridProviderOptions } from "@cartanova/qgrid-ai-sdk";
+
+const { text } = await generateText({
+  model: google("gemini-3-flash"),
+  prompt: "Do not persist this request",
+  providerOptions: {
+    qgrid: { logger: false } satisfies QgridProviderOptions,
+  },
+  experimental_telemetry: createQgridLogger({ serverUrl: "http://localhost:44900" }),
+});
+```
+
+External-provider request logs store model names as `provider/modelId`. If the provider reports
+a different served model in the AI SDK response metadata, step and final log rows record that
+observed model while retaining the requested model separately. This does not alter the AI SDK
+runtime `response.modelId`. AI SDK adapter suffixes are normalized to the base provider, for
+example `openai.responses` to `openai` and `anthropic.messages` to `anthropic`.
+
 ### Using alongside the qgrid provider
 
 The `qgrid()` provider has its own lifecycle, so the logger automatically suppresses itself for qgrid calls. Mixing the qgrid provider and other providers in the same code does not double-log.
@@ -295,6 +319,7 @@ type QgridSupportedModel =
   | "anthropic/claude-opus-4-6"
   | "anthropic/claude-opus-4-7"
   | "anthropic/claude-opus-4-8"
+  | "anthropic/claude-opus-5"
 ```
 
 ### GPT-5.6 specifications
@@ -307,7 +332,9 @@ type QgridSupportedModel =
 
 All GPT-5.6 models support reasoning through `max`. The OpenAI native API spec is a 1.05M context window with 128K max output, but qgrid runs on the codex app-server subscription path, where all three models report a 372K context window (95% effective — about 353K of usable input) that cannot be raised by configuration. Prompts over 272K input tokens apply a 2x input and 1.5x output surcharge to the full request; cache writes cost 1.25x the uncached input rate.
 
-`anthropic/claude-fable-5` has a 1M context window and 128K max output. Its standard prices per 1M tokens are $10 input, $1 cache read, $12.50 five-minute cache write, $20 one-hour cache write, and $50 output. qgrid preserves Claude's 5m/1h cache-creation breakdown and prices each TTL separately; only legacy responses without that breakdown fall back to the one-hour TTL automatically selected by Claude Code on subscription OAuth. Fable requires always-on adaptive thinking, so qgrid preserves adaptive thinking for this model while continuing to disable thinking for existing Anthropic models.
+`anthropic/claude-fable-5` has a 1M context window and 128K max output. Its standard prices per 1M tokens are $10 input, $1 cache read, $12.50 five-minute cache write, $20 one-hour cache write, and $50 output. qgrid preserves Claude's 5m/1h cache-creation breakdown and prices each TTL separately; only legacy responses without that breakdown fall back to the one-hour TTL automatically selected by Claude Code on subscription OAuth. Fable requires always-on adaptive thinking, so qgrid preserves adaptive thinking for this model.
+
+`anthropic/claude-opus-5` has a default 1M context window and 128K max output. Its prices per 1M tokens are $5 input, $0.50 cache read, $6.25 five-minute cache write, $10 one-hour cache write, and $25 output. qgrid keeps Opus 5's default adaptive thinking behavior and uses `effort` to control reasoning depth. This also avoids the invalid `thinking: disabled` combination at `xhigh` or `max` effort.
 
 Claude Code may automatically retry a Fable safety refusal on Opus 4.8. In that case, the AI SDK response's `response.modelId` and `providerMetadata.qgrid.model` identify Opus as the actual serving model. `providerMetadata.qgrid.requestedModel` remains Fable, and `providerMetadata.qgrid.modelFallbacks` contains the refusal fallback history. The metadata also exposes `costSource` and the 5m/1h cache-write token split.
 

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { LanguageModelV3 } from "@ai-sdk/provider";
 import { TelemetrySettings } from "ai";
-
 //#region src/index.types.d.ts
 type QgridProviderConfig = {
   serverUrl?: string;
@@ -13,6 +12,11 @@ type QgridProviderConfig = {
  * providerOptions.qgrid 로 전달한다.
  */
 type QgridProviderOptions = {
+  /**
+   * qgrid request log 저장 여부. 기본값은 true.
+   * false여도 client tool 실행과 multi-step 연결은 계속 동작한다.
+   */
+  logger?: boolean;
   /**
    * 멀티턴 시 codex thread reuse를 위한 대화 식별자, 호출자가 자기 도메인 ID(예: 게임 세션 ID) 하나만 넘기면
    * provider가 같은 sessionKey 의 thread 좌표를 내부에서 회송해 prompt cache 를 적중시킨다
@@ -47,13 +51,7 @@ type QgridProviderOptions = {
     size?: "1024x1024" | "1024x1536" | "1536x1024";
   };
 };
-/**
- * codex thread 좌표
- * 멀티턴 대화에서 같은 대화를 같은 codex thread 로 라우팅 → conversation_id 고정 → 캐시 적중
- * provider 내부 threadCoordStore 가 sessionKey 별로 관리
- */
-
-type QgridSupportedModel = "openai/gpt-5.6-sol" | "openai/gpt-5.6-terra" | "openai/gpt-5.6-luna" | "openai/gpt-5.5" | "openai/gpt-5.4" | "openai/gpt-5.2" | "openai/gpt-5.4-mini" | "openai/gpt-5.3-codex" | "openai/gpt-5.3-codex-spark" | "anthropic/claude-fable-5" | "anthropic/claude-haiku-4-5" | "anthropic/claude-sonnet-4" | "anthropic/claude-sonnet-4-5" | "anthropic/claude-sonnet-4-6" | "anthropic/claude-sonnet-4-7" | "anthropic/claude-sonnet-5" | "anthropic/claude-opus-4" | "anthropic/claude-opus-4-1" | "anthropic/claude-opus-4-5" | "anthropic/claude-opus-4-6" | "anthropic/claude-opus-4-7" | "anthropic/claude-opus-4-8";
+type QgridSupportedModel = "openai/gpt-5.6-sol" | "openai/gpt-5.6-terra" | "openai/gpt-5.6-luna" | "openai/gpt-5.5" | "openai/gpt-5.4" | "openai/gpt-5.2" | "openai/gpt-5.4-mini" | "openai/gpt-5.3-codex" | "openai/gpt-5.3-codex-spark" | "anthropic/claude-fable-5" | "anthropic/claude-haiku-4-5" | "anthropic/claude-sonnet-4" | "anthropic/claude-sonnet-4-5" | "anthropic/claude-sonnet-4-6" | "anthropic/claude-sonnet-4-7" | "anthropic/claude-sonnet-5" | "anthropic/claude-opus-4" | "anthropic/claude-opus-4-1" | "anthropic/claude-opus-4-5" | "anthropic/claude-opus-4-6" | "anthropic/claude-opus-4-7" | "anthropic/claude-opus-4-8" | "anthropic/claude-opus-5";
 type QgridLoggerConfig = {
   /** qgrid 서버 주소. default: process.env.QGRID_URL, 없으면 기본값은 "http://localhost:44900" */
   serverUrl?: string;

package/dist/index.js

@@ -356,6 +356,12 @@ function serializeHistory(messages) {
 const DEFAULT_RUN_KEY = "__qgrid_default_run__";
 const DEFAULT_STALE_RUN_TIMEOUT_MS = 1800 * 1e3;
 const STALE_RUN_GRACE_MS = 5e3;
+const OVERLAPPING_RUN_ERROR = "createQgridLogger received overlapping runs for the same telemetry key. Pass a unique metadata.qgridRunId per AI SDK call or create a fresh logger integration per call.";
+function fullModelName(provider, modelId) {
+	if (!provider || !modelId) return void 0;
+	const prefix = `${provider.split(".", 1)[0] ?? provider}/`;
+	return modelId.startsWith(prefix) ? modelId : `${prefix}${modelId}`;
+}
 function timedKeySet() {
 	const keys = /* @__PURE__ */ new Set();
 	const timers = /* @__PURE__ */ new Map();
@@ -385,8 +391,9 @@ function createQgridLogger(config = {}) {
 	const projectName = config.projectName ?? process.env.QGRID_PROJECT_NAME;
 	const onLogError = config.onLogError ?? ((e) => console.warn(`[qgrid-logger] ${e.message}`));
 	const runs = /* @__PURE__ */ new Map();
+	const starting = /* @__PURE__ */ new Map();
 	const keyTtl = typeof config.staleRunTimeoutMs === "number" && config.staleRunTimeoutMs > 0 ? config.staleRunTimeoutMs : DEFAULT_STALE_RUN_TIMEOUT_MS;
-	const suppressedQgrid = timedKeySet();
+	const suppressedRuns = timedKeySet();
 	const quarantined = timedKeySet();
 	const finalizeRun = async (runKey, result) => {
 		const run = runs.get(runKey);
@@ -403,6 +410,8 @@ function createQgridLogger(config = {}) {
 			toolCallId: pending.toolCallId,
 			toolName: pending.toolName,
 			toolArgs: pending.toolArgs,
+			modelName: pending.modelName,
+			requestedModelName: pending.requestedModelName,
 			toolDurationMs: run.toolDurations.get(pending.toolCallId)
 		}).catch((e) => onLogError(e instanceof Error ? e : new Error(String(e)))));
 		run.pendingToolCalls = [];
@@ -412,6 +421,8 @@ function createQgridLogger(config = {}) {
 			status: result.status,
 			response: result.response,
 			tokenName: config.tokenName ?? "external",
+			modelName: result.modelName,
+			requestedModelName: result.requestedModelName ?? run.requestedModelName,
 			totalInputTokens: result.totalUsage?.inputTokens ?? 0,
 			totalOutputTokens: result.totalUsage?.outputTokens ?? 0,
 			totalCacheReadTokens: result.totalUsage?.inputTokenDetails?.cacheReadTokens ?? 0,
@@ -433,34 +444,63 @@ function createQgridLogger(config = {}) {
 			async onStart(event) {
 				if (!event.metadata?.qgridRunId && !event.functionId && event.metadata) event.metadata.qgridRunId = `auto-${++autoRunIdCounter}`;
 				const runKey = resolveRunKey(event);
+				if (event.model.provider === "qgrid") return;
 				if (quarantined.has(runKey)) {
 					onLogError(/* @__PURE__ */ new Error("createQgridLogger: telemetry key is quarantined after overlap"));
 					return;
 				}
-				if (event.model.provider === "qgrid") {
-					suppressedQgrid.add(runKey, keyTtl);
-					return;
-				}
-				if (runs.has(runKey)) {
-					const msg = "createQgridLogger received overlapping runs for the same telemetry key. Pass a unique metadata.qgridRunId per AI SDK call or create a fresh logger integration per call.";
-					await finalizeRun(runKey, {
+				if (runs.has(runKey) || starting.has(runKey) || suppressedRuns.has(runKey)) {
+					const reservation = starting.get(runKey);
+					if (reservation) {
+						reservation.errorMessage = OVERLAPPING_RUN_ERROR;
+						starting.delete(runKey);
+					}
+					suppressedRuns.remove(runKey);
+					quarantined.add(runKey, keyTtl);
+					const finalizing = finalizeRun(runKey, {
 						status: "error",
-						errorMessage: msg
+						errorMessage: OVERLAPPING_RUN_ERROR
 					});
-					quarantined.add(runKey, keyTtl);
-					onLogError(new Error(msg));
+					onLogError(/* @__PURE__ */ new Error(OVERLAPPING_RUN_ERROR));
+					await finalizing;
 					return;
 				}
+				if (event.providerOptions?.qgrid?.logger === false) {
+					suppressedRuns.add(runKey, keyTtl);
+					return;
+				}
+				const requestedModelName = fullModelName(event.model.provider, event.model.modelId) ?? event.model.modelId;
+				const reservation = {
+					requestedModelName,
+					startTime: Date.now()
+				};
+				starting.set(runKey, reservation);
 				try {
 					const messages = event.messages ?? (Array.isArray(event.prompt) ? event.prompt : void 0);
 					const history = serializeHistory(messages);
 					const result = await createRun(serverUrl, {
 						userPrompt: extractUserPrompt(event.prompt, messages),
 						systemPrompt: extractSystemPrompt(event.system),
-						modelName: event.model.modelId,
+						modelName: requestedModelName,
 						projectName,
 						history
 					});
+					if (reservation.errorMessage || quarantined.has(runKey) || starting.get(runKey) !== reservation) {
+						if (starting.get(runKey) === reservation) starting.delete(runKey);
+						await finishRun(serverUrl, {
+							requestLogId: result.requestLogId,
+							status: "error",
+							tokenName: config.tokenName ?? "external",
+							requestedModelName: reservation.requestedModelName,
+							totalInputTokens: 0,
+							totalOutputTokens: 0,
+							totalCacheReadTokens: 0,
+							totalCacheCreationTokens: 0,
+							totalDurationMs: Date.now() - reservation.startTime,
+							errorMessage: reservation.errorMessage ?? OVERLAPPING_RUN_ERROR
+						}).catch((e) => onLogError(e instanceof Error ? e : new Error(String(e))));
+						return;
+					}
 					let watchdogTimeout = DEFAULT_STALE_RUN_TIMEOUT_MS;
 					if (typeof config.staleRunTimeoutMs === "number") watchdogTimeout = config.staleRunTimeoutMs;
 					else if (typeof event.timeout === "number" && event.timeout > 0) watchdogTimeout = event.timeout + STALE_RUN_GRACE_MS;
@@ -493,8 +533,10 @@ function createQgridLogger(config = {}) {
 							cleanupAbortListener = () => signal.removeEventListener("abort", onAbort);
 						}
 					}
+					starting.delete(runKey);
 					runs.set(runKey, {
 						requestLogId: result.requestLogId,
+						requestedModelName,
 						pendingSteps: [],
 						pendingToolCalls: [],
 						startTime: Date.now(),
@@ -504,22 +546,27 @@ function createQgridLogger(config = {}) {
 						finishing: false
 					});
 				} catch (e) {
+					if (starting.get(runKey) === reservation) starting.delete(runKey);
 					onLogError(e instanceof Error ? e : new Error(String(e)));
 				}
 			},
 			onToolCallFinish(event) {
+				if (event.model?.provider === "qgrid") return;
 				const runKey = resolveRunKey(event);
-				if (suppressedQgrid.has(runKey) || quarantined.has(runKey)) return;
+				if (suppressedRuns.has(runKey) || quarantined.has(runKey)) return;
 				const run = runs.get(runKey);
 				if (!run) return;
 				run.toolDurations.set(event.toolCall.toolCallId, Math.round(event.durationMs));
 			},
 			onStepFinish(event) {
+				if (event.model?.provider === "qgrid") return;
 				const runKey = resolveRunKey(event);
-				if (suppressedQgrid.has(runKey) || quarantined.has(runKey)) return;
+				if (suppressedRuns.has(runKey) || quarantined.has(runKey)) return;
 				const run = runs.get(runKey);
 				if (!run) return;
 				const { content, usage, reasoningText, finishReason, stepNumber } = event;
+				const requestedModelName = fullModelName(event.model?.provider, event.model?.modelId) ?? run.requestedModelName;
+				const modelName = fullModelName(event.model?.provider, event.response?.modelId);
 				const remainingPending = [];
 				for (const pending of run.pendingToolCalls) {
 					const tr = content.find((p) => p.type === "tool-result" && p.toolCallId === pending.toolCallId);
@@ -533,6 +580,8 @@ function createQgridLogger(config = {}) {
 							toolCallId: pending.toolCallId,
 							toolName: pending.toolName,
 							toolArgs: pending.toolArgs,
+							modelName: pending.modelName,
+							requestedModelName: pending.requestedModelName,
 							toolResult: tr && "output" in tr ? safeStringify(tr.output) : void 0,
 							toolDurationMs: run.toolDurations.get(pending.toolCallId),
 							error: te && "error" in te ? safeStringify(te.error) : void 0
@@ -545,6 +594,8 @@ function createQgridLogger(config = {}) {
 					requestLogId: run.requestLogId,
 					stepIndex: stepNumber,
 					type: "generate",
+					modelName,
+					requestedModelName,
 					inputTokens: usage.inputTokens ?? 0,
 					outputTokens: usage.outputTokens ?? 0,
 					cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
@@ -566,6 +617,8 @@ function createQgridLogger(config = {}) {
 							toolCallId: tc.toolCallId,
 							toolName: tc.toolName,
 							toolArgs: safeStringify(tc.input),
+							modelName,
+							requestedModelName,
 							toolResult: tr && "output" in tr ? safeStringify(tr.output) : void 0,
 							toolDurationMs: run.toolDurations.get(tc.toolCallId),
 							error: te && "error" in te ? safeStringify(te.error) : void 0
@@ -576,23 +629,31 @@ function createQgridLogger(config = {}) {
 						toolCallIndex: i,
 						toolCallId: tc.toolCallId,
 						toolName: tc.toolName,
-						toolArgs: safeStringify(tc.input)
+						toolArgs: safeStringify(tc.input),
+						modelName,
+						requestedModelName
 					});
 				}
 			},
 			async onFinish(event) {
+				if (event.model?.provider === "qgrid") return;
 				const runKey = resolveRunKey(event);
-				if (suppressedQgrid.has(runKey)) {
-					suppressedQgrid.remove(runKey);
+				if (suppressedRuns.has(runKey)) {
+					suppressedRuns.remove(runKey);
 					return;
 				}
 				if (quarantined.has(runKey)) return;
-				if (!runs.get(runKey)) return;
+				const run = runs.get(runKey);
+				if (!run) return;
 				const status = event.finishReason === "error" ? "error" : "succeeded";
+				const requestedModelName = fullModelName(event.model?.provider, event.model?.modelId) ?? run.requestedModelName;
+				const modelName = fullModelName(event.model?.provider, event.response?.modelId);
 				await finalizeRun(runKey, {
 					status,
 					response: event.text,
 					totalUsage: event.totalUsage,
+					modelName,
+					requestedModelName,
 					...status === "error" && "error" in event ? { errorMessage: getErrorMessage(event.error) } : {}
 				});
 			}
@@ -675,8 +736,8 @@ function qgrid(modelId, config) {
 	const clientRuns = /* @__PURE__ */ new Map();
 	let anonymousClientRunId = 0;
 	function clientRunKey(runContext) {
-		if (runContext.requestLogId !== void 0) return `request:${runContext.requestLogId}`;
-		if (runContext.threadCoord) {
+		if (runContext?.requestLogId !== void 0) return `request:${runContext.requestLogId}`;
+		if (runContext?.threadCoord) {
 			const { workerId, epoch, threadId } = runContext.threadCoord;
 			return `thread:${workerId}:${epoch}:${threadId}`;
 		}
@@ -721,6 +782,7 @@ function qgrid(modelId, config) {
 			const verbosity = qgridOptions.verbosity;
 			const reasoningSummary = qgridOptions.reasoningSummary;
 			const serviceTier = qgridOptions.serviceTier;
+			const logger = qgridOptions.logger;
 			const imageGenerationOptions = qgridOptions.imageGenerationOptions;
 			if (imageGeneration) assertImageInputFitsJsonTransport(imageUrls);
 			const sessionKey = qgridOptions.sessionKey;
@@ -731,16 +793,13 @@ function qgrid(modelId, config) {
 			const jsonSchema = !hasTools && rawSchema && schemaType === "object" ? JSON.stringify(rawSchema) : void 0;
 			let runContext;
 			let toolResultsPayload;
-			let logMode;
 			const matchedClientRun = matchClientRun(options.prompt);
 			if (matchedClientRun) {
 				runContext = matchedClientRun.runContext;
 				toolResultsPayload = matchedClientRun.toolResultsPayload;
-				logMode = "run";
 			}
 			const storedCoord = reuseSessionKey ? getThreadCoord(reuseSessionKey) : void 0;
-			if (!runContext && storedCoord) runContext = { threadCoord: storedCoord };
-			if (!logMode && hasTools) logMode = "run";
+			if (!matchedClientRun && storedCoord) runContext = { threadCoord: storedCoord };
 			const data = await fetch(`${serverUrl}/api/qgrid/query`, {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
@@ -757,7 +816,7 @@ function qgrid(modelId, config) {
 					...jsonSchema ? { jsonSchema } : {},
 					...history.length > 0 ? { history: JSON.stringify(history) } : {},
 					...projectName ? { projectName } : {},
-					...logMode ? { logMode } : {},
+					...logger === false ? { logger: false } : {},
 					...runContext ? { runContext } : {},
 					...toolResultsPayload ? { toolResults: toolResultsPayload } : {},
 					...imageGeneration ? { imageGeneration } : {},
@@ -800,9 +859,9 @@ function qgrid(modelId, config) {
 				type: "text",
 				text: data.text
 			});
-			if (imageGeneration && !content.some((c) => c.type === "file")) throw new Error("qgrid: imageGeneration was requested but the response contained no image — the server may be an older version that does not support image generation.");
+			if (imageGeneration && finishReason.unified !== "tool-calls" && !content.some((c) => c.type === "file")) throw new Error("qgrid: imageGeneration was requested but the response contained no image — the server may be an older version that does not support image generation.");
 			if (matchedClientRun) clientRuns.delete(matchedClientRun.key);
-			if (data.runContext && finishReason.unified === "tool-calls") rememberClientRun(data.runContext, content.filter((c) => c.type === "tool-call").map((c) => c.toolCallId));
+			if (finishReason.unified === "tool-calls") rememberClientRun(data.runContext, content.filter((c) => c.type === "tool-call").map((c) => c.toolCallId));
 			if (reuseSessionKey && data.runContext?.threadCoord) setThreadCoord(reuseSessionKey, data.runContext.threadCoord);
 			return {
 				content,
@@ -821,6 +880,7 @@ function qgrid(modelId, config) {
 			const verbosity = qgridOptions.verbosity;
 			const reasoningSummary = qgridOptions.reasoningSummary;
 			const serviceTier = qgridOptions.serviceTier;
+			const logger = qgridOptions.logger;
 			if (qgridOptions.imageGeneration) throw new Error("qgrid: imageGeneration is not supported with streamText — use generateText instead.");
 			const { prompt, system, history, droppedImageCount } = extractPromptAndHistory(options.prompt, { includeImages: false });
 			warnDroppedImages(droppedImageCount);
@@ -830,16 +890,13 @@ function qgrid(modelId, config) {
 			const jsonSchema = !hasTools && rawSchema && rawSchema.type === "object" ? JSON.stringify(rawSchema) : void 0;
 			let runContext;
 			let toolResultsPayload;
-			let logMode;
 			const matchedClientRun = matchClientRun(options.prompt);
 			if (matchedClientRun) {
 				runContext = matchedClientRun.runContext;
 				toolResultsPayload = matchedClientRun.toolResultsPayload;
-				logMode = "run";
 			}
 			const storedCoord = reuseSessionKey ? getThreadCoord(reuseSessionKey) : void 0;
-			if (!runContext && storedCoord) runContext = { threadCoord: storedCoord };
-			if (!logMode && hasTools) logMode = "run";
+			if (!matchedClientRun && storedCoord) runContext = { threadCoord: storedCoord };
 			const prepRes = await fetch(`${serverUrl}/api/qgrid/prepareStream`, {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
@@ -855,7 +912,7 @@ function qgrid(modelId, config) {
 					...jsonSchema ? { jsonSchema } : {},
 					...history.length > 0 ? { history: JSON.stringify(history) } : {},
 					...projectName ? { projectName } : {},
-					...logMode ? { logMode } : {},
+					...logger === false ? { logger: false } : {},
 					...runContext ? { runContext } : {},
 					...toolResultsPayload ? { toolResults: toolResultsPayload } : {}
 				} }),
@@ -903,7 +960,7 @@ function qgrid(modelId, config) {
 						}
 						const done = event.data;
 						if (matchedClientRun) clientRuns.delete(matchedClientRun.key);
-						if (done.runContext && done.finishReason === "tool-calls") rememberClientRun(done.runContext, (done.content ?? []).filter((c) => c.type === "tool-call").map((c) => c.toolCallId));
+						if (done.finishReason === "tool-calls") rememberClientRun(done.runContext, (done.content ?? []).filter((c) => c.type === "tool-call").map((c) => c.toolCallId));
 						if (reuseSessionKey && done.runContext?.threadCoord) setThreadCoord(reuseSessionKey, done.runContext.threadCoord);
 						if (done.content) {
 							for (const item of done.content) if (item.type === "text" && !deltaTextEmitted) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cartanova/qgrid-ai-sdk",
-  "version": "2.4.8",
+  "version": "2.5.0",
   "description": "AI SDK LanguageModelV3 provider for qgrid",
   "repository": {
     "type": "git",
@@ -22,16 +22,16 @@
   "devDependencies": {
     "@ai-sdk/provider": "^3.0.0",
     "ai": "^6.0.190",
-    "tsdown": "^0.12.9",
+    "tsdown": "^0.22.3",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.10"
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "@ai-sdk/provider": "^3.0.0",
     "ai": "^6.0.0"
   },
   "scripts": {
-    "build": "tsdown && mv dist/index-*.d.ts dist/index.d.ts",
+    "build": "tsdown",
     "test": "vitest run",
     "e2e": "tsx e2e/e2e.ts",
     "e2e:logger": "tsx e2e/e2e-logger.ts"