@shawnstack/quickforge 1.3.18 → 1.3.19

package/node_modules/@mariozechner/pi-ai/dist/models.js

@@ -27,29 +27,37 @@ export function calculateCost(model, usage) {
     usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
     return usage.cost;
 }
-/**
- * Check if a model supports xhigh thinking level.
- *
- * Supported today:
- * - GPT-5.2 / GPT-5.3 / GPT-5.4 / GPT-5.5 model families
- * - DeepSeek V4 Pro
- * - Opus 4.6+ models (xhigh maps to adaptive effort "max" on Anthropic-compatible providers)
- */
-export function supportsXhigh(model) {
-    if (model.id.includes("gpt-5.2") ||
-        model.id.includes("gpt-5.3") ||
-        model.id.includes("gpt-5.4") ||
-        model.id.includes("gpt-5.5") ||
-        model.id.includes("deepseek-v4-pro")) {
+const EXTENDED_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+export function getSupportedThinkingLevels(model) {
+    if (!model.reasoning)
+        return ["off"];
+    return EXTENDED_THINKING_LEVELS.filter((level) => {
+        const mapped = model.thinkingLevelMap?.[level];
+        if (mapped === null)
+            return false;
+        if (level === "xhigh")
+            return mapped !== undefined;
         return true;
+    });
+}
+export function clampThinkingLevel(model, level) {
+    const availableLevels = getSupportedThinkingLevels(model);
+    if (availableLevels.includes(level))
+        return level;
+    const requestedIndex = EXTENDED_THINKING_LEVELS.indexOf(level);
+    if (requestedIndex === -1)
+        return availableLevels[0] ?? "off";
+    for (let i = requestedIndex; i < EXTENDED_THINKING_LEVELS.length; i++) {
+        const candidate = EXTENDED_THINKING_LEVELS[i];
+        if (availableLevels.includes(candidate))
+            return candidate;
     }
-    if (model.id.includes("opus-4-6") ||
-        model.id.includes("opus-4.6") ||
-        model.id.includes("opus-4-7") ||
-        model.id.includes("opus-4.7")) {
-        return true;
+    for (let i = requestedIndex - 1; i >= 0; i--) {
+        const candidate = EXTENDED_THINKING_LEVELS[i];
+        if (availableLevels.includes(candidate))
+            return candidate;
     }
-    return false;
+    return availableLevels[0] ?? "off";
 }
 /**
  * Check if two models are equal by comparing both their id and provider.

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

@@ -358,8 +358,16 @@ function supportsAdaptiveThinking(modelId, modelName) {
     const candidates = getModelMatchCandidates(modelId, modelName);
     return candidates.some((s) => s.includes("opus-4-6") || s.includes("opus-4-7") || s.includes("sonnet-4-6"));
 }
-function mapThinkingLevelToEffort(level, modelId, modelName) {
-    const candidates = getModelMatchCandidates(modelId, modelName);
+function supportsNativeXhighEffort(model) {
+    const candidates = getModelMatchCandidates(model.id, model.name);
+    return candidates.some((s) => s.includes("opus-4-7"));
+}
+function mapThinkingLevelToEffort(model, level) {
+    if (level === "xhigh" && supportsNativeXhighEffort(model))
+        return "xhigh";
+    const mapped = level ? model.thinkingLevelMap?.[level] : undefined;
+    if (typeof mapped === "string")
+        return mapped;
     switch (level) {
         case "minimal":
         case "low":
@@ -368,14 +376,6 @@ function mapThinkingLevelToEffort(level, modelId, modelName) {
             return "medium";
         case "high":
             return "high";
-        case "xhigh":
-            if (candidates.some((s) => s.includes("opus-4-6"))) {
-                return "max";
-            }
-            if (candidates.some((s) => s.includes("opus-4-7"))) {
-                return "xhigh";
-            }
-            return "high";
         default:
             return "high";
     }
@@ -702,7 +702,7 @@ function buildAdditionalModelRequestFields(model, options) {
         const result = supportsAdaptiveThinking(model.id, model.name)
             ? {
                 thinking: { type: "adaptive", ...(display !== undefined ? { display } : {}) },
-                output_config: { effort: mapThinkingLevelToEffort(options.reasoning, model.id, model.name) },
+                output_config: { effort: mapThinkingLevelToEffort(model, options.reasoning) },
             }
             : (() => {
                 const defaultBudgets = {

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

@@ -5,6 +5,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { adjustMaxTokensForThinking, buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -244,6 +245,8 @@ async function* iterateAnthropicEvents(response, signal) {
     if (!response.body) {
         throw new Error("Attempted to iterate over an Anthropic response with no body");
     }
+    let sawMessageStart = false;
+    let sawMessageEnd = false;
     for await (const sse of iterateSseMessages(response.body, signal)) {
         if (sse.event === "error") {
             throw new Error(sse.data);
@@ -252,13 +255,23 @@ async function* iterateAnthropicEvents(response, signal) {
             continue;
         }
         try {
-            yield parseJsonWithRepair(sse.data);
+            const event = parseJsonWithRepair(sse.data);
+            if (event.type === "message_start") {
+                sawMessageStart = true;
+            }
+            else if (event.type === "message_stop") {
+                sawMessageEnd = true;
+            }
+            yield event;
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             throw new Error(`Could not parse Anthropic SSE event ${sse.event}: ${message}; data=${sse.data}; raw=${sse.raw.join("\\n")}`);
         }
     }
+    if (sawMessageStart && !sawMessageEnd) {
+        throw new Error("Anthropic stream ended before message_stop");
+    }
 }
 export const streamAnthropic = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
@@ -523,24 +536,18 @@ function supportsAdaptiveThinking(modelId) {
  * Map ThinkingLevel to Anthropic effort levels for adaptive thinking.
  * Note: effort "max" is only valid on Opus 4.6, while Opus 4.7 supports "xhigh".
  */
-function mapThinkingLevelToEffort(level, modelId) {
+function mapThinkingLevelToEffort(model, level) {
+    const mapped = level ? model.thinkingLevelMap?.[level] : undefined;
+    if (typeof mapped === "string")
+        return mapped;
     switch (level) {
         case "minimal":
-            return "low";
         case "low":
             return "low";
         case "medium":
             return "medium";
         case "high":
             return "high";
-        case "xhigh":
-            if (modelId.includes("opus-4-6") || modelId.includes("opus-4.6")) {
-                return "max";
-            }
-            if (modelId.includes("opus-4-7") || modelId.includes("opus-4.7")) {
-                return "xhigh";
-            }
-            return "high";
         default:
             return "high";
     }
@@ -557,7 +564,7 @@ export const streamSimpleAnthropic = (model, context, options) => {
     // For Opus 4.6 and Sonnet 4.6: use adaptive thinking with effort level
     // For older models: use budget-based thinking
     if (supportsAdaptiveThinking(model.id)) {
-        const effort = mapThinkingLevelToEffort(options.reasoning, model.id);
+        const effort = mapThinkingLevelToEffort(model, options.reasoning);
         return streamAnthropic(model, context, {
             ...base,
             thinkingEnabled: true,
@@ -579,15 +586,32 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     // Adaptive thinking models (Opus 4.6, Sonnet 4.6) have interleaved thinking built-in.
     // The beta header is deprecated on Opus 4.6 and redundant on Sonnet 4.6, so skip it.
     const needsInterleavedBeta = interleavedThinking && !supportsAdaptiveThinking(model.id);
+    const betaFeatures = [];
+    if (useFineGrainedToolStreamingBeta) {
+        betaFeatures.push(FINE_GRAINED_TOOL_STREAMING_BETA);
+    }
+    if (needsInterleavedBeta) {
+        betaFeatures.push(INTERLEAVED_THINKING_BETA);
+    }
+    if (model.provider === "cloudflare-ai-gateway") {
+        const client = new Anthropic({
+            apiKey: null,
+            authToken: null,
+            baseURL: resolveCloudflareBaseUrl(model),
+            dangerouslyAllowBrowser: true,
+            defaultHeaders: mergeHeaders({
+                accept: "application/json",
+                "anthropic-dangerous-direct-browser-access": "true",
+                "cf-aig-authorization": `Bearer ${apiKey}`,
+                "x-api-key": null,
+                Authorization: null,
+                ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
+            }, model.headers, optionsHeaders),
+        });
+        return { client, isOAuthToken: false };
+    }
     // Copilot: Bearer auth, selective betas.
     if (model.provider === "github-copilot") {
-        const betaFeatures = [];
-        if (useFineGrainedToolStreamingBeta) {
-            betaFeatures.push(FINE_GRAINED_TOOL_STREAMING_BETA);
-        }
-        if (needsInterleavedBeta) {
-            betaFeatures.push(INTERLEAVED_THINKING_BETA);
-        }
         const client = new Anthropic({
             apiKey: null,
             authToken: apiKey,
@@ -601,13 +625,6 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
         });
         return { client, isOAuthToken: false };
     }
-    const betaFeatures = [];
-    if (useFineGrainedToolStreamingBeta) {
-        betaFeatures.push(FINE_GRAINED_TOOL_STREAMING_BETA);
-    }
-    if (needsInterleavedBeta) {
-        betaFeatures.push(INTERLEAVED_THINKING_BETA);
-    }
     // OAuth: Bearer auth, Claude Code identity headers
     if (isOAuthToken(apiKey)) {
         const client = new Anthropic({

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

@@ -1,10 +1,10 @@
 import { AzureOpenAI } 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 { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
-import { buildBaseOptions, clampReasoning } from "./simple-options.js";
+import { buildBaseOptions } from "./simple-options.js";
 const DEFAULT_AZURE_API_VERSION = "v1";
 const AZURE_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode", "azure-openai-responses"]);
 function parseDeploymentNameMap(value) {
@@ -101,7 +101,8 @@ export const streamSimpleAzureOpenAIResponses = (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 streamAzureOpenAIResponses(model, context, {
         ...base,
         reasoningEffort,
@@ -187,14 +188,19 @@ function buildParams(model, context, options, deploymentName) {
     }
     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 {
-            params.reasoning = { effort: "none" };
+        else if (model.thinkingLevelMap?.off !== null) {
+            params.reasoning = {
+                effort: (model.thinkingLevelMap?.off ?? "none"),
+            };
         }
     }
     return params;

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

@@ -1,19 +1,26 @@
-/** Workers AI endpoint. `{CLOUDFLARE_ACCOUNT_ID}` is substituted at request time. */
+/** 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/ */
+export const CLOUDFLARE_AI_GATEWAY_COMPAT_BASE_URL = "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/compat";
+/** AI Gateway → OpenAI passthrough. Used until /compat supports /v1/responses. */
+export const CLOUDFLARE_AI_GATEWAY_OPENAI_BASE_URL = "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai";
+/** AI Gateway → Anthropic passthrough. */
+export const CLOUDFLARE_AI_GATEWAY_ANTHROPIC_BASE_URL = "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic";
 export function isCloudflareProvider(provider) {
-    return provider === "cloudflare-workers-ai";
+    return provider === "cloudflare-workers-ai" || provider === "cloudflare-ai-gateway";
 }
 /** Substitute `{VAR}` placeholders in a Cloudflare baseUrl from process.env. */
 export function resolveCloudflareBaseUrl(model) {
     const url = model.baseUrl;
     if (!url.includes("{"))
         return url;
-    return url.replace(/\{([A-Z_][A-Z0-9_]*)\}/g, (_match, name) => {
+    const baseUrl = url.replace(/\{([A-Z_][A-Z0-9_]*)\}/g, (_match, name) => {
         const value = process.env[name];
         if (!value) {
             throw new Error(`${name} is required for provider ${model.provider} but is not set.`);
         }
         return value;
     });
+    return baseUrl;
 }
 //# sourceMappingURL=cloudflare.js.map

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

@@ -1,5 +1,5 @@
 /**
- * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
+ * Shared utilities for Google Generative AI and Google Vertex providers.
  */
 import { FinishReason, FunctionCallingConfigMode } from "@google/genai";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
@@ -38,10 +38,6 @@ export function retainThoughtSignature(existing, incoming) {
 }
 // Thought signatures must be base64 for Google APIs (TYPE_BYTES).
 const base64SignaturePattern = /^[A-Za-z0-9+/]+={0,2}$/;
-// Sentinel value that tells the Gemini API to skip thought signature validation.
-// Used for unsigned function call parts (e.g. replayed from providers without thought signatures).
-// See: https://ai.google.dev/gemini-api/docs/thought-signatures
-const SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
 function isValidThoughtSignature(signature) {
     if (!signature)
         return false;
@@ -121,7 +117,7 @@ export function convertMessages(model, context) {
             const isSameProviderAndModel = msg.provider === model.provider && msg.model === model.id;
             for (const block of msg.content) {
                 if (block.type === "text") {
-                    // Skip empty text blocks - they can cause issues with some models (e.g. Claude via Antigravity)
+                    // Skip empty text blocks
                     if (!block.text || block.text.trim() === "")
                         continue;
                     const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.textSignature);
@@ -152,18 +148,13 @@ export function convertMessages(model, context) {
                 }
                 else if (block.type === "toolCall") {
                     const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
-                    // Gemini 3 requires thoughtSignature on all function calls when thinking mode is enabled.
-                    // Use the skip_thought_signature_validator sentinel for unsigned function calls
-                    // (e.g. replayed from providers without thought signatures like Claude via Antigravity).
-                    const isGemini3 = model.id.toLowerCase().includes("gemini-3");
-                    const effectiveSignature = thoughtSignature || (isGemini3 ? SKIP_THOUGHT_SIGNATURE : undefined);
                     const part = {
                         functionCall: {
                             name: block.name,
                             args: block.arguments ?? {},
                             ...(requiresToolCallId(model.id) ? { id: block.id } : {}),
                         },
-                        ...(effectiveSignature && { thoughtSignature: effectiveSignature }),
+                        ...(thoughtSignature && { thoughtSignature }),
                     };
                     parts.push(part);
                 }
@@ -186,7 +177,7 @@ export function convertMessages(model, context) {
             const hasImages = imageContent.length > 0;
             // Gemini 3+ models support multimodal function responses with images nested inside
             // functionResponse.parts. Claude and other non-Gemini models behind Cloud Code Assist /
-            // Antigravity also accept this shape. Gemini < 3 still needs a separate user image turn.
+            // Gemini < 3 still needs a separate user image turn.
             const modelSupportsMultimodalFunctionResponse = supportsMultimodalFunctionResponse(model.id);
             // Use "output" key for success, "error" key for errors as per SDK documentation
             const responseValue = hasText ? sanitizeSurrogates(textResult) : hasImages ? "(see attached image)" : "";

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

@@ -1,9 +1,9 @@
 import { GoogleGenAI, ResourceScope, ThinkingLevel, } from "@google/genai";
-import { calculateCost } from "../models.js";
+import { calculateCost, clampThinkingLevel } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { convertMessages, convertTools, isThinkingPart, mapStopReason, mapToolChoice, retainThoughtSignature, } from "./google-shared.js";
-import { buildBaseOptions, clampReasoning } from "./simple-options.js";
+import { buildBaseOptions } from "./simple-options.js";
 const API_VERSION = "v1";
 const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
 const THINKING_LEVEL_MAP = {
@@ -231,7 +231,8 @@ export const streamSimpleGoogleVertex = (model, context, options) => {
             thinking: { enabled: false },
         });
     }
-    const effort = clampReasoning(options.reasoning);
+    const clampedReasoning = clampThinkingLevel(model, options.reasoning);
+    const effort = (clampedReasoning === "off" ? "high" : clampedReasoning);
     const geminiModel = model;
     if (isGemini3ProModel(geminiModel) || isGemini3FlashModel(geminiModel)) {
         return streamGoogleVertex(model, context, {

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

@@ -1,10 +1,10 @@
 import { GoogleGenAI, } from "@google/genai";
 import { getEnvApiKey } from "../env-api-keys.js";
-import { calculateCost } from "../models.js";
+import { calculateCost, clampThinkingLevel } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { convertMessages, convertTools, isThinkingPart, mapStopReason, mapToolChoice, retainThoughtSignature, } from "./google-shared.js";
-import { buildBaseOptions, clampReasoning } from "./simple-options.js";
+import { buildBaseOptions } from "./simple-options.js";
 // Counter for generating unique tool call IDs
 let toolCallCounter = 0;
 export const streamGoogle = (model, context, options) => {
@@ -222,7 +222,8 @@ export const streamSimpleGoogle = (model, context, options) => {
     if (!options?.reasoning) {
         return streamGoogle(model, context, { ...base, thinking: { enabled: false } });
     }
-    const effort = clampReasoning(options.reasoning);
+    const clampedReasoning = clampThinkingLevel(model, options.reasoning);
+    const effort = (clampedReasoning === "off" ? "high" : clampedReasoning);
     const googleModel = model;
     if (isGemini3ProModel(googleModel) || isGemini3FlashModel(googleModel) || isGemma4Model(googleModel)) {
         return streamGoogle(model, context, {

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

@@ -1,11 +1,11 @@
 import { Mistral } from "@mistralai/mistralai";
 import { getEnvApiKey } from "../env-api-keys.js";
-import { calculateCost } from "../models.js";
+import { calculateCost, clampThinkingLevel } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { shortHash } from "../utils/hash.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { buildBaseOptions, clampReasoning } from "./simple-options.js";
+import { buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 const MISTRAL_TOOL_CALL_ID_LENGTH = 9;
 const MAX_MISTRAL_ERROR_BODY_CHARS = 4000;
@@ -67,12 +67,13 @@ export const streamSimpleMistral = (model, context, options) => {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
     const base = buildBaseOptions(model, options, apiKey);
-    const reasoning = clampReasoning(options?.reasoning);
+    const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+    const reasoning = clampedReasoning === "off" ? undefined : clampedReasoning;
     const shouldUseReasoning = model.reasoning && reasoning !== undefined;
     return streamMistral(model, context, {
         ...base,
         promptMode: shouldUseReasoning && usesPromptModeReasoning(model) ? "reasoning" : undefined,
-        reasoningEffort: shouldUseReasoning && usesReasoningEffort(model) ? mapReasoningEffort(reasoning) : undefined,
+        reasoningEffort: shouldUseReasoning && usesReasoningEffort(model) ? mapReasoningEffort(model, reasoning) : undefined,
     });
 };
 function createOutput(model) {
@@ -495,13 +496,13 @@ function buildToolResultText(text, hasImages, supportsImages, isError) {
     return isError ? "[tool error] (no tool output)" : "(no tool output)";
 }
 function usesReasoningEffort(model) {
-    return model.id === "mistral-small-2603" || model.id === "mistral-small-latest";
+    return model.id === "mistral-small-2603" || model.id === "mistral-small-latest" || model.id === "mistral-medium-3.5";
 }
 function usesPromptModeReasoning(model) {
     return model.reasoning && !usesReasoningEffort(model);
 }
-function mapReasoningEffort(_level) {
-    return "high";
+function mapReasoningEffort(model, level) {
+    return (model.thinkingLevelMap?.[level] ?? "high");
 }
 function mapToolChoice(choice) {
     if (!choice)