@oh-my-pi/pi-ai 16.1.3 → 16.1.5

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [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

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.3",
+	"version": "16.1.5",
 	"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.3",
-		"@oh-my-pi/pi-utils": "16.1.3",
-		"@oh-my-pi/pi-wire": "16.1.3",
+		"@oh-my-pi/pi-catalog": "16.1.5",
+		"@oh-my-pi/pi-utils": "16.1.5",
+		"@oh-my-pi/pi-wire": "16.1.5",
 		"arktype": "^2.2.0",
 		"partial-json": "^0.1.7",
 		"zod": "^4"

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/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;
+}