@oh-my-pi/pi-ai 16.1.2 → 16.1.4

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [16.1.4] - 2026-06-19
+
+### Added
+
+- Added bounded auto-retry for empty assistant completions specifically to the OpenAI Responses provider
+- Added bounded auto-retry for empty assistant completions across the OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages providers. A benign terminal stop that streamed no content and billed no output tokens — the signature of a flaky OpenAI-/Anthropic-compatible gateway that intermittently 200s with an empty body — is now retried up to twice with exponential backoff (honoring `providerRetryWait`) before being surfaced, instead of silently stalling the agent loop. Retries fire only before any content streams, so live streaming (including thinking) is never delayed, retried, or duplicated.
+
+### Fixed
+
+- Fixed the Antigravity (`google-antigravity`) request builder dropping `labels.model_enum` when the wire profile does not declare one. Required for Claude 4.6 ids whose `AntigravityModelWireProfile` carries only `maxOutputTokens` (no captured `model_enum`); the label is now emitted only when the catalog defines it. ([#3067](https://github.com/can1357/oh-my-pi/issues/3067))
+
+## [16.1.3] - 2026-06-19
+
+### Added
+
+- Added regression test pinning that `openai-completions` emits a `thinking` block for `reasoning_content` deltas even when `delta.content` is explicitly JSON `null` (the DeepSeek-format dual-key pattern used by custom GLM/Qwen reasoning providers). See [#2996](https://github.com/can1357/oh-my-pi/issues/2996).
+
+### Changed
+
+- Improved the thinking loop guard to treat assistant text loops as retryable errors
+- Refined text normalization logic to reduce false positives in the thinking loop detector
+
+### Fixed
+
+- Fixed Ollama chat requests sending image payloads to text-only models. Image blocks are now omitted and replaced with the standard non-vision placeholder for models without vision support, while vision-capable Ollama models continue to receive images. ([#3009](https://github.com/can1357/oh-my-pi/pull/3009) by [@serverinspector](https://github.com/serverinspector))
+- Fixed `SqliteAuthCredentialStore.close()` leaking one-off prepared statements created by inline `this.#db.prepare()` calls in `#authCredentialsTableExists`, `#readAuthSchemaVersion`, `#inferAuthSchemaVersion`, `#migrateAuthSchemaV0ToV1`, `#backfillCredentialIdentityKeys`, and `updateAuthCredential`. Each statement is now wrapped in `try/finally` with `stmt.finalize()`, and the `close()` method finalizes `#insertUsageCostStmt` and `#listUsageCostsStmt` which were previously missed. This caused EBUSY on Windows when tests tried to delete temp dirs containing open SQLite handles.
+
 ## [16.1.2] - 2026-06-19
 
 ### Added
@@ -3934,4 +3961,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/dist/types/providers/anthropic.d.ts

@@ -190,6 +190,13 @@ export type AnthropicUsageLike = {
  * zero-valued objects clear prior extras from earlier stream usage snapshots.
  */
 export declare function applyAnthropicUsageExtras(usage: Usage, source: AnthropicUsageLike): void;
+/**
+ * Public entry: wrap the single-attempt streamer with bounded empty-completion
+ * retries (a benign terminal stop carrying no content/usage would otherwise
+ * stall the agent loop). The inner attempt keeps its own provider-failure retry
+ * loop; this layer only re-issues a fresh request on an empty success. Shared
+ * with the OpenAI-completions provider via `withEmptyCompletionRetry`.
+ */
 export declare const streamAnthropic: StreamFunction<"anthropic-messages">;
 export type AnthropicSystemBlock = {
     type: "text";

package/dist/types/providers/openai-completions.d.ts

@@ -34,6 +34,12 @@ export interface OpenAICompletionsOptions extends StreamOptions {
      */
     openrouterVariant?: string;
 }
+/**
+ * Public entry: wrap the single-attempt streamer with bounded empty-completion
+ * retries — flaky gateways occasionally 200 with `delta: {}` + `finish_reason:
+ * "stop"` and no usage, which would otherwise stall the agent loop. Shared with
+ * the Anthropic provider via `withEmptyCompletionRetry`.
+ */
 export declare const streamOpenAICompletions: StreamFunction<"openai-completions">;
 export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined): AssistantMessage["usage"];
 export declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: ResolvedOpenAICompat): ChatCompletionMessageParam[];

package/dist/types/providers/openai-responses.d.ts

@@ -94,7 +94,10 @@ type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
     };
 };
 /**
- * Generate function for OpenAI Responses API
+ * Public entry: wrap the single-attempt Responses streamer with bounded
+ * empty-completion retries — a `response.completed` carrying no content/usage
+ * would otherwise stall the agent loop. Shared with the OpenAI-completions and
+ * Anthropic providers via `withEmptyCompletionRetry`.
  */
 export declare const streamOpenAIResponses: StreamFunction<"openai-responses">;
 export declare function buildParams(model: Model<"openai-responses">, context: Context, options: OpenAIResponsesOptions | undefined, providerSessionState: OpenAIResponsesProviderSessionState | undefined, strictToolsScope?: OpenAIStrictToolsScope, disableStrictToolsOverride?: boolean): {

package/dist/types/utils/empty-completion-retry.d.ts

@@ -0,0 +1,21 @@
+import type { AssistantMessage, Context } from "../types";
+import { AssistantMessageEventStream } from "./event-stream";
+export declare const MAX_EMPTY_COMPLETION_RETRIES = 2;
+export declare const EMPTY_COMPLETION_BASE_DELAY_MS = 500;
+/**
+ * Whether a completed assistant message carries content worth delivering: a tool
+ * call or any non-whitespace text. An empty/whitespace-only message — or one
+ * that only ever produced thinking — is the "empty response" failure.
+ */
+export declare function hasVisibleAssistantContent(message: AssistantMessage): boolean;
+interface EmptyCompletionRetryOptions {
+    signal?: AbortSignal;
+    providerRetryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+}
+/**
+ * Wrap a single-attempt provider stream with bounded empty-completion retries.
+ * `attempt` MUST create a fresh request (and its own output message) on each
+ * call so a retry never inherits stale metadata from an empty attempt.
+ */
+export declare function withEmptyCompletionRetry<M, O extends EmptyCompletionRetryOptions>(model: M, context: Context, options: O | undefined, attempt: (model: M, context: Context, options?: O) => AssistantMessageEventStream): AssistantMessageEventStream;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.1.2",
+	"version": "16.1.4",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.1.2",
-		"@oh-my-pi/pi-utils": "16.1.2",
-		"@oh-my-pi/pi-wire": "16.1.2",
+		"@oh-my-pi/pi-catalog": "16.1.4",
+		"@oh-my-pi/pi-utils": "16.1.4",
+		"@oh-my-pi/pi-wire": "16.1.4",
 		"arktype": "^2.2.0",
 		"partial-json": "^0.1.7",
 		"zod": "^4"

package/src/auth-storage.ts

@@ -4742,25 +4742,47 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 	}
 
 	#authCredentialsTableExists(): boolean {
-		const row = this.#db
-			.prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = 'auth_credentials'")
-			.get() as { present?: number } | undefined;
-		return row?.present === 1;
+		const stmt = this.#db.prepare(
+			"SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = 'auth_credentials'",
+		);
+		try {
+			const row = stmt.get() as { present?: number } | undefined;
+			return row?.present === 1;
+		} finally {
+			stmt.finalize();
+		}
 	}
 
 	#readAuthSchemaVersion(): number | null {
-		const row = this.#db.prepare("SELECT version FROM auth_schema_version WHERE id = 1").get() as
-			| { version?: number }
-			| undefined;
-		return typeof row?.version === "number" ? row.version : null;
+		const stmt = this.#db.prepare("SELECT version FROM auth_schema_version WHERE id = 1");
+		try {
+			const row = stmt.get() as { version?: number } | undefined;
+			return typeof row?.version === "number" ? row.version : null;
+		} finally {
+			stmt.finalize();
+		}
 	}
 
 	#writeAuthSchemaVersion(version: number): void {
-		this.#db.prepare("INSERT OR REPLACE INTO auth_schema_version(id, version) VALUES (1, ?)").run(version);
+		const stmt = this.#db.prepare("INSERT OR REPLACE INTO auth_schema_version(id, version) VALUES (1, ?)");
+		try {
+			stmt.run(version);
+		} finally {
+			stmt.finalize();
+		}
 	}
 
 	#inferAuthSchemaVersion(): number {
-		const cols = this.#db.prepare("PRAGMA table_info(auth_credentials)").all() as Array<{ name?: string }>;
+		const stmt = this.#db.prepare("PRAGMA table_info(auth_credentials)");
+		try {
+			const cols = stmt.all() as Array<{ name?: string }>;
+			return this.#inferAuthSchemaVersionFromColumns(cols);
+		} finally {
+			stmt.finalize();
+		}
+	}
+
+	#inferAuthSchemaVersionFromColumns(cols: Array<{ name?: string }>): number {
 		const hasDisabledCause = cols.some(column => column.name === "disabled_cause");
 		const hasIdentityKey = cols.some(column => column.name === "identity_key");
 		const hasAccountId = cols.some(column => column.name === "account_id");
@@ -4808,8 +4830,14 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 
 	#migrateAuthSchemaV0ToV1(): void {
 		const migrate = this.#db.transaction(() => {
-			const v0Cols = this.#db.prepare("PRAGMA table_info(auth_credentials)").all() as Array<{ name?: string }>;
-			const hasDisabled = v0Cols.some(col => col.name === "disabled");
+			const stmt = this.#db.prepare("PRAGMA table_info(auth_credentials)");
+			let hasDisabled = false;
+			try {
+				const v0Cols = stmt.all() as Array<{ name?: string }>;
+				hasDisabled = v0Cols.some(col => col.name === "disabled");
+			} finally {
+				stmt.finalize();
+			}
 
 			this.#db.run("ALTER TABLE auth_credentials RENAME TO auth_credentials_v0");
 			this.#db.run(`
@@ -4885,21 +4913,29 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 	}
 
 	#backfillCredentialIdentityKeys(): void {
-		const rows = this.#db
-			.prepare(
-				"SELECT id, provider, credential_type, data, disabled_cause, identity_key FROM auth_credentials WHERE identity_key IS NULL ORDER BY id ASC",
-			)
-			.all() as AuthRow[];
+		const selectRowsStmt = this.#db.prepare(
+			"SELECT id, provider, credential_type, data, disabled_cause, identity_key FROM auth_credentials WHERE identity_key IS NULL ORDER BY id ASC",
+		);
+		let rows: AuthRow[];
+		try {
+			rows = selectRowsStmt.all() as AuthRow[];
+		} finally {
+			selectRowsStmt.finalize();
+		}
 		if (rows.length === 0) return;
 
 		let updateIdentity: Statement | null = null;
-		for (const row of rows) {
-			const identityKey = resolveRowCredentialIdentityKey(row.provider, row);
-			// Rows whose identity cannot be derived stay NULL; writing NULL over
-			// NULL would just burn a write transaction on every boot.
-			if (identityKey === null) continue;
-			updateIdentity ??= this.#db.prepare("UPDATE auth_credentials SET identity_key = ? WHERE id = ?");
-			updateIdentity.run(identityKey, row.id);
+		try {
+			for (const row of rows) {
+				const identityKey = resolveRowCredentialIdentityKey(row.provider, row);
+				// Rows whose identity cannot be derived stay NULL; writing NULL over
+				// NULL would just burn a write transaction on every boot.
+				if (identityKey === null) continue;
+				updateIdentity ??= this.#db.prepare("UPDATE auth_credentials SET identity_key = ? WHERE id = ?");
+				updateIdentity.run(identityKey, row.id);
+			}
+		} finally {
+			updateIdentity?.finalize();
 		}
 	}
 
@@ -5063,9 +5099,13 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 
 	updateAuthCredential(id: number, credential: AuthCredential): void {
 		try {
-			const providerRow = this.#db.prepare("SELECT provider FROM auth_credentials WHERE id = ?").get(id) as
-				| { provider?: string }
-				| undefined;
+			const providerStmt = this.#db.prepare("SELECT provider FROM auth_credentials WHERE id = ?");
+			let providerRow: { provider?: string } | undefined;
+			try {
+				providerRow = providerStmt.get(id) as { provider?: string } | undefined;
+			} finally {
+				providerStmt.finalize();
+			}
 			const provider = providerRow?.provider ?? "";
 			const serialized = serializeCredential(provider, credential);
 			if (!serialized) return;
@@ -5334,6 +5374,8 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 		this.#lastUsageHistoryStmt.finalize();
 		this.#listUsageHistoryStmt.finalize();
 		this.#updateUsageHistoryStmt.finalize();
+		this.#insertUsageCostStmt.finalize();
+		this.#listUsageCostsStmt.finalize();
 		this.#db.close();
 	}
 }

package/src/providers/anthropic.ts

@@ -46,6 +46,7 @@ import type {
 import { resolveServiceTier } from "../types";
 import { isRecord, normalizeSystemPrompts, normalizeToolCallId, resolveCacheRetention } from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
+import { withEmptyCompletionRetry } from "../utils/empty-completion-retry";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { isFoundryEnabled } from "../utils/foundry";
 import { finalizeErrorMessage, type RawHttpRequestDump, rewriteCopilotError } from "../utils/http-inspector";
@@ -1575,7 +1576,7 @@ export function applyAnthropicUsageExtras(usage: Usage, source: AnthropicUsageLi
 	}
 }
 
-export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
+const streamAnthropicOnce = (
 	model: Model<"anthropic-messages">,
 	context: Context,
 	options?: AnthropicOptions,
@@ -2309,6 +2310,16 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 	return stream;
 };
 
+/**
+ * Public entry: wrap the single-attempt streamer with bounded empty-completion
+ * retries (a benign terminal stop carrying no content/usage would otherwise
+ * stall the agent loop). The inner attempt keeps its own provider-failure retry
+ * loop; this layer only re-issues a fresh request on an empty success. Shared
+ * with the OpenAI-completions provider via `withEmptyCompletionRetry`.
+ */
+export const streamAnthropic: StreamFunction<"anthropic-messages"> = (model, context, options) =>
+	withEmptyCompletionRetry(model, context, options, streamAnthropicOnce);
+
 export type AnthropicSystemBlock = {
 	type: "text";
 	text: string;

package/src/providers/google-gemini-cli.ts

@@ -940,7 +940,7 @@ function buildAntigravityRequestEnvelope(
 	const labels: Record<string, string> = {};
 	if (state?.lastExecutionId) labels.last_execution_id = state.lastExecutionId;
 	labels.last_step_index = String(step - 1);
-	if (profile) labels.model_enum = profile.modelEnum;
+	if (profile?.modelEnum !== undefined) labels.model_enum = profile.modelEnum;
 	labels.trajectory_id = trajectoryId;
 	labels.used_claude = String(isClaude);
 	labels.used_claude_conservative = String(isClaude);

package/src/providers/ollama.ts

@@ -5,15 +5,14 @@ import type {
 	Api,
 	AssistantMessage,
 	Context,
-	DeveloperMessage,
+	ImageContent,
 	Message,
 	Model,
 	StreamFunction,
 	StreamOptions,
+	TextContent,
 	Tool,
 	ToolChoice,
-	ToolResultMessage,
-	UserMessage,
 } from "../types";
 import { normalizeSystemPrompts } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
@@ -32,6 +31,7 @@ import {
 	type StreamMarkupHealingEvent,
 } from "../utils/stream-markup-healing";
 import { transformMessages } from "./transform-messages";
+import { joinTextWithImagePlaceholder, partitionVisionContent } from "./vision-guard";
 
 /** Non-2xx response from the Ollama `/api/chat` endpoint. */
 export class OllamaApiError extends ProviderHttpError {
@@ -174,40 +174,35 @@ function selectToolsForToolChoice(tools: Tool[] | undefined, toolChoice: ToolCho
 	return [];
 }
 
-function toPlainContent(content: string | Array<{ type: "text" | "image"; text?: string; data?: string }>): {
+function toPlainContent(
+	content: string | ReadonlyArray<TextContent | ImageContent>,
+	supportsImages: boolean,
+): {
 	content: string;
 	images?: string[];
 } {
 	if (typeof content === "string") {
 		return { content };
 	}
-	const textParts: string[] = [];
-	const images: string[] = [];
-	for (const block of content) {
-		if (block.type === "text" && typeof block.text === "string") {
-			textParts.push(block.text);
-		}
-		if (block.type === "image" && typeof block.data === "string") {
-			images.push(block.data);
-		}
-	}
+	const { textBlocks, imageBlocks, omittedImages } = partitionVisionContent(content, supportsImages);
+	const text = textBlocks.map(block => block.text).join("\n");
 	return {
-		content: textParts.join("\n"),
-		...(images.length > 0 ? { images } : {}),
+		content: joinTextWithImagePlaceholder(text, omittedImages),
+		...(imageBlocks.length > 0 ? { images: imageBlocks.map(block => block.data) } : {}),
 	};
 }
 
-function convertMessage(message: Message): OllamaMessage {
+function convertMessage(message: Message, supportsImages: boolean): OllamaMessage {
 	if (message.role === "user") {
-		const converted = toPlainContent(message.content as UserMessage["content"]);
+		const converted = toPlainContent(message.content, supportsImages);
 		return { role: "user", ...converted };
 	}
 	if (message.role === "developer") {
-		const converted = toPlainContent(message.content as DeveloperMessage["content"]);
+		const converted = toPlainContent(message.content, supportsImages);
 		return { role: "system", ...converted };
 	}
 	if (message.role === "toolResult") {
-		const converted = toPlainContent(message.content as ToolResultMessage["content"]);
+		const converted = toPlainContent(message.content, supportsImages);
 		return {
 			role: "tool",
 			tool_name: message.toolName,
@@ -259,8 +254,9 @@ function convertMessages(model: Model<"ollama-chat">, context: Context): OllamaM
 	}
 	messages.push(...context.messages);
 	const isCloud = model.provider === "ollama-cloud";
+	const supportsImages = model.input.includes("image");
 	return transformMessages(messages, model).map(msg => {
-		const converted = convertMessage(msg);
+		const converted = convertMessage(msg, supportsImages);
 		// Ollama cloud rejects requests when assistant history messages contain the `thinking`
 		// field — it's valid in model responses but not accepted as a history input. Strip it
 		// to prevent HTTP 400 errors. Local Ollama instances are unaffected.

package/src/providers/openai-completions.ts

@@ -27,6 +27,7 @@ import type {
 } from "../types";
 import { normalizeSystemPrompts } from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
+import { hasVisibleAssistantContent, withEmptyCompletionRetry } from "../utils/empty-completion-retry";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { finalizeErrorMessage, type RawHttpRequestDump, rewriteCopilotError } from "../utils/http-inspector";
 import {
@@ -537,7 +538,7 @@ const OPENAI_COMPLETIONS_FIRST_EVENT_TIMEOUT_MESSAGE =
 // converts the already-successful response into a timeout error.
 const OPENAI_COMPLETIONS_POST_FINISH_GRACE_MS = 2_500;
 
-export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
+const streamOpenAICompletionsOnce = (
 	model: Model<"openai-completions">,
 	context: Context,
 	options?: OpenAICompletionsOptions,
@@ -1234,7 +1235,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 			if (
 				policy.stream.emptyLengthFinishIsContextError &&
 				output.stopReason === "length" &&
-				!hasVisibleCompletionContent(output)
+				!hasVisibleAssistantContent(output)
 			) {
 				output.stopReason = "error";
 				output.errorMessage = EMPTY_OLLAMA_LENGTH_COMPLETION_MESSAGE;
@@ -1288,6 +1289,15 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 	return stream;
 };
 
+/**
+ * Public entry: wrap the single-attempt streamer with bounded empty-completion
+ * retries — flaky gateways occasionally 200 with `delta: {}` + `finish_reason:
+ * "stop"` and no usage, which would otherwise stall the agent loop. Shared with
+ * the Anthropic provider via `withEmptyCompletionRetry`.
+ */
+export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (model, context, options) =>
+	withEmptyCompletionRetry(model, context, options, streamOpenAICompletionsOnce);
+
 function createRequestSetup(
 	model: Model<"openai-completions">,
 	context: Context,
@@ -2061,16 +2071,6 @@ function convertTools(
 	};
 }
 
-const NON_WHITESPACE_RE = /\S/;
-
-function hasVisibleCompletionContent(message: AssistantMessage): boolean {
-	for (const block of message.content) {
-		if (block.type === "toolCall") return true;
-		if (block.type === "text" && NON_WHITESPACE_RE.test(block.text)) return true;
-	}
-	return false;
-}
-
 const EMPTY_OLLAMA_LENGTH_COMPLETION_MESSAGE =
 	"Model returned no content: prompt filled the context window; raise Ollama num_ctx or shorten the prompt.";
 

package/src/providers/openai-responses.ts

@@ -21,6 +21,7 @@ import {
 	sanitizeOpenAIResponsesHistoryItemsForReplay,
 } from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
+import { withEmptyCompletionRetry } from "../utils/empty-completion-retry";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { finalizeErrorMessage, type RawHttpRequestDump, rewriteCopilotError } from "../utils/http-inspector";
 import {
@@ -338,7 +339,7 @@ type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
 /**
  * Generate function for OpenAI Responses API
  */
-export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
+const streamOpenAIResponsesOnce = (
 	model: Model<"openai-responses">,
 	context: Context,
 	options?: OpenAIResponsesOptions,
@@ -737,6 +738,15 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 	return stream;
 };
 
+/**
+ * Public entry: wrap the single-attempt Responses streamer with bounded
+ * empty-completion retries — a `response.completed` carrying no content/usage
+ * would otherwise stall the agent loop. Shared with the OpenAI-completions and
+ * Anthropic providers via `withEmptyCompletionRetry`.
+ */
+export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (model, context, options) =>
+	withEmptyCompletionRetry(model, context, options, streamOpenAIResponsesOnce);
+
 export function buildParams(
 	model: Model<"openai-responses">,
 	context: Context,

package/src/utils/empty-completion-retry.ts

@@ -0,0 +1,159 @@
+/**
+ * Bounded retries for an empty assistant completion.
+ *
+ * Some providers — and especially flaky OpenAI-/Anthropic-compatible gateways —
+ * intermittently return a benign terminal stop carrying no content and no usage
+ * (e.g. a single OpenAI `delta: {}` + `finish_reason: "stop"` chunk). Delivered
+ * as-is the agent loop has nothing to act on and silently halts mid-task, so the
+ * request must be retried instead of surfaced.
+ *
+ * This wraps a single-attempt provider stream and re-invokes it (a fresh request
+ * with its own message state) when an attempt produces no meaningful content.
+ * Only a stream that streamed nothing meaningful is retried: the moment any
+ * text/thinking/tool delta is forwarded the attempt is committed, so live
+ * streaming (including thinking) is never delayed, retried, or duplicated.
+ *
+ * Mirrors the Gemini empty-response policy in `google-shared` (which keeps its
+ * own integrated loop) and is shared by the OpenAI-completions and
+ * Anthropic-messages providers.
+ */
+import { scheduler } from "node:timers/promises";
+import type { AssistantMessage, AssistantMessageEvent, Context } from "../types";
+import { AssistantMessageEventStream } from "./event-stream";
+
+export const MAX_EMPTY_COMPLETION_RETRIES = 2;
+export const EMPTY_COMPLETION_BASE_DELAY_MS = 500;
+
+const NON_WHITESPACE_RE = /\S/;
+
+/**
+ * Whether a completed assistant message carries content worth delivering: a tool
+ * call or any non-whitespace text. An empty/whitespace-only message — or one
+ * that only ever produced thinking — is the "empty response" failure.
+ */
+export function hasVisibleAssistantContent(message: AssistantMessage): boolean {
+	for (const block of message.content) {
+		if (block.type === "toolCall") return true;
+		if (block.type === "text" && NON_WHITESPACE_RE.test(block.text)) return true;
+	}
+	return false;
+}
+
+/** A streamed event that delivers content worth committing the attempt for. */
+function isMeaningfulCompletionEvent(event: AssistantMessageEvent): boolean {
+	switch (event.type) {
+		case "text_delta":
+		case "thinking_delta":
+		case "toolcall_delta":
+			return event.delta.length > 0;
+		case "text_end":
+		case "thinking_end":
+			return event.content.length > 0;
+		case "toolcall_start":
+		case "toolcall_end":
+			return true;
+		default:
+			return false;
+	}
+}
+
+interface EmptyCompletionRetryOptions {
+	signal?: AbortSignal;
+	providerRetryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+}
+
+/**
+ * Wrap a single-attempt provider stream with bounded empty-completion retries.
+ * `attempt` MUST create a fresh request (and its own output message) on each
+ * call so a retry never inherits stale metadata from an empty attempt.
+ */
+export function withEmptyCompletionRetry<M, O extends EmptyCompletionRetryOptions>(
+	model: M,
+	context: Context,
+	options: O | undefined,
+	attempt: (model: M, context: Context, options?: O) => AssistantMessageEventStream,
+): AssistantMessageEventStream {
+	const outer = new AssistantMessageEventStream();
+	const signal = options?.signal;
+	void (async () => {
+		for (let emptyAttempt = 0; ; emptyAttempt++) {
+			const inner = attempt(model, context, options);
+			const buffered: AssistantMessageEvent[] = [];
+			let committed = false;
+			let terminal: AssistantMessageEvent | undefined;
+			const flush = (): void => {
+				for (const event of buffered) outer.push(event);
+				buffered.length = 0;
+			};
+			try {
+				for await (const event of inner) {
+					if (event.type === "done" || event.type === "error") {
+						terminal = event;
+						break;
+					}
+					// Buffer pre-content events (start/*_start) so an empty attempt can
+					// be discarded; commit the moment real content streams.
+					if (!committed && !isMeaningfulCompletionEvent(event)) {
+						buffered.push(event);
+						continue;
+					}
+					committed = true;
+					flush();
+					outer.push(event);
+					if (outer.done) return;
+				}
+			} catch (error) {
+				flush();
+				outer.fail(error);
+				return;
+			}
+
+			// Retry only a genuinely degenerate completion: a normal stop that
+			// produced no visible content AND billed no output tokens (the flaky
+			// gateway signature — charged nothing, returned nothing). A stop that
+			// reports output tokens spent its budget somewhere (e.g. thinking) and
+			// is left alone.
+			const message = terminal?.type === "done" ? terminal.message : undefined;
+			const isRetryableEmpty =
+				!committed &&
+				message !== undefined &&
+				message.stopReason === "stop" &&
+				!message.errorMessage &&
+				(message.usage?.output ?? 0) <= 0 &&
+				!hasVisibleAssistantContent(message);
+
+			if (isRetryableEmpty && emptyAttempt < MAX_EMPTY_COMPLETION_RETRIES && !signal?.aborted) {
+				const delayMs = EMPTY_COMPLETION_BASE_DELAY_MS * 2 ** emptyAttempt;
+				try {
+					if (options?.providerRetryWait) await options.providerRetryWait(delayMs, signal);
+					else await scheduler.wait(delayMs, { signal });
+				} catch (waitError) {
+					// Aborted during backoff: deliver the empty result rather than hang.
+					// Any other wait failure is a real error and must surface.
+					flush();
+					if (signal?.aborted) {
+						if (terminal) outer.push(terminal);
+					} else {
+						outer.fail(waitError);
+					}
+					return;
+				}
+				// Discard the buffered `start` from this empty attempt and retry.
+				continue;
+			}
+
+			flush();
+			if (terminal) {
+				outer.push(terminal);
+			} else if (!outer.done) {
+				try {
+					outer.end(await inner.result());
+				} catch (error) {
+					outer.fail(error);
+				}
+			}
+			return;
+		}
+	})();
+	return outer;
+}

package/src/utils/thinking-loop.ts

@@ -25,11 +25,11 @@
  *    13.5k non-loop thinking blocks (zero false positives; hardest negative
  *    scored 3 against the trigger of 4).
  *
- * Scope is deliberately narrow: **thinking only**. Answer text is left
- * untouched so the guard can never discard already-streamed visible output. The
- * guard is gated to Gemini models and wraps the provider stream, so it works
- * across every Gemini transport (OpenRouter `openai-completions`, direct
- * `google-generative-ai` / `google-gemini-cli`, Vertex). Disable with
+ * Scope is narrow: guarded Gemini/DeepSeek streams before any tool call. Native
+ * thinking is checked first; assistant text can also be checked for providers
+ * that surface reasoning as visible prose. On a hit, the failed turn is emitted
+ * as an empty retryable stream-stall error so the session drops and re-samples
+ * it instead of committing the runaway transcript. Disable with
  * `PI_NO_THINKING_LOOP_GUARD=1`.
  */
 import { logger } from "@oh-my-pi/pi-utils";
@@ -208,7 +208,6 @@ export function guardThinkingLoopStream(
 	void (async () => {
 		let thinkingArmed = true;
 		let textArmed = checkAssistantContent;
-		let accumulatedText = "";
 		try {
 			for await (const event of inner) {
 				let detail: string | null = null;
@@ -221,7 +220,6 @@ export function guardThinkingLoopStream(
 					thinkingArmed = false;
 					if (textArmed && event.type === "text_delta") {
 						detail = textDetector.push(event.delta);
-						accumulatedText += event.delta;
 					}
 				} else if (event.type === "toolcall_start" || event.type === "toolcall_delta") {
 					thinkingArmed = false;
@@ -244,7 +242,7 @@ export function guardThinkingLoopStream(
 					outer.push({
 						type: "error",
 						reason: "error",
-						error: buildThinkingLoopError(model, detail, accumulatedText),
+						error: buildThinkingLoopError(model, detail),
 					});
 					return;
 				}
@@ -289,13 +287,13 @@ export function withGeminiThinkingLoopGuard<
 	return guardThinkingLoopStream(dispatch(merged), model, controller, options);
 }
 
-function buildThinkingLoopError(model: Model<Api>, detail: string, accumulatedText?: string): AssistantMessage {
-	const hasText = Boolean(accumulatedText);
+function buildThinkingLoopError(model: Model<Api>, detail: string): AssistantMessage {
 	return {
 		role: "assistant",
-		// Empty content is load-bearing: a contentful error stop is replay-unsafe
-		// and would NOT be auto-retried by the session.
-		content: hasText ? [{ type: "text", text: accumulatedText! }] : [],
+		// Empty content is load-bearing: loop-guard output is replay garbage, even
+		// when it arrived as assistant text instead of native thinking. Keeping it
+		// would persist the failed attempt before AgentSession retries.
+		content: [],
 		api: model.api,
 		provider: model.provider,
 		model: model.id,
@@ -310,7 +308,7 @@ function buildThinkingLoopError(model: Model<Api>, detail: string, accumulatedTe
 		stopReason: "error",
 		// "stream stall" makes the transport/session retry classifiers treat this
 		// as a transient (retryable) failure with no bespoke rule.
-		errorMessage: `${THINKING_LOOP_ERROR_MARKER}: the model repeated near-identical content (${detail}).${hasText ? " Non-retryable because output was already streamed." : " Treating as a stream stall and retrying."}`,
+		errorMessage: `${THINKING_LOOP_ERROR_MARKER}: the model repeated near-identical content (${detail}). Treating as a stream stall and retrying.`,
 		timestamp: Date.now(),
 	};
 }
@@ -345,14 +343,15 @@ function detectVerbatimRepetition(text: string): [unit: string, count: number] |
 	return null;
 }
 
-/** Lowercase, drop code spans / paths / digits, keep only letter words. */
+/** Lowercase and tokenize prose plus code/path payloads, dropping pure numbers. */
 function normalizeSegment(segment: string): string {
 	return segment
 		.toLowerCase()
-		.replace(/`[^`]*`/g, " ")
-		.replace(/\/[^\s`]+/g, " ")
-		.replace(/\d+/g, " ")
-		.replace(/[^a-z]+/g, " ")
+		.replace(/`([^`]*)`/g, " $1 ")
+		.replace(/[^a-z0-9]+/g, " ")
+		.split(/\s+/)
+		.filter(token => /[a-z]/.test(token))
+		.join(" ")
 		.trim();
 }