@cartanova/qgrid-ai-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,750 @@
+//#region src/utils.ts
+async function createRun(serverUrl, body) {
+	return (await fetch(`${serverUrl}/api/qgrid/createRun`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ input: body })
+	})).json();
+}
+async function appendStep(serverUrl, body) {
+	return (await fetch(`${serverUrl}/api/qgrid/appendStep`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ input: body })
+	})).json();
+}
+async function finishRun(serverUrl, body) {
+	return (await fetch(`${serverUrl}/api/qgrid/finishRun`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ input: body })
+	})).json();
+}
+function toQgridTool(tool) {
+	const source = tool;
+	return {
+		name: tool.name,
+		description: tool.description,
+		inputSchema: source.inputSchema ?? source.parameters ?? {}
+	};
+}
+function extractToolResultsFromHistory(messages) {
+	const calls = /* @__PURE__ */ new Map();
+	const results = /* @__PURE__ */ new Map();
+	for (const msg of messages) if (msg.role === "assistant") {
+		for (const part of msg.content) if ("type" in part && part.type === "tool-call") calls.set(part.toolCallId, {
+			toolName: part.toolName,
+			args: typeof part.input === "string" ? part.input : JSON.stringify(part.input)
+		});
+	} else if (msg.role === "tool") {
+		for (const part of msg.content) if ("type" in part && part.type === "tool-result") {
+			const id = "toolCallId" in part ? part.toolCallId : "";
+			const output = part.output;
+			const text = "value" in output ? typeof output.value === "string" ? output.value : JSON.stringify(output.value) : JSON.stringify(output);
+			results.set(id, text);
+		}
+	}
+	const out = [];
+	for (const [callId, call] of calls) if (results.has(callId)) out.push({
+		callId,
+		toolName: call.toolName,
+		args: call.args,
+		result: results.get(callId)
+	});
+	return out;
+}
+async function* parseSSE(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let eventType = "";
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		const lines = buffer.split("\n");
+		buffer = lines.pop() ?? "";
+		for (const line of lines) if (line.startsWith("event: ")) eventType = line.slice(7).trim();
+		else if (line.startsWith("data: ")) {
+			const raw = line.slice(6);
+			try {
+				yield {
+					type: eventType || "message",
+					data: JSON.parse(raw)
+				};
+			} catch {}
+			eventType = "";
+		}
+	}
+}
+function extractPromptAndHistory(messages) {
+	let system;
+	const nonSystem = [];
+	for (const msg of messages) if (msg.role === "system") system = extractTextFromContent(msg.content);
+	else nonSystem.push(msg);
+	if (nonSystem.length === 0) return {
+		prompt: "",
+		system,
+		history: []
+	};
+	if (nonSystem.length === 1 && nonSystem[0].role === "user") return {
+		prompt: extractTextFromContent(nonSystem[0].content),
+		system,
+		history: []
+	};
+	const last = nonSystem[nonSystem.length - 1];
+	const prompt = last.role === "user" ? extractTextFromContent(last.content) : "";
+	const historyEnd = last.role === "user" ? nonSystem.length - 1 : nonSystem.length;
+	const history = [];
+	for (let i = 0; i < historyEnd; i++) {
+		const msg = nonSystem[i];
+		if (msg.role === "user") history.push({
+			type: "message",
+			role: "user",
+			content: [{
+				type: "input_text",
+				text: extractTextFromContent(msg.content)
+			}]
+		});
+		else if (msg.role === "assistant") {
+			for (const part of msg.content) if ("text" in part && typeof part.text === "string") history.push({
+				type: "message",
+				role: "assistant",
+				content: [{
+					type: "output_text",
+					text: part.text
+				}]
+			});
+			else if ("toolName" in part && part.type === "tool-call") history.push({
+				type: "function_call",
+				name: part.toolName,
+				arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input),
+				call_id: part.toolCallId
+			});
+		} else if (msg.role === "tool") {
+			for (const part of msg.content) if ("toolName" in part && part.type === "tool-result") {
+				const output = part.output;
+				const text = "value" in output ? typeof output.value === "string" ? output.value : JSON.stringify(output.value) : JSON.stringify(output);
+				history.push({
+					type: "function_call_output",
+					call_id: ("toolCallId" in part ? part.toolCallId : "") ?? "",
+					output: text
+				});
+			}
+		}
+	}
+	return {
+		prompt,
+		system,
+		history
+	};
+}
+function extractTextFromContent(content) {
+	if (typeof content === "string") return content;
+	const parts = [];
+	for (const part of content) if ("text" in part && typeof part.text === "string") parts.push(part.text);
+	return parts.join("\n");
+}
+function safeStringify(value) {
+	try {
+		const json = JSON.stringify(value);
+		return json === void 0 ? String(value) : json;
+	} catch {
+		return String(value);
+	}
+}
+function getRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function extractTextContent(content) {
+	if (typeof content === "string") return content;
+	const parts = [];
+	if (Array.isArray(content)) {
+		for (const part of content) if (part && typeof part === "object" && "type" in part) {
+			if (part.type === "text" && "text" in part && typeof part.text === "string") parts.push(part.text);
+		}
+	}
+	return parts.join("\n");
+}
+function getErrorMessage(value) {
+	if (value instanceof Error) return String(value);
+	if (value === void 0 || value === null) return "unknown error";
+	return String(value);
+}
+function extractUserPrompt(prompt, messages) {
+	if (typeof prompt === "string") return prompt;
+	const messageList = Array.isArray(messages) ? messages : Array.isArray(prompt) ? prompt : [];
+	for (let i = messageList.length - 1; i >= 0; i--) {
+		const msg = getRecord(messageList[i]);
+		if (msg?.role === "user") return extractTextContent(msg.content);
+	}
+	return "";
+}
+function extractSystemPrompt(system) {
+	if (typeof system === "string") return system;
+	if (system && typeof system === "object" && "content" in system) {
+		const content = system.content;
+		if (typeof content === "string") return content;
+	}
+}
+function serializeHistory(messages) {
+	if (!Array.isArray(messages) || messages.length === 0) return void 0;
+	const sliced = getRecord(messages[messages.length - 1])?.role === "user" ? messages.slice(0, -1) : messages;
+	const history = [];
+	for (const msg of sliced) {
+		const record = getRecord(msg);
+		if (record?.role !== "user" && record?.role !== "assistant") continue;
+		const text = extractTextContent(record.content);
+		if (text.length === 0) continue;
+		history.push({
+			type: "message",
+			role: record.role,
+			content: [{
+				type: record.role === "user" ? "input_text" : "output_text",
+				text
+			}]
+		});
+	}
+	if (history.length === 0) return void 0;
+	return safeStringify(history);
+}
+//#endregion
+//#region src/logger.ts
+const DEFAULT_RUN_KEY = "__qgrid_default_run__";
+const DEFAULT_STALE_RUN_TIMEOUT_MS = 1800 * 1e3;
+const STALE_RUN_GRACE_MS = 5e3;
+function timedKeySet() {
+	const keys = /* @__PURE__ */ new Set();
+	const timers = /* @__PURE__ */ new Map();
+	return {
+		has: (k) => keys.has(k),
+		add(k, ttlMs) {
+			keys.add(k);
+			const existing = timers.get(k);
+			if (existing) clearTimeout(existing);
+			const t = setTimeout(() => {
+				keys.delete(k);
+				timers.delete(k);
+			}, ttlMs);
+			t.unref?.();
+			timers.set(k, t);
+		},
+		remove(k) {
+			keys.delete(k);
+			const t = timers.get(k);
+			if (t) clearTimeout(t);
+			timers.delete(k);
+		}
+	};
+}
+function createQgridLogger(config) {
+	const runs = /* @__PURE__ */ new Map();
+	const keyTtl = typeof config.staleRunTimeoutMs === "number" && config.staleRunTimeoutMs > 0 ? config.staleRunTimeoutMs : DEFAULT_STALE_RUN_TIMEOUT_MS;
+	const suppressedQgrid = timedKeySet();
+	const quarantined = timedKeySet();
+	const finalizeRun = async (runKey, result) => {
+		const run = runs.get(runKey);
+		if (!run || run.finishing) return;
+		run.finishing = true;
+		runs.delete(runKey);
+		if (run.watchdog) clearTimeout(run.watchdog);
+		run.cleanupAbortListener?.();
+		for (const pending of run.pendingToolCalls) run.pendingSteps.push(appendStep(config.serverUrl, {
+			requestLogId: run.requestLogId,
+			stepIndex: pending.stepIndex,
+			type: "tool_call",
+			toolCallIndex: pending.toolCallIndex,
+			toolCallId: pending.toolCallId,
+			toolName: pending.toolName,
+			toolArgs: pending.toolArgs,
+			toolDurationMs: run.toolDurations.get(pending.toolCallId)
+		}).catch((e) => config.onLogError?.(e instanceof Error ? e : new Error(String(e)))));
+		run.pendingToolCalls = [];
+		await Promise.allSettled(run.pendingSteps);
+		await finishRun(config.serverUrl, {
+			requestLogId: run.requestLogId,
+			status: result.status,
+			response: result.response,
+			tokenName: config.tokenName ?? "external",
+			totalInputTokens: result.totalUsage?.inputTokens ?? 0,
+			totalOutputTokens: result.totalUsage?.outputTokens ?? 0,
+			totalCacheReadTokens: result.totalUsage?.inputTokenDetails?.cacheReadTokens ?? 0,
+			totalCacheCreationTokens: result.totalUsage?.inputTokenDetails?.cacheWriteTokens ?? 0,
+			totalDurationMs: Date.now() - run.startTime,
+			history: run.history,
+			...result.errorMessage ? { errorMessage: result.errorMessage } : {}
+		}).catch((e) => config.onLogError?.(e instanceof Error ? e : new Error(String(e))));
+	};
+	let autoRunIdCounter = 0;
+	const resolveRunKey = (event) => {
+		const qgridRunId = event.metadata?.qgridRunId;
+		if (typeof qgridRunId === "string" && qgridRunId.length > 0) return `qgridRunId:${qgridRunId}`;
+		if (typeof event.functionId === "string" && event.functionId.length > 0) return `functionId:${event.functionId}`;
+		return DEFAULT_RUN_KEY;
+	};
+	return {
+		isEnabled: true,
+		integrations: [{
+			async onStart(event) {
+				if (!event.metadata?.qgridRunId && !event.functionId && event.metadata) event.metadata.qgridRunId = `auto-${++autoRunIdCounter}`;
+				const runKey = resolveRunKey(event);
+				if (quarantined.has(runKey)) {
+					config.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, {
+						status: "error",
+						errorMessage: msg
+					});
+					quarantined.add(runKey, keyTtl);
+					config.onLogError?.(new Error(msg));
+					return;
+				}
+				try {
+					const messages = event.messages ?? (Array.isArray(event.prompt) ? event.prompt : void 0);
+					const result = await createRun(config.serverUrl, {
+						userPrompt: extractUserPrompt(event.prompt, messages),
+						systemPrompt: extractSystemPrompt(event.system),
+						modelName: event.model.modelId,
+						projectName: config.projectName
+					});
+					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;
+					else {
+						const totalMs = getRecord(event.timeout)?.totalMs;
+						if (typeof totalMs === "number" && totalMs > 0) watchdogTimeout = totalMs + STALE_RUN_GRACE_MS;
+					}
+					let watchdog;
+					if (watchdogTimeout > 0) {
+						watchdog = setTimeout(() => {
+							finalizeRun(runKey, {
+								status: "error",
+								errorMessage: "AI SDK generation ended before onFinish was emitted"
+							});
+						}, watchdogTimeout);
+						watchdog.unref?.();
+					}
+					let cleanupAbortListener;
+					const signal = event.abortSignal;
+					if (signal) {
+						const onAbort = () => {
+							finalizeRun(runKey, {
+								status: "aborted",
+								errorMessage: getErrorMessage(signal.reason)
+							});
+						};
+						if (signal.aborted) queueMicrotask(onAbort);
+						else {
+							signal.addEventListener("abort", onAbort, { once: true });
+							cleanupAbortListener = () => signal.removeEventListener("abort", onAbort);
+						}
+					}
+					runs.set(runKey, {
+						requestLogId: result.requestLogId,
+						pendingSteps: [],
+						pendingToolCalls: [],
+						startTime: Date.now(),
+						toolDurations: /* @__PURE__ */ new Map(),
+						history: serializeHistory(messages),
+						watchdog,
+						cleanupAbortListener,
+						finishing: false
+					});
+				} catch (e) {
+					config.onLogError?.(e instanceof Error ? e : new Error(String(e)));
+				}
+			},
+			onToolCallFinish(event) {
+				const runKey = resolveRunKey(event);
+				if (suppressedQgrid.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) {
+				const runKey = resolveRunKey(event);
+				if (suppressedQgrid.has(runKey) || quarantined.has(runKey)) return;
+				const run = runs.get(runKey);
+				if (!run) return;
+				const { content, usage, reasoningText, finishReason, stepNumber } = event;
+				const remainingPending = [];
+				for (const pending of run.pendingToolCalls) {
+					const tr = content.find((p) => p.type === "tool-result" && p.toolCallId === pending.toolCallId);
+					const te = content.find((p) => p.type === "tool-error" && p.toolCallId === pending.toolCallId);
+					if (tr || te) {
+						run.pendingSteps.push(appendStep(config.serverUrl, {
+							requestLogId: run.requestLogId,
+							stepIndex: pending.stepIndex,
+							type: "tool_call",
+							toolCallIndex: pending.toolCallIndex,
+							toolCallId: pending.toolCallId,
+							toolName: pending.toolName,
+							toolArgs: pending.toolArgs,
+							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
+						}).catch((e) => config.onLogError?.(e instanceof Error ? e : new Error(String(e)))));
+						run.toolDurations.delete(pending.toolCallId);
+					} else remainingPending.push(pending);
+				}
+				run.pendingToolCalls = remainingPending;
+				run.pendingSteps.push(appendStep(config.serverUrl, {
+					requestLogId: run.requestLogId,
+					stepIndex: stepNumber,
+					type: "generate",
+					inputTokens: usage.inputTokens ?? 0,
+					outputTokens: usage.outputTokens ?? 0,
+					cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+					cacheCreationTokens: usage.inputTokenDetails?.cacheWriteTokens ?? 0,
+					finishReason,
+					reasoningText: typeof reasoningText === "string" && reasoningText.length > 0 ? reasoningText : void 0,
+					reasoningTokens: usage.outputTokenDetails?.reasoningTokens
+				}).catch((e) => config.onLogError?.(e instanceof Error ? e : new Error(String(e)))));
+				const toolCalls = content.filter((p) => p.type === "tool-call");
+				for (const [i, tc] of toolCalls.entries()) {
+					const tr = content.find((p) => p.type === "tool-result" && p.toolCallId === tc.toolCallId);
+					const te = content.find((p) => p.type === "tool-error" && p.toolCallId === tc.toolCallId);
+					if (tr || te) {
+						run.pendingSteps.push(appendStep(config.serverUrl, {
+							requestLogId: run.requestLogId,
+							stepIndex: stepNumber,
+							type: "tool_call",
+							toolCallIndex: i,
+							toolCallId: tc.toolCallId,
+							toolName: tc.toolName,
+							toolArgs: safeStringify(tc.input),
+							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
+						}).catch((e) => config.onLogError?.(e instanceof Error ? e : new Error(String(e)))));
+						run.toolDurations.delete(tc.toolCallId);
+					} else run.pendingToolCalls.push({
+						stepIndex: stepNumber,
+						toolCallIndex: i,
+						toolCallId: tc.toolCallId,
+						toolName: tc.toolName,
+						toolArgs: safeStringify(tc.input)
+					});
+				}
+			},
+			async onFinish(event) {
+				const runKey = resolveRunKey(event);
+				if (suppressedQgrid.has(runKey)) {
+					suppressedQgrid.remove(runKey);
+					return;
+				}
+				if (quarantined.has(runKey)) return;
+				if (!runs.get(runKey)) return;
+				const status = event.finishReason === "error" ? "error" : "succeeded";
+				await finalizeRun(runKey, {
+					status,
+					response: event.text,
+					totalUsage: event.totalUsage,
+					...status === "error" && "error" in event ? { errorMessage: getErrorMessage(event.error) } : {}
+				});
+			}
+		}]
+	};
+}
+//#endregion
+//#region src/index.ts
+const DEFAULT_SERVER_URL = "http://localhost:44900";
+const DEFAULT_EFFORT = "low";
+function qgrid(modelId, config) {
+	const serverUrl = config?.serverUrl ?? process.env.QGRID_URL ?? DEFAULT_SERVER_URL;
+	const effort = config?.defaultEffort ?? DEFAULT_EFFORT;
+	let clientRun = null;
+	return {
+		specificationVersion: "v3",
+		provider: "qgrid",
+		modelId,
+		supportedUrls: {},
+		async doGenerate(options) {
+			const tools = options.tools?.filter((t) => t.type === "function");
+			const hasTools = tools && tools.length > 0;
+			const { prompt, system, history } = extractPromptAndHistory(options.prompt);
+			const openaiOpts = options.providerOptions?.openai;
+			const effectiveEffort = openaiOpts?.reasoningEffort ?? effort;
+			const verbosity = openaiOpts?.textVerbosity ?? openaiOpts?.verbosity;
+			const reasoningSummary = openaiOpts?.reasoningSummary;
+			const rawSchema = options.responseFormat?.type === "json" ? options.responseFormat.schema : void 0;
+			const schemaType = rawSchema ? rawSchema.type : void 0;
+			if (rawSchema && !hasTools && schemaType !== "object") console.warn(`[qgrid] responseFormat.schema top-level type is "${schemaType ?? "unknown"}". OpenAI structured output requires "object". Falling back to client-side parsing.`);
+			const jsonSchema = !hasTools && rawSchema && schemaType === "object" ? JSON.stringify(rawSchema) : void 0;
+			let runContext;
+			let toolResultsPayload;
+			let logMode;
+			if (clientRun) {
+				const toolResults = extractToolResultsFromHistory(options.prompt);
+				const resultIds = new Set(toolResults.map((r) => r.callId));
+				if (clientRun.pendingToolCallIds.size > 0 && [...clientRun.pendingToolCallIds].every((id) => resultIds.has(id))) {
+					runContext = clientRun.runContext;
+					toolResultsPayload = toolResults.filter((r) => clientRun.pendingToolCallIds.has(r.callId)).map((r) => ({
+						toolCallId: r.callId,
+						output: r.result
+					}));
+					logMode = "run";
+				} else {
+					console.warn("[qgrid] pending tool results not found in prompt, clearing client run state");
+					clientRun = null;
+				}
+			}
+			if (!logMode && hasTools) logMode = "run";
+			const data = await fetch(`${serverUrl}/api/qgrid/query`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ args: {
+					prompt,
+					model: modelId,
+					system,
+					effort: effectiveEffort,
+					...verbosity ? { verbosity } : {},
+					...reasoningSummary ? { reasoningSummary } : {},
+					...hasTools ? { tools: tools.map(toQgridTool) } : {},
+					...jsonSchema ? { jsonSchema } : {},
+					...history.length > 0 ? { history: JSON.stringify(history) } : {},
+					...logMode ? { logMode } : {},
+					...runContext ? { runContext } : {},
+					...toolResultsPayload ? { toolResults: toolResultsPayload } : {}
+				} }),
+				signal: options.abortSignal
+			}).then(async (res) => {
+				if (!res.ok) {
+					const text = await res.text().catch(() => "");
+					throw new Error(`qgrid ${res.status}: ${text}`);
+				}
+				return await res.json();
+			});
+			const content = [];
+			let finishReason = {
+				unified: "stop",
+				raw: "stop"
+			};
+			if (data.content) {
+				for (const item of data.content) if (item.type === "text") content.push({
+					type: "text",
+					text: item.text
+				});
+				else content.push({
+					type: "tool-call",
+					toolCallId: item.toolCallId,
+					toolName: item.toolName,
+					input: item.input
+				});
+				if (data.finishReason === "tool-calls") finishReason = {
+					unified: "tool-calls",
+					raw: "tool_call"
+				};
+			} else content.push({
+				type: "text",
+				text: data.text
+			});
+			if (data.runContext && finishReason.unified === "tool-calls") clientRun = {
+				runContext: data.runContext,
+				pendingToolCallIds: new Set(content.filter((c) => c.type === "tool-call").map((c) => c.toolCallId))
+			};
+			else clientRun = null;
+			return {
+				content,
+				finishReason,
+				usage: {
+					inputTokens: {
+						total: data.usage.input_tokens,
+						noCache: data.usage.input_tokens - data.usage.cache_read_input_tokens,
+						cacheRead: data.usage.cache_read_input_tokens,
+						cacheWrite: data.usage.cache_creation_input_tokens
+					},
+					outputTokens: {
+						total: data.usage.output_tokens,
+						text: data.usage.output_tokens,
+						reasoning: void 0
+					}
+				},
+				warnings: [],
+				providerMetadata: { qgrid: {
+					model: data.model,
+					tokenName: data.tokenName ?? null,
+					durationMs: data.durationMs,
+					costUsd: data.costUsd
+				} },
+				response: { modelId: data.model }
+			};
+		},
+		async doStream(options) {
+			const tools = options.tools?.filter((t) => t.type === "function");
+			const hasTools = tools && tools.length > 0;
+			const { prompt, system, history } = extractPromptAndHistory(options.prompt);
+			const openaiOpts = options.providerOptions?.openai;
+			const effectiveEffort = openaiOpts?.reasoningEffort ?? effort;
+			const verbosity = openaiOpts?.textVerbosity ?? openaiOpts?.verbosity;
+			const reasoningSummary = openaiOpts?.reasoningSummary;
+			const rawSchema = options.responseFormat?.type === "json" ? options.responseFormat.schema : void 0;
+			const jsonSchema = !hasTools && rawSchema && rawSchema.type === "object" ? JSON.stringify(rawSchema) : void 0;
+			let runContext;
+			let toolResultsPayload;
+			if (clientRun) {
+				const toolResults = extractToolResultsFromHistory(options.prompt);
+				const resultIds = new Set(toolResults.map((r) => r.callId));
+				if (clientRun.pendingToolCallIds.size > 0 && [...clientRun.pendingToolCallIds].every((id) => resultIds.has(id))) {
+					runContext = clientRun.runContext;
+					toolResultsPayload = toolResults.filter((r) => clientRun.pendingToolCallIds.has(r.callId)).map((r) => ({
+						toolCallId: r.callId,
+						output: r.result
+					}));
+				} else {
+					console.warn("[qgrid] pending tool results not found in prompt, clearing client run state");
+					clientRun = null;
+				}
+			}
+			const prepRes = await fetch(`${serverUrl}/api/qgrid/prepareStream`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ args: {
+					prompt,
+					model: modelId,
+					system,
+					effort: effectiveEffort,
+					...verbosity ? { verbosity } : {},
+					...reasoningSummary ? { reasoningSummary } : {},
+					...hasTools ? { tools: tools.map(toQgridTool) } : {},
+					...jsonSchema ? { jsonSchema } : {},
+					...history.length > 0 ? { history: JSON.stringify(history) } : {},
+					logMode: "run",
+					...runContext ? { runContext } : {},
+					...toolResultsPayload ? { toolResults: toolResultsPayload } : {}
+				} }),
+				signal: options.abortSignal
+			});
+			if (!prepRes.ok) {
+				const text = await prepRes.text().catch(() => "");
+				throw new Error(`qgrid prepareStream ${prepRes.status}: ${text}`);
+			}
+			const { streamId } = await prepRes.json();
+			const streamRes = await fetch(`${serverUrl}/api/qgrid/queryStream?streamId=${streamId}`, { signal: options.abortSignal });
+			if (!streamRes.ok || !streamRes.body) {
+				const text = await streamRes.text().catch(() => "");
+				throw new Error(`qgrid stream ${streamRes.status}: ${text}`);
+			}
+			const textId = `text_${Math.random().toString(36).slice(2, 10)}`;
+			let textStarted = false;
+			let deltaTextEmitted = false;
+			return { stream: new ReadableStream({ async start(controller) {
+				try {
+					let streamCompleted = false;
+					for await (const event of parseSSE(streamRes.body)) if (event.type === "delta") {
+						if (!hasTools) {
+							if (!textStarted) {
+								controller.enqueue({
+									type: "text-start",
+									id: textId
+								});
+								textStarted = true;
+							}
+							controller.enqueue({
+								type: "text-delta",
+								id: textId,
+								delta: event.data.text
+							});
+							deltaTextEmitted = true;
+						}
+					} else if (event.type === "done") {
+						if (textStarted) {
+							controller.enqueue({
+								type: "text-end",
+								id: textId
+							});
+							textStarted = false;
+						}
+						const done = event.data;
+						if (done.runContext && done.finishReason === "tool-calls") clientRun = {
+							runContext: done.runContext,
+							pendingToolCallIds: new Set((done.content ?? []).filter((c) => c.type === "tool-call").map((c) => c.toolCallId))
+						};
+						else clientRun = null;
+						if (done.content) {
+							for (const item of done.content) if (item.type === "text" && !deltaTextEmitted) {
+								const tid = `text_${Math.random().toString(36).slice(2, 10)}`;
+								controller.enqueue({
+									type: "text-start",
+									id: tid
+								});
+								controller.enqueue({
+									type: "text-delta",
+									id: tid,
+									delta: item.text
+								});
+								controller.enqueue({
+									type: "text-end",
+									id: tid
+								});
+							} else if (item.type === "tool-call") {
+								controller.enqueue({
+									type: "tool-input-start",
+									id: item.toolCallId,
+									toolName: item.toolName
+								});
+								controller.enqueue({
+									type: "tool-input-delta",
+									id: item.toolCallId,
+									delta: item.input
+								});
+								controller.enqueue({
+									type: "tool-input-end",
+									id: item.toolCallId
+								});
+								controller.enqueue({
+									type: "tool-call",
+									toolCallId: item.toolCallId,
+									toolName: item.toolName,
+									input: item.input
+								});
+							}
+						}
+						controller.enqueue({
+							type: "finish",
+							finishReason: done.finishReason === "tool-calls" ? {
+								unified: "tool-calls",
+								raw: "tool_call"
+							} : {
+								unified: "stop",
+								raw: "stop"
+							},
+							usage: {
+								inputTokens: {
+									total: done.usage.input_tokens,
+									noCache: done.usage.input_tokens - done.usage.cache_read_input_tokens,
+									cacheRead: done.usage.cache_read_input_tokens,
+									cacheWrite: done.usage.cache_creation_input_tokens
+								},
+								outputTokens: {
+									total: done.usage.output_tokens,
+									text: done.usage.output_tokens,
+									reasoning: void 0
+								}
+							}
+						});
+						streamCompleted = true;
+						controller.close();
+						return;
+					} else if (event.type === "error") {
+						streamCompleted = true;
+						controller.error(new Error(event.data.message));
+						return;
+					}
+					if (!streamCompleted) controller.error(/* @__PURE__ */ new Error("qgrid stream ended unexpectedly"));
+				} catch (e) {
+					controller.error(e);
+				}
+			} }) };
+		}
+	};
+}
+//#endregion
+export { createQgridLogger, qgrid as default, qgrid };