@oh-my-pi/pi-ai 17.0.7 → 17.0.8

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+### Fixed
+
+- Fixed GitHub Copilot OpenAI-compatible requests being rejected when the session's native OpenAI service tier was set to `priority` ([#5160](https://github.com/can1357/oh-my-pi/pull/5160) by [@audreyt](https://github.com/audreyt)).
+
+## [17.0.8] - 2026-07-22
+
+### Fixed
+
+- Fixed Gemini Flash Cloud Code Assist empty-response retries when responses contain only intercepted planning-leak JSON.
+- Fixed Antigravity auto-routing to correctly fail over to the sandbox endpoint when the daily endpoint exhausts its retries.
+- Fixed OpenAI-compatible providers configured with auth: none incorrectly sending an Authorization: Bearer N/A header, which broke custom endpoints using alternative authentication headers.
+- Fixed auth-gateway model listings exposing duplicate or ambiguous model IDs by ensuring only provider-qualified routing IDs are advertised.
+- Improved connection error handling by classifying generic connection failures as transient, allowing them to be retried, while keeping explicit authentication rejections non-retryable.
+- Fixed custom Anthropic base URLs losing native thinking signatures during continuation requests.
+- Fixed Alibaba Coding Plan Custom login rejecting valid API keys on endpoints that do not serve the default validation model by validating against the model catalog instead.
+
 ## [17.0.6] - 2026-07-20
 
 ### Fixed

package/dist/types/error/flags.d.ts

@@ -73,7 +73,13 @@ export declare function classifyMessage(message: {
 export declare function attach<E extends object>(error: E, id: number): E;
 export declare function isContextOverflow(message: AssistantMessage, contextWindow?: number): boolean;
 export declare function stringify(id: number | undefined): string;
-/** Transient stream corruption where the response was truncated mid-JSON. */
+/**
+ * Transient stream corruption where the response was truncated mid-JSON.
+ *
+ * Strings (persisted `stopDetails.explanation`/`errorMessage` diagnostics) are matched with the
+ * stricter {@link STREAM_PARSE_DIAGNOSTIC_PATTERN} — bare "truncated"/"end of file" text is too
+ * low-signal to trust once detached from a live transport `Error`, which keeps the broad pattern.
+ */
 export declare function isTransientStreamParseError(error: unknown): boolean;
 /** Any malformed stream-envelope error (prefix-tagged or out-of-order events). */
 export declare function isStreamEnvelopeError(error: unknown): boolean;

package/dist/types/providers/__tests__/keyless-auth-header.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -7,6 +7,15 @@ import type { CapturedHttpErrorResponse } from "../utils/http-inspector.js";
 import type { ChatCompletionCreateParamsStreaming } from "./openai-chat-wire.js";
 import type { InputItem } from "./openai-codex/request-transformer.js";
 import type { ResponseContentPartAddedEvent, ResponseCreateParamsStreaming, ResponseInput, ResponseInputContent, ResponseInputItem, ResponseOutputItem, ResponseOutputMessage, ResponseReasoningItem, ResponseStatus, ResponseStreamEvent } from "./openai-responses-wire.js";
+/**
+ * Keyless-provider sentinel. Custom providers configured with `auth: none`
+ * (models.yml) have no credential, so the coding-agent resolves their API key
+ * to this literal instead of a real secret. Providers must treat it as "no
+ * credential" and suppress any credential-bearing header (e.g. `Authorization:
+ * Bearer …`) rather than forwarding the sentinel on the wire. See #6188; the
+ * google-vertex and amazon-bedrock transports apply the same guard inline.
+ */
+export declare const NO_AUTH_SENTINEL = "N/A";
 export interface OpenAIModelIdentity {
     provider: string;
     id: string;

package/dist/types/types.d.ts

@@ -108,7 +108,8 @@ type ServiceTierModel = Pick<Model, "provider" | "api" | "id">;
  * `openai/`); Claude on Bedrock/Vertex (api `anthropic-messages`) is the
  * anthropic family even though its provider is `amazon-bedrock`/`google-vertex`.
  * Custom OpenAI-compatible relays that serve OpenAI model ids are OpenAI family
- * too unless that provider owns a separate tier control such as Fireworks.
+ * too unless the provider owns a separate tier control (Fireworks) or rejects
+ * OpenAI's service-tier field (GitHub Copilot).
  */
 export declare function serviceTierFamily(model: ServiceTierModel): ServiceTierFamily | undefined;
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "17.0.7",
+	"version": "17.0.8",
 	"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.1",
-		"@oh-my-pi/pi-catalog": "17.0.7",
-		"@oh-my-pi/pi-utils": "17.0.7",
-		"@oh-my-pi/pi-wire": "17.0.7",
+		"@oh-my-pi/pi-catalog": "17.0.8",
+		"@oh-my-pi/pi-utils": "17.0.8",
+		"@oh-my-pi/pi-wire": "17.0.8",
 		"arktype": "2.2.3",
 		"zod": "^4"
 	},

package/src/auth-gateway/server.ts

@@ -726,13 +726,19 @@ async function handleCredentialsCheck(storage: AuthStorage, signal: AbortSignal)
 }
 
 function handleModelsList(opts: AuthGatewayBootOptions): Response {
-	const list = opts.listModels ? Array.from(opts.listModels()) : [];
-	const data = list.map(model => ({
-		id: model.id,
-		object: "model" as const,
-		owned_by: model.provider,
-		api: model.api,
-	}));
+	const seen = new Set<string>();
+	const data: Array<{ id: string; object: "model"; owned_by: string; api: Api }> = [];
+	for (const model of opts.listModels?.() ?? []) {
+		const id = `${model.provider}/${model.id}`;
+		if (seen.has(id)) continue;
+		seen.add(id);
+		data.push({
+			id,
+			object: "model",
+			owned_by: model.provider,
+			api: model.api,
+		});
+	}
 	return json(200, { object: "list", data });
 }
 

package/src/error/flags.ts

@@ -90,7 +90,7 @@ const TRANSIENT_ENVELOPE_PATTERN = /anthropic stream envelope error:/i;
 const TRANSIENT_ENVELOPE_BEFORE_START_PATTERN = /before message_start/i;
 export const STREAM_READ_ERROR_PATTERN = /stream[_ -]?read[_ -]?error/i;
 export const TRANSIENT_TRANSPORT_PATTERN =
-	/overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|retry your request|network.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|upstream.?request.?failed|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay|stream stall|no error details in response|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)|malformed.?function.?call/i;
+	/overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|retry your request|network.?error|connection.?error|connection.?refused|unable.?to.?connect\.\s*is the computer able to access the url\?|other side closed|fetch failed|upstream.?connect|upstream.?request.?failed|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay|stream stall|no error details in response|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)|malformed.?function.?call/i;
 const AUTH_FAILURE_PATTERN =
 	/\b(?:401|403|unauthorized|forbidden|authentication|auth[_ ]?unavailable|no auth available|(?:invalid|no)[_ ]?api[_ ]?key)\b/i;
 const MALFORMED_FUNCTION_CALL_PATTERN = /\bmalformed.?function.?call\b/i;
@@ -505,10 +505,19 @@ export function stringify(id: number | undefined): string {
 
 const STREAM_PARSE_TRUNCATION_PATTERN =
 	/unterminated string|unexpected end of json input|unexpected end of data|unexpected eof|end of file|eof while parsing|truncated/i;
+const STREAM_PARSE_DIAGNOSTIC_PATTERN =
+	/(?:json parse error:\s*(?:unterminated string|unexpected end of json input|unexpected end of data|unexpected eof|end of file|eof while parsing|truncated)|json\.parse:\s*(?:unterminated string|unexpected end of data)|unexpected end of json input|unexpected eof|eof while parsing)/i;
 const STREAM_EVENT_ORDER_PATTERN = /stream event order|before message_start/i;
 
-/** Transient stream corruption where the response was truncated mid-JSON. */
+/**
+ * Transient stream corruption where the response was truncated mid-JSON.
+ *
+ * Strings (persisted `stopDetails.explanation`/`errorMessage` diagnostics) are matched with the
+ * stricter {@link STREAM_PARSE_DIAGNOSTIC_PATTERN} — bare "truncated"/"end of file" text is too
+ * low-signal to trust once detached from a live transport `Error`, which keeps the broad pattern.
+ */
 export function isTransientStreamParseError(error: unknown): boolean {
+	if (typeof error === "string") return STREAM_PARSE_DIAGNOSTIC_PATTERN.test(error);
 	return error instanceof Error && STREAM_PARSE_TRUNCATION_PATTERN.test(error.message);
 }
 

package/src/providers/__tests__/keyless-auth-header.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+import { NO_AUTH_SENTINEL, resolveOpenAIRequestSetup } from "../openai-shared";
+
+describe("resolveOpenAIRequestSetup keyless auth", () => {
+	test("omits Authorization for the keyless (auth: none) sentinel, keeping custom headers", () => {
+		const setup = resolveOpenAIRequestSetup(
+			{
+				provider: "qwen",
+				id: "Qwen3.6-35B-A3B",
+				baseUrl: "http://localhost:8788",
+				headers: { "x-api-key": "real-key" },
+			},
+			{ apiKey: NO_AUTH_SENTINEL, messages: [] },
+		);
+		expect(setup.headers.Authorization).toBeUndefined();
+		expect(setup.headers["x-api-key"]).toBe("real-key");
+	});
+
+	test("still injects Bearer for a real key", () => {
+		const setup = resolveOpenAIRequestSetup(
+			{ provider: "custom", id: "m", baseUrl: "http://localhost:8788" },
+			{ apiKey: "sk-real", messages: [] },
+		);
+		expect(setup.headers.Authorization).toBe("Bearer sk-real");
+	});
+
+	test("caller-supplied Authorization in model.headers is preserved even when keyless", () => {
+		const setup = resolveOpenAIRequestSetup(
+			{
+				provider: "qwen",
+				id: "m",
+				baseUrl: "http://localhost:8788",
+				headers: { Authorization: "Bearer custom-token" },
+			},
+			{ apiKey: NO_AUTH_SENTINEL, messages: [] },
+		);
+		expect(setup.headers.Authorization).toBe("Bearer custom-token");
+	});
+});

package/src/providers/__tests__/kimi-code-thinking.test.ts

@@ -161,7 +161,7 @@ describe("Kimi K3 thinking transport", () => {
 	it("downgrades named tool choice to required for K3 thinking", async () => {
 		vi.spyOn(kimiOauth, "getKimiCommonHeaders").mockReturnValue(KIMI_HEADERS);
 		const bundledModel = getBundledModel<"openai-completions">("kimi-code", "k3");
-		expect(bundledModel.compat.thinkingFormat).toBe("zai");
+		expect(bundledModel.compat.thinkingFormat).toBe("kimi");
 		let payload: unknown;
 		const capturePayload = async (
 			model: Model<"openai-completions">,

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

@@ -815,9 +815,6 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 									if (isBuffering) {
 										const buffered = consumePlanningBuffer(textBuffer, toolNames);
 										if (buffered.kind !== "incomplete") {
-											if (buffered.kind === "leak") {
-												sawLeak = true;
-											}
 											const visibleSignature = bufferedTextSignature;
 											isBuffering = false;
 											textBuffer = "";
@@ -896,9 +893,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 
 				if (isBuffering && textBuffer !== "") {
 					const buffered = consumePlanningBuffer(textBuffer, toolNames, true);
-					if (buffered.kind === "leak") {
-						sawLeak = true;
-					}
+
 					if (buffered.kind !== "incomplete") {
 						feedVisibleText(buffered.visibleText, bufferedTextSignature);
 					}
@@ -910,11 +905,10 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 				flushVisibleText(bufferedTextSignature);
 				endCurrentBlock();
 
-				return hasMeaningfulGoogleContent(output) || sawLeak;
+				return hasMeaningfulGoogleContent(output);
 			};
 
 			let receivedContent = false;
-			let sawLeak = false;
 
 			for (let i = 0; i < endpoints.length; i++) {
 				const endpoint = endpoints[i];
@@ -1055,10 +1049,15 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 					break;
 				} catch (error) {
 					const status = extractHttpStatusFromError(error);
-					if (AIError.isTransientStatus(status)) {
-						if (!isLastEndpoint && !started) {
-							continue;
-						}
+					if (
+						!isLastEndpoint &&
+						!started &&
+						(AIError.isTransientStatus(status) ||
+							(status === undefined &&
+								!(error instanceof AIError.ProviderResponseError && error.kind === "output") &&
+								AIError.retriable(AIError.classify(error))))
+					) {
+						continue;
 					}
 					throw error;
 				}

package/src/providers/openai-shared.ts

@@ -101,6 +101,16 @@ import type {
 import { transformMessages } from "./transform-messages";
 import { joinTextWithImagePlaceholder, NON_VISION_IMAGE_PLACEHOLDER, partitionVisionContent } from "./vision-guard";
 
+/**
+ * Keyless-provider sentinel. Custom providers configured with `auth: none`
+ * (models.yml) have no credential, so the coding-agent resolves their API key
+ * to this literal instead of a real secret. Providers must treat it as "no
+ * credential" and suppress any credential-bearing header (e.g. `Authorization:
+ * Bearer …`) rather than forwarding the sentinel on the wire. See #6188; the
+ * google-vertex and amazon-bedrock transports apply the same guard inline.
+ */
+export const NO_AUTH_SENTINEL = "N/A";
+
 export interface OpenAIModelIdentity {
 	provider: string;
 	id: string;
@@ -279,7 +289,15 @@ export function resolveOpenAIRequestSetup(
 		baseUrl = baseUrl ?? ($env.OPENAI_BASE_URL?.trim() || options.defaultBaseUrl);
 	}
 	const requestHeaders = { ...headers };
-	headers.Authorization ??= `Bearer ${apiKey}`;
+	// A keyless provider (`auth: none` in models.yml) resolves to the `N/A`
+	// sentinel rather than a real key. Injecting `Authorization: Bearer N/A`
+	// breaks custom endpoints that authenticate via their own headers (e.g.
+	// `headers.x-api-key`) and reject the bogus bearer — mirror the sentinel
+	// guards in google-vertex / amazon-bedrock and send no Authorization here
+	// (#6188). A caller-supplied Authorization in `model.headers` still wins.
+	if (apiKey !== NO_AUTH_SENTINEL) {
+		headers.Authorization ??= `Bearer ${apiKey}`;
+	}
 	return { copilotPremiumRequests, baseUrl, headers, query, requestHeaders };
 }
 

package/src/registry/alibaba-coding-plan.ts

@@ -71,13 +71,22 @@ export async function loginAlibabaCodingPlan(options: OAuthController): Promise<
 	}
 
 	options.onProgress?.("Validating API key...");
-	await apiKeyValidation.validateOpenAICompatibleApiKey({
-		provider: "Alibaba Coding Plan",
-		apiKey: trimmed,
-		baseUrl,
-		model: VALIDATION_MODEL,
-		signal: options.signal,
-	});
+	if (choice === "3") {
+		await apiKeyValidation.validateApiKeyAgainstModelsEndpoint({
+			provider: "Alibaba Coding Plan",
+			apiKey: trimmed,
+			modelsUrl: `${baseUrl}/models`,
+			signal: options.signal,
+		});
+	} else {
+		await apiKeyValidation.validateOpenAICompatibleApiKey({
+			provider: "Alibaba Coding Plan",
+			apiKey: trimmed,
+			baseUrl,
+			model: VALIDATION_MODEL,
+			signal: options.signal,
+		});
+	}
 
 	return {
 		access: trimmed,

package/src/types.ts

@@ -141,13 +141,17 @@ function isOpenAIServiceTierApi(api: Api | undefined): boolean {
 	return api === "openai-completions" || api === "openai-responses" || api === "openai-codex-responses";
 }
 
-function hasDedicatedServiceTierControl(provider: Provider | undefined): boolean {
-	return provider === "fireworks";
+function excludesInferredOpenAIServiceTier(provider: Provider | undefined): boolean {
+	// Fireworks has its own priority-only control. GitHub Copilot proxies OpenAI
+	// models but rejects OpenAI's `service_tier` request field.
+	return provider === "fireworks" || provider === "github-copilot";
 }
 
 function isOpenAIServiceTierModel(model: ServiceTierModel): boolean {
 	return (
-		!hasDedicatedServiceTierControl(model.provider) && isOpenAIServiceTierApi(model.api) && isOpenAIModelId(model.id)
+		!excludesInferredOpenAIServiceTier(model.provider) &&
+		isOpenAIServiceTierApi(model.api) &&
+		isOpenAIModelId(model.id)
 	);
 }
 
@@ -159,7 +163,8 @@ function isOpenAIServiceTierModel(model: ServiceTierModel): boolean {
  * `openai/`); Claude on Bedrock/Vertex (api `anthropic-messages`) is the
  * anthropic family even though its provider is `amazon-bedrock`/`google-vertex`.
  * Custom OpenAI-compatible relays that serve OpenAI model ids are OpenAI family
- * too unless that provider owns a separate tier control such as Fireworks.
+ * too unless the provider owns a separate tier control (Fireworks) or rejects
+ * OpenAI's service-tier field (GitHub Copilot).
  */
 export function serviceTierFamily(model: ServiceTierModel): ServiceTierFamily | undefined {
 	const provider = model.provider;

package/src/utils/leaked-thinking-stream.ts

@@ -75,7 +75,19 @@ export function wrapLeakedThinkingStream(inner: AssistantMessageEventStream): As
 					case "thinking_delta": {
 						projector ??= new LeakedThinkingProjector(out, event.partial);
 						const block = event.partial.content[event.contentIndex];
-						projector.thinking(event.delta, block?.type === "thinking" ? block.thinkingSignature : undefined);
+						projector.thinking(
+							event.contentIndex,
+							event.delta,
+							block?.type === "thinking" ? block.thinkingSignature : undefined,
+						);
+						break;
+					}
+					case "thinking_end": {
+						const block = event.partial.content[event.contentIndex];
+						projector?.thinkingEnd(
+							event.contentIndex,
+							block?.type === "thinking" ? block.thinkingSignature : undefined,
+						);
 						break;
 					}
 					case "image_end":
@@ -108,8 +120,9 @@ export function wrapLeakedThinkingStream(inner: AssistantMessageEventStream): As
 						out.push({ type: "error", reason: event.reason, error: { ...event.error, content } });
 						return;
 					}
-					// text_start/text_end/thinking_start/thinking_end are ignored: the
-					// projector owns block boundaries (matches wrapInbandToolStream).
+					// text_start/text_end/thinking_start are ignored: the projector owns
+					// block boundaries (matches wrapInbandToolStream). thinking_end is
+					// handled to capture the signature Anthropic delivers at block close.
 				}
 			}
 			// Inner ended via end(result) without a terminal event.
@@ -144,6 +157,10 @@ class LeakedThinkingProjector {
 	#lastTextSignature: string | undefined;
 	/** Forwarded native tool calls, keyed by the inner stream's `contentIndex`. */
 	#toolBlocks = new Map<number, { index: number; block: StreamingToolCall }>();
+	/** Projected native thinking blocks, keyed by the inner stream's `contentIndex`. */
+	#thinkingBlocks = new Map<number, number>();
+	/** Native thinking blocks whose projected `thinking_end` awaits the source end event. */
+	#pendingThinkingEnds = new Set<number>();
 
 	constructor(out: AssistantMessageEventStream, seed: AssistantMessage) {
 		this.#out = out;
@@ -158,15 +175,37 @@ class LeakedThinkingProjector {
 		this.#apply(this.#healer.feedEvents(delta), this.#lastTextSignature);
 	}
 
-	/** Forward a native thinking delta, preserving its signature. */
-	thinking(delta: string, signature: string | undefined): void {
-		const index = this.#openThinking();
+	/** Forward a native thinking delta, preserving its source block identity and signature. */
+	thinking(srcIndex: number, delta: string, signature: string | undefined): void {
+		let index = this.#thinkingBlocks.get(srcIndex);
+		if (index === undefined) {
+			if (this.#thinking && this.#pendingThinkingEnds.has(this.#thinking.index)) this.#closeThinking();
+			index = this.#openThinking();
+			this.#thinkingBlocks.set(srcIndex, index);
+			this.#pendingThinkingEnds.add(index);
+		}
 		const block = this.#partial.content[index] as ThinkingContent;
 		block.thinking += delta;
 		if (signature !== undefined) block.thinkingSignature = signature;
 		this.#out.push({ type: "thinking_delta", contentIndex: index, delta, partial: this.#partial });
 	}
 
+	/**
+	 * Finalize a native thinking block by source identity. Its projected end is
+	 * deferred until this event so stream consumers observe the completed
+	 * signature before the block closes, even when later blocks started first.
+	 */
+	thinkingEnd(srcIndex: number, signature: string | undefined): void {
+		const index = this.#thinkingBlocks.get(srcIndex);
+		if (index === undefined) return;
+		if (signature !== undefined) {
+			(this.#partial.content[index] as ThinkingContent).thinkingSignature = signature;
+		}
+		if (!this.#pendingThinkingEnds.delete(index)) return;
+		if (this.#thinking?.index === index) this.#thinking = undefined;
+		this.#emitThinkingEnd(index);
+	}
+
 	/** Forward a completed native image after releasing held text. */
 	image(content: ImageContent): void {
 		this.#apply(this.#healer.flushEvents(), this.#lastTextSignature);
@@ -234,6 +273,10 @@ class LeakedThinkingProjector {
 	 * flush held-back fragments, close open blocks, and return the healed content.
 	 */
 	finish(message: AssistantMessage): AssistantMessage["content"] {
+		for (const [srcIndex] of this.#thinkingBlocks) {
+			const block = message.content[srcIndex];
+			this.thinkingEnd(srcIndex, block?.type === "thinking" ? block.thinkingSignature : undefined);
+		}
 		let fullText = "";
 		let tailSignature: string | undefined;
 		for (const block of message.content) {
@@ -304,13 +347,19 @@ class LeakedThinkingProjector {
 
 	#closeThinking(): void {
 		if (!this.#thinking) return;
-		const block = this.#partial.content[this.#thinking.index] as ThinkingContent;
+		const index = this.#thinking.index;
+		this.#thinking = undefined;
+		if (this.#pendingThinkingEnds.has(index)) return;
+		this.#emitThinkingEnd(index);
+	}
+
+	#emitThinkingEnd(index: number): void {
+		const block = this.#partial.content[index] as ThinkingContent;
 		this.#out.push({
 			type: "thinking_end",
-			contentIndex: this.#thinking.index,
+			contentIndex: index,
 			content: block.thinking,
 			partial: this.#partial,
 		});
-		this.#thinking = undefined;
 	}
 }