@oh-my-pi/pi-ai 14.6.0 → 14.6.1

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "14.6.0",
+	"version": "14.6.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,8 +46,8 @@
 		"@aws-sdk/credential-provider-node": "^3.972.36",
 		"@bufbuild/protobuf": "^2.12.0",
 		"@google/genai": "^1.50.1",
-		"@oh-my-pi/pi-natives": "14.6.0",
-		"@oh-my-pi/pi-utils": "14.6.0",
+		"@oh-my-pi/pi-natives": "14.6.1",
+		"@oh-my-pi/pi-utils": "14.6.1",
 		"@sinclair/typebox": "^0.34.49",
 		"@smithy/node-http-handler": "^4.6.1",
 		"ajv": "^8.20.0",

package/src/models.json

@@ -28105,6 +28105,44 @@
 			"contextWindow": 222222,
 			"maxTokens": 8888
 		},
+		"poolside/laguna-m.1": {
+			"id": "poolside/laguna-m.1",
+			"name": "poolside/laguna-m.1",
+			"api": "openai-completions",
+			"provider": "nanogpt",
+			"baseUrl": "https://nano-gpt.com/api/v1",
+			"reasoning": false,
+			"input": [
+				"text"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 222222,
+			"maxTokens": 8888
+		},
+		"poolside/laguna-xs.2": {
+			"id": "poolside/laguna-xs.2",
+			"name": "poolside/laguna-xs.2",
+			"api": "openai-completions",
+			"provider": "nanogpt",
+			"baseUrl": "https://nano-gpt.com/api/v1",
+			"reasoning": false,
+			"input": [
+				"text"
+			],
+			"cost": {
+				"input": 0,
+				"output": 0,
+				"cacheRead": 0,
+				"cacheWrite": 0
+			},
+			"contextWindow": 222222,
+			"maxTokens": 8888
+		},
 		"qvq-max": {
 			"id": "qvq-max",
 			"name": "qvq-max",
@@ -35776,9 +35814,9 @@
 		"minimax-m2.7": {
 			"id": "minimax-m2.7",
 			"name": "MiniMax M2.7",
-			"api": "anthropic-messages",
+			"api": "openai-completions",
 			"provider": "opencode-go",
-			"baseUrl": "https://opencode.ai/zen/go",
+			"baseUrl": "https://opencode.ai/zen/go/v1",
 			"reasoning": true,
 			"input": [
 				"text"
@@ -35792,7 +35830,7 @@
 			"contextWindow": 204800,
 			"maxTokens": 131072,
 			"thinking": {
-				"mode": "budget",
+				"mode": "effort",
 				"minLevel": "minimal",
 				"maxLevel": "xhigh"
 			}
@@ -38485,7 +38523,7 @@
 				"cacheRead": 0.024999999999999998,
 				"cacheWrite": 0.08333333333333334
 			},
-			"contextWindow": 1000000,
+			"contextWindow": 1048576,
 			"maxTokens": 8192
 		},
 		"google/gemini-2.0-flash-lite-001": {
@@ -42996,13 +43034,13 @@
 				"image"
 			],
 			"cost": {
-				"input": 0.325,
-				"output": 3.25,
+				"input": 0.32,
+				"output": 3.1999999999999997,
 				"cacheRead": 0,
 				"cacheWrite": 0
 			},
-			"contextWindow": 256000,
-			"maxTokens": 65536,
+			"contextWindow": 262144,
+			"maxTokens": 81920,
 			"thinking": {
 				"mode": "effort",
 				"minLevel": "minimal",
@@ -55034,6 +55072,26 @@
 			"contextWindow": 2000000,
 			"maxTokens": 30000
 		},
+		"x-ai/grok-4.3": {
+			"id": "x-ai/grok-4.3",
+			"name": "xAI: Grok 4.3",
+			"api": "openai-completions",
+			"provider": "zenmux",
+			"baseUrl": "https://zenmux.ai/api/v1",
+			"reasoning": false,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 1.25,
+				"output": 2.5,
+				"cacheRead": 0.2,
+				"cacheWrite": 0
+			},
+			"contextWindow": 1000000,
+			"maxTokens": 8888
+		},
 		"x-ai/grok-code-fast-1": {
 			"id": "x-ai/grok-code-fast-1",
 			"name": "Grok Code Fast 1",

package/src/provider-models/openai-compat.ts

@@ -1868,12 +1868,18 @@ function createOpenCodeApiResolution(
 }
 
 const OPENCODE_ZEN_API_RESOLUTION = createOpenCodeApiResolution("https://opencode.ai/zen");
-// OpenCode Go: models.dev declares qwen3.5-plus / qwen3.6-plus with
-// `provider.npm = "@ai-sdk/anthropic"`, but per the OpenCode Go endpoint table
-// (https://opencode.ai/docs/go/#endpoints) they are served via @ai-sdk/alibaba
-// at https://opencode.ai/zen/go/v1/chat/completions (OpenAI-compatible).
-// Override the resolver so regenerating models.json keeps the correct routing.
+// OpenCode Go: models.dev declares minimax-m2.7 / qwen3.5-plus / qwen3.6-plus
+// with `provider.npm = "@ai-sdk/anthropic"`, but the OpenCode Go gateway only
+// serves them at `https://opencode.ai/zen/go/v1/chat/completions` (verified
+// against https://opencode.ai/zen/go/v1/models and the upstream endpoint
+// table at https://opencode.ai/docs/go/#endpoints — minimax-m2.5 works the
+// same way and lacks an `npm` field on models.dev so it already falls through
+// to the openai-completions default). Without this override the resolver
+// would POST anthropic-style requests to /v1/messages and the gateway would
+// return its `Page Not Found` HTML (issue #887). Override the resolver so
+// regenerating models.json keeps the correct routing.
 const OPENCODE_GO_API_RESOLUTION = createOpenCodeApiResolution("https://opencode.ai/zen/go", {
+	"minimax-m2.7": "openai-completions",
 	"qwen3.5-plus": "openai-completions",
 	"qwen3.6-plus": "openai-completions",
 });

package/src/providers/openai-completions.ts

@@ -81,6 +81,43 @@ function normalizeMistralToolId(id: string, isMistral: boolean): string {
 	return normalized;
 }
 
+/**
+ * Normalize OpenAI-compatible streaming `delta.content` into plain text.
+ *
+ * Most providers stream `delta.content` as a string, but some (notably Mistral
+ * Medium 3.5 / `mistral-medium-2604`) return an array of typed content parts
+ * — e.g. `[{ type: "text", text: "Hello" }]`. Without normalization those
+ * parts get string-coerced via `text += array`, producing the literal
+ * `[object Object]` sequences observed in issue #911.
+ *
+ * Returns the joined text. Non-text parts and unknown shapes are skipped so
+ * we never emit JS object sigils as visible output.
+ */
+function normalizeStreamingContentText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		let out = "";
+		for (const part of content) {
+			if (typeof part === "string") {
+				out += part;
+			} else if (part && typeof part === "object") {
+				const obj = part as { type?: unknown; text?: unknown };
+				if ((obj.type === undefined || obj.type === "text") && typeof obj.text === "string") {
+					out += obj.text;
+				}
+			}
+		}
+		return out;
+	}
+	if (content && typeof content === "object") {
+		const obj = content as { type?: unknown; text?: unknown };
+		if ((obj.type === undefined || obj.type === "text") && typeof obj.text === "string") {
+			return obj.text;
+		}
+	}
+	return "";
+}
+
 function serializeToolArguments(value: unknown): string {
 	if (value && typeof value === "object" && !Array.isArray(value)) {
 		try {
@@ -537,6 +574,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				idleTimeoutMs,
 				errorMessage: "OpenAI completions stream stalled while waiting for the next event",
 				onIdle: () => requestAbortController.abort(),
+				abortSignal: options?.signal,
 			})) {
 				if (!chunk || typeof chunk !== "object") continue;
 
@@ -567,20 +605,17 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				}
 
 				if (choice.delta) {
-					if (
-						choice.delta.content !== null &&
-						choice.delta.content !== undefined &&
-						choice.delta.content.length > 0
-					) {
+					const normalizedDeltaText = normalizeStreamingContentText(choice.delta.content);
+					if (normalizedDeltaText.length > 0) {
 						if (!firstTokenTime) firstTokenTime = Date.now();
 						if (parseMiniMaxThinkTags) {
-							taggedTextBuffer += choice.delta.content;
+							taggedTextBuffer += normalizedDeltaText;
 							flushTaggedTextBuffer();
 						} else if (stripDeepseekChatTemplateTokens) {
-							deepseekStripBuffer += choice.delta.content;
+							deepseekStripBuffer += normalizedDeltaText;
 							flushDeepseekStripBuffer(false);
 						} else {
-							appendTextDelta(choice.delta.content);
+							appendTextDelta(normalizedDeltaText);
 						}
 					}
 

package/src/providers/openai-responses-shared.ts

@@ -540,13 +540,26 @@ export async function processResponsesStream<TApi extends Api>(
 			}
 			calculateCost(model, output.usage);
 			output.stopReason = mapOpenAIResponsesStopReason(response?.status);
+			if (response?.status === "failed" || response?.status === "cancelled") {
+				const error = response?.error ?? (response as any)?.status_details?.error;
+				const details = response?.incomplete_details;
+				const statusDetailsReason = (response as any)?.status_details?.reason;
+				const message = error
+					? `${error.code || "unknown"}: ${error.message || "no message"}`
+					: details?.reason
+						? `incomplete: ${details.reason}`
+						: typeof statusDetailsReason === "string" && statusDetailsReason.length > 0
+							? `status_details: ${statusDetailsReason}`
+							: "Unknown error (no error details in response)";
+				throw new Error(message);
+			}
 			if (output.content.some(block => block.type === "toolCall") && output.stopReason === "stop") {
 				output.stopReason = "toolUse";
 			}
 		} else if (event.type === "error") {
 			throw new Error(`Error Code ${event.code}: ${event.message}` || "Unknown error");
 		} else if (event.type === "response.failed") {
-			const error = event.response?.error;
+			const error = event.response?.error ?? (event.response as any)?.status_details?.error;
 			const details = event.response?.incomplete_details;
 			const message = error
 				? `${error.code || "unknown"}: ${error.message || "no message"}`

package/src/providers/openai-responses.ts

@@ -220,6 +220,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 					watchdog: firstEventWatchdog,
 					errorMessage: "OpenAI responses stream stalled while waiting for the next event",
 					onIdle: () => requestAbortController.abort(),
+					abortSignal: options?.signal,
 				}),
 				output,
 				stream,

package/src/providers/register-builtins.ts

@@ -132,8 +132,6 @@ interface BedrockProviderModule {
 // Module-level lazy promise caches
 // ---------------------------------------------------------------------------
 
-const importNodeOnlyProvider = (specifier: string): Promise<unknown> => import(specifier);
-
 let anthropicProviderModulePromise: Promise<LazyProviderModule<"anthropic-messages">> | undefined;
 let azureOpenAIResponsesProviderModulePromise: Promise<LazyProviderModule<"azure-openai-responses">> | undefined;
 let googleProviderModulePromise: Promise<LazyProviderModule<"google-generative-ai">> | undefined;
@@ -320,7 +318,7 @@ function loadBedrockProviderModule(): Promise<LazyProviderModule<"bedrock-conver
 	if (bedrockProviderModuleOverride) {
 		return Promise.resolve(bedrockProviderModuleOverride);
 	}
-	bedrockProviderModulePromise ||= importNodeOnlyProvider("./amazon-bedrock").then(module => {
+	bedrockProviderModulePromise ||= import("./amazon-bedrock").then(module => {
 		const provider = module as BedrockProviderModule;
 		return { stream: provider.streamBedrock };
 	});

package/src/utils/idle-iterator.ts

@@ -59,6 +59,15 @@ export interface IdleTimeoutIteratorOptions {
 	firstItemErrorMessage?: string;
 	onIdle?: () => void;
 	onFirstItemTimeout?: () => void;
+	/**
+	 * Cancel iteration as soon as this signal aborts. Required for caller-driven
+	 * cancellation (ESC) when the underlying transport does not surface signal
+	 * aborts to the iterator (HTTP/2 proxies, native sockets, mocked fetch).
+	 * Without this, the consumer sleeps on iterator.next() until the idle/first
+	 * -event watchdog fires — observable as the issue #912 "Working… forever"
+	 * symptom on the github-copilot provider.
+	 */
+	abortSignal?: AbortSignal;
 }
 
 /**
@@ -73,19 +82,20 @@ export async function* iterateWithIdleTimeout<T>(
 ): AsyncGenerator<T> {
 	let watchdog = options.watchdog;
 	const firstItemTimeoutMs = options.firstItemTimeoutMs ?? options.idleTimeoutMs;
-	if (
-		(firstItemTimeoutMs === undefined || firstItemTimeoutMs <= 0) &&
-		(options.idleTimeoutMs === undefined || options.idleTimeoutMs <= 0)
-	) {
-		for await (const item of iterable) {
-			watchdog && clearTimeout(watchdog);
-			watchdog = undefined;
-			yield item;
+	const abortSignal = options.abortSignal;
+	const iterator = iterable[Symbol.asyncIterator]();
+
+	const closeIterator = (): void => {
+		const returnPromise = iterator.return?.();
+		if (returnPromise) {
+			void returnPromise.catch(() => {});
 		}
-		return;
-	}
+	};
 
-	const iterator = iterable[Symbol.asyncIterator]();
+	if (abortSignal?.aborted) {
+		closeIterator();
+		throw abortReason(abortSignal);
+	}
 
 	const withRacy = <T>(promise: Promise<T>) =>
 		promise.then(
@@ -98,54 +108,83 @@ export async function* iterateWithIdleTimeout<T>(
 		onFirst = null;
 	};
 
+	const noTimeoutEnforced =
+		(firstItemTimeoutMs === undefined || firstItemTimeoutMs <= 0) &&
+		(options.idleTimeoutMs === undefined || options.idleTimeoutMs <= 0);
+
 	while (true) {
 		const nextResultPromise = withRacy(iterator.next());
 		const activeTimeoutMs = !onFirst ? options.idleTimeoutMs : firstItemTimeoutMs;
 
-		if (activeTimeoutMs === undefined || activeTimeoutMs <= 0) {
-			const outcome = await nextResultPromise;
-			if (outcome.kind === "error") {
-				throw outcome.error;
-			}
-			if (outcome.result.done) {
-				return;
-			}
-			onFirst?.();
-			yield outcome.result.value;
-			continue;
+		const racers: Array<
+			Promise<
+				| { kind: "next"; result: IteratorResult<T> }
+				| { kind: "error"; error: unknown }
+				| { kind: "timeout" }
+				| { kind: "abort" }
+			>
+		> = [nextResultPromise];
+
+		let timer: NodeJS.Timeout | undefined;
+		let resolveTimeout: ((value: { kind: "timeout" }) => void) | undefined;
+		const enforceTimeout = !noTimeoutEnforced && activeTimeoutMs !== undefined && activeTimeoutMs > 0;
+		if (enforceTimeout) {
+			const { promise, resolve } = Promise.withResolvers<{ kind: "timeout" }>();
+			resolveTimeout = resolve;
+			timer = setTimeout(() => resolve({ kind: "timeout" }), activeTimeoutMs);
+			racers.push(promise);
 		}
 
-		const { promise: timeoutPromise, resolve: resolveTimeout } = Promise.withResolvers<{
-			kind: "timeout";
-		}>();
-		const timer = setTimeout(() => resolveTimeout({ kind: "timeout" }), activeTimeoutMs);
+		let abortListener: (() => void) | undefined;
+		let resolveAbort: ((value: { kind: "abort" }) => void) | undefined;
+		if (abortSignal) {
+			const { promise, resolve } = Promise.withResolvers<{ kind: "abort" }>();
+			resolveAbort = resolve;
+			abortListener = () => resolve({ kind: "abort" });
+			abortSignal.addEventListener("abort", abortListener, { once: true });
+			racers.push(promise);
+		}
 
 		try {
-			const outcome = await Promise.race([nextResultPromise, timeoutPromise]);
+			const outcome = await Promise.race(racers);
+			if (outcome.kind === "abort") {
+				closeIterator();
+				throw abortReason(abortSignal!);
+			}
 			if (outcome.kind === "timeout") {
 				if (!onFirst) {
 					options.onIdle?.();
 				} else {
 					options.onFirstItemTimeout?.();
 				}
-				const returnPromise = iterator.return?.();
-				if (returnPromise) {
-					void returnPromise.catch(() => {});
-				}
+				closeIterator();
 				throw new Error(!onFirst ? options.errorMessage : (options.firstItemErrorMessage ?? options.errorMessage));
 			}
-			watchdog && clearTimeout(watchdog);
-			watchdog = undefined;
 			if (outcome.kind === "error") {
 				throw outcome.error;
 			}
+			watchdog && clearTimeout(watchdog);
+			watchdog = undefined;
 			if (outcome.result.done) {
 				return;
 			}
 			onFirst?.();
 			yield outcome.result.value;
 		} finally {
-			clearTimeout(timer);
+			if (timer !== undefined) clearTimeout(timer);
+			// Resolve dangling promises so the racers don't leak (Promise.race is one-shot).
+			resolveTimeout?.({ kind: "timeout" });
+			if (abortListener && abortSignal) {
+				abortSignal.removeEventListener("abort", abortListener);
+			}
+			resolveAbort?.({ kind: "abort" });
 		}
 	}
 }
+
+function abortReason(signal: AbortSignal): Error {
+	const reason = signal.reason;
+	if (reason instanceof Error) return reason;
+	if (typeof reason === "string") return new Error(reason);
+	return new Error("Request was aborted");
+}