@shawnstack/quickforge 1.3.18 → 1.3.19

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

@@ -1,13 +1,13 @@
 import OpenAI from "openai";
 import { getEnvApiKey } from "../env-api-keys.js";
-import { calculateCost, supportsXhigh } from "../models.js";
+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 { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
-import { buildBaseOptions, clampReasoning } from "./simple-options.js";
+import { buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 /**
  * Check if conversation messages contain tool calls or tool results.
@@ -89,46 +89,103 @@ export const streamOpenAICompletions = (model, context, options) => {
                 .withResponse();
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
-            let currentBlock = null;
+            let textBlock = null;
+            let thinkingBlock = null;
+            const toolCallBlocksByIndex = new Map();
+            const toolCallBlocksById = new Map();
             const blocks = output.content;
-            const getContentIndex = (block) => (block ? blocks.indexOf(block) : -1);
-            const currentContentIndex = () => getContentIndex(currentBlock);
-            const finishCurrentBlock = (block) => {
-                if (block) {
-                    const contentIndex = getContentIndex(block);
-                    if (contentIndex === -1) {
-                        return;
-                    }
-                    if (block.type === "text") {
-                        stream.push({
-                            type: "text_end",
-                            contentIndex,
-                            content: block.text,
-                            partial: output,
-                        });
-                    }
-                    else if (block.type === "thinking") {
-                        stream.push({
-                            type: "thinking_end",
-                            contentIndex,
-                            content: block.thinking,
-                            partial: output,
-                        });
+            const getContentIndex = (block) => blocks.indexOf(block);
+            const finishBlock = (block) => {
+                const contentIndex = getContentIndex(block);
+                if (contentIndex === -1) {
+                    return;
+                }
+                if (block.type === "text") {
+                    stream.push({
+                        type: "text_end",
+                        contentIndex,
+                        content: block.text,
+                        partial: output,
+                    });
+                }
+                else if (block.type === "thinking") {
+                    stream.push({
+                        type: "thinking_end",
+                        contentIndex,
+                        content: block.thinking,
+                        partial: output,
+                    });
+                }
+                else if (block.type === "toolCall") {
+                    block.arguments = parseStreamingJson(block.partialArgs);
+                    // Finalize in-place and strip the scratch buffers so replay only
+                    // carries parsed arguments.
+                    delete block.partialArgs;
+                    delete block.streamIndex;
+                    stream.push({
+                        type: "toolcall_end",
+                        contentIndex,
+                        toolCall: block,
+                        partial: output,
+                    });
+                }
+            };
+            const ensureTextBlock = () => {
+                if (!textBlock) {
+                    textBlock = { type: "text", text: "" };
+                    blocks.push(textBlock);
+                    stream.push({ type: "text_start", contentIndex: getContentIndex(textBlock), partial: output });
+                }
+                return textBlock;
+            };
+            const ensureThinkingBlock = (thinkingSignature) => {
+                if (!thinkingBlock) {
+                    thinkingBlock = {
+                        type: "thinking",
+                        thinking: "",
+                        thinkingSignature,
+                    };
+                    blocks.push(thinkingBlock);
+                    stream.push({ type: "thinking_start", contentIndex: getContentIndex(thinkingBlock), partial: output });
+                }
+                return thinkingBlock;
+            };
+            const ensureToolCallBlock = (toolCall) => {
+                const streamIndex = typeof toolCall.index === "number" ? toolCall.index : undefined;
+                let block = streamIndex !== undefined ? toolCallBlocksByIndex.get(streamIndex) : undefined;
+                if (!block && toolCall.id) {
+                    block = toolCallBlocksById.get(toolCall.id);
+                }
+                if (!block) {
+                    block = {
+                        type: "toolCall",
+                        id: toolCall.id || "",
+                        name: toolCall.function?.name || "",
+                        arguments: {},
+                        partialArgs: "",
+                        streamIndex,
+                    };
+                    if (streamIndex !== undefined) {
+                        toolCallBlocksByIndex.set(streamIndex, block);
                     }
-                    else if (block.type === "toolCall") {
-                        block.arguments = parseStreamingJson(block.partialArgs);
-                        // Finalize in-place and strip the scratch buffers so replay only
-                        // carries parsed arguments.
-                        delete block.partialArgs;
-                        delete block.streamIndex;
-                        stream.push({
-                            type: "toolcall_end",
-                            contentIndex,
-                            toolCall: block,
-                            partial: output,
-                        });
+                    if (toolCall.id) {
+                        toolCallBlocksById.set(toolCall.id, block);
                     }
+                    blocks.push(block);
+                    stream.push({
+                        type: "toolcall_start",
+                        contentIndex: getContentIndex(block),
+                        partial: output,
+                    });
                 }
+                if (streamIndex !== undefined && block.streamIndex === undefined) {
+                    block.streamIndex = streamIndex;
+                    toolCallBlocksByIndex.set(streamIndex, block);
+                }
+                if (toolCall.id) {
+                    toolCallBlocksById.set(toolCall.id, block);
+                }
+                return block;
             };
             for await (const chunk of openaiStream) {
                 if (!chunk || typeof chunk !== "object")
@@ -136,6 +193,9 @@ export const streamOpenAICompletions = (model, context, options) => {
                 // OpenAI documents ChatCompletionChunk.id as the unique chat completion identifier,
                 // and each chunk in a streamed completion carries the same id.
                 output.responseId ||= chunk.id;
+                if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== model.id) {
+                    output.responseModel ||= chunk.model;
+                }
                 if (chunk.usage) {
                     output.usage = parseChunkUsage(chunk.usage, model);
                 }
@@ -158,55 +218,37 @@ export const streamOpenAICompletions = (model, context, options) => {
                     if (choice.delta.content !== null &&
                         choice.delta.content !== undefined &&
                         choice.delta.content.length > 0) {
-                        if (!currentBlock || currentBlock.type !== "text") {
-                            finishCurrentBlock(currentBlock);
-                            currentBlock = { type: "text", text: "" };
-                            output.content.push(currentBlock);
-                            stream.push({ type: "text_start", contentIndex: currentContentIndex(), partial: output });
-                        }
-                        if (currentBlock.type === "text") {
-                            currentBlock.text += choice.delta.content;
-                            stream.push({
-                                type: "text_delta",
-                                contentIndex: currentContentIndex(),
-                                delta: choice.delta.content,
-                                partial: output,
-                            });
-                        }
+                        const block = ensureTextBlock();
+                        block.text += choice.delta.content;
+                        stream.push({
+                            type: "text_delta",
+                            contentIndex: getContentIndex(block),
+                            delta: choice.delta.content,
+                            partial: output,
+                        });
                     }
                     // Some endpoints return reasoning in reasoning_content (llama.cpp),
                     // or reasoning (other openai compatible endpoints)
                     // Use the first non-empty reasoning field to avoid duplication
                     // (e.g., chutes.ai returns both reasoning_content and reasoning with same content)
                     const reasoningFields = ["reasoning_content", "reasoning", "reasoning_text"];
+                    const deltaFields = choice.delta;
                     let foundReasoningField = null;
                     for (const field of reasoningFields) {
-                        if (choice.delta[field] !== null &&
-                            choice.delta[field] !== undefined &&
-                            choice.delta[field].length > 0) {
-                            if (!foundReasoningField) {
-                                foundReasoningField = field;
-                                break;
-                            }
+                        const value = deltaFields[field];
+                        if (typeof value === "string" && value.length > 0) {
+                            foundReasoningField = field;
+                            break;
                         }
                     }
                     if (foundReasoningField) {
-                        if (!currentBlock || currentBlock.type !== "thinking") {
-                            finishCurrentBlock(currentBlock);
-                            currentBlock = {
-                                type: "thinking",
-                                thinking: "",
-                                thinkingSignature: foundReasoningField,
-                            };
-                            output.content.push(currentBlock);
-                            stream.push({ type: "thinking_start", contentIndex: currentContentIndex(), partial: output });
-                        }
-                        if (currentBlock.type === "thinking") {
-                            const delta = choice.delta[foundReasoningField];
-                            currentBlock.thinking += delta;
+                        const delta = deltaFields[foundReasoningField];
+                        if (typeof delta === "string" && delta.length > 0) {
+                            const block = ensureThinkingBlock(foundReasoningField);
+                            block.thinking += delta;
                             stream.push({
                                 type: "thinking_delta",
-                                contentIndex: currentContentIndex(),
+                                contentIndex: getContentIndex(block),
                                 delta,
                                 partial: output,
                             });
@@ -214,50 +256,26 @@ export const streamOpenAICompletions = (model, context, options) => {
                     }
                     if (choice?.delta?.tool_calls) {
                         for (const toolCall of choice.delta.tool_calls) {
-                            const streamIndex = typeof toolCall.index === "number" ? toolCall.index : undefined;
-                            const sameToolCall = currentBlock?.type === "toolCall" &&
-                                ((streamIndex !== undefined && currentBlock.streamIndex === streamIndex) ||
-                                    (streamIndex === undefined && toolCall.id && currentBlock.id === toolCall.id));
-                            if (!sameToolCall) {
-                                finishCurrentBlock(currentBlock);
-                                currentBlock = {
-                                    type: "toolCall",
-                                    id: toolCall.id || "",
-                                    name: toolCall.function?.name || "",
-                                    arguments: {},
-                                    partialArgs: "",
-                                    streamIndex,
-                                };
-                                output.content.push(currentBlock);
-                                stream.push({
-                                    type: "toolcall_start",
-                                    contentIndex: getContentIndex(currentBlock),
-                                    partial: output,
-                                });
+                            const block = ensureToolCallBlock(toolCall);
+                            if (!block.id && toolCall.id) {
+                                block.id = toolCall.id;
+                                toolCallBlocksById.set(toolCall.id, block);
                             }
-                            const currentToolCallBlock = currentBlock?.type === "toolCall" ? currentBlock : null;
-                            if (currentToolCallBlock) {
-                                if (!currentToolCallBlock.id && toolCall.id)
-                                    currentToolCallBlock.id = toolCall.id;
-                                if (!currentToolCallBlock.name && toolCall.function?.name) {
-                                    currentToolCallBlock.name = toolCall.function.name;
-                                }
-                                if (currentToolCallBlock.streamIndex === undefined && streamIndex !== undefined) {
-                                    currentToolCallBlock.streamIndex = streamIndex;
-                                }
-                                let delta = "";
-                                if (toolCall.function?.arguments) {
-                                    delta = toolCall.function.arguments;
-                                    currentToolCallBlock.partialArgs += toolCall.function.arguments;
-                                    currentToolCallBlock.arguments = parseStreamingJson(currentToolCallBlock.partialArgs);
-                                }
-                                stream.push({
-                                    type: "toolcall_delta",
-                                    contentIndex: getContentIndex(currentToolCallBlock),
-                                    delta,
-                                    partial: output,
-                                });
+                            if (!block.name && toolCall.function?.name) {
+                                block.name = toolCall.function.name;
+                            }
+                            let delta = "";
+                            if (toolCall.function?.arguments) {
+                                delta = toolCall.function.arguments;
+                                block.partialArgs = (block.partialArgs ?? "") + toolCall.function.arguments;
+                                block.arguments = parseStreamingJson(block.partialArgs);
                             }
+                            stream.push({
+                                type: "toolcall_delta",
+                                contentIndex: getContentIndex(block),
+                                delta,
+                                partial: output,
+                            });
                         }
                     }
                     const reasoningDetails = choice.delta.reasoning_details;
@@ -273,7 +291,9 @@ export const streamOpenAICompletions = (model, context, options) => {
                     }
                 }
             }
-            finishCurrentBlock(currentBlock);
+            for (const block of blocks) {
+                finishBlock(block);
+            }
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
@@ -311,7 +331,8 @@ export const streamSimpleOpenAICompletions = (model, context, options) => {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
     const base = buildBaseOptions(model, options, apiKey);
-    const reasoningEffort = supportsXhigh(model) ? options?.reasoning : clampReasoning(options?.reasoning);
+    const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+    const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     const toolChoice = options?.toolChoice;
     return streamOpenAICompletions(model, context, {
         ...base,
@@ -344,11 +365,18 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
     if (optionsHeaders) {
         Object.assign(headers, optionsHeaders);
     }
+    const defaultHeaders = model.provider === "cloudflare-ai-gateway"
+        ? {
+            ...headers,
+            Authorization: headers.Authorization ?? null,
+            "cf-aig-authorization": `Bearer ${apiKey}`,
+        }
+        : headers;
     return new OpenAI({
         apiKey,
         baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl,
         dangerouslyAllowBrowser: true,
-        defaultHeaders: headers,
+        defaultHeaders,
     });
 }
 function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention)) {
@@ -412,7 +440,8 @@ 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.reasoning_effort = mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap);
+            params.reasoning_effort =
+                model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
         }
     }
     else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
@@ -420,16 +449,22 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
         const openRouterParams = params;
         if (options?.reasoningEffort) {
             openRouterParams.reasoning = {
-                effort: mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap),
+                effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort,
             };
         }
-        else {
-            openRouterParams.reasoning = { effort: "none" };
+        else if (model.thinkingLevelMap?.off !== null) {
+            openRouterParams.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
         }
     }
     else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
         // OpenAI-style reasoning_effort
-        params.reasoning_effort = mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap);
+        params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+    }
+    else if (!options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
+        const offValue = model.thinkingLevelMap?.off;
+        if (typeof offValue === "string") {
+            params.reasoning_effort = offValue;
+        }
     }
     // OpenRouter provider routing preferences
     if (model.baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) {
@@ -449,9 +484,6 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     }
     return params;
 }
-function mapReasoningEffort(effort, reasoningEffortMap) {
-    return reasoningEffortMap[effort] ?? effort;
-}
 function getCompatCacheControl(compat, cacheRetention) {
     if (compat.cacheControlFormat !== "anthropic" || cacheRetention === "none") {
         return undefined;
@@ -762,7 +794,7 @@ function convertTools(tools, compat) {
 }
 function parseChunkUsage(rawUsage, model) {
     const promptTokens = rawUsage.prompt_tokens || 0;
-    const reportedCachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
+    const reportedCachedTokens = 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
@@ -816,7 +848,9 @@ function detectCompat(model) {
     const provider = model.provider;
     const baseUrl = model.baseUrl;
     const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
+    const isMoonshot = provider === "moonshotai" || provider === "moonshotai-cn" || baseUrl.includes("api.moonshot.");
     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" ||
         baseUrl.includes("cerebras.ai") ||
         provider === "xai" ||
@@ -824,36 +858,19 @@ function detectCompat(model) {
         baseUrl.includes("chutes.ai") ||
         baseUrl.includes("deepseek.com") ||
         isZai ||
+        isMoonshot ||
         provider === "opencode" ||
         baseUrl.includes("opencode.ai") ||
-        isCloudflareWorkersAI;
-    const useMaxTokens = baseUrl.includes("chutes.ai");
+        isCloudflareWorkersAI ||
+        isCloudflareAiGateway;
+    const useMaxTokens = baseUrl.includes("chutes.ai") || isMoonshot || isCloudflareAiGateway;
     const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-    const isGroq = provider === "groq" || baseUrl.includes("groq.com");
     const isDeepSeek = provider === "deepseek" || baseUrl.includes("deepseek.com");
     const cacheControlFormat = provider === "openrouter" && model.id.startsWith("anthropic/") ? "anthropic" : undefined;
-    const reasoningEffortMap = isDeepSeek
-        ? {
-            minimal: "high",
-            low: "high",
-            medium: "high",
-            high: "high",
-            xhigh: "max",
-        }
-        : isGroq && model.id === "qwen/qwen3-32b"
-            ? {
-                minimal: "default",
-                low: "default",
-                medium: "default",
-                high: "default",
-                xhigh: "default",
-            }
-            : {};
     return {
         supportsStore: !isNonStandard,
         supportsDeveloperRole: !isNonStandard,
-        supportsReasoningEffort: !isGrok && !isZai,
-        reasoningEffortMap,
+        supportsReasoningEffort: !isGrok && !isZai && !isMoonshot && !isCloudflareAiGateway,
         supportsUsageInStreaming: true,
         maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
         requiresToolResultName: false,
@@ -870,10 +887,10 @@ function detectCompat(model) {
         openRouterRouting: {},
         vercelGatewayRouting: {},
         zaiToolStream: false,
-        supportsStrictMode: true,
+        supportsStrictMode: !isMoonshot && !isCloudflareAiGateway,
         cacheControlFormat,
         sendSessionAffinityHeaders: false,
-        supportsLongCacheRetention: true,
+        supportsLongCacheRetention: !(isCloudflareWorkersAI || isCloudflareAiGateway),
     };
 }
 /**
@@ -888,7 +905,6 @@ function getCompat(model) {
         supportsStore: model.compat.supportsStore ?? detected.supportsStore,
         supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
         supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
-        reasoningEffortMap: model.compat.reasoningEffortMap ?? detected.reasoningEffortMap,
         supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
         maxTokensField: model.compat.maxTokensField ?? detected.maxTokensField,
         requiresToolResultName: model.compat.requiresToolResultName ?? detected.requiresToolResultName,

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

@@ -287,6 +287,17 @@ export async function processResponsesStream(openaiStream, output, stream, model
                 }
             }
         }
+        else if (event.type === "response.reasoning_text.delta") {
+            if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
+                currentBlock.thinking += event.delta;
+                stream.push({
+                    type: "thinking_delta",
+                    contentIndex: blockIndex(),
+                    delta: event.delta,
+                    partial: output,
+                });
+            }
+        }
         else if (event.type === "response.content_part.added") {
             if (currentItem?.type === "message") {
                 currentItem.content = currentItem.content || [];
@@ -365,7 +376,9 @@ export async function processResponsesStream(openaiStream, output, stream, model
         else if (event.type === "response.output_item.done") {
             const item = event.item;
             if (item.type === "reasoning" && currentBlock?.type === "thinking") {
-                currentBlock.thinking = item.summary?.map((s) => s.text).join("\n\n") || "";
+                const summaryText = item.summary?.map((s) => s.text).join("\n\n") || "";
+                const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
+                currentBlock.thinking = summaryText || contentText || currentBlock.thinking;
                 currentBlock.thinkingSignature = JSON.stringify(item);
                 stream.push({
                     type: "thinking_end",

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

@@ -1,11 +1,12 @@
 import OpenAI from "openai";
 import { getEnvApiKey } from "../env-api-keys.js";
-import { supportsXhigh } from "../models.js";
+import { clampThinkingLevel } from "../models.js";
 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 { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
-import { buildBaseOptions, clampReasoning } from "./simple-options.js";
+import { buildBaseOptions } from "./simple-options.js";
 const OPENAI_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
 /**
  * Resolve cache retention preference.
@@ -105,7 +106,8 @@ export const streamSimpleOpenAIResponses = (model, context, options) => {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
     const base = buildBaseOptions(model, options, apiKey);
-    const reasoningEffort = supportsXhigh(model) ? options?.reasoning : clampReasoning(options?.reasoning);
+    const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+    const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     return streamOpenAIResponses(model, context, {
         ...base,
         reasoningEffort,
@@ -138,11 +140,18 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId) {
     if (optionsHeaders) {
         Object.assign(headers, optionsHeaders);
     }
+    const defaultHeaders = model.provider === "cloudflare-ai-gateway"
+        ? {
+            ...headers,
+            Authorization: headers.Authorization ?? null,
+            "cf-aig-authorization": `Bearer ${apiKey}`,
+        }
+        : headers;
     return new OpenAI({
         apiKey,
-        baseURL: model.baseUrl,
+        baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl,
         dangerouslyAllowBrowser: true,
-        defaultHeaders: headers,
+        defaultHeaders,
     });
 }
 function buildParams(model, context, options) {
@@ -171,14 +180,19 @@ function buildParams(model, context, options) {
     }
     if (model.reasoning) {
         if (options?.reasoningEffort || options?.reasoningSummary) {
+            const effort = options?.reasoningEffort
+                ? (model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort)
+                : "medium";
             params.reasoning = {
-                effort: options?.reasoningEffort || "medium",
+                effort: effort,
                 summary: options?.reasoningSummary || "auto",
             };
             params.include = ["reasoning.encrypted_content"];
         }
-        else if (model.provider !== "github-copilot") {
-            params.reasoning = { effort: "none" };
+        else if (model.provider !== "github-copilot" && model.thinkingLevelMap?.off !== null) {
+            params.reasoning = {
+                effort: (model.thinkingLevelMap?.off ?? "none"),
+            };
         }
     }
     return params;

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

@@ -4,7 +4,6 @@ const importNodeOnlyProvider = (specifier) => import(specifier);
 let anthropicProviderModulePromise;
 let azureOpenAIResponsesProviderModulePromise;
 let googleProviderModulePromise;
-let googleGeminiCliProviderModulePromise;
 let googleVertexProviderModulePromise;
 let mistralProviderModulePromise;
 let openAICodexResponsesProviderModulePromise;
@@ -108,16 +107,6 @@ function loadGoogleProviderModule() {
     });
     return googleProviderModulePromise;
 }
-function loadGoogleGeminiCliProviderModule() {
-    googleGeminiCliProviderModulePromise ||= import("./google-gemini-cli.js").then((module) => {
-        const provider = module;
-        return {
-            stream: provider.streamGoogleGeminiCli,
-            streamSimple: provider.streamSimpleGoogleGeminiCli,
-        };
-    });
-    return googleGeminiCliProviderModulePromise;
-}
 function loadGoogleVertexProviderModule() {
     googleVertexProviderModulePromise ||= import("./google-vertex.js").then((module) => {
         const provider = module;
@@ -187,8 +176,6 @@ export const streamAzureOpenAIResponses = createLazyStream(loadAzureOpenAIRespon
 export const streamSimpleAzureOpenAIResponses = createLazySimpleStream(loadAzureOpenAIResponsesProviderModule);
 export const streamGoogle = createLazyStream(loadGoogleProviderModule);
 export const streamSimpleGoogle = createLazySimpleStream(loadGoogleProviderModule);
-export const streamGoogleGeminiCli = createLazyStream(loadGoogleGeminiCliProviderModule);
-export const streamSimpleGoogleGeminiCli = createLazySimpleStream(loadGoogleGeminiCliProviderModule);
 export const streamGoogleVertex = createLazyStream(loadGoogleVertexProviderModule);
 export const streamSimpleGoogleVertex = createLazySimpleStream(loadGoogleVertexProviderModule);
 export const streamMistral = createLazyStream(loadMistralProviderModule);
@@ -237,11 +224,6 @@ export function registerBuiltInApiProviders() {
         stream: streamGoogle,
         streamSimple: streamSimpleGoogle,
     });
-    registerApiProvider({
-        api: "google-gemini-cli",
-        stream: streamGoogleGeminiCli,
-        streamSimple: streamSimpleGoogleGeminiCli,
-    });
     registerApiProvider({
         api: "google-vertex",
         stream: streamGoogleVertex,

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

@@ -4,6 +4,7 @@ export function buildBaseOptions(model, options, apiKey) {
         maxTokens: options?.maxTokens ?? (model.maxTokens > 0 ? Math.min(model.maxTokens, 32000) : undefined),
         signal: options?.signal,
         apiKey: apiKey || options?.apiKey,
+        transport: options?.transport,
         cacheRetention: options?.cacheRetention,
         sessionId: options?.sessionId,
         headers: options?.headers,

package/node_modules/@mariozechner/pi-ai/dist/session-resources.js

@@ -0,0 +1,22 @@
+const sessionResourceCleanups = new Set();
+export function registerSessionResourceCleanup(cleanup) {
+    sessionResourceCleanups.add(cleanup);
+    return () => {
+        sessionResourceCleanups.delete(cleanup);
+    };
+}
+export function cleanupSessionResources(sessionId) {
+    const errors = [];
+    for (const cleanup of sessionResourceCleanups) {
+        try {
+            cleanup(sessionId);
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    if (errors.length > 0) {
+        throw new AggregateError(errors, "Failed to cleanup session resources");
+    }
+}
+//# sourceMappingURL=session-resources.js.map