pi2dsh 0.8.0 → 0.10.0

package/dist/{pi-ai-C6Xag6xt.mjs → pi-ai-Dyg4zyLZ.mjs}

@@ -2,18 +2,199 @@
 import { createRequire } from "node:module";
 import { Type as Type$1 } from "typebox";
 //#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
+//#region src/compat/vendor/pi-uuid.ts
+let lastTimestamp = -Infinity;
+let sequence = 0;
+function fillRandomBytes(bytes) {
+	if (globalThis.crypto?.getRandomValues) {
+		globalThis.crypto.getRandomValues(bytes);
+		return;
+	}
+	for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+}
+/** Generate a time-ordered UUIDv7. */
+function uuidv7() {
+	const random = /* @__PURE__ */ new Uint8Array(16);
+	fillRandomBytes(random);
+	const timestamp = Date.now();
+	if (timestamp > lastTimestamp) {
+		sequence = random[6] * 16777216 + random[7] * 65536 + random[8] * 256 + random[9];
+		lastTimestamp = timestamp;
+	} else {
+		sequence = sequence + 1 >>> 0;
+		if (sequence === 0) lastTimestamp++;
+	}
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	bytes[0] = lastTimestamp / 1099511627776 & 255;
+	bytes[1] = lastTimestamp / 4294967296 & 255;
+	bytes[2] = lastTimestamp / 16777216 & 255;
+	bytes[3] = lastTimestamp / 65536 & 255;
+	bytes[4] = lastTimestamp / 256 & 255;
+	bytes[5] = lastTimestamp & 255;
+	bytes[6] = 112 | sequence >>> 28 & 15;
+	bytes[7] = sequence >>> 20 & 255;
+	bytes[8] = 128 | sequence >>> 14 & 63;
+	bytes[9] = sequence >>> 6 & 255;
+	bytes[10] = (sequence & 63) << 2 | random[10] & 3;
+	bytes[11] = random[11];
+	bytes[12] = random[12];
+	bytes[13] = random[13];
+	bytes[14] = random[14];
+	bytes[15] = random[15];
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+	return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+}
+//#endregion
+//#region src/compat/vendor/pi-ai-retry.ts
+function buildProviderErrorPattern(patterns) {
+	return new RegExp(patterns.join("|"), "i");
+}
+const NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN = buildProviderErrorPattern([
+	"GoUsageLimitError",
+	"FreeUsageLimitError",
+	"Monthly usage limit reached",
+	"available balance",
+	"insufficient_quota",
+	"out of budget",
+	"quota exceeded",
+	"billing"
+]);
+const RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
+	"overloaded",
+	"rate.?limit",
+	"too many requests",
+	"429",
+	"500",
+	"502",
+	"503",
+	"504",
+	"524",
+	"service.?unavailable",
+	"server.?error",
+	"internal.?error",
+	"provider.?returned.?error",
+	"exceeded request buffer limit while retrying upstream",
+	"network.?error",
+	"connection.?error",
+	"connection.?refused",
+	"connection.?lost",
+	"other side closed",
+	"fetch failed",
+	"getaddrinfo",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"upstream.?connect",
+	"reset before headers",
+	"socket hang up",
+	"socket connection was closed",
+	"timed? out",
+	"timeout",
+	"terminated",
+	"websocket.?closed",
+	"websocket.?error",
+	"ended without",
+	"stream ended before message_stop",
+	"stream ended before a terminal response event",
+	"http2 request did not get a response",
+	"retry delay",
+	"you can retry your request",
+	"try your request again",
+	"please retry your request",
+	"ResourceExhausted"
+]);
+var RetrySleepAbortError = class extends Error {
+	constructor() {
+		super("Aborted");
+	}
+};
+function sleep$1(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new RetrySleepAbortError());
+			return;
+		}
+		const timeout = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timeout);
+			reject(new RetrySleepAbortError());
+		}, { once: true });
+	});
+}
+/**
+* Run a single assistant-producing call with bounded retry on transient errors.
+*
+* Behavior:
+* - A successful response is returned immediately. Aborts are terminal and never
+*   retried, but reported as unsuccessful if they happen after a retry was scheduled.
+*   Aborts during the backoff sleep are normalized to an aborted `AssistantMessage`
+*   too, so callers do not need to care when cancellation happened.
+* - A non-retryable error (per {@link isRetryableAssistantError}, including quota/
+*   billing exhaustion) is returned immediately so deterministic errors fail fast.
+* - Otherwise retries up to `maxRetries` times with exponential backoff, emitting
+*   `onRetryScheduled` before each sleep, `onRetryAttemptStart` after each sleep before
+*   the retried call starts, and `onRetryFinished` once at the end (whether the loop
+*   ends in success, exhausted retries, or an aborted backoff).
+*
+* When `policy` is undefined or disabled, the first response is returned unchanged
+* (equivalent to calling `produce()` directly).
+*/
+async function retryAssistantCall(produce, policy, signal, callbacks) {
+	const maxAttempts = policy?.enabled ? policy.maxRetries : 0;
+	let attempt = 0;
+	let lastRetry;
+	for (;;) {
+		const response = await produce();
+		if (response.stopReason === "aborted") {
+			if (lastRetry) await callbacks?.onRetryFinished?.(false, lastRetry.attempt);
+			return response;
+		}
+		if (response.stopReason !== "error") {
+			if (lastRetry) await callbacks?.onRetryFinished?.(true, lastRetry.attempt);
+			return response;
+		}
+		if (attempt >= maxAttempts || !isRetryableAssistantError(response)) {
+			if (lastRetry) await callbacks?.onRetryFinished?.(false, lastRetry.attempt, response.errorMessage);
+			return response;
+		}
+		attempt++;
+		lastRetry = {
+			attempt,
+			errorMessage: response.errorMessage || "Unknown error"
+		};
+		const delayMs = policy.baseDelayMs * 2 ** (attempt - 1);
+		await callbacks?.onRetryScheduled?.(attempt, maxAttempts, delayMs, lastRetry.errorMessage);
+		try {
+			await sleep$1(delayMs, signal);
+		} catch (error) {
+			await callbacks?.onRetryFinished?.(false, attempt, lastRetry.errorMessage);
+			if (error instanceof RetrySleepAbortError) return {
+				...response,
+				stopReason: "aborted",
+				errorMessage: void 0
+			};
+			throw error;
+		}
+		await callbacks?.onRetryAttemptStart?.();
+	}
+}
+/**
+* Classifies whether a failed assistant message looks like a transient provider
+* or transport error, so callers can decide if the last assistant turn should be
+* restarted.
+*
+* This does not implement retry policy. Callers should first handle context
+* overflow separately, then apply their own retry budget, backoff, and reporting
+* before restarting the assistant turn.
+*/
+function isRetryableAssistantError(message) {
+	if (message.stopReason !== "error" || !message.errorMessage) return false;
+	const errorMessage = message.errorMessage;
+	if (NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN.test(errorMessage)) return false;
+	return RETRYABLE_PROVIDER_ERROR_PATTERN.test(errorMessage);
+}
+//#endregion
 //#region src/compat/vendor/pi-ai-overflow.ts
 /**
 * Regex patterns to detect context overflow errors from different providers.
@@ -166,79 +347,6 @@ function isRecoverableLength(message, desiredMaxOutput) {
 	return message.stopReason === "length" && desiredMaxOutput > 0 && message.usage.output < desiredMaxOutput;
 }
 //#endregion
-//#region src/compat/vendor/pi-ai-retry.ts
-function buildProviderErrorPattern(patterns) {
-	return new RegExp(patterns.join("|"), "i");
-}
-const NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN = buildProviderErrorPattern([
-	"GoUsageLimitError",
-	"FreeUsageLimitError",
-	"Monthly usage limit reached",
-	"available balance",
-	"insufficient_quota",
-	"out of budget",
-	"quota exceeded",
-	"billing"
-]);
-const RETRYABLE_PROVIDER_ERROR_PATTERN = buildProviderErrorPattern([
-	"overloaded",
-	"rate.?limit",
-	"too many requests",
-	"429",
-	"500",
-	"502",
-	"503",
-	"504",
-	"524",
-	"service.?unavailable",
-	"server.?error",
-	"internal.?error",
-	"provider.?returned.?error",
-	"exceeded request buffer limit while retrying upstream",
-	"network.?error",
-	"connection.?error",
-	"connection.?refused",
-	"connection.?lost",
-	"other side closed",
-	"fetch failed",
-	"getaddrinfo",
-	"ENOTFOUND",
-	"EAI_AGAIN",
-	"upstream.?connect",
-	"reset before headers",
-	"socket hang up",
-	"socket connection was closed",
-	"timed? out",
-	"timeout",
-	"terminated",
-	"websocket.?closed",
-	"websocket.?error",
-	"ended without",
-	"stream ended before message_stop",
-	"stream ended before a terminal response event",
-	"http2 request did not get a response",
-	"retry delay",
-	"you can retry your request",
-	"try your request again",
-	"please retry your request",
-	"ResourceExhausted"
-]);
-/**
-* Classifies whether a failed assistant message looks like a transient provider
-* or transport error, so callers can decide if the last assistant turn should be
-* restarted.
-*
-* This does not implement retry policy. Callers should first handle context
-* overflow separately, then apply their own retry budget, backoff, and reporting
-* before restarting the assistant turn.
-*/
-function isRetryableAssistantError(message) {
-	if (message.stopReason !== "error" || !message.errorMessage) return false;
-	const errorMessage = message.errorMessage;
-	if (NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN.test(errorMessage)) return false;
-	return RETRYABLE_PROVIDER_ERROR_PATTERN.test(errorMessage);
-}
-//#endregion
 //#region src/compat/vendor/pi-ai-event-stream.ts
 var EventStream = class {
 	queue = [];
@@ -2929,6 +3037,9 @@ let activeLlmBridge;
 function __setPiAiLlmBridge(bridge) {
 	activeLlmBridge = bridge;
 }
+function __getPiAiLlmBridge() {
+	return activeLlmBridge;
+}
 function requireLlmBridge(api) {
 	if (activeLlmBridge === void 0) throw new Error(`pi2dsh: pi-ai ${api}() needs a DSH llm service; this composition mounts none, so model calls cannot be routed`);
 	return activeLlmBridge;
@@ -2950,6 +3061,6 @@ function StringEnum(values, options = {}) {
 	};
 }
 //#endregion
-export { ModelsError as A, unregisterApiProviders as C, openaiCodexOAuth as D, anthropicOAuth as E, isRetryableAssistantError as F, isContextOverflow as I, isRecoverableLength as L, lazyApi as M, lazyStream as N, generatePKCE as O, AssistantMessageEventStream as P, __exportAll as R, stream as S, githubCopilotOAuth as T, loadKimiCodingOAuth as _, clampThinkingLevel as a, registerApiProvider as b, getApiProvider as c, getModels as d, getProvider as f, loadGitHubCopilotOAuth as g, loadAnthropicOAuth as h, builtinProviders as i, createProvider as j, pollOAuthDeviceCodeFlow as k, getApiProviders as l, getSupportedThinkingLevels as m, Type$1 as n, complete as o, getProviders as p, __setPiAiLlmBridge as r, contentText as s, StringEnum as t, getModel as u, loadOpenAICodexOAuth as v, kimiCodingOAuth as w, registerProvider as x, modelsAreEqual as y };
+export { pollOAuthDeviceCodeFlow as A, uuidv7 as B, stream as C, anthropicOAuth as D, githubCopilotOAuth as E, AssistantMessageEventStream as F, isContextOverflow as I, isRecoverableLength as L, createProvider as M, lazyApi as N, openaiCodexOAuth as O, lazyStream as P, isRetryableAssistantError as R, registerProvider as S, kimiCodingOAuth as T, loadGitHubCopilotOAuth as _, builtinProviders as a, modelsAreEqual as b, contentText as c, getModel as d, getModels as f, loadAnthropicOAuth as g, getSupportedThinkingLevels as h, __setPiAiLlmBridge as i, ModelsError as j, generatePKCE as k, getApiProvider as l, getProviders as m, Type$1 as n, clampThinkingLevel as o, getProvider as p, __getPiAiLlmBridge as r, complete as s, StringEnum as t, getApiProviders as u, loadKimiCodingOAuth as v, unregisterApiProviders as w, registerApiProvider as x, loadOpenAICodexOAuth as y, retryAssistantCall as z };
 
-//# sourceMappingURL=pi-ai-C6Xag6xt.mjs.map
+//# sourceMappingURL=pi-ai-Dyg4zyLZ.mjs.map