@psnext/slingcli 2.5.20260617-1 → 2.5.20260617-2

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

@@ -20,10 +20,13 @@ export function getModels(provider) {
     return models ? Array.from(models.values()) : [];
 }
 export function calculateCost(model, usage) {
+    // Anthropic charges 2x base input for 1h cache writes.
+    const longWrite = usage.cacheWrite1h ?? 0;
+    const shortWrite = usage.cacheWrite - longWrite;
     usage.cost.input = (model.cost.input / 1000000) * usage.input;
     usage.cost.output = (model.cost.output / 1000000) * usage.output;
     usage.cost.cacheRead = (model.cost.cacheRead / 1000000) * usage.cacheRead;
-    usage.cost.cacheWrite = (model.cost.cacheWrite / 1000000) * usage.cacheWrite;
+    usage.cost.cacheWrite = (model.cost.cacheWrite * shortWrite + model.cost.input * 2 * longWrite) / 1000000;
     usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
     return usage.cost;
 }

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

@@ -1,9 +1,12 @@
 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 { HttpProxyAgent } from "http-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
 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 { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
+import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, clampReasoning } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -30,21 +33,22 @@ export const streamBedrock = (model, context, options = {}) => {
         };
         const blocks = output.content;
         const config = {
-            profile: options.profile,
+            profile: options.profile || getProviderEnvValue("AWS_PROFILE", options.env),
         };
         const configuredRegion = getConfiguredBedrockRegion(options);
-        const hasConfiguredProfile = hasConfiguredBedrockProfile();
+        const hasAmbientConfiguredProfile = Boolean(getProviderEnvValue("AWS_PROFILE"));
         const endpointRegion = getStandardBedrockEndpointRegion(model.baseUrl);
-        const useExplicitEndpoint = shouldUseExplicitBedrockEndpoint(model.baseUrl, configuredRegion, hasConfiguredProfile);
-        // Only pin standard AWS Bedrock runtime endpoints when no region/profile is configured.
+        const useExplicitEndpoint = shouldUseExplicitBedrockEndpoint(model.baseUrl, configuredRegion, hasAmbientConfiguredProfile);
+        // Only pin standard AWS Bedrock runtime endpoints when no region or ambient AWS_PROFILE is configured.
         // This preserves custom endpoints (VPC/proxy) from #3402 without forcing built-in
         // catalog defaults such as us-east-1 to override AWS_REGION/AWS_PROFILE.
         if (useExplicitEndpoint) {
             config.endpoint = model.baseUrl;
         }
         // Resolve bearer token for Bedrock API key auth.
-        const bearerToken = options.bearerToken || process.env.AWS_BEARER_TOKEN_BEDROCK || undefined;
-        const useBearerToken = bearerToken !== undefined && process.env.AWS_BEDROCK_SKIP_AUTH !== "1";
+        const skipAuth = getProviderEnvValue("AWS_BEDROCK_SKIP_AUTH", options.env) === "1";
+        const bearerToken = options.bearerToken || getProviderEnvValue("AWS_BEARER_TOKEN_BEDROCK", options.env) || undefined;
+        const useBearerToken = bearerToken !== undefined && !skipAuth;
         // in Node.js/Bun environment only
         if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
             // Region resolution: ARN-embedded > explicit option > env vars > SDK default chain.
@@ -60,24 +64,31 @@ export const streamBedrock = (model, context, options = {}) => {
             else if (endpointRegion && useExplicitEndpoint) {
                 config.region = endpointRegion;
             }
-            else if (!hasConfiguredProfile) {
+            else if (!hasAmbientConfiguredProfile) {
                 config.region = "us-east-1";
             }
             // Support proxies that don't need authentication
-            if (process.env.AWS_BEDROCK_SKIP_AUTH === "1") {
+            if (skipAuth) {
                 config.credentials = {
                     accessKeyId: "dummy-access-key",
                     secretAccessKey: "dummy-secret-key",
                 };
             }
-            const proxyAgents = createHttpProxyAgentsForTarget(model.baseUrl);
-            if (proxyAgents) {
+            const credentials = getConfiguredBedrockCredentials(options.env);
+            if (!skipAuth && credentials) {
+                config.credentials = credentials;
+            }
+            const proxyUrl = resolveHttpProxyUrlForTarget(model.baseUrl, options.env);
+            if (proxyUrl) {
                 // 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(S) proxy agents.
-                config.requestHandler = new NodeHttpHandler(proxyAgents);
+                config.requestHandler = new NodeHttpHandler({
+                    httpAgent: new HttpProxyAgent(proxyUrl),
+                    httpsAgent: new HttpsProxyAgent(proxyUrl),
+                });
             }
-            else if (process.env.AWS_BEDROCK_FORCE_HTTP1 === "1") {
+            else if (getProviderEnvValue("AWS_BEDROCK_FORCE_HTTP1", options.env) === "1") {
                 // Some custom endpoints require HTTP/1.1 instead of HTTP/2
                 config.requestHandler = new NodeHttpHandler();
             }
@@ -97,12 +108,12 @@ export const streamBedrock = (model, context, options = {}) => {
             if (options.headers && Object.keys(options.headers).length > 0) {
                 addCustomHeadersMiddleware(client, options.headers);
             }
-            const cacheRetention = resolveCacheRetention(options.cacheRetention);
+            const cacheRetention = resolveCacheRetention(options.cacheRetention, options.env);
             const inferenceMaxTokens = options.maxTokens ?? (isAnthropicClaudeModel(model) ? model.maxTokens : undefined);
             let commandInput = {
                 modelId: model.id,
-                messages: convertMessages(context, model, cacheRetention),
-                system: buildSystemPrompt(context.systemPrompt, model, cacheRetention),
+                messages: convertMessages(context, model, cacheRetention, options.env),
+                system: buildSystemPrompt(context.systemPrompt, model, cacheRetention, options.env),
                 inferenceConfig: {
                     ...(inferenceMaxTokens !== undefined && { maxTokens: inferenceMaxTokens }),
                     ...(options.temperature !== undefined && { temperature: options.temperature }),
@@ -432,11 +443,11 @@ function mapThinkingLevelToEffort(model, level) {
  * Resolve cache retention preference.
  * Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
  */
-function resolveCacheRetention(cacheRetention) {
+function resolveCacheRetention(cacheRetention, env) {
     if (cacheRetention) {
         return cacheRetention;
     }
-    if (typeof process !== "undefined" && process.env.PI_CACHE_RETENTION === "long") {
+    if (getProviderEnvValue("PI_CACHE_RETENTION", env) === "long") {
         return "long";
     }
     return "short";
@@ -467,13 +478,13 @@ function isAnthropicClaudeModel(model) {
  * As a last resort, set AWS_BEDROCK_FORCE_CACHE=1 to enable cache points.
  * Amazon Nova models have automatic caching and don't need explicit cache points.
  */
-function supportsPromptCaching(model) {
+function supportsPromptCaching(model, env) {
     const candidates = getModelMatchCandidates(model.id, model.name);
     const hasClaudeRef = candidates.some((s) => s.includes("claude"));
     if (!hasClaudeRef) {
         // Application inference profiles don't contain the model name in the ARN.
         // Allow users to force cache points via environment variable.
-        if (typeof process !== "undefined" && process.env.AWS_BEDROCK_FORCE_CACHE === "1")
+        if (getProviderEnvValue("AWS_BEDROCK_FORCE_CACHE", env) === "1")
             return true;
         return false;
     }
@@ -499,12 +510,12 @@ function supportsPromptCaching(model) {
 function supportsThinkingSignature(model) {
     return isAnthropicClaudeModel(model);
 }
-function buildSystemPrompt(systemPrompt, model, cacheRetention) {
+function buildSystemPrompt(systemPrompt, model, cacheRetention, env) {
     if (!systemPrompt)
         return undefined;
     const blocks = [{ text: sanitizeSurrogates(systemPrompt) }];
     // Add cache point for supported Claude models when caching is enabled
-    if (cacheRetention !== "none" && supportsPromptCaching(model)) {
+    if (cacheRetention !== "none" && supportsPromptCaching(model, env)) {
         blocks.push({
             cachePoint: { type: CachePointType.DEFAULT, ...(cacheRetention === "long" ? { ttl: CacheTTL.ONE_HOUR } : {}) },
         });
@@ -538,7 +549,7 @@ function convertToolResultContent(content) {
         result.push({ text: EMPTY_TEXT_PLACEHOLDER });
     return result;
 }
-function convertMessages(context, model, cacheRetention) {
+function convertMessages(context, model, cacheRetention, env) {
     const result = [];
     const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
     for (let i = 0; i < transformedMessages.length; i++) {
@@ -683,7 +694,7 @@ function convertMessages(context, model, cacheRetention) {
         }
     }
     // Add cache point to the last user message for supported Claude models when caching is enabled
-    if (cacheRetention !== "none" && supportsPromptCaching(model) && result.length > 0) {
+    if (cacheRetention !== "none" && supportsPromptCaching(model, env) && result.length > 0) {
         const lastMessage = result[result.length - 1];
         if (lastMessage.role === ConversationRole.USER && lastMessage.content) {
             lastMessage.content.push({
@@ -736,16 +747,23 @@ function mapStopReason(reason) {
     }
 }
 function getConfiguredBedrockRegion(options) {
-    if (typeof process === "undefined") {
-        return options.region;
-    }
-    return options.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || undefined;
+    return (options.region ||
+        getProviderEnvValue("AWS_REGION", options.env) ||
+        getProviderEnvValue("AWS_DEFAULT_REGION", options.env) ||
+        undefined);
 }
-function hasConfiguredBedrockProfile() {
-    if (typeof process === "undefined") {
-        return false;
+function getConfiguredBedrockCredentials(env) {
+    const accessKeyId = getProviderEnvValue("AWS_ACCESS_KEY_ID", env);
+    const secretAccessKey = getProviderEnvValue("AWS_SECRET_ACCESS_KEY", env);
+    if (!accessKeyId || !secretAccessKey) {
+        return undefined;
     }
-    return Boolean(process.env.AWS_PROFILE);
+    const sessionToken = getProviderEnvValue("AWS_SESSION_TOKEN", env);
+    return {
+        accessKeyId,
+        secretAccessKey,
+        ...(sessionToken ? { sessionToken } : {}),
+    };
 }
 function getStandardBedrockEndpointRegion(baseUrl) {
     if (!baseUrl) {
@@ -760,12 +778,12 @@ function getStandardBedrockEndpointRegion(baseUrl) {
         return undefined;
     }
 }
-function shouldUseExplicitBedrockEndpoint(baseUrl, configuredRegion, hasConfiguredProfile) {
+function shouldUseExplicitBedrockEndpoint(baseUrl, configuredRegion, hasAmbientConfiguredProfile) {
     const endpointRegion = getStandardBedrockEndpointRegion(baseUrl);
     if (!endpointRegion) {
         return true;
     }
-    return !configuredRegion && !hasConfiguredProfile;
+    return !configuredRegion && !hasAmbientConfiguredProfile;
 }
 function isGovCloudBedrockTarget(model, options) {
     const region = getConfiguredBedrockRegion(options);

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

@@ -3,6 +3,7 @@ import { calculateCost } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
+import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
@@ -12,17 +13,17 @@ import { transformMessages } from "./transform-messages.js";
  * Resolve cache retention preference.
  * Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
  */
-function resolveCacheRetention(cacheRetention) {
+function resolveCacheRetention(cacheRetention, env) {
     if (cacheRetention) {
         return cacheRetention;
     }
-    if (typeof process !== "undefined" && process.env.PI_CACHE_RETENTION === "long") {
+    if (getProviderEnvValue("PI_CACHE_RETENTION", env) === "long") {
         return "long";
     }
     return "short";
 }
-function getCacheControl(model, cacheRetention) {
-    const retention = resolveCacheRetention(cacheRetention);
+function getCacheControl(model, cacheRetention, env) {
+    const retention = resolveCacheRetention(cacheRetention, env);
     if (retention === "none") {
         return { retention };
     }
@@ -319,9 +320,9 @@ export const streamAnthropic = (model, context, options) => {
                         hasImages,
                     });
                 }
-                const cacheRetention = options?.cacheRetention ?? resolveCacheRetention();
+                const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
                 const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, copilotDynamicHeaders, cacheSessionId);
+                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, copilotDynamicHeaders, cacheSessionId, options?.env);
                 client = created.client;
                 isOAuth = created.isOAuthToken;
             }
@@ -348,6 +349,7 @@ export const streamAnthropic = (model, context, options) => {
                     output.usage.output = event.message.usage.output_tokens || 0;
                     output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;
                     output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;
+                    output.usage.cacheWrite1h = event.message.usage.cache_creation?.ephemeral_1h_input_tokens || 0;
                     // Anthropic doesn't provide total_tokens, compute from components
                     output.usage.totalTokens =
                         output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
@@ -587,7 +589,7 @@ export const streamSimpleAnthropic = (model, context, options) => {
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, optionsHeaders, dynamicHeaders, sessionId) {
+function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, optionsHeaders, dynamicHeaders, sessionId, env) {
     // Adaptive thinking models have interleaved thinking built in, so skip the beta header.
     const needsInterleavedBeta = interleavedThinking && model.compat?.forceAdaptiveThinking !== true;
     const betaFeatures = [];
@@ -601,7 +603,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
         const client = new Anthropic({
             apiKey: null,
             authToken: null,
-            baseURL: resolveCloudflareBaseUrl(model),
+            baseURL: resolveCloudflareBaseUrl(model, env),
             dangerouslyAllowBrowser: true,
             defaultHeaders: mergeHeaders({
                 accept: "application/json",
@@ -662,7 +664,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     return { client, isOAuthToken: false };
 }
 function buildParams(model, context, isOAuthToken, options) {
-    const { cacheControl } = getCacheControl(model, options?.cacheRetention);
+    const { cacheControl } = getCacheControl(model, options?.cacheRetention, options?.env);
     const compat = getAnthropicCompat(model);
     const params = {
         model: model.id,

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

@@ -2,6 +2,7 @@ import { AzureOpenAI } from "openai";
 import { clampThinkingLevel } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
+import { getProviderEnvValue } from "../utils/provider-env.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
@@ -26,7 +27,7 @@ function resolveDeploymentName(model, options) {
     if (options?.azureDeploymentName) {
         return options.azureDeploymentName;
     }
-    const mappedDeployment = parseDeploymentNameMap(process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP).get(model.id);
+    const mappedDeployment = parseDeploymentNameMap(getProviderEnvValue("AZURE_OPENAI_DEPLOYMENT_NAME_MAP", options?.env)).get(model.id);
     return mappedDeployment || model.id;
 }
 function formatAzureOpenAIError(error) {
@@ -150,9 +151,11 @@ function buildDefaultBaseUrl(resourceName) {
     return `https://${resourceName}.openai.azure.com/openai/v1`;
 }
 function resolveAzureConfig(model, options) {
-    const apiVersion = options?.azureApiVersion || process.env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION;
-    const baseUrl = options?.azureBaseUrl?.trim() || process.env.AZURE_OPENAI_BASE_URL?.trim() || undefined;
-    const resourceName = options?.azureResourceName || process.env.AZURE_OPENAI_RESOURCE_NAME;
+    const apiVersion = options?.azureApiVersion ||
+        getProviderEnvValue("AZURE_OPENAI_API_VERSION", options?.env) ||
+        DEFAULT_AZURE_API_VERSION;
+    const baseUrl = options?.azureBaseUrl?.trim() || getProviderEnvValue("AZURE_OPENAI_BASE_URL", options?.env)?.trim() || undefined;
+    const resourceName = options?.azureResourceName || getProviderEnvValue("AZURE_OPENAI_RESOURCE_NAME", options?.env);
     let resolvedBaseUrl = baseUrl;
     if (!resolvedBaseUrl && resourceName) {
         resolvedBaseUrl = buildDefaultBaseUrl(resourceName);

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

@@ -1,3 +1,4 @@
+import { getProviderEnvValue } from "../utils/provider-env.js";
 /** Workers AI direct endpoint. */
 export const CLOUDFLARE_WORKERS_AI_BASE_URL = "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1";
 /** AI Gateway Unified API. https://developers.cloudflare.com/ai-gateway/usage/unified-api/ */
@@ -9,13 +10,13 @@ export const CLOUDFLARE_AI_GATEWAY_ANTHROPIC_BASE_URL = "https://gateway.ai.clou
 export function isCloudflareProvider(provider) {
     return provider === "cloudflare-workers-ai" || provider === "cloudflare-ai-gateway";
 }
-/** Substitute `{VAR}` placeholders in a Cloudflare baseUrl from process.env. */
-export function resolveCloudflareBaseUrl(model) {
+/** Substitute `{VAR}` placeholders in a Cloudflare baseUrl from provider env or process.env. */
+export function resolveCloudflareBaseUrl(model, env) {
     const url = model.baseUrl;
     if (!url.includes("{"))
         return url;
     const baseUrl = url.replace(/\{([A-Z_][A-Z0-9_]*)\}/g, (_match, name) => {
-        const value = process.env[name];
+        const value = getProviderEnvValue(name, env);
         if (!value) {
             throw new Error(`${name} is required for provider ${model.provider} but is not set.`);
         }

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

@@ -1,6 +1,7 @@
 import { GoogleGenAI, ResourceScope, ThinkingLevel, } from "@google/genai";
 import { calculateCost, clampThinkingLevel } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
+import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { convertMessages, convertTools, isThinkingPart, mapStopReason, mapToolChoice, retainThoughtSignature, } from "./google-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
@@ -40,7 +41,7 @@ export const streamGoogleVertex = (model, context, options) => {
             // Create the client using either a Vertex API key, if provided, or ADC with project and location
             const client = apiKey
                 ? createClientWithApiKey(model, apiKey, options?.headers)
-                : createClient(model, resolveProject(options), resolveLocation(options), options?.headers);
+                : createClient(model, resolveProject(options), resolveLocation(options), options?.headers, options?.env);
             let params = buildParams(model, context, options);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
@@ -251,12 +252,14 @@ export const streamSimpleGoogleVertex = (model, context, options) => {
         },
     });
 };
-function createClient(model, project, location, optionsHeaders) {
+function createClient(model, project, location, optionsHeaders, env) {
+    const googleAuthOptions = buildGoogleAuthOptions(env);
     return new GoogleGenAI({
         vertexai: true,
         project,
         location,
         apiVersion: API_VERSION,
+        ...(googleAuthOptions ? { googleAuthOptions } : {}),
         httpOptions: buildHttpOptions(model, optionsHeaders),
     });
 }
@@ -299,6 +302,10 @@ function baseUrlIncludesApiVersion(baseUrl) {
         return /(?:^|\/)v\d+(?:beta\d*)?(?:\/|$)/.test(baseUrl);
     }
 }
+function buildGoogleAuthOptions(env) {
+    const keyFilename = getProviderEnvValue("GOOGLE_APPLICATION_CREDENTIALS", env);
+    return keyFilename ? { keyFilename } : undefined;
+}
 function resolveApiKey(options) {
     const apiKey = options?.apiKey?.trim();
     if (!apiKey || apiKey === GCP_VERTEX_CREDENTIALS_MARKER || isPlaceholderApiKey(apiKey)) {
@@ -310,14 +317,16 @@ function isPlaceholderApiKey(apiKey) {
     return /^<[^>]+>$/.test(apiKey);
 }
 function resolveProject(options) {
-    const project = options?.project || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
+    const project = options?.project ||
+        getProviderEnvValue("GOOGLE_CLOUD_PROJECT", options?.env) ||
+        getProviderEnvValue("GCLOUD_PROJECT", options?.env);
     if (!project) {
         throw new Error("Vertex AI requires a project ID. Set GOOGLE_CLOUD_PROJECT/GCLOUD_PROJECT or pass project in options.");
     }
     return project;
 }
 function resolveLocation(options) {
-    const location = options?.location || process.env.GOOGLE_CLOUD_LOCATION;
+    const location = options?.location || getProviderEnvValue("GOOGLE_CLOUD_LOCATION", options?.env);
     if (!location) {
         throw new Error("Vertex AI requires a location. Set GOOGLE_CLOUD_LOCATION or pass location in options.");
     }
@@ -377,7 +386,8 @@ function isGemini3ProModel(model) {
     return /gemini-3(?:\.\d+)?-pro/.test(model.id.toLowerCase());
 }
 function isGemini3FlashModel(model) {
-    return /gemini-3(?:\.\d+)?-flash/.test(model.id.toLowerCase());
+    const id = model.id.toLowerCase();
+    return /gemini-3(?:\.\d+)?-flash/.test(id) || id === "gemini-flash-latest" || id === "gemini-flash-lite-latest";
 }
 function getDisabledThinkingConfig(model) {
     // Google docs: Gemini 3.1 Pro cannot disable thinking, and Gemini 3 Flash / Flash-Lite

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

@@ -316,7 +316,8 @@ function isGemini3ProModel(model) {
     return /gemini-3(?:\.\d+)?-pro/.test(model.id.toLowerCase());
 }
 function isGemini3FlashModel(model) {
-    return /gemini-3(?:\.\d+)?-flash/.test(model.id.toLowerCase());
+    const id = model.id.toLowerCase();
+    return /gemini-3(?:\.\d+)?-flash/.test(id) || id === "gemini-flash-latest" || id === "gemini-flash-lite-latest";
 }
 function getDisabledThinkingConfig(model) {
     // Google docs: Gemini 3.1 Pro cannot disable thinking, and Gemini 3 Flash / Flash-Lite

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

@@ -21,6 +21,7 @@ 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";
+import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
@@ -598,16 +599,13 @@ function recordWebSocketFailure(sessionId, error) {
     stats.websocketFallbackActive = true;
 }
 let _cachedWebsocket = null;
-async function getWebSocketConstructor() {
-    if (_cachedWebsocket)
+async function getWebSocketConstructor(env) {
+    if (!env && _cachedWebsocket)
         return _cachedWebsocket;
     // bun doesn't respect http proxy envs, ref: https://github.com/oven-sh/bun/issues/15489
     // TODO: remove this when bun supports proxy envs in websocket.
-    if (process?.versions?.bun &&
-        (process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)) {
-        const m = await dynamicImport("proxy-from-env");
-        const getProxyForUrl = m.getProxyForUrl;
-        _cachedWebsocket = class extends WebSocket {
+    if (typeof process !== "undefined" && process.versions?.bun) {
+        const WebSocketWithProxy = class extends WebSocket {
             constructor(url, options) {
                 let _opts = {};
                 if (Array.isArray(options) || typeof options === "string") {
@@ -616,11 +614,14 @@ async function getWebSocketConstructor() {
                 else {
                     _opts = { ...options };
                 }
-                const proxy = getProxyForUrl(url.toString().replace(/^wss:/, "https:").replace(/^ws:/, "http:"));
-                super(url, { ..._opts, ...(proxy ? { proxy } : {}) });
+                const proxyUrl = resolveHttpProxyUrlForTarget(url.toString().replace(/^wss:/, "https:").replace(/^ws:/, "http:"), env);
+                super(url, { ..._opts, ...(proxyUrl ? { proxy: proxyUrl.toString() } : {}) });
             }
         };
-        return _cachedWebsocket;
+        if (!env) {
+            _cachedWebsocket = WebSocketWithProxy;
+        }
+        return WebSocketWithProxy;
     }
     const ctor = globalThis.WebSocket;
     if (typeof ctor !== "function")
@@ -665,8 +666,8 @@ function scheduleSessionWebSocketExpiry(sessionId, entry) {
         websocketSessionCache.delete(sessionId);
     }, SESSION_WEBSOCKET_CACHE_TTL_MS);
 }
-async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS) {
-    const WebSocketCtor = await getWebSocketConstructor();
+async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS, env) {
+    const WebSocketCtor = await getWebSocketConstructor(env);
     if (!WebSocketCtor) {
         throw new Error("WebSocket transport is not available in this runtime");
     }
@@ -733,9 +734,9 @@ async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT
         }
     });
 }
-async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutMs) {
+async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutMs, env) {
     if (!sessionId) {
-        const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
+        const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
         return {
             socket,
             reused: false,
@@ -766,7 +767,7 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
             };
         }
         if (cached.busy) {
-            const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
+            const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
             return {
                 socket,
                 reused: false,
@@ -780,7 +781,7 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
             websocketSessionCache.delete(sessionId);
         }
     }
-    const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs);
+    const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
     const entry = { socket, busy: true };
     websocketSessionCache.set(sessionId, entry);
     return {
@@ -1020,7 +1021,7 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart
     }
 }
 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);
+    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal, websocketConnectTimeoutMs, options?.env);
     let keepConnection = true;
     const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
     // ChatGPT Codex Responses rejects `store: true` ("Store must be set to false").

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

@@ -3,6 +3,7 @@ import { calculateCost, clampThinkingLevel } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
+import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
@@ -39,11 +40,11 @@ function isToolCallBlock(block) {
 function isImageContentBlock(block) {
     return block.type === "image";
 }
-function resolveCacheRetention(cacheRetention) {
+function resolveCacheRetention(cacheRetention, env) {
     if (cacheRetention) {
         return cacheRetention;
     }
-    if (typeof process !== "undefined" && process.env.PI_CACHE_RETENTION === "long") {
+    if (getProviderEnvValue("PI_CACHE_RETENTION", env) === "long") {
         return "long";
     }
     return "short";
@@ -74,9 +75,9 @@ export const streamOpenAICompletions = (model, context, options) => {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
             const compat = getCompat(model);
-            const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+            const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
             const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-            const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat);
+            const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat, options?.env);
             let params = buildParams(model, context, options, compat, cacheRetention);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
@@ -351,7 +352,7 @@ export const streamSimpleOpenAICompletions = (model, context, options) => {
         toolChoice,
     });
 };
-function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = getCompat(model)) {
+function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = getCompat(model), env) {
     const headers = { ...model.headers };
     if (model.provider === "github-copilot") {
         const hasImages = hasCopilotVisionInput(context.messages);
@@ -379,12 +380,12 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
         : headers;
     return new OpenAI({
         apiKey,
-        baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl,
+        baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model, env) : model.baseUrl,
         dangerouslyAllowBrowser: true,
         defaultHeaders,
     });
 }
-function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention)) {
+function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env)) {
     const messages = convertMessages(model, context, compat);
     const cacheControl = getCompatCacheControl(compat, cacheRetention);
     const params = {
@@ -433,6 +434,13 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     if (compat.thinkingFormat === "zai" && model.reasoning) {
         const zaiParams = params;
         zaiParams.thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
+        if (options?.reasoningEffort && compat.supportsReasoningEffort) {
+            const mappedEffort = model.thinkingLevelMap?.[options.reasoningEffort];
+            const effort = mappedEffort === undefined ? options.reasoningEffort : mappedEffort;
+            if (typeof effort === "string") {
+                zaiParams.reasoning_effort = effort;
+            }
+        }
     }
     else if (compat.thinkingFormat === "qwen" && model.reasoning) {
         params.enable_thinking = !!options?.reasoningEffort;
@@ -444,7 +452,12 @@ 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) {
+            params.thinking = { type: "enabled" };
+        }
+        else if (model.thinkingLevelMap?.off !== null) {
+            params.thinking = { type: "disabled" };
+        }
         if (options?.reasoningEffort && compat.supportsReasoningEffort) {
             params.reasoning_effort =
                 model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;

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

@@ -393,7 +393,8 @@ export async function processResponsesStream(openaiStream, output, stream, model
                 currentBlock = null;
             }
             else if (item.type === "message" && currentBlock?.type === "text") {
-                currentBlock.text = item.content.map((c) => (c.type === "output_text" ? c.text : c.refusal)).join("");
+                currentBlock.text =
+                    item.content?.map((c) => (c.type === "output_text" ? c.text : c.refusal)).join("") || "";
                 currentBlock.textSignature = encodeTextSignatureV1(item.id, item.phase ?? undefined);
                 stream.push({
                     type: "text_end",