@psnext/slingcli 2.4.20260601-1 → 2.5.20260602-2

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

@@ -15,9 +15,9 @@ if (typeof process !== "undefined" && (process.versions?.node || process.version
         _os = m;
     });
 }
-import { getEnvApiKey } from "../env-api-keys.js";
 import { clampThinkingLevel } from "../models.js";
 import { registerSessionResourceCleanup } from "../session-resources.js";
+import { combineAbortSignals } from "../utils/abort-signals.js";
 import { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic, formatThrownValue, } from "../utils/diagnostics.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
@@ -32,6 +32,8 @@ const JWT_CLAIM_PATH = "https://api.openai.com/auth";
 const DEFAULT_MAX_RETRIES = 0;
 const BASE_DELAY_MS = 1000;
 const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
+const DEFAULT_SSE_HEADER_TIMEOUT_MS = 10_000;
+const DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS = 15_000;
 const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const CODEX_RESPONSE_STATUSES = new Set([
@@ -96,6 +98,27 @@ function sleep(ms, signal) {
         });
     });
 }
+function normalizeTimeoutMs(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`Invalid timeoutMs: ${String(value)}`);
+    }
+    return Math.floor(value);
+}
+function createSSEHeaderTimeout() {
+    const controller = new AbortController();
+    let error;
+    const timeout = setTimeout(() => {
+        error = new Error(`Codex SSE response headers timed out after ${DEFAULT_SSE_HEADER_TIMEOUT_MS}ms`);
+        controller.abort(error);
+    }, DEFAULT_SSE_HEADER_TIMEOUT_MS);
+    return {
+        signal: controller.signal,
+        clear: () => clearTimeout(timeout),
+        error: () => error,
+    };
+}
 // ============================================================================
 // Main Stream Function
 // ============================================================================
@@ -120,11 +143,11 @@ export const streamOpenAICodexResponses = (model, context, options) => {
             timestamp: Date.now(),
         };
         try {
-            const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+            const apiKey = options?.apiKey;
             if (!apiKey) {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
-            const accountId = extractAccountId(apiKey) || "";
+            const accountId = extractAccountId(apiKey);
             let body = buildRequestBody(model, context, options);
             const nextBody = await options?.onPayload?.(body, model);
             if (nextBody !== undefined) {
@@ -134,6 +157,8 @@ export const streamOpenAICodexResponses = (model, context, options) => {
             const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, options?.sessionId);
             const websocketHeaders = buildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, websocketRequestId);
             const bodyJson = JSON.stringify(body);
+            const idleTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
+            const websocketConnectTimeoutMs = normalizeTimeoutMs(options?.websocketConnectTimeoutMs);
             const transport = options?.transport || "auto";
             const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(options?.sessionId);
             if (websocketDisabledForSession) {
@@ -144,7 +169,7 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                 try {
                     await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
                         websocketStarted = true;
-                    }, options);
+                    }, idleTimeoutMs, websocketConnectTimeoutMs, options);
                     if (options?.signal?.aborted) {
                         throw new Error("Request was aborted");
                     }
@@ -184,12 +209,24 @@ export const streamOpenAICodexResponses = (model, context, options) => {
                     throw new Error("Request was aborted");
                 }
                 try {
-                    response = await fetch(resolveCodexUrl(model.baseUrl), {
-                        method: "POST",
-                        headers: sseHeaders,
-                        body: bodyJson,
-                        signal: options?.signal,
-                    });
+                    const headerTimeout = createSSEHeaderTimeout();
+                    const combinedSignal = combineAbortSignals([options?.signal, headerTimeout.signal]);
+                    try {
+                        response = await fetch(resolveCodexUrl(model.baseUrl), {
+                            method: "POST",
+                            headers: sseHeaders,
+                            body: bodyJson,
+                            signal: combinedSignal.signal,
+                        });
+                    }
+                    catch (error) {
+                        const timeoutError = headerTimeout.error();
+                        throw timeoutError && !options?.signal?.aborted ? timeoutError : error;
+                    }
+                    finally {
+                        combinedSignal.cleanup();
+                        headerTimeout.clear();
+                    }
                     await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
                     if (response.ok) {
                         break;
@@ -257,7 +294,7 @@ export const streamOpenAICodexResponses = (model, context, options) => {
     return stream;
 };
 export const streamSimpleOpenAICodexResponses = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+    const apiKey = options?.apiKey;
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
@@ -282,7 +319,7 @@ function buildRequestBody(model, context, options) {
         stream: true,
         instructions: context.systemPrompt || "You are a helpful assistant.",
         input: messages,
-        text: { verbosity: options?.textVerbosity || "medium" },
+        text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],
         prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
         tool_choice: "auto",
@@ -339,7 +376,11 @@ function resolveCodexServiceTier(responseServiceTier, requestServiceTier) {
 function resolveCodexUrl(baseUrl) {
     const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE_URL;
     const normalized = raw.replace(/\/+$/, "");
-    return `${normalized}/responses`;
+    if (normalized.endsWith("/codex/responses"))
+        return normalized;
+    if (normalized.endsWith("/codex"))
+        return `${normalized}/responses`;
+    return `${normalized}/codex/responses`;
 }
 function resolveCodexWebSocketUrl(baseUrl) {
     const url = new URL(resolveCodexUrl(baseUrl));
@@ -353,7 +394,7 @@ function resolveCodexWebSocketUrl(baseUrl) {
 // Response Processing
 // ============================================================================
 async function processStream(response, output, stream, model, options) {
-    await processResponsesStream(mapCodexEvents(parseSSE(response)), output, stream, model, {
+    await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal)), output, stream, model, {
         serviceTier: options?.serviceTier,
         resolveServiceTier: resolveCodexServiceTier,
         applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
@@ -420,15 +461,25 @@ function normalizeCodexStatus(status) {
 // ============================================================================
 // SSE Parsing
 // ============================================================================
-async function* parseSSE(response) {
+async function* parseSSE(response, signal) {
     if (!response.body)
         return;
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
+    const onAbort = () => {
+        void reader.cancel().catch(() => { });
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
     try {
         while (true) {
+            if (signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
             const { done, value } = await reader.read();
+            if (signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
             if (done)
                 break;
             buffer += decoder.decode(value, { stream: true });
@@ -459,6 +510,7 @@ async function* parseSSE(response) {
         }
     }
     finally {
+        signal?.removeEventListener("abort", onAbort);
         try {
             await reader.cancel();
         }
@@ -615,7 +667,7 @@ function scheduleSessionWebSocketExpiry(sessionId, entry) {
         websocketSessionCache.delete(sessionId);
     }, SESSION_WEBSOCKET_CACHE_TTL_MS);
 }
-async function connectWebSocket(url, headers, signal) {
+async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS) {
     const WebSocketCtor = await getWebSocketConstructor();
     if (!WebSocketCtor) {
         throw new Error("WebSocket transport is not available in this runtime");
@@ -624,6 +676,7 @@ async function connectWebSocket(url, headers, signal) {
     delete wsHeaders["OpenAI-Beta"];
     return new Promise((resolve, reject) => {
         let settled = false;
+        let timeout;
         let socket;
         try {
             socket = new WebSocketCtor(url, { headers: wsHeaders });
@@ -632,62 +685,63 @@ async function connectWebSocket(url, headers, signal) {
             reject(error instanceof Error ? error : new Error(String(error)));
             return;
         }
-        const onOpen = () => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(socket);
+        const cleanup = () => {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+            socket.removeEventListener("open", onOpen);
+            socket.removeEventListener("error", onError);
+            socket.removeEventListener("close", onClose);
+            signal?.removeEventListener("abort", onAbort);
         };
-        const onError = (event) => {
-            const error = extractWebSocketError(event);
+        const fail = (error, closeReason) => {
             if (settled)
                 return;
             settled = true;
             cleanup();
+            if (closeReason) {
+                closeWebSocketSilently(socket, 1000, closeReason);
+            }
             reject(error);
         };
-        const onClose = (event) => {
-            const error = extractWebSocketCloseError(event);
+        const onOpen = () => {
             if (settled)
                 return;
             settled = true;
             cleanup();
-            reject(error);
+            resolve(socket);
         };
-        const onAbort = () => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            socket.close(1000, "aborted");
-            reject(new Error("Request was aborted"));
+        const onError = (event) => {
+            fail(extractWebSocketError(event));
         };
-        const cleanup = () => {
-            socket.removeEventListener("open", onOpen);
-            socket.removeEventListener("error", onError);
-            socket.removeEventListener("close", onClose);
-            signal?.removeEventListener("abort", onAbort);
+        const onClose = (event) => {
+            fail(extractWebSocketCloseError(event));
+        };
+        const onAbort = () => {
+            fail(new Error("Request was aborted"), "aborted");
         };
         socket.addEventListener("open", onOpen);
         socket.addEventListener("error", onError);
         socket.addEventListener("close", onClose);
         signal?.addEventListener("abort", onAbort);
+        if (connectTimeoutMs > 0) {
+            timeout = setTimeout(() => {
+                fail(new Error(`WebSocket connect timeout after ${connectTimeoutMs}ms`), "connect_timeout");
+            }, connectTimeoutMs);
+        }
+        if (signal?.aborted) {
+            onAbort();
+        }
     });
 }
-async function acquireWebSocket(url, headers, sessionId, signal) {
+async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutMs) {
     if (!sessionId) {
-        const socket = await connectWebSocket(url, headers, signal);
+        const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
         return {
             socket,
             reused: false,
-            release: ({ keep } = {}) => {
-                if (keep === false) {
-                    closeWebSocketSilently(socket);
-                    return;
-                }
-                closeWebSocketSilently(socket);
-            },
+            release: () => closeWebSocketSilently(socket),
         };
     }
     const cached = websocketSessionCache.get(sessionId);
@@ -714,7 +768,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
             };
         }
         if (cached.busy) {
-            const socket = await connectWebSocket(url, headers, signal);
+            const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
             return {
                 socket,
                 reused: false,
@@ -728,7 +782,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
             websocketSessionCache.delete(sessionId);
         }
     }
-    const socket = await connectWebSocket(url, headers, signal);
+    const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
     const entry = { socket, busy: true };
     websocketSessionCache.set(sessionId, entry);
     return {
@@ -804,7 +858,7 @@ async function decodeWebSocketData(data) {
     }
     return null;
 }
-async function* parseWebSocket(socket, signal) {
+async function* parseWebSocket(socket, signal, idleTimeoutMs) {
     const queue = [];
     let pending = null;
     let done = false;
@@ -882,8 +936,23 @@ async function* parseWebSocket(socket, signal) {
             }
             if (done)
                 break;
-            await new Promise((resolve) => {
+            let timeout;
+            await new Promise((resolve, reject) => {
                 pending = resolve;
+                if (idleTimeoutMs !== undefined && idleTimeoutMs > 0) {
+                    timeout = setTimeout(() => {
+                        const error = new Error(`WebSocket idle timeout after ${idleTimeoutMs}ms`);
+                        failed = error;
+                        done = true;
+                        pending = null;
+                        closeWebSocketSilently(socket, 1000, "idle_timeout");
+                        reject(error);
+                    }, idleTimeoutMs);
+                }
+            }).finally(() => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
             });
         }
         if (failed) {
@@ -952,8 +1021,8 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart
         yield event;
     }
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, options) {
-    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
+async function processWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, options) {
+    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal, websocketConnectTimeoutMs);
     let keepConnection = true;
     const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
     // ChatGPT Codex Responses rejects `store: true` ("Store must be set to false").
@@ -985,7 +1054,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
     }
     try {
         socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
-        await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal)), output, stream, onStart), output, stream, model, {
+        await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs)), output, stream, onStart), output, stream, model, {
             serviceTier: options?.serviceTier,
             resolveServiceTier: resolveCodexServiceTier,
             applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
@@ -1048,13 +1117,15 @@ function extractAccountId(token) {
     try {
         const parts = token.split(".");
         if (parts.length !== 3)
-            return null;
+            throw new Error("Invalid token");
         const payload = JSON.parse(atob(parts[1]));
         const accountId = payload?.[JWT_CLAIM_PATH]?.chatgpt_account_id;
-        return accountId || null;
+        if (!accountId)
+            throw new Error("No account ID in token");
+        return accountId;
     }
     catch {
-        return null;
+        throw new Error("Failed to extract accountId from token");
     }
 }
 function createCodexRequestId() {
@@ -1069,10 +1140,7 @@ function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token)
         headers.set(key, value);
     }
     headers.set("Authorization", `Bearer ${token}`);
-    // Only set chatgpt-account-id if we have one (OpenAI-specific)
-    if (accountId) {
-        headers.set("chatgpt-account-id", accountId);
-    }
+    headers.set("chatgpt-account-id", accountId);
     headers.set("originator", "pi");
     const userAgent = _os ? `pi (${_os.platform()} ${_os.release()}; ${_os.arch()})` : "pi (browser)";
     headers.set("User-Agent", userAgent);

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

@@ -1,5 +1,4 @@
 import OpenAI from "openai";
-import { getEnvApiKey } from "../env-api-keys.js";
 import { calculateCost, clampThinkingLevel } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
@@ -70,7 +69,10 @@ export const streamOpenAICompletions = (model, context, options) => {
             timestamp: Date.now(),
         };
         try {
-            const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+            const apiKey = options?.apiKey;
+            if (!apiKey) {
+                throw new Error(`No API key for provider: ${model.provider}`);
+            }
             const compat = getCompat(model);
             const cacheRetention = resolveCacheRetention(options?.cacheRetention);
             const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
@@ -335,7 +337,7 @@ export const streamOpenAICompletions = (model, context, options) => {
     return stream;
 };
 export const streamSimpleOpenAICompletions = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+    const apiKey = options?.apiKey;
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
@@ -350,12 +352,6 @@ export const streamSimpleOpenAICompletions = (model, context, options) => {
     });
 };
 function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = getCompat(model)) {
-    if (!apiKey) {
-        if (!process.env.OPENAI_API_KEY) {
-            throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.");
-        }
-        apiKey = process.env.OPENAI_API_KEY;
-    }
     const headers = { ...model.headers };
     if (model.provider === "github-copilot") {
         const hasImages = hasCopilotVisionInput(context.messages);
@@ -448,7 +444,7 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     }
     else if (compat.thinkingFormat === "deepseek" && model.reasoning) {
         params.thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
-        if (options?.reasoningEffort) {
+        if (options?.reasoningEffort && compat.supportsReasoningEffort) {
             params.reasoning_effort =
                 model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
         }
@@ -472,6 +468,15 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
             togetherParams.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
         }
     }
+    else if (compat.thinkingFormat === "string-thinking" && model.reasoning) {
+        const stringThinkingParams = params;
+        if (options?.reasoningEffort) {
+            stringThinkingParams.thinking = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+        }
+        else if (model.thinkingLevelMap?.off !== null) {
+            stringThinkingParams.thinking = model.thinkingLevelMap?.off ?? "none";
+        }
+    }
     else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
         // OpenAI-style reasoning_effort
         params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
@@ -871,6 +876,7 @@ function detectCompat(model) {
     const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
     const isTogether = provider === "together" || baseUrl.includes("api.together.ai") || baseUrl.includes("api.together.xyz");
     const isMoonshot = provider === "moonshotai" || provider === "moonshotai-cn" || baseUrl.includes("api.moonshot.");
+    const isOpenRouter = provider === "openrouter" || baseUrl.includes("openrouter.ai");
     const isCloudflareWorkersAI = provider === "cloudflare-workers-ai" || baseUrl.includes("api.cloudflare.com");
     const isCloudflareAiGateway = provider === "cloudflare-ai-gateway" || baseUrl.includes("gateway.ai.cloudflare.com");
     const isNonStandard = provider === "cerebras" ||
@@ -892,7 +898,7 @@ function detectCompat(model) {
     const cacheControlFormat = provider === "openrouter" && model.id.startsWith("anthropic/") ? "anthropic" : undefined;
     return {
         supportsStore: !isNonStandard,
-        supportsDeveloperRole: !isNonStandard,
+        supportsDeveloperRole: !isNonStandard && !isOpenRouter,
         supportsReasoningEffort: !isGrok && !isZai && !isMoonshot && !isTogether && !isCloudflareAiGateway,
         supportsUsageInStreaming: true,
         maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
@@ -906,7 +912,7 @@ function detectCompat(model) {
                 ? "zai"
                 : isTogether
                     ? "together"
-                    : provider === "openrouter" || baseUrl.includes("openrouter.ai")
+                    : isOpenRouter
                         ? "openrouter"
                         : "openai",
         openRouterRouting: {},

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

@@ -106,6 +106,7 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
             const isDifferentModel = assistantMsg.model !== model.id &&
                 assistantMsg.provider === model.provider &&
                 assistantMsg.api === model.api;
+            let textBlockIndex = 0;
             for (const block of msg.content) {
                 if (block.type === "thinking") {
                     if (block.thinkingSignature) {
@@ -116,10 +117,12 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
                 else if (block.type === "text") {
                     const textBlock = block;
                     const parsedSignature = parseTextSignature(textBlock.textSignature);
+                    const fallbackMessageId = textBlockIndex === 0 ? `msg_pi_${msgIndex}` : `msg_pi_${msgIndex}_${textBlockIndex}`;
+                    textBlockIndex++;
                     // OpenAI requires id to be max 64 characters
                     let msgId = parsedSignature?.id;
                     if (!msgId) {
-                        msgId = `msg_${msgIndex}`;
+                        msgId = fallbackMessageId;
                     }
                     else if (msgId.length > 64) {
                         msgId = `msg_${shortHash(msgId)}`;

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

@@ -1,5 +1,4 @@
 import OpenAI from "openai";
-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";
@@ -73,7 +72,10 @@ export const streamOpenAIResponses = (model, context, options) => {
         };
         try {
             // Create OpenAI client
-            const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+            const apiKey = options?.apiKey;
+            if (!apiKey) {
+                throw new Error(`No API key for provider: ${model.provider}`);
+            }
             const cacheRetention = resolveCacheRetention(options?.cacheRetention);
             const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
             const client = createClient(model, context, apiKey, options?.headers, cacheSessionId);
@@ -118,7 +120,7 @@ export const streamOpenAIResponses = (model, context, options) => {
     return stream;
 };
 export const streamSimpleOpenAIResponses = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+    const apiKey = options?.apiKey;
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
@@ -131,12 +133,6 @@ export const streamSimpleOpenAIResponses = (model, context, options) => {
     });
 };
 function createClient(model, context, apiKey, optionsHeaders, sessionId) {
-    if (!apiKey) {
-        if (!process.env.OPENAI_API_KEY) {
-            throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.");
-        }
-        apiKey = process.env.OPENAI_API_KEY;
-    }
     const compat = getCompat(model);
     const headers = { ...model.headers };
     if (model.provider === "github-copilot") {

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

@@ -11,6 +11,7 @@ export function buildBaseOptions(_model, options, apiKey) {
         onPayload: options?.onPayload,
         onResponse: options?.onResponse,
         timeoutMs: options?.timeoutMs,
+        websocketConnectTimeoutMs: options?.websocketConnectTimeoutMs,
         maxRetries: options?.maxRetries,
         maxRetryDelayMs: options?.maxRetryDelayMs,
         metadata: options?.metadata,

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

@@ -1,6 +1,18 @@
 import "./providers/register-builtins.js";
 import { getApiProvider } from "./api-registry.js";
+import { getEnvApiKey } from "./env-api-keys.js";
 export { getEnvApiKey } from "./env-api-keys.js";
+function hasExplicitApiKey(apiKey) {
+    return typeof apiKey === "string" && apiKey.trim().length > 0;
+}
+function withEnvApiKey(model, options) {
+    if (hasExplicitApiKey(options?.apiKey))
+        return options;
+    const apiKey = getEnvApiKey(model.provider);
+    if (!apiKey)
+        return options;
+    return { ...options, apiKey };
+}
 function resolveApiProvider(api) {
     const provider = getApiProvider(api);
     if (!provider) {
@@ -10,7 +22,7 @@ function resolveApiProvider(api) {
 }
 export function stream(model, context, options) {
     const provider = resolveApiProvider(model.api);
-    return provider.stream(model, context, options);
+    return provider.stream(model, context, withEnvApiKey(model, options));
 }
 export async function complete(model, context, options) {
     const s = stream(model, context, options);
@@ -18,7 +30,7 @@ export async function complete(model, context, options) {
 }
 export function streamSimple(model, context, options) {
     const provider = resolveApiProvider(model.api);
-    return provider.streamSimple(model, context, options);
+    return provider.streamSimple(model, context, withEnvApiKey(model, options));
 }
 export async function completeSimple(model, context, options) {
     const s = streamSimple(model, context, options);

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

@@ -0,0 +1,34 @@
+export function combineAbortSignals(signals) {
+    const activeSignals = signals.filter((signal) => signal !== undefined);
+    if (activeSignals.length === 0) {
+        return { cleanup: () => { } };
+    }
+    if (activeSignals.length === 1) {
+        return { signal: activeSignals[0], cleanup: () => { } };
+    }
+    const controller = new AbortController();
+    const listeners = [];
+    const abort = (signal) => {
+        if (!controller.signal.aborted) {
+            controller.abort(signal.reason);
+        }
+    };
+    for (const signal of activeSignals) {
+        if (signal.aborted) {
+            abort(signal);
+            break;
+        }
+        const listener = () => abort(signal);
+        signal.addEventListener("abort", listener, { once: true });
+        listeners.push({ signal, listener });
+    }
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            for (const { signal, listener } of listeners) {
+                signal.removeEventListener("abort", listener);
+            }
+        },
+    };
+}
+//# sourceMappingURL=abort-signals.js.map

package/node_modules/@earendil-works/pi-ai/dist/utils/oauth/device-code.js

@@ -33,22 +33,23 @@ export async function pollOAuthDeviceCodeFlow(options) {
         if (options.signal?.aborted) {
             throw new Error(CANCEL_MESSAGE);
         }
-        const remainingMs = deadline - Date.now();
-        await abortableSleep(Math.min(intervalMs, remainingMs), options.signal, CANCEL_MESSAGE);
         const result = await options.poll();
         if (result.status === "complete") {
-            return result.accessToken;
+            return result.value;
         }
-        if (result.status === "pending") {
-            continue;
+        if (result.status === "failed") {
+            throw new Error(result.message);
         }
         if (result.status === "slow_down") {
             slowDownResponses += 1;
             // RFC 8628 section 3.5: apply this increase to this and all subsequent requests.
             intervalMs = Math.max(MINIMUM_INTERVAL_MS, intervalMs + SLOW_DOWN_INTERVAL_INCREMENT_MS);
-            continue;
         }
-        throw new Error(result.message);
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            break;
+        }
+        await abortableSleep(Math.min(intervalMs, remainingMs), options.signal, CANCEL_MESSAGE);
     }
     throw new Error(slowDownResponses > 0 ? SLOW_DOWN_TIMEOUT_MESSAGE : TIMEOUT_MESSAGE);
 }