@psnext/slingcli 2.4.20260520-3 → 2.4.20260520-4

package/node_modules/@earendil-works/pi-ai/dist/providers/amazon-bedrock.js

@@ -1,7 +1,9 @@
 import { BedrockRuntimeClient, BedrockRuntimeServiceException, StopReason as BedrockStopReason, CachePointType, CacheTTL, ConversationRole, ConverseStreamCommand, ImageFormat, ToolResultStatus, } from "@aws-sdk/client-bedrock-runtime";
+import { NodeHttpHandler } from "@smithy/node-http-handler";
 import { calculateCost } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
+import { createHttpProxyAgentsForTarget } from "../utils/node-http-proxy.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, clampReasoning } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -63,27 +65,16 @@ export const streamBedrock = (model, context, options = {}) => {
                     secretAccessKey: "dummy-secret-key",
                 };
             }
-            if (process.env.HTTP_PROXY ||
-                process.env.HTTPS_PROXY ||
-                process.env.NO_PROXY ||
-                process.env.http_proxy ||
-                process.env.https_proxy ||
-                process.env.no_proxy) {
-                const nodeHttpHandler = await import("@smithy/node-http-handler");
-                const proxyAgent = await import("proxy-agent");
-                const agent = new proxyAgent.ProxyAgent();
+            const proxyAgents = createHttpProxyAgentsForTarget(model.baseUrl);
+            if (proxyAgents) {
                 // Bedrock runtime uses NodeHttp2Handler by default since v3.798.0, which is based
                 // on `http2` module and has no support for http agent.
-                // Use NodeHttpHandler to support http agent.
-                config.requestHandler = new nodeHttpHandler.NodeHttpHandler({
-                    httpAgent: agent,
-                    httpsAgent: agent,
-                });
+                // Use NodeHttpHandler to support HTTP(S) proxy agents.
+                config.requestHandler = new NodeHttpHandler(proxyAgents);
             }
             else if (process.env.AWS_BEDROCK_FORCE_HTTP1 === "1") {
                 // Some custom endpoints require HTTP/1.1 instead of HTTP/2
-                const nodeHttpHandler = await import("@smithy/node-http-handler");
-                config.requestHandler = new nodeHttpHandler.NodeHttpHandler();
+                config.requestHandler = new NodeHttpHandler();
             }
         }
         else {
@@ -226,7 +217,9 @@ export const streamSimpleBedrock = (model, context, options) => {
                 thinkingBudgets: options.thinkingBudgets,
             });
         }
-        const adjusted = adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning, options.thinkingBudgets);
+        // Undefined means the caller did not request an output cap; let the helper use the model cap.
+        // Do not coerce to 0 here, or the thinking budget would become the entire maxTokens value.
+        const adjusted = adjustMaxTokensForThinking(base.maxTokens, model.maxTokens, options.reasoning, options.thinkingBudgets);
         return streamBedrock(model, context, {
             ...base,
             maxTokens: adjusted.maxTokens,
@@ -473,23 +466,33 @@ function convertMessages(context, model, cacheRetention) {
     for (let i = 0; i < transformedMessages.length; i++) {
         const m = transformedMessages[i];
         switch (m.role) {
-            case "user":
+            case "user": {
+                const content = [];
+                if (typeof m.content === "string") {
+                    content.push({ text: sanitizeSurrogates(m.content) });
+                }
+                else {
+                    for (const c of m.content) {
+                        switch (c.type) {
+                            case "text":
+                                content.push({ text: sanitizeSurrogates(c.text) });
+                                break;
+                            case "image":
+                                content.push({ image: createImageBlock(c.mimeType, c.data) });
+                                break;
+                            default:
+                                continue;
+                        }
+                    }
+                }
+                if (content.length === 0)
+                    continue;
                 result.push({
                     role: ConversationRole.USER,
-                    content: typeof m.content === "string"
-                        ? [{ text: sanitizeSurrogates(m.content) }]
-                        : m.content.map((c) => {
-                            switch (c.type) {
-                                case "text":
-                                    return { text: sanitizeSurrogates(c.text) };
-                                case "image":
-                                    return { image: createImageBlock(c.mimeType, c.data) };
-                                default:
-                                    throw new Error("Unknown user content type");
-                            }
-                        }),
+                    content,
                 });
                 break;
+            }
             case "assistant": {
                 // Skip assistant messages with empty content (e.g., from aborted requests)
                 // Bedrock rejects messages with empty content arrays
@@ -544,7 +547,7 @@ function convertMessages(context, model, cacheRetention) {
                             }
                             break;
                         default:
-                            throw new Error("Unknown assistant content type");
+                            continue;
                     }
                 }
                 // Skip if all content blocks were filtered out
@@ -595,7 +598,7 @@ function convertMessages(context, model, cacheRetention) {
                 break;
             }
             default:
-                throw new Error("Unknown message role");
+                continue;
         }
     }
     // Add cache point to the last user message for supported Claude models when caching is enabled

package/node_modules/@earendil-works/pi-ai/dist/providers/anthropic.js

@@ -578,7 +578,9 @@ export const streamSimpleAnthropic = (model, context, options) => {
             effort,
         });
     }
-    const adjusted = adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning, options.thinkingBudgets);
+    // Undefined means the caller did not request an output cap; let the helper use the model cap.
+    // Do not coerce to 0 here, or the thinking budget would become the entire max_tokens value.
+    const adjusted = adjustMaxTokensForThinking(base.maxTokens, model.maxTokens, options.reasoning, options.thinkingBudgets);
     return streamAnthropic(model, context, {
         ...base,
         maxTokens: adjusted.maxTokens,
@@ -653,6 +655,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     const sessionAffinityHeaders = sessionId && getAnthropicCompat(model).sendSessionAffinityHeaders ? { "x-session-affinity": sessionId } : {};
     const client = new Anthropic({
         apiKey,
+        authToken: null,
         baseURL: model.baseUrl,
         dangerouslyAllowBrowser: true,
         defaultHeaders: mergeHeaders({
@@ -668,7 +671,7 @@ function buildParams(model, context, isOAuthToken, options) {
     const params = {
         model: model.id,
         messages: convertMessages(context.messages, model, isOAuthToken, cacheControl),
-        max_tokens: options?.maxTokens || (model.maxTokens / 3) | 0,
+        max_tokens: options?.maxTokens ?? model.maxTokens,
         stream: true,
     };
     // For OAuth tokens, we MUST include Claude Code identity

package/node_modules/@earendil-works/pi-ai/dist/providers/azure-openai-responses.js

@@ -3,6 +3,7 @@ import { getEnvApiKey } from "../env-api-keys.js";
 import { clampThinkingLevel } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
+import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
 const DEFAULT_AZURE_API_VERSION = "v1";
@@ -29,6 +30,22 @@ function resolveDeploymentName(model, options) {
     const mappedDeployment = parseDeploymentNameMap(process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP).get(model.id);
     return mappedDeployment || model.id;
 }
+function formatAzureOpenAIError(error) {
+    if (error instanceof Error) {
+        const status = error.status;
+        const statusCode = typeof status === "number" ? status : undefined;
+        if (statusCode !== undefined) {
+            return `Azure OpenAI API error (${statusCode}): ${error.message}`;
+        }
+        return error.message;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
 /**
  * Generate function for Azure OpenAI Responses API
  */
@@ -88,7 +105,7 @@ export const streamAzureOpenAIResponses = (model, context, options) => {
                 delete block.partialJson;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+            output.errorMessage = formatAzureOpenAIError(error);
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -175,7 +192,7 @@ function buildParams(model, context, options, deploymentName) {
         model: deploymentName,
         input: messages,
         stream: true,
-        prompt_cache_key: options?.sessionId,
+        prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
     };
     if (options?.maxTokens) {
         params.max_output_tokens = options?.maxTokens;

package/node_modules/@earendil-works/pi-ai/dist/providers/openai-codex-responses.js

@@ -1,6 +1,14 @@
-// NEVER convert to top-level runtime imports - breaks browser/Vite builds (web-ui)
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// NEVER convert to top-level runtime imports - breaks browser/Vite builds
 let _os = null;
-const dynamicImport = (specifier) => import(specifier);
+const dynamicImport = (specifier) => import(__rewriteRelativeImportExtension(specifier));
 const NODE_OS_SPECIFIER = "node:" + "os";
 if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
     dynamicImport(NODE_OS_SPECIFIER).then((m) => {
@@ -13,6 +21,7 @@ import { registerSessionResourceCleanup } from "../session-resources.js";
 import { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic, formatThrownValue, } from "../utils/diagnostics.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
+import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
 // ============================================================================
@@ -153,7 +162,29 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                     }
                     const errorText = await response.text();
                     if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {
-                        const delayMs = BASE_DELAY_MS * 2 ** attempt;
+                        let delayMs = BASE_DELAY_MS * 2 ** attempt;
+                        const retryAfterMs = response.headers.get("retry-after-ms");
+                        if (retryAfterMs !== null) {
+                            const millis = Number(retryAfterMs);
+                            if (Number.isFinite(millis)) {
+                                delayMs = Math.max(0, millis);
+                            }
+                        }
+                        else {
+                            const retryAfter = response.headers.get("retry-after");
+                            if (retryAfter) {
+                                const seconds = Number(retryAfter);
+                                if (Number.isFinite(seconds)) {
+                                    delayMs = Math.max(0, seconds * 1000);
+                                }
+                                else {
+                                    const date = Date.parse(retryAfter);
+                                    if (!Number.isNaN(date)) {
+                                        delayMs = Math.max(0, date - Date.now());
+                                    }
+                                }
+                            }
+                        }
                         await sleep(delayMs, options?.signal);
                         continue;
                     }
@@ -236,7 +267,7 @@ function buildRequestBody(model, context, options) {
         input: messages,
         text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],
-        prompt_cache_key: options?.sessionId,
+        prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
         tool_choice: "auto",
         parallel_tool_calls: true,
     };

package/node_modules/@earendil-works/pi-ai/dist/providers/openai-completions.js

@@ -7,6 +7,7 @@ import { parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
+import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 /**
@@ -91,6 +92,7 @@ export const streamOpenAICompletions = (model, context, options) => {
             stream.push({ type: "start", partial: output });
             let textBlock = null;
             let thinkingBlock = null;
+            let hasFinishReason = false;
             const toolCallBlocksByIndex = new Map();
             const toolCallBlocksById = new Map();
             const blocks = output.content;
@@ -213,6 +215,7 @@ export const streamOpenAICompletions = (model, context, options) => {
                     if (finishReasonResult.errorMessage) {
                         output.errorMessage = finishReasonResult.errorMessage;
                     }
+                    hasFinishReason = true;
                 }
                 if (choice.delta) {
                     if (choice.delta.content !== null &&
@@ -244,7 +247,10 @@ export const streamOpenAICompletions = (model, context, options) => {
                     if (foundReasoningField) {
                         const delta = deltaFields[foundReasoningField];
                         if (typeof delta === "string" && delta.length > 0) {
-                            const block = ensureThinkingBlock(foundReasoningField);
+                            const thinkingSignature = model.provider === "opencode-go" && foundReasoningField === "reasoning"
+                                ? "reasoning_content"
+                                : foundReasoningField;
+                            const block = ensureThinkingBlock(thinkingSignature);
                             block.thinking += delta;
                             stream.push({
                                 type: "thinking_delta",
@@ -303,6 +309,9 @@ export const streamOpenAICompletions = (model, context, options) => {
             if (output.stopReason === "error") {
                 throw new Error(output.errorMessage || "Provider returned an error stop reason");
             }
+            if (!hasFinishReason) {
+                throw new Error("Stream ended without finish_reason");
+            }
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
@@ -388,7 +397,7 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
         stream: true,
         prompt_cache_key: (model.baseUrl.includes("api.openai.com") && cacheRetention !== "none") ||
             (cacheRetention === "long" && compat.supportsLongCacheRetention)
-            ? options?.sessionId
+            ? clampOpenAIPromptCacheKey(options?.sessionId)
             : undefined,
         prompt_cache_retention: cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : undefined,
     };
@@ -665,7 +674,10 @@ export function convertMessages(model, context, compat) {
                         assistantMsg.content = assistantText;
                     }
                     // Use the signature from the first thinking block if available (for llama.cpp server + gpt-oss)
-                    const signature = nonEmptyThinkingBlocks[0].thinkingSignature;
+                    let signature = nonEmptyThinkingBlocks[0].thinkingSignature;
+                    if (model.provider === "opencode-go" && signature === "reasoning") {
+                        signature = "reasoning_content";
+                    }
                     if (signature && signature.length > 0) {
                         assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => block.thinking).join("\n");
                     }
@@ -801,14 +813,16 @@ function convertTools(tools, compat) {
 }
 function parseChunkUsage(rawUsage, model) {
     const promptTokens = rawUsage.prompt_tokens || 0;
-    const reportedCachedTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
+    const cacheReadTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
     const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
-    // Normalize to pi-ai semantics:
-    // - cacheRead: hits from cache created by previous requests only
-    // - cacheWrite: tokens written to cache in this request
-    // Some OpenAI-compatible providers (observed on OpenRouter) report cached_tokens
-    // as (previous hits + current writes). In that case, remove cacheWrite from cacheRead.
-    const cacheReadTokens = cacheWriteTokens > 0 ? Math.max(0, reportedCachedTokens - cacheWriteTokens) : reportedCachedTokens;
+    // Follow documented OpenAI/OpenRouter semantics: cached_tokens is cache-read
+    // tokens (hits). OpenAI does not document or emit cache_write_tokens, but
+    // OpenRouter-compatible providers can include it as a separate write count.
+    // OpenRouter's own provider/tests affirm the separate mapping:
+    // https://github.com/OpenRouterTeam/ai-sdk-provider/pull/409
+    // Do not subtract writes from cached_tokens, otherwise spec-compliant
+    // providers are under-reported. DS4 mirrors this contract too:
+    // https://github.com/antirez/ds4/pull/29
     const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
     // OpenAI completion_tokens already includes reasoning_tokens.
     const outputTokens = rawUsage.completion_tokens || 0;

package/node_modules/@earendil-works/pi-ai/dist/providers/openai-prompt-cache.js

@@ -0,0 +1,10 @@
+export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+export function clampOpenAIPromptCacheKey(key) {
+    if (key === undefined)
+        return undefined;
+    const chars = Array.from(key);
+    if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH)
+        return key;
+    return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("");
+}
+//# sourceMappingURL=openai-prompt-cache.js.map

package/node_modules/@earendil-works/pi-ai/dist/providers/openai-responses.js

@@ -5,6 +5,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
+import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
 const OPENAI_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
@@ -30,6 +31,22 @@ function getCompat(model) {
 function getPromptCacheRetention(compat, cacheRetention) {
     return cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : undefined;
 }
+function formatOpenAIResponsesError(error) {
+    if (error instanceof Error) {
+        const status = error.status;
+        const statusCode = typeof status === "number" ? status : undefined;
+        if (statusCode !== undefined) {
+            return `OpenAI API error (${statusCode}): ${error.message}`;
+        }
+        return error.message;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
 /**
  * Generate function for OpenAI Responses API
  */
@@ -93,7 +110,7 @@ export const streamOpenAIResponses = (model, context, options) => {
                 delete block.partialJson;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+            output.errorMessage = formatOpenAIResponsesError(error);
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -162,7 +179,7 @@ function buildParams(model, context, options) {
         model: model.id,
         input: messages,
         stream: true,
-        prompt_cache_key: cacheRetention === "none" ? undefined : options?.sessionId,
+        prompt_cache_key: cacheRetention === "none" ? undefined : clampOpenAIPromptCacheKey(options?.sessionId),
         prompt_cache_retention: getPromptCacheRetention(compat, cacheRetention),
         store: false,
     };

package/node_modules/@earendil-works/pi-ai/dist/providers/register-builtins.js

@@ -1,6 +1,17 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { clearApiProviders, registerApiProvider } from "../api-registry.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
-const importNodeOnlyProvider = (specifier) => import(specifier);
+const importNodeOnlyProvider = (specifier) => {
+    const runtimeSpecifier = import.meta.url.endsWith(".js") ? specifier.replace(/\.ts$/, ".js") : specifier;
+    return import(__rewriteRelativeImportExtension(runtimeSpecifier));
+};
 let anthropicProviderModulePromise;
 let azureOpenAIResponsesProviderModulePromise;
 let googleProviderModulePromise;
@@ -161,7 +172,7 @@ function loadBedrockProviderModule() {
     if (bedrockProviderModuleOverride) {
         return Promise.resolve(bedrockProviderModuleOverride);
     }
-    bedrockProviderModulePromise ||= importNodeOnlyProvider("./amazon-bedrock.js").then((module) => {
+    bedrockProviderModulePromise ||= importNodeOnlyProvider("./amazon-bedrock.ts").then((module) => {
         const provider = module;
         return {
             stream: provider.streamBedrock,

package/node_modules/@earendil-works/pi-ai/dist/providers/simple-options.js

@@ -1,7 +1,7 @@
-export function buildBaseOptions(model, options, apiKey) {
+export function buildBaseOptions(_model, options, apiKey) {
     return {
         temperature: options?.temperature,
-        maxTokens: options?.maxTokens ?? (model.maxTokens > 0 ? Math.min(model.maxTokens, 32000) : undefined),
+        maxTokens: options?.maxTokens,
         signal: options?.signal,
         apiKey: apiKey || options?.apiKey,
         transport: options?.transport,
@@ -19,7 +19,9 @@ export function buildBaseOptions(model, options, apiKey) {
 export function clampReasoning(effort) {
     return effort === "xhigh" ? "high" : effort;
 }
-export function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+export function adjustMaxTokensForThinking(
+// Undefined means no explicit caller cap. Use the model cap and fit thinking inside it.
+baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
     const defaultBudgets = {
         minimal: 1024,
         low: 2048,
@@ -30,7 +32,7 @@ export function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reason
     const minOutputTokens = 1024;
     const level = clampReasoning(reasoningLevel);
     let thinkingBudget = budgets[level];
-    const maxTokens = Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+    const maxTokens = baseMaxTokens === undefined ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
     if (maxTokens <= thinkingBudget) {
         thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
     }

package/node_modules/@earendil-works/pi-ai/dist/utils/event-stream.js

@@ -1,12 +1,12 @@
 // Generic event stream class for async iteration
 export class EventStream {
-    isComplete;
-    extractResult;
     queue = [];
     waiting = [];
     done = false;
     finalResultPromise;
     resolveFinalResult;
+    isComplete;
+    extractResult;
     constructor(isComplete, extractResult) {
         this.isComplete = isComplete;
         this.extractResult = extractResult;

package/node_modules/@earendil-works/pi-ai/dist/utils/node-http-proxy.js

@@ -0,0 +1,97 @@
+import { HttpProxyAgent } from "http-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
+const DEFAULT_PROXY_PORTS = {
+    ftp: 21,
+    gopher: 70,
+    http: 80,
+    https: 443,
+    ws: 80,
+    wss: 443,
+};
+export const UNSUPPORTED_PROXY_PROTOCOL_MESSAGE = "Unsupported proxy protocol. SOCKS and PAC proxy URLs are not supported; use an HTTP or HTTPS proxy URL.";
+function getProxyEnv(key) {
+    return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || "";
+}
+function parseProxyTargetUrl(targetUrl) {
+    if (targetUrl instanceof URL) {
+        return targetUrl;
+    }
+    try {
+        return new URL(targetUrl);
+    }
+    catch {
+        return undefined;
+    }
+}
+function shouldProxyHostname(hostname, port) {
+    const noProxy = getProxyEnv("no_proxy").toLowerCase();
+    if (!noProxy) {
+        return true;
+    }
+    if (noProxy === "*") {
+        return false;
+    }
+    return noProxy.split(/[,\s]/).every((proxy) => {
+        if (!proxy) {
+            return true;
+        }
+        const parsedProxy = proxy.match(/^(.+):(\d+)$/);
+        let proxyHostname = parsedProxy ? parsedProxy[1] : proxy;
+        const proxyPort = parsedProxy ? Number.parseInt(parsedProxy[2], 10) : 0;
+        if (proxyPort && proxyPort !== port) {
+            return true;
+        }
+        if (!/^[.*]/.test(proxyHostname)) {
+            return hostname !== proxyHostname;
+        }
+        if (proxyHostname.startsWith("*")) {
+            proxyHostname = proxyHostname.slice(1);
+        }
+        return !hostname.endsWith(proxyHostname);
+    });
+}
+function getProxyForUrl(targetUrl) {
+    const parsedUrl = parseProxyTargetUrl(targetUrl);
+    if (!parsedUrl?.protocol || !parsedUrl.host) {
+        return "";
+    }
+    const protocol = parsedUrl.protocol.split(":", 1)[0];
+    const hostname = parsedUrl.host.replace(/:\d*$/, "");
+    const port = Number.parseInt(parsedUrl.port, 10) || DEFAULT_PROXY_PORTS[protocol] || 0;
+    if (!shouldProxyHostname(hostname, port)) {
+        return "";
+    }
+    let proxy = getProxyEnv(`${protocol}_proxy`) || getProxyEnv("all_proxy");
+    if (proxy && !proxy.includes("://")) {
+        proxy = `${protocol}://${proxy}`;
+    }
+    return proxy;
+}
+export function resolveHttpProxyUrlForTarget(targetUrl) {
+    const proxy = getProxyForUrl(targetUrl);
+    if (!proxy) {
+        return undefined;
+    }
+    let proxyUrl;
+    try {
+        proxyUrl = new URL(proxy);
+    }
+    catch (error) {
+        throw new Error(`Invalid proxy URL ${JSON.stringify(proxy)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (proxyUrl.protocol !== "http:" && proxyUrl.protocol !== "https:") {
+        throw new Error(`${UNSUPPORTED_PROXY_PROTOCOL_MESSAGE} Got ${proxyUrl.protocol}`);
+    }
+    return proxyUrl;
+}
+export function createHttpProxyAgentsForTarget(targetUrl) {
+    const proxyUrl = resolveHttpProxyUrlForTarget(targetUrl);
+    if (!proxyUrl) {
+        return undefined;
+    }
+    return {
+        httpAgent: new HttpProxyAgent(proxyUrl),
+        httpsAgent: new HttpsProxyAgent(proxyUrl),
+    };
+}
+//# sourceMappingURL=node-http-proxy.js.map

package/node_modules/@earendil-works/pi-ai/dist/utils/oauth/openai-codex.js

@@ -4,7 +4,7 @@
  * NOTE: This module uses Node.js crypto and http for the OAuth callback.
  * It is only intended for CLI use, not browser environments.
  */
-// NEVER convert to top-level imports - breaks browser/Vite builds (web-ui)
+// NEVER convert to top-level imports - breaks browser/Vite builds
 let _randomBytes = null;
 let _http = null;
 if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {

package/node_modules/@earendil-works/pi-ai/dist/utils/overflow.js

@@ -9,6 +9,7 @@
  * - Anthropic: "prompt is too long: 213462 tokens > 200000 maximum"
  * - Anthropic: "413 {\"error\":{\"type\":\"request_too_large\",\"message\":\"Request exceeds the maximum size\"}}"
  * - OpenAI: "Your input exceeds the context window of this model"
+ * - OpenAI/LiteLLM: "Requested token count exceeds the model's maximum context length of 131072 tokens"
  * - Google: "The input token count (1196265) exceeds the maximum number of tokens allowed (1048575)"
  * - xAI: "This model's maximum prompt length is 131072 but the request contains 537812 tokens"
  * - Groq: "Please reduce the length of the messages or completion"
@@ -32,6 +33,7 @@ const OVERFLOW_PATTERNS = [
     /request_too_large/i, // Anthropic request byte-size overflow (HTTP 413)
     /input is too long for requested model/i, // Amazon Bedrock
     /exceeds the context window/i, // OpenAI (Completions & Responses API)
+    /exceeds (?:the )?(?:model'?s )?maximum context length of [\d,]+ tokens?/i, // OpenAI-compatible proxies (LiteLLM)
     /input token count.*exceeds the maximum/i, // Google (Gemini)
     /maximum prompt length is \d+/i, // xAI (Grok)
     /reduce the length of the messages/i, // Groq
@@ -77,7 +79,7 @@ const NON_OVERFLOW_PATTERNS = [
  *
  * **Reliable detection (returns error with detectable message):**
  * - Anthropic: "prompt is too long: X tokens > Y maximum" or "request_too_large"
- * - OpenAI (Completions & Responses): "exceeds the context window"
+ * - OpenAI (Completions & Responses): "exceeds the context window" or "exceeds the model's maximum context length of X tokens"
  * - Google Gemini: "input token count exceeds the maximum"
  * - xAI (Grok): "maximum prompt length is X but request contains Y"
  * - Groq: "reduce the length of the messages"