@xiaoso/dsh-tool-plus 0.1.5 → 0.1.7-beta.0

package/lib/{google-shared-CVbHK5vZ.mjs → google-shared-B0aNCYEH.mjs}

@@ -1,16 +1,117 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-import { o as readSseJson } from "./src-BcD0_rQR.mjs";
-import { R as GoogleApiError, l as finalize, r as ValidationError, s as ProviderResponseError, t as ConfigurationError, v as AbortError } from "./error-C-f_Wnw4.mjs";
-import { M as normalizeSchemaForCCA, N as normalizeSchemaForGoogle, a as normalizeSystemPrompts, k as toolWireSchema, m as transformMessages, w as renderDemotedThinking } from "./utils-Cp2Mxf_U.mjs";
-import { t as calculateCost } from "./models-DRA2c_8U.mjs";
-import { o as shouldSendServiceTier, t as NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard-mBmtAHx0.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-Dh2guZxS.mjs";
+import { o as readSseJson } from "./src-BwW51vA5.mjs";
+import { R as GoogleApiError, _ as AbortError, c as finalize, r as ValidationError, s as ProviderResponseError, t as ConfigurationError } from "./error-CORgGg5a.mjs";
+import { A as toolWireSchema, N as normalizeSchemaForCCA, P as normalizeSchemaForGoogle, T as renderDemotedThinking, h as transformMessages, o as normalizeSystemPrompts } from "./utils-CUPhpw9A.mjs";
+import { t as calculateCost } from "./models-DnXMYGcJ.mjs";
+import { o as shouldSendServiceTier, t as NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard-_XwsL1DF.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-ulcDenZD.mjs";
 import { scheduler } from "node:timers/promises";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/google-shared.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/dialect/thinking-fence-strip.ts
+/**
+* Strip self-referential reasoning-fence delimiters that a provider leaks
+* *inside* a structured thinking part.
+*
+* The visible-channel healers ({@link ../utils/leaked-thinking-stream},
+* {@link ./fenced-thinking}) split leaked ` ```thinking ` fences out of the
+* *text* stream. They never run over parts a provider already flags as
+* thinking, so when a model (observed on Gemini thought summaries — issue
+* #8719) emits a bare ` ```thinking ` / ` ``````thinking ` opener line between
+* summaries, that delimiter reaches display and persistence verbatim as fence
+* spam inside the reasoning block.
+*
+* This stripper removes only a *standalone* reasoning-fence opener line — a line
+* that is nothing but a run of ≥3 backticks immediately followed by the info
+* string `thinking` or `reasoning`. Such a line is always redundant inside an
+* already-structured thinking block and never carries content. Inline mentions
+* (prose on the same line), language-tagged code fences (` ```rs `), and bare
+* closers (` ``` `) are left untouched so legitimate fenced code inside the
+* reasoning survives.
+*
+* Streaming-safe: deltas may split a line anywhere. A trailing partial line is
+* held only while it remains a viable opener prefix; the moment it cannot be an
+* opener it is flushed and the rest of the line passes through character-level.
+* Correctness never depends on the prefix heuristic — every held line is
+* classified strictly on its newline (or on {@link ThinkingFenceStripper.flush})
+* before it is dropped.
+*/
+/**
+* A complete standalone reasoning-fence opener: ≤3 lead spaces, ≥3 backticks,
+* `thinking`/`reasoning`, optional trailing spaces, tolerating a trailing CR
+* from a CRLF newline.
+*/
+const OPENER_LINE = /^ {0,3}`{3,}(?:thinking|reasoning)[ \t]*\r?$/i;
+/** Could `line` (a partial, newline-not-yet-seen) still grow into {@link OPENER_LINE}? */
+function couldBeOpenerPrefix(line) {
+	const s = line.endsWith("\r") ? line.slice(0, -1) : line;
+	const m = /^ {0,3}(`*)([\s\S]*)$/.exec(s);
+	if (!m) return false;
+	const ticks = m[1].length;
+	const rest = m[2];
+	if (rest === "") return true;
+	if (ticks < 3) return false;
+	const word = rest.replace(/[ \t]+$/, "").toLowerCase();
+	return "thinking".startsWith(word) || "reasoning".startsWith(word);
+}
+/**
+* Stateful, line-oriented stripper for leaked reasoning-fence openers in one
+* structured thinking block. One instance per thinking block; feed every
+* thinking delta through {@link push} and drain the tail with {@link flush}.
+*/
+var ThinkingFenceStripper = class {
+	/** Buffered content of the current line still being classified. */
+	#carry = "";
+	/** True once the current line is known not to be an opener; passes through until newline. */
+	#passthrough = false;
+	/** Consume one thinking delta; returns the sanitized text to emit (may be empty). */
+	push(chunk) {
+		let out = "";
+		for (const ch of chunk) {
+			if (this.#passthrough) {
+				out += ch;
+				if (ch === "\n") this.#passthrough = false;
+				continue;
+			}
+			if (ch === "\n") {
+				if (!OPENER_LINE.test(this.#carry)) out += `${this.#carry}\n`;
+				this.#carry = "";
+				continue;
+			}
+			this.#carry += ch;
+			if (!couldBeOpenerPrefix(this.#carry)) {
+				out += this.#carry;
+				this.#carry = "";
+				this.#passthrough = true;
+			}
+		}
+		return out;
+	}
+	/** Drain any held partial line at block end; returns text to emit (may be empty). */
+	flush() {
+		const carry = this.#carry;
+		this.#carry = "";
+		this.#passthrough = false;
+		return OPENER_LINE.test(carry) ? "" : carry;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/google-shared.ts
 /**
 * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
 */
+function convertGoogleImagePart(image) {
+	if (image.providerFile?.provider === "google" && image.providerFile.uri) return { fileData: {
+		fileUri: image.providerFile.uri,
+		mimeType: image.mimeType
+	} };
+	return image.url ? { fileData: {
+		fileUri: image.url,
+		mimeType: image.mimeType
+	} } : { inlineData: {
+		mimeType: image.mimeType,
+		data: image.data
+	} };
+}
 /**
 * Determines whether a streamed Gemini `Part` should be treated as "thinking".
 *
@@ -55,23 +156,6 @@ function isValidThoughtSignature(signature) {
 function resolveThoughtSignature(isSameProviderAndModel, signature) {
 	return isSameProviderAndModel && isValidThoughtSignature(signature) ? signature : void 0;
 }
-function supportsFunctionPartId(model) {
-	if (model.api === "google-vertex") return false;
-	return model.id.startsWith("claude-") || model.api === "google-generative-ai" && isGemini3Model(model.id);
-}
-function getGeminiMajorVersion(modelId) {
-	const match = modelId.toLowerCase().match(/^gemini(?:-live)?-(\d+)/);
-	if (!match) return void 0;
-	return Number.parseInt(match[1], 10);
-}
-function supportsMultimodalFunctionResponse(modelId) {
-	const geminiMajorVersion = getGeminiMajorVersion(modelId);
-	if (geminiMajorVersion !== void 0) return geminiMajorVersion >= 3;
-	return true;
-}
-function isGemini3Model(modelId) {
-	return modelId.includes("gemini-3");
-}
 /**
 * Convert internal messages to Gemini Content[] format.
 */
@@ -108,10 +192,7 @@ function convertMessages(model, context) {
 					const text = item.text.toWellFormed();
 					if (text.trim().length === 0) continue;
 					parts.push({ text });
-				} else if (supportsImages) parts.push({ inlineData: {
-					mimeType: item.mimeType,
-					data: item.data
-				} });
+				} else if (supportsImages) parts.push(convertGoogleImagePart(item));
 				else omittedImages = true;
 				if (omittedImages) parts.push({ text: NON_VISION_IMAGE_PLACEHOLDER });
 				if (parts.length === 0) continue;
@@ -123,7 +204,8 @@ function convertMessages(model, context) {
 		} else if (msg.role === "assistant") {
 			const parts = [];
 			const isSameProviderAndModel = msg.provider === model.provider && msg.model === model.id;
-			const dropsUnsignedThinking = model.provider === "google-antigravity" && model.id.toLowerCase().includes("claude");
+			const dropsUnsignedThinking = model.compat.dropUnsignedThinking;
+			let isFirstToolCall = true;
 			for (const block of msg.content) if (block.type === "text") {
 				if (!block.text || block.text.trim() === "") continue;
 				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.textSignature);
@@ -143,13 +225,15 @@ function convertMessages(model, context) {
 				else parts.push({ text: renderDemotedThinking(model.id, block.thinking) });
 			} else if (block.type === "toolCall") {
 				emittedToolCallNames.set(block.id, block.name);
-				const effectiveSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature) || (isGemini3Model(model.id) ? SKIP_THOUGHT_SIGNATURE : void 0);
+				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
+				const requiresFallback = model.compat.requiresSkipThoughtSignature || isFirstToolCall && model.compat.requiresSkipThoughtSignatureOnFirstFunctionCall;
+				const effectiveSignature = thoughtSignature || (requiresFallback ? SKIP_THOUGHT_SIGNATURE : void 0);
+				isFirstToolCall = false;
 				const part = { functionCall: {
 					name: block.name,
 					args: block.arguments ?? {},
-					...supportsFunctionPartId(model) ? { id: block.id } : {}
+					...model.compat.supportsFunctionPartId ? { id: block.id } : {}
 				} };
-				if (model.provider === "google-vertex" && part?.functionCall?.id) delete part.functionCall.id;
 				if (effectiveSignature) part.thoughtSignature = effectiveSignature;
 				parts.push(part);
 			}
@@ -165,20 +249,16 @@ function convertMessages(model, context) {
 			const omittedImages = !supportsImages && msg.content.some((c) => c.type === "image");
 			const hasText = textResult.length > 0;
 			const hasImages = imageContent.length > 0;
-			const modelSupportsMultimodalFunctionResponse = supportsMultimodalFunctionResponse(model.id);
+			const modelSupportsMultimodalFunctionResponse = model.compat.multimodalFunctionResponse;
 			const responseValue = omittedImages ? [hasText ? textResult.toWellFormed() : "", NON_VISION_IMAGE_PLACEHOLDER].filter(Boolean).join("\n") : hasText ? textResult.toWellFormed() : hasImages ? "(see attached image)" : "";
-			const imageParts = imageContent.map((imageBlock) => ({ inlineData: {
-				mimeType: imageBlock.mimeType,
-				data: imageBlock.data
-			} }));
-			const includeId = supportsFunctionPartId(model);
+			const imageParts = imageContent.map(convertGoogleImagePart);
+			const includeId = model.compat.supportsFunctionPartId;
 			const functionResponsePart = { functionResponse: {
 				name: emittedToolCallNames.get(msg.toolCallId) ?? msg.toolName,
 				response: msg.isError ? { error: responseValue } : { output: responseValue },
 				...hasImages && modelSupportsMultimodalFunctionResponse && { parts: imageParts },
 				...includeId ? { id: msg.toolCallId } : {}
 			} };
-			if (model.provider === "google-vertex" && functionResponsePart.functionResponse?.id) delete functionResponsePart.functionResponse.id;
 			const lastContent = contents[contents.length - 1];
 			if (lastContent?.role === "user" && lastContent.parts?.some((p) => p.functionResponse)) lastContent.parts.push(functionResponsePart);
 			else contents.push({
@@ -206,7 +286,7 @@ function convertTools(tools, model) {
 	* Claude models on Cloud Code Assist need the legacy `parameters` field;
 	* the API translates it into Anthropic's `input_schema`.
 	*/
-	const useParameters = model.id.startsWith("claude-");
+	const useParameters = model.compat.ccaLegacyParametersSchema;
 	return [{ functionDeclarations: tools.map((tool) => ({
 		name: tool.name,
 		description: tool.description || "",
@@ -391,10 +471,24 @@ async function consumeGoogleStream(args) {
 	const blocks = output.content;
 	const blockIndex = () => blocks.length - 1;
 	let currentBlock = null;
+	let thinkingStripper = null;
 	let firstTokenSeen = false;
 	let sawFinishReason = false;
 	const flushCurrent = () => {
 		if (!currentBlock) return;
+		if (currentBlock.type === "thinking" && thinkingStripper) {
+			const tail = thinkingStripper.flush();
+			if (tail) {
+				currentBlock.thinking += tail;
+				stream.push({
+					type: "thinking_delta",
+					contentIndex: blockIndex(),
+					delta: tail,
+					partial: output
+				});
+			}
+		}
+		thinkingStripper = null;
 		pushBlockEndEvent(currentBlock, blockIndex(), output, stream);
 	};
 	for await (const chunk of googleStream) {
@@ -425,12 +519,14 @@ async function consumeGoogleStream(args) {
 					currentBlock = startTextOrThinkingBlock(isThinking, output, stream);
 				}
 				if (currentBlock.type === "thinking") {
-					currentBlock.thinking += part.text;
+					thinkingStripper ??= new ThinkingFenceStripper();
+					const cleaned = thinkingStripper.push(part.text);
+					currentBlock.thinking += cleaned;
 					currentBlock.thinkingSignature = retainThoughtSignature(currentBlock.thinkingSignature, part.thoughtSignature);
-					stream.push({
+					if (cleaned) stream.push({
 						type: "thinking_delta",
 						contentIndex: blockIndex(),
-						delta: part.text,
+						delta: cleaned,
 						partial: output
 					});
 				} else {
@@ -491,7 +587,7 @@ async function consumeGoogleStream(args) {
 					total: 0
 				}
 			};
-			calculateCost(model, output.usage);
+			calculateCost(model, output.usage, output.timestamp);
 		}
 	}
 	flushCurrent();

package/lib/{google-validation-Cgbn3tWJ.mjs → google-validation-BEkNs-Bx.mjs}

@@ -1,6 +1,6 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/google-validation.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/google-validation.ts
 function extractGoogleValidationUrl(errorBody) {
 	if (!errorBody.includes("VALIDATION_REQUIRED")) return void 0;
 	const start = errorBody.indexOf("{");

package/lib/{google-vertex-Bui-ypAe.mjs → google-vertex-Bbd1tYNc.mjs}

@@ -1,11 +1,11 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-import { P as $env } from "./src-BcD0_rQR.mjs";
-import { t as ConfigurationError } from "./error-C-f_Wnw4.mjs";
-import { P as resolveVertexEndpointHost } from "./models-DRA2c_8U.mjs";
-import { t as getVertexAccessToken } from "./google-auth-DYJLM792.mjs";
-import { p as streamGoogleGenAI, t as buildGoogleGenerateContentParams } from "./google-shared-CVbHK5vZ.mjs";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/google-vertex.ts
+import { N as $env } from "./src-BwW51vA5.mjs";
+import { t as ConfigurationError } from "./error-CORgGg5a.mjs";
+import { i as resolveVertexEndpointHost } from "./hosts-00rjRzUD.mjs";
+import { t as getVertexAccessToken } from "./google-auth-ieLBaneO.mjs";
+import { p as streamGoogleGenAI, t as buildGoogleGenerateContentParams } from "./google-shared-B0aNCYEH.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/google-vertex.ts
 const API_VERSION = "v1";
 const streamGoogleVertex = (model, context, options) => {
 	return streamGoogleGenAI({
@@ -36,8 +36,8 @@ const streamGoogleVertex = (model, context, options) => {
 				}
 			];
 			const baseHeaders = {
-				...model.headers ?? {},
-				...options?.headers ?? {}
+				...model.headers,
+				...options?.headers
 			};
 			if (options?.serviceTier === "priority") baseHeaders["X-Vertex-AI-LLM-Shared-Request-Type"] = "priority";
 			if (apiKey) {

package/lib/hosts-00rjRzUD.mjs

@@ -0,0 +1,203 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/hosts.ts
+const KNOWN_HOSTS = {
+	openai: {
+		providers: ["openai"],
+		urlMarkers: ["api.openai.com"]
+	},
+	azureOpenAI: {
+		providers: ["azure"],
+		urlMarkers: [
+			".openai.azure.com",
+			"azure.com/openai",
+			"models.inference.ai.azure.com"
+		]
+	},
+	openrouter: {
+		providers: ["openrouter"],
+		urlMarkers: ["openrouter.ai"]
+	},
+	vercelAIGateway: {
+		providers: ["vercel-ai-gateway"],
+		urlMarkers: ["ai-gateway.vercel.sh"]
+	},
+	githubCopilot: {
+		providers: ["github-copilot"],
+		urlMarkers: ["githubcopilot.com", "copilot-api."]
+	},
+	anthropic: {
+		providers: ["anthropic"],
+		urlMarkers: ["api.anthropic.com"]
+	},
+	/** DeepSeek's first-party API only — gates direct-API quirks (max_tokens field, thinking extraBody). */
+	deepseekDirect: {
+		providers: ["deepseek"],
+		urlMarkers: ["api.deepseek.com"]
+	},
+	/** Any DeepSeek-operated host (first-party API, web-chat fronts). Wider than `deepseekDirect` on purpose. */
+	deepseekFamily: {
+		providers: ["deepseek"],
+		urlMarkers: ["deepseek.com"]
+	},
+	cerebras: {
+		providers: ["cerebras"],
+		urlMarkers: ["cerebras.ai"]
+	},
+	zai: {
+		providers: ["zai"],
+		urlMarkers: ["api.z.ai"]
+	},
+	zhipu: {
+		providers: ["zhipu-coding-plan"],
+		urlMarkers: ["open.bigmodel.cn"]
+	},
+	kilo: {
+		providers: ["kilo"],
+		urlMarkers: ["api.kilo.ai"]
+	},
+	alibabaDashscope: {
+		providers: ["alibaba-coding-plan", "alibaba-token-plan"],
+		urlMarkers: ["dashscope", "token-plan."]
+	},
+	umans: {
+		providers: ["umans"],
+		urlMarkers: ["api.code.umans.ai"]
+	},
+	xiaomi: {
+		providers: ["xiaomi"],
+		providerPrefixes: ["xiaomi-token-plan-"],
+		urlMarkers: ["xiaomimimo.com"]
+	},
+	xai: {
+		providers: ["xai", "xai-oauth"],
+		urlMarkers: ["api.x.ai"]
+	},
+	mistral: {
+		providers: ["mistral"],
+		urlMarkers: ["mistral.ai"]
+	},
+	together: {
+		providers: ["together"],
+		urlMarkers: ["api.together.xyz"]
+	},
+	baseten: {
+		providers: ["baseten"],
+		urlMarkers: ["baseten.co"]
+	},
+	/** URL-only on purpose: the `fireworks`/`firepass` providers route per-model and not every model is Fireworks-shaped. */
+	fireworks: { urlMarkers: ["fireworks.ai"] },
+	groq: {
+		providers: ["groq"],
+		urlMarkers: ["api.groq.com"]
+	},
+	minimax: {
+		providers: [
+			"minimax",
+			"minimax-code",
+			"minimax-code-cn"
+		],
+		urlMarkers: ["api.minimax.io", "api.minimaxi.com"]
+	},
+	qwenPortal: {
+		providers: ["qwen-portal"],
+		urlMarkers: ["portal.qwen.ai"]
+	},
+	/** NVIDIA NIM (`integrate.api.nvidia.com`). Qwen NIM endpoints take `chat_template_kwargs.enable_thinking`, never top-level `enable_thinking`. */
+	nvidia: {
+		providers: ["nvidia"],
+		urlMarkers: ["integrate.api.nvidia.com"]
+	},
+	/** Venice AI (`api.venice.ai`). OpenAI-compatible; drives reasoning via top-level `reasoning_effort` (and `venice_parameters.disable_thinking`), and rejects DashScope's top-level `enable_thinking` with a 400 (`additionalProperties: false` request schema). */
+	venice: {
+		providers: ["venice"],
+		urlMarkers: ["api.venice.ai"]
+	},
+	moonshotNative: {
+		providers: ["moonshot", "kimi-code"],
+		urlMarkers: ["api.moonshot.ai", "api.kimi.com"]
+	},
+	/** Google AI Studio's OpenAI-compatible shim (`/v1beta/openai`) — a subset of chat-completions; rejects `store` with a 400. Native Gemini uses `google-generative-ai` api instead. */
+	googleAistudio: {
+		providers: [],
+		urlMarkers: ["generativelanguage.googleapis.com"]
+	},
+	opencode: {
+		providers: ["opencode-go", "opencode-zen"],
+		urlMarkers: ["opencode.ai"]
+	},
+	/** ZenMux's Anthropic-compatible proxy (`zenmux.ai/api/anthropic`) forwards to signature-enforcing Anthropic. */
+	zenmux: {
+		providers: ["zenmux"],
+		urlMarkers: ["zenmux.ai"]
+	},
+	chutes: { urlMarkers: ["chutes.ai"] }
+};
+const MAX_URL_HOST_MATCHES = 512;
+const urlHostMatches = /* @__PURE__ */ new Map();
+function getUrlHostMatches(baseUrl) {
+	let matches = urlHostMatches.get(baseUrl);
+	if (matches !== void 0) return matches;
+	if (urlHostMatches.size === MAX_URL_HOST_MATCHES) urlHostMatches.clear();
+	matches = /* @__PURE__ */ new Map();
+	urlHostMatches.set(baseUrl, matches);
+	return matches;
+}
+/** URL-only host check (for call sites that have no provider id, e.g. raw env config). */
+function hostMatchesUrl(baseUrl, host) {
+	if (!baseUrl) return false;
+	const matches = getUrlHostMatches(baseUrl);
+	const cached = matches.get(host);
+	if (cached !== void 0) return cached;
+	const spec = KNOWN_HOSTS[host];
+	for (const marker of spec.urlMarkers) if (includesAsciiCaseInsensitive(baseUrl, marker)) {
+		matches.set(host, true);
+		return true;
+	}
+	matches.set(host, false);
+	return false;
+}
+/** Provider-or-URL host check — the canonical `provider === id || baseUrl.includes(marker)` idiom. */
+function modelMatchesHost(model, host) {
+	const spec = KNOWN_HOSTS[host];
+	if (spec.providers) {
+		for (const provider of spec.providers) if (model.provider === provider) return true;
+	}
+	if (spec.providerPrefixes) {
+		for (const prefix of spec.providerPrefixes) if (model.provider.startsWith(prefix)) return true;
+	}
+	return hostMatchesUrl(model.baseUrl, host);
+}
+function includesAsciiCaseInsensitive(value, lowerNeedle) {
+	const needleLength = lowerNeedle.length;
+	const end = value.length - needleLength;
+	for (let start = 0; start <= end; start++) {
+		let offset = 0;
+		for (; offset < needleLength; offset++) if ((value.charCodeAt(start + offset) | 32) !== lowerNeedle.charCodeAt(offset)) break;
+		if (offset === needleLength) return true;
+	}
+	return false;
+}
+/**
+* Hostname for a Vertex AI GenerateContent / rawPredict / OpenAI-compat
+* request for the given location.
+*
+* - `global` → global endpoint (`aiplatform.googleapis.com`)
+* - `eu` / `us` multi-regions → REP endpoints (`aiplatform.{eu|us}.rep.googleapis.com`)
+* - every other location → regional (`{location}-aiplatform.googleapis.com`)
+*
+* Multi-region codes do NOT follow the regional `{location}-aiplatform` pattern;
+* interpolating them that way yields hosts like `eu-aiplatform.googleapis.com`
+* that 404.
+*/
+function resolveVertexEndpointHost(location) {
+	if (location === "global") return "aiplatform.googleapis.com";
+	if (location === "eu" || location === "us") return `aiplatform.${location}.rep.googleapis.com`;
+	return `${location}-aiplatform.googleapis.com`;
+}
+/** Vertex AI Anthropic raw-predict endpoints (`:streamRawPredict` / `:rawPredict`). */
+function isVertexRawPredictUrl(baseUrl) {
+	return baseUrl.includes(":streamRawPredict") || baseUrl.includes(":rawPredict");
+}
+//#endregion
+export { resolveVertexEndpointHost as i, isVertexRawPredictUrl as n, modelMatchesHost as r, hostMatchesUrl as t };

package/lib/id-AL5obQzR.mjs

@@ -0,0 +1,71 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/identity/id.ts
+const LEADING_BRACKETED_AFFIX_PATTERN = /^(?:\s*(?:\[|【)[^\]】]+(?:\]|】)\s*)+/u;
+const TRAILING_BRACKETED_AFFIX_PATTERN = /(?:\s*(?:\[|【)[^\]】]+(?:\]|】)\s*)+$/u;
+/** Strip a provider namespace prefix (`openai/gpt-5.4` → `gpt-5.4`). */
+const bareModelIdCache = /* @__PURE__ */ new Map();
+function bareModelId(modelId) {
+	const cached = bareModelIdCache.get(modelId);
+	if (cached !== void 0) return cached;
+	const separator = modelId.lastIndexOf("/");
+	const result = separator === -1 ? modelId : modelId.slice(separator + 1);
+	bareModelIdCache.set(modelId, result);
+	return result;
+}
+const MODEL_ID_SEGMENT_PATTERN = /[a-z0-9.:-]+/g;
+const MODEL_FAMILY_PREFIX_PATTERN = /^(claude|gemini|gpt|grok|glm|qwen|deepseek|kimi|mimo|doubao|ernie|gpt-oss|gemma|minimax|step|command|jamba|llama|o[1345])/i;
+function normalizeModelIdWhitespace(value) {
+	return value.trim().replace(/\s+/g, " ");
+}
+/** Ordering for model-like segments: longest first, ties broken lexicographically. */
+function compareSegmentPreference(left, right) {
+	return left.length !== right.length ? right.length - left.length : left.localeCompare(right);
+}
+function getModelLikeIdSegments(modelId) {
+	const matches = normalizeModelIdWhitespace(modelId).toLowerCase().match(MODEL_ID_SEGMENT_PATTERN);
+	if (!matches) return [];
+	const segments = /* @__PURE__ */ new Set();
+	for (const segment of matches) if (MODEL_FAMILY_PREFIX_PATTERN.test(segment) && /\d/.test(segment)) segments.add(segment);
+	return [...segments].sort(compareSegmentPreference);
+}
+function getLongestModelLikeIdSegment(modelId) {
+	const matches = normalizeModelIdWhitespace(modelId).toLowerCase().match(MODEL_ID_SEGMENT_PATTERN);
+	if (!matches) return void 0;
+	let best;
+	for (const segment of matches) if (MODEL_FAMILY_PREFIX_PATTERN.test(segment) && /\d/.test(segment) && (best === void 0 || compareSegmentPreference(segment, best) < 0)) best = segment;
+	return best;
+}
+function hasBracketAffixMarker(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code === 91 || code === 93 || code === 12304 || code === 12305) return true;
+	}
+	return false;
+}
+/**
+* Strip reseller / wrapper tags that are injected as bracketed affixes around an
+* upstream model id, e.g.
+*   "[Kiro] claude-opus-4-8"                -> "claude-opus-4-8"
+*   "[gcli转] gemini-3.1-pro-preview [假流]" -> "gemini-3.1-pro-preview"
+*
+* Candidates are returned most-stripped first: both ends, then leading-only, then trailing-only.
+*/
+function getBracketStrippedModelIdCandidates(modelId) {
+	if (!hasBracketAffixMarker(modelId)) return [];
+	const normalized = normalizeModelIdWhitespace(modelId);
+	if (!normalized) return [];
+	const strippedLeading = normalized.replace(LEADING_BRACKETED_AFFIX_PATTERN, "");
+	const withoutLeading = normalizeModelIdWhitespace(strippedLeading);
+	const withoutTrailing = normalizeModelIdWhitespace(normalized.replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""));
+	const withoutBoth = normalizeModelIdWhitespace(strippedLeading.replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""));
+	const candidates = /* @__PURE__ */ new Set();
+	for (const candidate of [
+		withoutBoth,
+		withoutLeading,
+		withoutTrailing
+	]) if (candidate && candidate !== normalized) candidates.add(candidate);
+	return [...candidates];
+}
+//#endregion
+export { getModelLikeIdSegments as i, getBracketStrippedModelIdCandidates as n, getLongestModelLikeIdSegment as r, bareModelId as t };

package/lib/{idle-iterator-CYAxUkSD.mjs → idle-iterator-DlUkEfzW.mjs}

@@ -1,8 +1,8 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-import { P as $env } from "./src-BcD0_rQR.mjs";
-import { n as StreamTimeoutError, v as AbortError } from "./error-C-f_Wnw4.mjs";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/idle-iterator.ts
+import { N as $env } from "./src-BwW51vA5.mjs";
+import { _ as AbortError, n as StreamTimeoutError } from "./error-CORgGg5a.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/idle-iterator.ts
 const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
 const DEFAULT_STREAM_FIRST_EVENT_TIMEOUT_MS = 3e5;
 /** Re-mint persistent race promises every N iterations (see hoisted-racer comment). */