@oh-my-pi/pi-ai 13.17.5 → 13.17.6

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [13.17.6] - 2026-04-01
+
+### Fixed
+
+- Fixed Anthropic first-event timeouts to exclude stream connection setup from the watchdog, preserve timeout-specific retry classification after local aborts, and reset retry state cleanly between attempts
+
 ## [13.17.5] - 2026-04-01
 ### Changed
 
@@ -1959,4 +1965,4 @@ _Dedicated to Peter's shoulder ([@steipete](https://twitter.com/steipete))_
 
 ## [0.9.4] - 2025-11-26
 
-Initial release with multi-provider LLM support.
+Initial release with multi-provider LLM support.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "13.17.5",
+	"version": "13.17.6",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,7 +41,7 @@
 		"@aws-sdk/client-bedrock-runtime": "^3",
 		"@bufbuild/protobuf": "^2.11",
 		"@google/genai": "^1.43",
-		"@oh-my-pi/pi-utils": "13.17.5",
+		"@oh-my-pi/pi-utils": "13.17.6",
 		"@sinclair/typebox": "^0.34",
 		"@smithy/node-http-handler": "^4.4",
 		"ajv": "^8.18",

package/src/providers/anthropic.ts

@@ -29,11 +29,13 @@ import type {
 	Tool,
 	ToolCall,
 	ToolResultMessage,
+	Usage,
 } from "../types";
 import { isAnthropicOAuthToken, normalizeToolCallId, resolveCacheRetention } from "../utils";
+import { createAbortSourceTracker } from "../utils/abort";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
-import { getStreamFirstEventTimeoutMs, iterateWithIdleTimeout } from "../utils/idle-iterator";
+import { createFirstEventWatchdog, getStreamFirstEventTimeoutMs, markFirstStreamEvent } from "../utils/idle-iterator";
 import { parseStreamingJson } from "../utils/json-parse";
 import {
 	buildCopilotDynamicHeaders,
@@ -581,6 +583,18 @@ export function isProviderRetryableError(error: unknown): boolean {
 	);
 }
 
+function createEmptyUsage(premiumRequests?: number): Usage {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		...(premiumRequests === undefined ? {} : { premiumRequests }),
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
+}
+
 export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 	model: Model<"anthropic-messages">,
 	context: Context,
@@ -608,18 +622,12 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			api: model.api as Api,
 			provider: model.provider,
 			model: model.id,
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-			},
+			usage: createEmptyUsage(copilotDynamicHeaders?.premiumRequests),
 			stopReason: "stop",
 			timestamp: Date.now(),
 		};
 		let rawRequestDump: RawHttpRequestDump | undefined;
+		let activeAbortTracker = createAbortSourceTracker(options?.signal);
 
 		try {
 			let client: Anthropic;
@@ -675,22 +683,20 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			let providerRetryAttempt = 0;
 			let started = false;
 			do {
-				const requestAbortController = new AbortController();
-				const requestSignal = options?.signal
-					? AbortSignal.any([options.signal, requestAbortController.signal])
-					: requestAbortController.signal;
+				activeAbortTracker = createAbortSourceTracker(options?.signal);
+				const firstEventTimeoutAbortError = new Error(
+					"Anthropic stream timed out while waiting for the first event",
+				);
+				const { requestSignal } = activeAbortTracker;
 				const anthropicStream = client.messages.stream({ ...params, stream: true }, { signal: requestSignal });
-				if (copilotDynamicHeaders && output.usage.premiumRequests === undefined) {
-					output.usage.premiumRequests = copilotDynamicHeaders.premiumRequests;
-				}
 
 				try {
-					for await (const event of iterateWithIdleTimeout(anthropicStream, {
-						firstItemTimeoutMs: getStreamFirstEventTimeoutMs(),
-						errorMessage: "Anthropic stream stalled while waiting for the next event",
-						firstItemErrorMessage: "Anthropic stream timed out while waiting for the first event",
-						onFirstItemTimeout: () => requestAbortController.abort(),
-					})) {
+					await anthropicStream.withResponse();
+					const firstEventWatchdog = createFirstEventWatchdog(getStreamFirstEventTimeoutMs(), () =>
+						activeAbortTracker.abortLocally(firstEventTimeoutAbortError),
+					);
+
+					for await (const event of markFirstStreamEvent(anthropicStream, firstEventWatchdog)) {
 						started = true;
 						if (event.type === "message_start") {
 							output.responseId = event.message.id;
@@ -857,7 +863,11 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						}
 					}
 
-					if (options?.signal?.aborted) {
+					const firstEventTimeoutError = activeAbortTracker.getLocalAbortReason();
+					if (firstEventTimeoutError) {
+						throw firstEventTimeoutError;
+					}
+					if (activeAbortTracker.wasCallerAbort()) {
 						throw new Error("Request was aborted");
 					}
 
@@ -866,23 +876,28 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					}
 					break; // Stream completed successfully
 				} catch (streamError) {
+					const streamFailure = activeAbortTracker.getLocalAbortReason() ?? streamError;
 					// Transient stream parse errors (truncated JSON) are retryable even after content
 					// has started streaming, since the partial response is unusable anyway.
 					// Rate-limit/overload errors are only retried before content starts.
-					const isTransient = isTransientStreamParseError(streamError);
+					const isTransient = isTransientStreamParseError(streamFailure);
 					if (
-						options?.signal?.aborted ||
+						activeAbortTracker.wasCallerAbort() ||
 						providerRetryAttempt >= PROVIDER_MAX_RETRIES ||
 						(!isTransient && firstTokenTime !== undefined) ||
-						(!isTransient && !isProviderRetryableError(streamError))
+						(!isTransient && !isProviderRetryableError(streamFailure))
 					) {
-						throw streamError;
+						throw streamFailure;
 					}
 					providerRetryAttempt++;
 					const delayMs = PROVIDER_BASE_DELAY_MS * 2 ** (providerRetryAttempt - 1);
 					await abortableSleep(delayMs, options?.signal);
 					// Reset output state for clean retry
 					output.content.length = 0;
+					output.responseId = undefined;
+					output.errorMessage = undefined;
+					output.providerPayload = undefined;
+					output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
 					output.stopReason = "stop";
 					firstTokenTime = undefined;
 					started = false;
@@ -894,9 +909,10 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			stream.push({ type: "done", reason: output.stopReason, message: output });
 			stream.end();
 		} catch (error) {
-			for (const block of output.content) delete (block as any).index;
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = await finalizeErrorMessage(error, rawRequestDump);
+			for (const block of output.content) delete (block as { index?: number }).index;
+			const firstEventTimeoutError = activeAbortTracker.getLocalAbortReason();
+			output.stopReason = activeAbortTracker.wasCallerAbort() ? "aborted" : "error";
+			output.errorMessage = firstEventTimeoutError?.message ?? (await finalizeErrorMessage(error, rawRequestDump));
 			output.duration = Date.now() - startTime;
 			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "error", reason: output.stopReason, error: output });