pi2dsh 0.3.4 → 0.4.0

package/dist/dist-DeonWo7m.mjs

@@ -0,0 +1,1089 @@
+
+import { a as AssistantMessageEventStream, i as formatThrownValue, n as createAssistantMessageDiagnostic, o as EventStream, r as extractDiagnosticError, s as createAssistantMessageEventStream, t as appendAssistantMessageDiagnostic } from "./diagnostics-CJye1UFh.mjs";
+import { _ as lazyStream, a as calculateCost, c as createProvider, d as modelsAreEqual, f as InMemoryModelsStore, g as lazyApi, h as defaultProviderAuthContext, i as lazyOAuth, l as getSupportedThinkingLevels, m as InMemoryCredentialStore, n as createImagesProvider, o as clampThinkingLevel, p as ModelsError, r as envApiKeyAuth, s as createModels, t as createImagesModels, u as hasApi } from "./images-models-DJtHo9Rp.mjs";
+import { n as parseStreamingJson, r as repairJson, t as parseJsonWithRepair } from "./json-parse-Dz5sKMTv.mjs";
+import { n as cleanupSessionResources, r as registerSessionResourceCleanup, t as uuidv7 } from "./uuid-DtFT7tOE.mjs";
+import { Type, Type as Type$1 } from "typebox";
+import { Compile } from "typebox/compile";
+import { Value } from "typebox/value";
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/providers/faux.js
+const DEFAULT_API = "faux";
+const DEFAULT_PROVIDER = "faux";
+const DEFAULT_MODEL_ID = "faux-1";
+const DEFAULT_MODEL_NAME = "Faux Model";
+const DEFAULT_BASE_URL = "http://localhost:0";
+const DEFAULT_MIN_TOKEN_SIZE = 3;
+const DEFAULT_MAX_TOKEN_SIZE = 5;
+const DEFAULT_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		total: 0
+	}
+};
+function fauxText(text) {
+	return {
+		type: "text",
+		text
+	};
+}
+function fauxThinking(thinking) {
+	return {
+		type: "thinking",
+		thinking
+	};
+}
+function fauxToolCall(name, arguments_, options = {}) {
+	return {
+		type: "toolCall",
+		id: options.id ?? randomId("tool"),
+		name,
+		arguments: arguments_
+	};
+}
+function normalizeFauxAssistantContent(content) {
+	if (typeof content === "string") return [fauxText(content)];
+	return Array.isArray(content) ? content : [content];
+}
+function fauxAssistantMessage(content, options = {}) {
+	return {
+		role: "assistant",
+		content: normalizeFauxAssistantContent(content),
+		api: DEFAULT_API,
+		provider: DEFAULT_PROVIDER,
+		model: DEFAULT_MODEL_ID,
+		usage: DEFAULT_USAGE,
+		stopReason: options.stopReason ?? "stop",
+		deferred: options.deferred,
+		errorMessage: options.errorMessage,
+		responseId: options.responseId,
+		timestamp: options.timestamp ?? Date.now()
+	};
+}
+function estimateTokens(text) {
+	return Math.ceil(text.length / 4);
+}
+function randomId(prefix) {
+	return `${prefix}:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+}
+function contentToText(content) {
+	if (typeof content === "string") return content;
+	return content.map((block) => {
+		if (block.type === "text") return block.text;
+		return `[image:${block.mimeType}:${block.data.length}]`;
+	}).join("\n");
+}
+function assistantContentToText(content) {
+	return content.map((block) => {
+		if (block.type === "text") return block.text;
+		if (block.type === "thinking") return block.thinking;
+		return `${block.name}:${JSON.stringify(block.arguments)}`;
+	}).join("\n");
+}
+function toolResultToText(message) {
+	return [message.toolName, ...message.content.map((block) => contentToText([block]))].join("\n");
+}
+function messageToText(message) {
+	if (message.role === "user") return contentToText(message.content);
+	if (message.role === "assistant") return assistantContentToText(message.content);
+	return toolResultToText(message);
+}
+function serializeContext(context) {
+	const parts = [];
+	if (context.systemPrompt) parts.push(`system:${context.systemPrompt}`);
+	for (const message of context.messages) parts.push(`${message.role}:${messageToText(message)}`);
+	if (context.tools?.length) parts.push(`tools:${JSON.stringify(context.tools)}`);
+	return parts.join("\n\n");
+}
+function commonPrefixLength(a, b) {
+	const length = Math.min(a.length, b.length);
+	let index = 0;
+	while (index < length && a[index] === b[index]) index++;
+	return index;
+}
+function withUsageEstimate(message, context, options, promptCache) {
+	const promptText = serializeContext(context);
+	const promptTokens = estimateTokens(promptText);
+	const outputTokens = estimateTokens(assistantContentToText(message.content));
+	let input = promptTokens;
+	let cacheRead = 0;
+	let cacheWrite = 0;
+	const sessionId = options?.sessionId;
+	if (sessionId && options?.cacheRetention !== "none") {
+		const previousPrompt = promptCache.get(sessionId);
+		if (previousPrompt) {
+			const cachedChars = commonPrefixLength(previousPrompt, promptText);
+			cacheRead = estimateTokens(previousPrompt.slice(0, cachedChars));
+			cacheWrite = estimateTokens(promptText.slice(cachedChars));
+			input = Math.max(0, promptTokens - cacheRead);
+		} else cacheWrite = promptTokens;
+		promptCache.set(sessionId, promptText);
+	}
+	return {
+		...message,
+		usage: {
+			input,
+			output: outputTokens,
+			cacheRead,
+			cacheWrite,
+			totalTokens: input + outputTokens + cacheRead + cacheWrite,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		}
+	};
+}
+function splitStringByTokenSize(text, minTokenSize, maxTokenSize) {
+	const chunks = [];
+	let index = 0;
+	while (index < text.length) {
+		const tokenSize = minTokenSize + Math.floor(Math.random() * (maxTokenSize - minTokenSize + 1));
+		const charSize = Math.max(1, tokenSize * 4);
+		chunks.push(text.slice(index, index + charSize));
+		index += charSize;
+	}
+	return chunks.length > 0 ? chunks : [""];
+}
+function cloneMessage(message, api, provider, modelId) {
+	const cloned = structuredClone(message);
+	return {
+		...cloned,
+		api,
+		provider,
+		model: modelId,
+		timestamp: cloned.timestamp ?? Date.now(),
+		usage: cloned.usage ?? DEFAULT_USAGE
+	};
+}
+function createDeferredMessage(model, handle) {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: DEFAULT_USAGE,
+		stopReason: "deferred",
+		deferred: handle,
+		timestamp: Date.now()
+	};
+}
+function createErrorMessage(error, api, provider, modelId) {
+	return {
+		role: "assistant",
+		content: [],
+		api,
+		provider,
+		model: modelId,
+		usage: DEFAULT_USAGE,
+		stopReason: "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp: Date.now()
+	};
+}
+function createAbortedMessage(partial) {
+	return {
+		...partial,
+		stopReason: "aborted",
+		errorMessage: "Request was aborted",
+		timestamp: Date.now()
+	};
+}
+function scheduleChunk(chunk, tokensPerSecond) {
+	if (!tokensPerSecond || tokensPerSecond <= 0) return new Promise((resolve) => queueMicrotask(resolve));
+	const delayMs = estimateTokens(chunk) / tokensPerSecond * 1e3;
+	return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+async function streamWithDeltas(stream, message, minTokenSize, maxTokenSize, tokensPerSecond, signal) {
+	const partial = {
+		...message,
+		content: [],
+		stopReason: "pending"
+	};
+	if (signal?.aborted) {
+		const aborted = createAbortedMessage(partial);
+		stream.push({
+			type: "error",
+			reason: "aborted",
+			error: aborted
+		});
+		stream.end(aborted);
+		return;
+	}
+	stream.push({
+		type: "start",
+		partial: { ...partial }
+	});
+	for (let index = 0; index < message.content.length; index++) {
+		if (signal?.aborted) {
+			const aborted = createAbortedMessage(partial);
+			stream.push({
+				type: "error",
+				reason: "aborted",
+				error: aborted
+			});
+			stream.end(aborted);
+			return;
+		}
+		const block = message.content[index];
+		if (block.type === "thinking") {
+			partial.content = [...partial.content, {
+				type: "thinking",
+				thinking: ""
+			}];
+			stream.push({
+				type: "thinking_start",
+				contentIndex: index,
+				partial: { ...partial }
+			});
+			for (const chunk of splitStringByTokenSize(block.thinking, minTokenSize, maxTokenSize)) {
+				await scheduleChunk(chunk, tokensPerSecond);
+				if (signal?.aborted) {
+					const aborted = createAbortedMessage(partial);
+					stream.push({
+						type: "error",
+						reason: "aborted",
+						error: aborted
+					});
+					stream.end(aborted);
+					return;
+				}
+				partial.content[index].thinking += chunk;
+				stream.push({
+					type: "thinking_delta",
+					contentIndex: index,
+					delta: chunk,
+					partial: { ...partial }
+				});
+			}
+			stream.push({
+				type: "thinking_end",
+				contentIndex: index,
+				content: block.thinking,
+				partial: { ...partial }
+			});
+			continue;
+		}
+		if (block.type === "text") {
+			partial.content = [...partial.content, {
+				type: "text",
+				text: ""
+			}];
+			stream.push({
+				type: "text_start",
+				contentIndex: index,
+				partial: { ...partial }
+			});
+			for (const chunk of splitStringByTokenSize(block.text, minTokenSize, maxTokenSize)) {
+				await scheduleChunk(chunk, tokensPerSecond);
+				if (signal?.aborted) {
+					const aborted = createAbortedMessage(partial);
+					stream.push({
+						type: "error",
+						reason: "aborted",
+						error: aborted
+					});
+					stream.end(aborted);
+					return;
+				}
+				partial.content[index].text += chunk;
+				stream.push({
+					type: "text_delta",
+					contentIndex: index,
+					delta: chunk,
+					partial: { ...partial }
+				});
+			}
+			stream.push({
+				type: "text_end",
+				contentIndex: index,
+				content: block.text,
+				partial: { ...partial }
+			});
+			continue;
+		}
+		partial.content = [...partial.content, {
+			type: "toolCall",
+			id: block.id,
+			name: block.name,
+			arguments: {}
+		}];
+		stream.push({
+			type: "toolcall_start",
+			contentIndex: index,
+			partial: { ...partial }
+		});
+		for (const chunk of splitStringByTokenSize(JSON.stringify(block.arguments), minTokenSize, maxTokenSize)) {
+			await scheduleChunk(chunk, tokensPerSecond);
+			if (signal?.aborted) {
+				const aborted = createAbortedMessage(partial);
+				stream.push({
+					type: "error",
+					reason: "aborted",
+					error: aborted
+				});
+				stream.end(aborted);
+				return;
+			}
+			stream.push({
+				type: "toolcall_delta",
+				contentIndex: index,
+				delta: chunk,
+				partial: { ...partial }
+			});
+		}
+		partial.content[index].arguments = block.arguments;
+		stream.push({
+			type: "toolcall_end",
+			contentIndex: index,
+			toolCall: block,
+			partial: { ...partial }
+		});
+	}
+	if (message.stopReason === "pending") throw new Error("Faux response ended without a stop reason");
+	if (message.stopReason === "error" || message.stopReason === "aborted") {
+		stream.push({
+			type: "error",
+			reason: message.stopReason,
+			error: message
+		});
+		stream.end(message);
+		return;
+	}
+	stream.push({
+		type: "done",
+		reason: message.stopReason,
+		message
+	});
+	stream.end(message);
+}
+function createFauxCore(options) {
+	const api = options.api ?? randomId(DEFAULT_API);
+	const provider = options.provider ?? DEFAULT_PROVIDER;
+	const minTokenSize = Math.max(1, Math.min(options.tokenSize?.min ?? DEFAULT_MIN_TOKEN_SIZE, options.tokenSize?.max ?? DEFAULT_MAX_TOKEN_SIZE));
+	const maxTokenSize = Math.max(minTokenSize, options.tokenSize?.max ?? DEFAULT_MAX_TOKEN_SIZE);
+	let pendingResponses = [];
+	const tokensPerSecond = options.tokensPerSecond;
+	const state = {
+		callCount: 0,
+		deferredFetchCount: 0,
+		cancelledDeferred: []
+	};
+	const promptCache = /* @__PURE__ */ new Map();
+	const deferredResponses = /* @__PURE__ */ new Map();
+	const models = (options.models?.length ? options.models : [{
+		id: DEFAULT_MODEL_ID,
+		name: DEFAULT_MODEL_NAME,
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 128e3,
+		maxTokens: 16384
+	}]).map((definition) => ({
+		id: definition.id,
+		name: definition.name ?? definition.id,
+		api,
+		provider,
+		baseUrl: DEFAULT_BASE_URL,
+		reasoning: definition.reasoning ?? false,
+		input: definition.input ?? ["text", "image"],
+		cost: definition.cost ?? {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: definition.contextWindow ?? 128e3,
+		maxTokens: definition.maxTokens ?? 16384
+	}));
+	const resolveResponse = async (step, context, streamOptions, requestModel) => {
+		return withUsageEstimate(cloneMessage(typeof step === "function" ? await step(context, streamOptions, state, requestModel) : step, api, provider, requestModel.id), context, streamOptions, promptCache);
+	};
+	const stream = (requestModel, context, streamOptions) => {
+		const outer = createAssistantMessageEventStream();
+		const step = pendingResponses.shift();
+		state.callCount++;
+		queueMicrotask(async () => {
+			try {
+				await streamOptions?.onResponse?.({
+					status: 200,
+					headers: {}
+				}, requestModel);
+				if (!step) {
+					let message = createErrorMessage(/* @__PURE__ */ new Error("No more faux responses queued"), api, provider, requestModel.id);
+					message = withUsageEstimate(message, context, streamOptions, promptCache);
+					outer.push({
+						type: "error",
+						reason: "error",
+						error: message
+					});
+					outer.end(message);
+					return;
+				}
+				if (streamOptions?.deferred) {
+					const handle = {
+						provider: requestModel.provider,
+						modelId: requestModel.id,
+						api: requestModel.api,
+						id: randomId("deferred"),
+						...options.deferred?.pollAfterMs !== void 0 ? { pollAfterMs: options.deferred.pollAfterMs } : {}
+					};
+					deferredResponses.set(handle.id, {
+						handle,
+						step,
+						context,
+						options: streamOptions,
+						model: requestModel,
+						pendingFetches: Math.max(0, Math.floor(options.deferred?.pendingFetches ?? 0)),
+						cancelled: false
+					});
+					await streamWithDeltas(outer, createDeferredMessage(requestModel, handle), minTokenSize, maxTokenSize, tokensPerSecond, streamOptions.signal);
+					return;
+				}
+				const message = await resolveResponse(step, context, streamOptions, requestModel);
+				await streamWithDeltas(outer, message, minTokenSize, maxTokenSize, tokensPerSecond, streamOptions?.signal);
+			} catch (error) {
+				const message = createErrorMessage(error, api, provider, requestModel.id);
+				outer.push({
+					type: "error",
+					reason: "error",
+					error: message
+				});
+				outer.end(message);
+			}
+		});
+		return outer;
+	};
+	const streamSimple = (streamModel, context, streamOptions) => stream(streamModel, context, streamOptions);
+	const fetchDeferred = (requestModel, handle, fetchOptions) => {
+		const outer = createAssistantMessageEventStream();
+		state.deferredFetchCount++;
+		queueMicrotask(async () => {
+			try {
+				await fetchOptions?.onResponse?.({
+					status: 200,
+					headers: {}
+				}, requestModel);
+				const entry = deferredResponses.get(handle.id);
+				if (!entry || entry.handle.provider !== handle.provider || entry.handle.modelId !== handle.modelId || entry.handle.api !== handle.api) throw new Error(`Unknown faux deferred response: ${handle.id}`);
+				if (entry.cancelled) throw new Error(`Faux deferred response was cancelled: ${handle.id}`);
+				if (entry.pendingFetches > 0) {
+					entry.pendingFetches--;
+					await streamWithDeltas(outer, createDeferredMessage(requestModel, entry.handle), minTokenSize, maxTokenSize, tokensPerSecond, fetchOptions?.signal);
+					return;
+				}
+				if (!entry.final) {
+					const { deferred: _deferred, signal: _submissionSignal, onResponse: _submissionOnResponse, ...submissionOptions } = entry.options ?? {};
+					try {
+						entry.final = await resolveResponse(entry.step, entry.context, submissionOptions, entry.model);
+					} catch (error) {
+						entry.final = createErrorMessage(error, api, provider, entry.model.id);
+					}
+				}
+				await streamWithDeltas(outer, entry.final, minTokenSize, maxTokenSize, tokensPerSecond, fetchOptions?.signal);
+			} catch (error) {
+				const message = createErrorMessage(error, api, provider, requestModel.id);
+				outer.push({
+					type: "error",
+					reason: "error",
+					error: message
+				});
+				outer.end(message);
+			}
+		});
+		return outer;
+	};
+	const cancelDeferred = async (requestModel, handle, cancelOptions) => {
+		state.cancelledDeferred.push(structuredClone(handle));
+		const entry = deferredResponses.get(handle.id);
+		if (entry) entry.cancelled = true;
+		await cancelOptions?.onResponse?.({
+			status: 200,
+			headers: {}
+		}, requestModel);
+	};
+	function getModel(requestedModelId) {
+		if (!requestedModelId) return models[0];
+		return models.find((candidate) => candidate.id === requestedModelId);
+	}
+	return {
+		api,
+		provider,
+		models,
+		stream,
+		streamSimple,
+		fetchDeferred,
+		cancelDeferred,
+		getModel,
+		state,
+		setResponses(responses) {
+			pendingResponses = [...responses];
+		},
+		appendResponses(responses) {
+			pendingResponses.push(...responses);
+		},
+		getPendingResponseCount() {
+			return pendingResponses.length;
+		}
+	};
+}
+/**
+* Faux provider for tests built on explicit `Models` collections:
+*
+* ```ts
+* const faux = fauxProvider();
+* const models = createModels();
+* models.setProvider(faux.provider);
+* faux.setResponses([fauxAssistantMessage("hi")]);
+* ```
+*/
+function fauxProvider(options = {}) {
+	const core = createFauxCore(options);
+	return {
+		provider: createProvider({
+			id: core.provider,
+			auth: { apiKey: {
+				name: "Faux",
+				resolve: async () => ({ auth: {} })
+			} },
+			models: core.models,
+			api: {
+				stream: core.stream,
+				streamSimple: core.streamSimple,
+				fetchDeferred: core.fetchDeferred,
+				cancelDeferred: core.cancelDeferred
+			}
+		}),
+		api: core.api,
+		models: core.models,
+		getModel: core.getModel,
+		state: core.state,
+		setResponses: core.setResponses,
+		appendResponses: core.appendResponses,
+		getPendingResponseCount: core.getPendingResponseCount
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/utils/overflow.js
+/**
+* Regex patterns to detect context overflow errors from different providers.
+*
+* These patterns match error messages returned when the input exceeds
+* the model's context window.
+*
+* Provider-specific patterns (with example error messages):
+*
+* - Anthropic: "prompt is too long: 213462 tokens > 200000 maximum"
+* - Anthropic: "413 {\"error\":{\"type\":\"request_too_large\",\"message\":\"Request exceeds the maximum size\"}}"
+* - OpenAI: "Your input exceeds the context window of this model"
+* - OpenAI/LiteLLM: "Requested token count exceeds the model's maximum context length of 131072 tokens"
+* - OpenAI-compatible: "Input length (265330) exceeds model's maximum context length (262144)."
+* - Google: "The input token count (1196265) exceeds the maximum number of tokens allowed (1048575)"
+* - xAI: "This model's maximum prompt length is 131072 but the request contains 537812 tokens"
+* - Groq: "Please reduce the length of the messages or completion"
+* - OpenRouter: "This endpoint's maximum context length is X tokens. However, you requested about Y tokens"
+* - OpenRouter/Poolside: "Input length X exceeds the maximum allowed input length of Y tokens."
+* - Together AI: "The input (X tokens) is longer than the model's context length (Y tokens)."
+* - llama.cpp: "the request exceeds the available context size, try increasing it"
+* - LM Studio: "tokens to keep from the initial prompt is greater than the context length"
+* - GitHub Copilot: "prompt token count of X exceeds the limit of Y"
+* - MiniMax: "invalid params, context window exceeds limit"
+* - Kimi For Coding: "Your request exceeded model token limit: X (requested: Y)"
+* - DS4: "Prompt has X tokens, but the configured context size is Y tokens"
+* - Cerebras: "400/413 status code (no body)"
+* - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
+* - z.ai: Does NOT error, accepts overflow silently - handled via usage.input > contextWindow
+* - Xiaomi MiMo: Truncates input to fill contextWindow exactly, then returns finish_reason "length"
+*   with output=0 (no room left to generate). Detected via stopReason "length" + zero output +
+*   input filling the context window.
+* - DashScope/Qwen: "Range of input length should be [1, X]" (HTTP 400 invalid_parameter_error)
+* - Ollama: Some deployments truncate silently, others return errors like "prompt too long; exceeded max context length by X tokens"
+*/
+const OVERFLOW_PATTERNS = [
+	/prompt is too long/i,
+	/request_too_large/i,
+	/input is too long for requested model/i,
+	/exceeds the context window/i,
+	/exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
+	/input token count.*exceeds the maximum/i,
+	/maximum prompt length is \d+/i,
+	/reduce the length of the messages/i,
+	/maximum context length is \d+ tokens/i,
+	/exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
+	/input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+	/exceeds the limit of \d+/i,
+	/exceeds the available context size/i,
+	/greater than the context length/i,
+	/context window exceeds limit/i,
+	/exceeded model token limit/i,
+	/too large for model with \d+ maximum context length/i,
+	/prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
+	/model_context_window_exceeded/i,
+	/prompt too long; exceeded (?:max )?context length/i,
+	/range of input length should be/i,
+	/context[_ ]length[_ ]exceeded/i,
+	/too many tokens/i,
+	/token limit exceeded/i,
+	/^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i
+];
+/**
+* Patterns that indicate non-overflow errors (e.g. rate limiting, server errors).
+* Error messages matching any of these are excluded from overflow detection
+* even if they also match an OVERFLOW_PATTERN.
+*
+* Example: Bedrock formats throttling errors as "ThrottlingException: Too many tokens,
+* please wait before trying again." which would match the /too many tokens/i overflow
+* pattern without this exclusion.
+*/
+const NON_OVERFLOW_PATTERNS = [
+	/^(Throttling error|Service unavailable):/i,
+	/rate limit/i,
+	/too many requests/i
+];
+/**
+* Check if an assistant message represents a context overflow error.
+*
+* This handles three cases:
+* 1. Error-based overflow: Most providers return stopReason "error" with a
+*    specific error message pattern.
+* 2. Silent overflow: Some providers accept overflow requests and return
+*    successfully. For these, we check if usage.input exceeds the context window.
+* 3. Length-stop overflow: Xiaomi MiMo can return "length" with zero output when
+*    the input fills the context window.
+*
+* ## Reliability by Provider
+*
+* **Reliable detection (returns error with detectable message):**
+* - Anthropic: "prompt is too long: X tokens > Y maximum" or "request_too_large"
+* - OpenAI (Completions & Responses): "exceeds the context window", "exceeds the model's maximum context length of X tokens", or "exceeds model's maximum context length (X)"
+* - Google Gemini: "input token count exceeds the maximum"
+* - xAI (Grok): "maximum prompt length is X but request contains Y"
+* - Groq: "reduce the length of the messages"
+* - Cerebras: 400/413 status code (no body)
+* - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
+* - OpenRouter (most backends): "maximum context length is X tokens"
+* - OpenRouter/Poolside: "Input length X exceeds the maximum allowed input length of Y tokens."
+* - Together AI: "The input (X tokens) is longer than the model's context length (Y tokens)."
+* - llama.cpp: "exceeds the available context size"
+* - LM Studio: "greater than the context length"
+* - Kimi For Coding: "exceeded model token limit: X (requested: Y)"
+* - DS4: "Prompt has X tokens, but the configured context size is Y tokens"
+* - DashScope/Qwen: "Range of input length should be [1, X]"
+*
+* **Unreliable detection:**
+* - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
+*   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
+* - Xiaomi MiMo: Truncates input to fit contextWindow then returns stopReason "length" with
+*   output=0. Pass contextWindow param to detect via the "filled context + zero output" signal.
+* - Ollama: May truncate input silently for some setups, but may also return explicit
+*   overflow errors that match the patterns above. Silent truncation still cannot be
+*   detected here because we do not know the expected token count.
+*
+* ## Custom Providers
+*
+* If you've added custom models via settings.json, this function may not detect
+* overflow errors from those providers. To add support:
+*
+* 1. Send a request that exceeds the model's context window
+* 2. Check the errorMessage in the response
+* 3. Create a regex pattern that matches the error
+* 4. The pattern should be added to OVERFLOW_PATTERNS in this file, or
+*    check the errorMessage yourself before calling this function
+*
+* @param message - The assistant message to check
+* @param contextWindow - Optional context window size for detecting silent overflow (z.ai)
+* @returns true if the message indicates a context overflow
+*/
+function isContextOverflow(message, contextWindow) {
+	if (message.stopReason === "error" && message.errorMessage) {
+		if (!NON_OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage)) && OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage))) return true;
+	}
+	if (contextWindow && message.stopReason === "stop") {
+		if (message.usage.input + message.usage.cacheRead > contextWindow) return true;
+	}
+	if (contextWindow && message.stopReason === "length" && message.usage.output === 0) {
+		if (message.usage.input + message.usage.cacheRead >= contextWindow * .99) return true;
+	}
+	return false;
+}
+/**
+* Check whether a length stop ended below the caller or model's intended output limit.
+* Such responses may be caused by context pressure or provider-side truncation, so callers
+* can make one bounded compact-and-retry attempt. `desiredMaxOutput` must be the original
+* limit before any context-based clamping.
+*/
+function isRecoverableLength(message, desiredMaxOutput) {
+	return message.stopReason === "length" && desiredMaxOutput > 0 && message.usage.output < desiredMaxOutput;
+}
+/**
+* Get the overflow patterns for testing purposes.
+*/
+function getOverflowPatterns() {
+	return [...OVERFLOW_PATTERNS];
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/utils/retry.js
+function buildProviderErrorPattern(patterns) {
+	return new RegExp(patterns.join("|"), "i");
+}
+const NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN = buildProviderErrorPattern([
+	"GoUsageLimitError",
+	"FreeUsageLimitError",
+	"Monthly usage limit reached",
+	"available balance",
+	"insufficient_quota",
+	"out of budget",
+	"quota exceeded",
+	"billing"
+]);
+const RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
+	"overloaded",
+	"rate.?limit",
+	"too many requests",
+	"429",
+	"500",
+	"502",
+	"503",
+	"504",
+	"524",
+	"service.?unavailable",
+	"server.?error",
+	"internal.?error",
+	"provider.?returned.?error",
+	"network.?error",
+	"connection.?error",
+	"connection.?refused",
+	"connection.?lost",
+	"other side closed",
+	"fetch failed",
+	"getaddrinfo",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"upstream.?connect",
+	"reset before headers",
+	"socket hang up",
+	"socket connection was closed",
+	"timed? out",
+	"timeout",
+	"terminated",
+	"websocket.?closed",
+	"websocket.?error",
+	"ended without",
+	"stream ended before message_stop",
+	"stream ended before a terminal response event",
+	"http2 request did not get a response",
+	"retry delay",
+	"you can retry your request",
+	"try your request again",
+	"please retry your request",
+	"ResourceExhausted"
+]);
+var RetrySleepAbortError = class extends Error {
+	constructor() {
+		super("Aborted");
+	}
+};
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new RetrySleepAbortError());
+			return;
+		}
+		const timeout = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timeout);
+			reject(new RetrySleepAbortError());
+		}, { once: true });
+	});
+}
+/**
+* Run a single assistant-producing call with bounded retry on transient errors.
+*
+* Behavior:
+* - A successful response is returned immediately. Aborts are terminal and never
+*   retried, but reported as unsuccessful if they happen after a retry was scheduled.
+*   Aborts during the backoff sleep are normalized to an aborted `AssistantMessage`
+*   too, so callers do not need to care when cancellation happened.
+* - A non-retryable error (per {@link isRetryableAssistantError}, including quota/
+*   billing exhaustion) is returned immediately so deterministic errors fail fast.
+* - Otherwise retries up to `maxRetries` times with exponential backoff, emitting
+*   `onRetryScheduled` before each sleep, `onRetryAttemptStart` after each sleep before
+*   the retried call starts, and `onRetryFinished` once at the end (whether the loop
+*   ends in success, exhausted retries, or an aborted backoff).
+*
+* When `policy` is undefined or disabled, the first response is returned unchanged
+* (equivalent to calling `produce()` directly).
+*/
+async function retryAssistantCall(produce, policy, signal, callbacks) {
+	const maxAttempts = policy?.enabled ? policy.maxRetries : 0;
+	let attempt = 0;
+	let lastRetry;
+	for (;;) {
+		const response = await produce();
+		if (response.stopReason === "aborted") {
+			if (lastRetry) await callbacks?.onRetryFinished?.(false, lastRetry.attempt);
+			return response;
+		}
+		if (response.stopReason !== "error") {
+			if (lastRetry) await callbacks?.onRetryFinished?.(true, lastRetry.attempt);
+			return response;
+		}
+		if (attempt >= maxAttempts || !isRetryableAssistantError(response)) {
+			if (lastRetry) await callbacks?.onRetryFinished?.(false, lastRetry.attempt, response.errorMessage);
+			return response;
+		}
+		attempt++;
+		lastRetry = {
+			attempt,
+			errorMessage: response.errorMessage || "Unknown error"
+		};
+		const delayMs = policy.baseDelayMs * 2 ** (attempt - 1);
+		await callbacks?.onRetryScheduled?.(attempt, maxAttempts, delayMs, lastRetry.errorMessage);
+		try {
+			await sleep(delayMs, signal);
+		} catch (error) {
+			await callbacks?.onRetryFinished?.(false, attempt, lastRetry.errorMessage);
+			if (error instanceof RetrySleepAbortError) return {
+				...response,
+				stopReason: "aborted",
+				errorMessage: void 0
+			};
+			throw error;
+		}
+		await callbacks?.onRetryAttemptStart?.();
+	}
+}
+/**
+* Classifies whether a failed assistant message looks like a transient provider
+* or transport error, so callers can decide if the last assistant turn should be
+* restarted.
+*
+* This does not implement retry policy. Callers should first handle context
+* overflow separately, then apply their own retry budget, backoff, and reporting
+* before restarting the assistant turn.
+*/
+function isRetryableAssistantError(message) {
+	if (message.stopReason !== "error" || !message.errorMessage) return false;
+	const errorMessage = message.errorMessage;
+	if (NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN.test(errorMessage)) return false;
+	return RETRYABLE_PROVIDER_ERROR_PATTERN.test(errorMessage);
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/utils/text.js
+/** Extract and join text from message content. */
+function contentText(content, separator = "\n") {
+	if (typeof content === "string") return content;
+	return content.filter((block) => block.type === "text").map((block) => block.text).join(separator);
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/utils/typebox-helpers.js
+/**
+* Creates a string enum schema compatible with Google's API and other providers
+* that don't support anyOf/const patterns.
+*
+* @example
+* const OperationSchema = StringEnum(["add", "subtract", "multiply", "divide"], {
+*   description: "The operation to perform"
+* });
+*
+* type Operation = Static<typeof OperationSchema>; // "add" | "subtract" | "multiply" | "divide"
+*/
+function StringEnum(values, options) {
+	return Type$1.Unsafe({
+		type: "string",
+		enum: values,
+		...options?.description && { description: options.description },
+		...options?.default && { default: options.default }
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/@earendil-works+pi-ai@0.84.1_ws@8.21.3_zod@4.4.3/node_modules/@earendil-works/pi-ai/dist/utils/validation.js
+const validatorCache = /* @__PURE__ */ new WeakMap();
+const TYPEBOX_KIND = Symbol.for("TypeBox.Kind");
+function getSchemaTypes(schema) {
+	if (typeof schema.type === "string") return [schema.type];
+	if (Array.isArray(schema.type)) return schema.type.filter((type) => typeof type === "string");
+	return [];
+}
+function matchesJsonType(value, type) {
+	switch (type) {
+		case "number": return typeof value === "number";
+		case "integer": return typeof value === "number" && Number.isInteger(value);
+		case "boolean": return typeof value === "boolean";
+		case "string": return typeof value === "string";
+		case "null": return value === null;
+		case "array": return Array.isArray(value);
+		case "object": return typeof value === "object" && value !== null && !Array.isArray(value);
+		default: return false;
+	}
+}
+function getSubSchemaValidator(schema) {
+	try {
+		return getValidator(schema);
+	} catch {
+		return;
+	}
+}
+function coercePrimitiveByType(value, type) {
+	switch (type) {
+		case "number":
+			if (value === null) return 0;
+			if (typeof value === "string" && value.trim() !== "") {
+				const parsed = Number(value);
+				if (Number.isFinite(parsed)) return parsed;
+			}
+			if (typeof value === "boolean") return value ? 1 : 0;
+			return value;
+		case "integer":
+			if (value === null) return 0;
+			if (typeof value === "string" && value.trim() !== "") {
+				const parsed = Number(value);
+				if (Number.isInteger(parsed)) return parsed;
+			}
+			if (typeof value === "boolean") return value ? 1 : 0;
+			return value;
+		case "boolean":
+			if (value === null) return false;
+			if (typeof value === "string") {
+				if (value === "true") return true;
+				if (value === "false") return false;
+			}
+			if (typeof value === "number") {
+				if (value === 1) return true;
+				if (value === 0) return false;
+			}
+			return value;
+		case "string":
+			if (value === null) return "";
+			if (typeof value === "number" || typeof value === "boolean") return String(value);
+			return value;
+		case "null":
+			if (value === "" || value === 0 || value === false) return null;
+			return value;
+		default: return value;
+	}
+}
+function applySchemaObjectCoercion(value, schema) {
+	const properties = schema.properties;
+	const definedKeys = new Set(properties ? Object.keys(properties) : []);
+	if (properties) for (const [key, propertySchema] of Object.entries(properties)) {
+		if (!(key in value)) continue;
+		value[key] = coerceWithJsonSchema(value[key], propertySchema);
+	}
+	if (schema.additionalProperties && typeof schema.additionalProperties === "object") for (const [key, propertyValue] of Object.entries(value)) {
+		if (definedKeys.has(key)) continue;
+		value[key] = coerceWithJsonSchema(propertyValue, schema.additionalProperties);
+	}
+}
+function applySchemaArrayCoercion(value, schema) {
+	if (Array.isArray(schema.items)) {
+		for (let index = 0; index < value.length; index++) {
+			const itemSchema = schema.items[index];
+			if (!itemSchema) continue;
+			value[index] = coerceWithJsonSchema(value[index], itemSchema);
+		}
+		return;
+	}
+	if (schema.items && typeof schema.items === "object") for (let index = 0; index < value.length; index++) value[index] = coerceWithJsonSchema(value[index], schema.items);
+}
+function coerceWithUnionSchema(value, schemas) {
+	for (const schema of schemas) if (getSubSchemaValidator(schema)?.Check(value)) return value;
+	for (const schema of schemas) {
+		const coerced = coerceWithJsonSchema(structuredClone(value), schema);
+		if (getSubSchemaValidator(schema)?.Check(coerced)) return coerced;
+	}
+	return value;
+}
+function coerceWithJsonSchema(value, schema) {
+	let nextValue = value;
+	if (Array.isArray(schema.allOf)) for (const nested of schema.allOf) nextValue = coerceWithJsonSchema(nextValue, nested);
+	if (Array.isArray(schema.anyOf)) nextValue = coerceWithUnionSchema(nextValue, schema.anyOf);
+	if (Array.isArray(schema.oneOf)) nextValue = coerceWithUnionSchema(nextValue, schema.oneOf);
+	const schemaTypes = getSchemaTypes(schema);
+	const matchesUnionMember = schemaTypes.length > 1 && schemaTypes.some((schemaType) => matchesJsonType(nextValue, schemaType));
+	if (schemaTypes.length > 0 && !matchesUnionMember) for (const schemaType of schemaTypes) {
+		const candidate = coercePrimitiveByType(nextValue, schemaType);
+		if (candidate !== nextValue) {
+			nextValue = candidate;
+			break;
+		}
+	}
+	if (schemaTypes.includes("object") && typeof nextValue === "object" && nextValue !== null && !Array.isArray(nextValue)) applySchemaObjectCoercion(nextValue, schema);
+	if (schemaTypes.includes("array") && Array.isArray(nextValue)) applySchemaArrayCoercion(nextValue, schema);
+	return nextValue;
+}
+function getValidator(schema) {
+	const key = schema;
+	const cached = validatorCache.get(key);
+	if (cached) return cached;
+	const validator = Compile(schema);
+	validatorCache.set(key, validator);
+	return validator;
+}
+function formatValidationPath(error) {
+	if (error.keyword === "required") {
+		const requiredProperty = error.params.requiredProperties?.[0];
+		if (requiredProperty) {
+			const basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+			return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
+		}
+	}
+	return error.instancePath.replace(/^\//, "").replace(/\//g, ".") || "root";
+}
+/**
+* Finds a tool by name and validates the tool call arguments against its TypeBox schema
+* @param tools Array of tool definitions
+* @param toolCall The tool call from the LLM
+* @returns The validated arguments
+* @throws Error if tool is not found or validation fails
+*/
+function validateToolCall(tools, toolCall) {
+	const tool = tools.find((t) => t.name === toolCall.name);
+	if (!tool) throw new Error(`Tool "${toolCall.name}" not found`);
+	return validateToolArguments(tool, toolCall);
+}
+/**
+* Validates tool call arguments against the tool's TypeBox schema
+* @param tool The tool definition with TypeBox schema
+* @param toolCall The tool call from the LLM
+* @returns The validated (and potentially coerced) arguments
+* @throws Error with formatted message if validation fails
+*/
+function validateToolArguments(tool, toolCall) {
+	const args = structuredClone(toolCall.arguments);
+	Value.Convert(tool.parameters, args);
+	const validator = getValidator(tool.parameters);
+	if (!Object.getOwnPropertySymbols(tool.parameters).includes(TYPEBOX_KIND)) {
+		const coerced = coerceWithJsonSchema(args, tool.parameters);
+		if (coerced !== args) {
+			if (typeof args === "object" && args !== null && typeof coerced === "object" && coerced !== null) {
+				for (const key of Object.keys(args)) delete args[key];
+				Object.assign(args, coerced);
+			} else return validator.Check(coerced) ? coerced : args;
+		}
+	}
+	if (validator.Check(args)) return args;
+	const errors = validator.Errors(args).map((error) => `  - ${formatValidationPath(error)}: ${error.message}`).join("\n") || "Unknown validation error";
+	const errorMessage = `Validation failed for tool "${toolCall.name}":\n${errors}\n\nReceived arguments:\n${JSON.stringify(toolCall.arguments, null, 2)}`;
+	throw new Error(errorMessage);
+}
+//#endregion
+export { AssistantMessageEventStream, EventStream, InMemoryCredentialStore, InMemoryModelsStore, ModelsError, StringEnum, Type, appendAssistantMessageDiagnostic, calculateCost, clampThinkingLevel, cleanupSessionResources, contentText, createAssistantMessageDiagnostic, createAssistantMessageEventStream, createFauxCore, createImagesModels, createImagesProvider, createModels, createProvider, defaultProviderAuthContext, envApiKeyAuth, extractDiagnosticError, fauxAssistantMessage, fauxProvider, fauxText, fauxThinking, fauxToolCall, formatThrownValue, getOverflowPatterns, getSupportedThinkingLevels, hasApi, isContextOverflow, isRecoverableLength, isRetryableAssistantError, lazyApi, lazyOAuth, lazyStream, modelsAreEqual, parseJsonWithRepair, parseStreamingJson, registerSessionResourceCleanup, repairJson, retryAssistantCall, uuidv7, validateToolArguments, validateToolCall };
+
+//# sourceMappingURL=dist-DeonWo7m.mjs.map