@jaypie/llm 1.3.11 → 1.3.13

package/dist/cjs/index.cjs

@@ -37,6 +37,14 @@ const MODEL = {
     SONNET: "claude-sonnet-5",
     HAIKU: "claude-haiku-4-5",
     MYTHOS: "claude-mythos-5",
+    // Fireworks (serverless open models; ids provided by operator)
+    FIREWORKS: {
+        DEEPSEEK: "accounts/fireworks/models/deepseek-v4-pro",
+        GLM: "accounts/fireworks/models/glm-5p2",
+        KIMI: "accounts/fireworks/models/kimi-k2p7-code",
+        MINIMAX: "accounts/fireworks/models/minimax-m2p7",
+        QWEN: "accounts/fireworks/models/qwen3p7-plus",
+    },
     // Google
     GEMINI_FLASH: "gemini-3.5-flash",
     GEMINI_FLASH_LITE: "gemini-3.1-flash-lite",
@@ -141,6 +149,14 @@ const PROVIDER = {
             SCHEMA_VERSION: "v2",
         },
     },
+    FIREWORKS: {
+        // https://docs.fireworks.ai/
+        API_KEY: "FIREWORKS_API_KEY",
+        BASE_URL: "https://api.fireworks.ai/inference/v1",
+        DEFAULT: MODEL.FIREWORKS.GLM,
+        MODEL_MATCH_WORDS: ["fireworks"],
+        NAME: "fireworks",
+    },
     /** @deprecated Use PROVIDER.GOOGLE — "Google" is the provider; Gemini is the model family */
     GEMINI: GOOGLE_PROVIDER,
     GOOGLE: GOOGLE_PROVIDER,
@@ -278,6 +294,14 @@ function determineModelProvider(input) {
             provider: PROVIDER.OPENROUTER.NAME,
         };
     }
+    // Check for explicit fireworks: prefix
+    if (input.startsWith("fireworks:")) {
+        const model = input.slice("fireworks:".length);
+        return {
+            model,
+            provider: PROVIDER.FIREWORKS.NAME,
+        };
+    }
     // Check for explicit bedrock: prefix
     if (input.startsWith("bedrock:")) {
         const model = input.slice("bedrock:".length);
@@ -293,6 +317,12 @@ function determineModelProvider(input) {
             provider: PROVIDER.BEDROCK.NAME,
         };
     }
+    if (input === PROVIDER.FIREWORKS.NAME) {
+        return {
+            model: PROVIDER.FIREWORKS.DEFAULT,
+            provider: PROVIDER.FIREWORKS.NAME,
+        };
+    }
     if (input === PROVIDER.ANTHROPIC.NAME) {
         return {
             model: PROVIDER.ANTHROPIC.DEFAULT,
@@ -325,6 +355,18 @@ function determineModelProvider(input) {
     }
     // Exact model ids are classified by the "/" rule and MODEL_MATCH_WORDS below,
     // so no per-provider id catalog is consulted here.
+    // Check Fireworks match words before the "/" rule — Fireworks ids contain
+    // "/" (e.g., "accounts/fireworks/models/glm-5p2") and would otherwise route
+    // to OpenRouter
+    const lowerInputEarly = input.toLowerCase();
+    for (const matchWord of PROVIDER.FIREWORKS.MODEL_MATCH_WORDS) {
+        if (lowerInputEarly.includes(matchWord)) {
+            return {
+                model: input,
+                provider: PROVIDER.FIREWORKS.NAME,
+            };
+        }
+    }
     // Assume OpenRouter for models containing "/" (e.g., "openai/gpt-4", "anthropic/claude-3-opus")
     // This check must come before match words so that "openai/gpt-4" is not matched by "openai" keyword
     if (input.includes("/")) {
@@ -443,6 +485,15 @@ function resolveModelChain(model) {
  * Providers can extend this class to reduce boilerplate.
  */
 class BaseProviderAdapter {
+    constructor() {
+        /**
+         * Whether OperateLoop may take a corrective turn when a `format` request
+         * completes with prose instead of structured output. Providers whose
+         * structured output rides a tool emulation (where compliance is a model
+         * decision) opt in; native grammar-constrained providers do not need it.
+         */
+        this.supportsStructuredOutputRetry = false;
+    }
     /**
      * Default implementation checks if error is retryable via classifyError
      */
@@ -576,6 +627,19 @@ const GEMINI_THINKING_BUDGET = {
 function toGeminiThinkingBudget(effort) {
     return { papered: false, value: GEMINI_THINKING_BUDGET[effort] };
 }
+// Fireworks `reasoning_effort` — low | medium | high. Accepted on every model
+// (the API no-ops where unsupported). No sub-low or top rung, so `lowest`
+// collapses onto `low` and `highest` onto `high`.
+const FIREWORKS_EFFORT = {
+    [EFFORT.LOWEST]: { papered: true, value: "low" },
+    [EFFORT.LOW]: { papered: false, value: "low" },
+    [EFFORT.MEDIUM]: { papered: false, value: "medium" },
+    [EFFORT.HIGH]: { papered: false, value: "high" },
+    [EFFORT.HIGHEST]: { papered: true, value: "high" },
+};
+function toFireworksEffort(effort) {
+    return FIREWORKS_EFFORT[effort];
+}
 // OpenRouter `reasoning.effort` — accepts the full minimal..xhigh ladder and
 // maps to the routed provider's nearest supported level itself, so nothing is
 // papered here.
@@ -1062,7 +1126,7 @@ function jsonSchemaToOpenApi3(schema) {
     return result;
 }
 
-const getLogger$6 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$7 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 
 //
 //
@@ -1718,7 +1782,7 @@ function classifyProviderError(error) {
 //
 // Constants
 //
-const STRUCTURED_OUTPUT_TOOL_NAME$3 = "structured_output";
+const STRUCTURED_OUTPUT_TOOL_NAME$4 = "structured_output";
 /**
  * Whether `output_config.effort` may be sent for this model. Anthropic added
  * the effort control on the Claude 4.5 line and up (the 5 family); older models
@@ -1954,7 +2018,7 @@ const MODELS_WITHOUT_TEMPERATURE$2 = [
     /^claude-opus-4-[789]/,
     /^claude-opus-[5-9]/,
 ];
-function isTemperatureDeprecationError$3(error) {
+function isTemperatureDeprecationError$4(error) {
     if (!error || typeof error !== "object")
         return false;
     const err = error;
@@ -1973,7 +2037,7 @@ function isTemperatureDeprecationError$3(error) {
  * field) is also explicitly excluded — that's a code-path bug, not a model
  * gap; it should propagate so we notice and fix it.
  */
-function isStructuredOutputUnsupportedError$1(error) {
+function isStructuredOutputUnsupportedError$2(error) {
     if (!error || typeof error !== "object")
         return false;
     const err = error;
@@ -2106,7 +2170,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         if (useFallbackStructuredOutput && request.format) {
             log$1.log.warn(`[AnthropicAdapter] Using legacy structured_output tool fallback for model ${anthropicRequest.model}; native output_config previously rejected for this model.`);
             allTools.push({
-                name: STRUCTURED_OUTPUT_TOOL_NAME$3,
+                name: STRUCTURED_OUTPUT_TOOL_NAME$4,
                 description: "Output a structured JSON object, " +
                     "use this before your final response to give structured outputs to the user",
                 parameters: request.format,
@@ -2223,7 +2287,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 return undefined;
             // If the model rejected `temperature`, cache it and retry without the param
             if (anthropicRequest.temperature !== undefined &&
-                isTemperatureDeprecationError$3(error)) {
+                isTemperatureDeprecationError$4(error)) {
                 this.rememberModelRejectsTemperature(anthropicRequest.model);
                 const retryRequest = { ...anthropicRequest };
                 delete retryRequest.temperature;
@@ -2235,7 +2299,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
             }
             // If the model rejected native structured output, cache it and retry
             // via the legacy fake-tool emulation path.
-            if (wantsStructuredOutput && isStructuredOutputUnsupportedError$1(error)) {
+            if (wantsStructuredOutput && isStructuredOutputUnsupportedError$2(error)) {
                 const model = anthropicRequest.model;
                 this.rememberModelRejectsStructuredOutput(model);
                 log$1.log.warn(`[AnthropicAdapter] Model ${model} rejected native output_config; falling back to legacy structured_output tool emulation.`);
@@ -2260,7 +2324,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
             fallbackRequest.output_config = { effort: output_config.effort };
         }
         const fakeTool = {
-            name: STRUCTURED_OUTPUT_TOOL_NAME$3,
+            name: STRUCTURED_OUTPUT_TOOL_NAME$4,
             description: "Output a structured JSON object, " +
                 "use this before your final response to give structured outputs to the user",
             input_schema: {
@@ -2288,7 +2352,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         }
         catch (error) {
             if (streamRequest.temperature !== undefined &&
-                isTemperatureDeprecationError$3(error)) {
+                isTemperatureDeprecationError$4(error)) {
                 this.rememberModelRejectsTemperature(streamRequest.model);
                 streamRequest = {
                     ...streamRequest,
@@ -2551,7 +2615,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         // runtime has cached as not supporting `output_format`.
         const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
         return (lastBlock?.type === "tool_use" &&
-            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$3);
+            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$4);
     }
     extractStructuredOutput(response) {
         const anthropicResponse = response;
@@ -2577,7 +2641,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         // Fallback path: legacy fake-tool emulation
         const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
         if (lastBlock?.type === "tool_use" &&
-            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$3) {
+            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$4) {
             return lastBlock.input;
         }
         return undefined;
@@ -2666,12 +2730,12 @@ function convertContentToBedrock(content) {
 //
 // Constants / helpers
 //
-const STRUCTURED_OUTPUT_TOOL_NAME$2 = "structured_output";
+const STRUCTURED_OUTPUT_TOOL_NAME$3 = "structured_output";
 function isOutputConfigUnsupportedError(error) {
     const msg = error?.message ?? "";
     return /outputConfig|output_config/i.test(msg);
 }
-function isTemperatureDeprecationError$2(error) {
+function isTemperatureDeprecationError$3(error) {
     const msg = error?.message ?? "";
     return /temperature.*deprecated|deprecated.*temperature/i.test(msg);
 }
@@ -2818,7 +2882,7 @@ class BedrockAdapter extends BaseProviderAdapter {
             if (this.useFakeToolForStructuredOutput(model)) {
                 const fakeTool = {
                     toolSpec: {
-                        name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+                        name: STRUCTURED_OUTPUT_TOOL_NAME$3,
                         description: "REQUIRED: You MUST call this tool to provide your final response. " +
                             "After gathering all necessary information (including results from other tools), " +
                             "call this tool with the structured data to complete the request.",
@@ -2887,7 +2951,7 @@ class BedrockAdapter extends BaseProviderAdapter {
         }
         catch (error) {
             if (bedrockRequest.inferenceConfig?.temperature !== undefined &&
-                isTemperatureDeprecationError$2(error)) {
+                isTemperatureDeprecationError$3(error)) {
                 this.rememberModelRejectsTemperature(bedrockRequest.modelId || this.defaultModel);
                 const retryRequest = {
                     ...bedrockRequest,
@@ -2921,7 +2985,7 @@ class BedrockAdapter extends BaseProviderAdapter {
         }
         const fakeTool = {
             toolSpec: {
-                name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+                name: STRUCTURED_OUTPUT_TOOL_NAME$3,
                 description: "REQUIRED: You MUST call this tool to provide your final response. " +
                     "After gathering all necessary information (including results from other tools), " +
                     "call this tool with the structured data to complete the request.",
@@ -3010,7 +3074,7 @@ class BedrockAdapter extends BaseProviderAdapter {
         // Don't surface structured_output fake tool as a real tool call
         const allToolUses = (bedrockResponse.output?.message?.content ?? []).filter((b) => "toolUse" in b);
         const hasOnlyStructuredOutputTool = allToolUses.length > 0 &&
-            allToolUses.every((b) => b.toolUse.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
+            allToolUses.every((b) => b.toolUse.name === STRUCTURED_OUTPUT_TOOL_NAME$3);
         const hasToolCalls = bedrockResponse.stopReason === "tool_use" && !hasOnlyStructuredOutputTool;
         return {
             content,
@@ -3165,7 +3229,7 @@ class BedrockAdapter extends BaseProviderAdapter {
         const last = content[content.length - 1];
         return (!!last &&
             "toolUse" in last &&
-            last.toolUse.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
+            last.toolUse.name === STRUCTURED_OUTPUT_TOOL_NAME$3);
     }
     extractStructuredOutput(response) {
         const bedrockResponse = response;
@@ -3183,7 +3247,7 @@ class BedrockAdapter extends BaseProviderAdapter {
         const last = content[content.length - 1];
         if (last &&
             "toolUse" in last &&
-            last.toolUse.name === STRUCTURED_OUTPUT_TOOL_NAME$2) {
+            last.toolUse.name === STRUCTURED_OUTPUT_TOOL_NAME$3) {
             return last.toolUse.input;
         }
         return undefined;
@@ -3212,123 +3276,965 @@ const bedrockAdapter = new BedrockAdapter();
 //
 // Constants
 //
-const STRUCTURED_OUTPUT_TOOL_NAME$1 = "structured_output";
-// Gemini 3 family supports combining tools (function calling) with native
-// structured output via `responseJsonSchema`. Earlier Gemini families
-// (including 2.5 thinking) do not support the combo and fall back to the
-// legacy `structured_output` fake-tool emulation.
-const GEMINI_3_PATTERN = /^gemini-3/;
-// Reasoning-effort control differs by generation: Gemini 3.x takes the
-// `thinkingLevel` enum, Gemini 2.5 takes an integer `thinkingBudget`. Sending
-// the wrong one errors, and models outside these families have no thinking
-// control, so effort is only applied when one of these matches.
-const GEMINI_25_PATTERN = /^gemini-2\.5/;
+const STRUCTURED_OUTPUT_TOOL_NAME$2 = "structured_output";
+const STRUCTURED_OUTPUT_SCHEMA_NAME$1 = "response";
 /**
- * Detect 4xx errors that indicate the model itself does not support the
- * `responseJsonSchema` + tools combo. Triggers the runtime fallback to the
- * fake-tool emulation path. Other 400s propagate.
+ * Detect 4xx errors that indicate the model itself does not support
+ * `response_format: json_schema`. We only trigger the fake-tool fallback when
+ * the failure is plausibly a capability gap, not a generic 400.
  */
-function isStructuredOutputComboUnsupportedError(error) {
+function isStructuredOutputUnsupportedError$1(error) {
     if (!error || typeof error !== "object")
         return false;
     const err = error;
-    const status = err.status ?? err.code;
+    const status = err.status ?? err.statusCode;
+    if (status !== 400 && status !== 422)
+        return false;
+    const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
+    return messages.some((m) => /response[_ ]format|json[_ ]schema|structured[_ ]output/i.test(m));
+}
+function isTemperatureDeprecationError$2(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    const status = err.status ?? err.statusCode;
     if (status !== 400)
         return false;
     const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
-    return messages.some((m) => /response[_ ]?json[_ ]?schema|response[_ ]?schema|response[_ ]?mime|function[_ ]?call|tools/i.test(m));
+    return messages.some((m) => m.toLowerCase().includes("temperature"));
+}
+/**
+ * Convert standardized content items to Fireworks format. Images become
+ * `image_url` parts (vision models only; non-vision models 4xx — a
+ * model-capability mismatch surfaced by the call). File inputs are warned
+ * and discarded: Fireworks has no `file` part and rejects document `data:`
+ * URIs outright, so there is no wire shape that can carry them.
+ */
+function convertContentToFireworks(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    const parts = [];
+    for (const item of content) {
+        if (item.type === exports.LlmMessageType.InputText) {
+            parts.push({ type: "text", text: item.text });
+            continue;
+        }
+        if (item.type === exports.LlmMessageType.InputImage) {
+            const url = item.image_url ?? "";
+            if (!url) {
+                log$1.log.warn("Fireworks image content missing image_url; image discarded");
+                continue;
+            }
+            parts.push({ type: "image_url", imageUrl: { url } });
+            continue;
+        }
+        if (item.type === exports.LlmMessageType.InputFile) {
+            log$1.log.warn({ filename: item.filename }, "Fireworks does not support file inputs (no file part; document data: URIs rejected); file discarded");
+            continue;
+        }
+        // Unknown type - warn and skip
+        log$1.log.warn({ item }, "Unknown content type for Fireworks; discarded");
+    }
+    // If no parts remain, return empty string to avoid empty array
+    if (parts.length === 0) {
+        return "";
+    }
+    return parts;
+}
+/**
+ * Convert internal content parts to the OpenAI-compatible wire shape. The
+ * internal representation uses camelCase keys (`imageUrl`); the REST API wants
+ * snake_case (`image_url`).
+ */
+function contentToWire$1(content) {
+    if (content === null ||
+        content === undefined ||
+        typeof content === "string") {
+        return content;
+    }
+    return content.map((part) => {
+        if (part.type === "image_url") {
+            return { type: "image_url", image_url: part.imageUrl };
+        }
+        return part;
+    });
+}
+/**
+ * Serialize an internal message to the OpenAI-compatible wire shape, mapping
+ * camelCase tool fields (`toolCalls`, `toolCallId`) to snake_case. Tool-call
+ * objects are already wire-shaped (`{ id, type, function: { name, arguments } }`).
+ */
+function messageToWire$1(message) {
+    const wire = { role: message.role };
+    if (message.content !== undefined) {
+        wire.content = contentToWire$1(message.content);
+    }
+    if (message.toolCalls) {
+        wire.tool_calls = message.toolCalls;
+    }
+    if (message.toolCallId) {
+        wire.tool_call_id = message.toolCallId;
+    }
+    return wire;
+}
+// Fireworks error types based on HTTP status codes
+const RETRYABLE_STATUS_CODES$2 = [408, 500, 502, 503, 524, 529];
+const RATE_LIMIT_STATUS_CODE$1 = 429;
+/**
+ * Walk the JSON schema and force `additionalProperties: false` on every
+ * object node. Required by the OpenAI-style json_schema response_format when
+ * `strict: true`.
+ */
+function enforceAdditionalPropertiesFalse$1(schema) {
+    const stack = [schema];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === "object") {
+            node.additionalProperties = false;
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value)) {
+                for (const entry of value) {
+                    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+                        stack.push(entry);
+                    }
+                }
+            }
+            else if (value && typeof value === "object") {
+                stack.push(value);
+            }
+        }
+    }
 }
-// Gemini uses HTTP status codes for error classification
-// Documented at: https://ai.google.dev/api/rest/v1beta/Status
-const RETRYABLE_STATUS_CODES$1 = [
-    408, // Request Timeout
-    429, // Too Many Requests (Rate Limit)
-    500, // Internal Server Error
-    502, // Bad Gateway
-    503, // Service Unavailable
-    504, // Gateway Timeout
-];
-const NOT_RETRYABLE_STATUS_CODES = [
-    400, // Bad Request
-    401, // Unauthorized
-    403, // Forbidden
-    404, // Not Found
-    409, // Conflict
-    422, // Unprocessable Entity
-];
 //
 //
 // Main
 //
 /**
- * GoogleAdapter implements the ProviderAdapter interface for Google's Gemini API.
- * It handles request building, response parsing, and error classification
- * specific to Gemini's generateContent API.
+ * FireworksAdapter implements the ProviderAdapter interface for Fireworks AI's
+ * OpenAI-compatible Chat Completions API. It handles request building,
+ * response parsing, and error classification specific to Fireworks.
  */
-class GoogleAdapter extends BaseProviderAdapter {
+class FireworksAdapter extends BaseProviderAdapter {
     constructor() {
         super(...arguments);
-        this.name = PROVIDER.GOOGLE.NAME;
-        this.defaultModel = PROVIDER.GOOGLE.DEFAULT;
-        // Session-level cache of Gemini 3 models observed to reject the native
-        // `responseJsonSchema` + tools combo. When a model is in this set,
-        // buildRequest engages the legacy fake-tool path instead.
-        this.runtimeNoStructuredOutputComboModels = new Set();
+        this.name = PROVIDER.FIREWORKS.NAME;
+        this.defaultModel = PROVIDER.FIREWORKS.DEFAULT;
+        // Structured output with tools rides the structured_output tool emulation
+        // (Fireworks rejects response_format + tools), and emulation compliance is
+        // a model decision — opt in to OperateLoop's corrective retry turn.
+        this.supportsStructuredOutputRetry = true;
+        // Session-level cache of models observed to reject native
+        // `response_format: json_schema`. When a model is in this set, buildRequest
+        // engages the legacy fake-tool path instead of native structured output.
+        this.runtimeNoStructuredOutputModels = new Set();
+        // Session-level cache of models observed to reject `temperature`. Populated
+        // by executeRequest on 400 errors so repeat calls skip the param.
+        this.runtimeNoTemperatureModels = new Set();
     }
-    rememberModelRejectsStructuredOutputCombo(model) {
-        this.runtimeNoStructuredOutputComboModels.add(model);
+    rememberModelRejectsStructuredOutput(model) {
+        this.runtimeNoStructuredOutputModels.add(model);
     }
-    clearRuntimeNoStructuredOutputComboModels() {
-        this.runtimeNoStructuredOutputComboModels.clear();
+    clearRuntimeNoStructuredOutputModels() {
+        this.runtimeNoStructuredOutputModels.clear();
     }
-    supportsStructuredOutputCombo(model) {
-        if (this.runtimeNoStructuredOutputComboModels.has(model))
-            return false;
-        return GEMINI_3_PATTERN.test(model);
+    supportsStructuredOutput(model) {
+        return !this.runtimeNoStructuredOutputModels.has(model);
+    }
+    rememberModelRejectsTemperature(model) {
+        this.runtimeNoTemperatureModels.add(model);
+    }
+    clearRuntimeNoTemperatureModels() {
+        this.runtimeNoTemperatureModels.clear();
+    }
+    supportsTemperature(model) {
+        return !this.runtimeNoTemperatureModels.has(model);
     }
     //
     // Request Building
     //
     buildRequest(request) {
-        // Convert messages to Gemini format (Content[])
-        const contents = this.convertMessagesToContents(request.messages);
-        const geminiRequest = {
+        // Convert messages to Fireworks format (OpenAI-compatible)
+        const messages = this.convertMessagesToFireworks(request.messages, request.system);
+        // Append instructions to last message if provided
+        if (request.instructions && messages.length > 0) {
+            const lastMsg = messages[messages.length - 1];
+            if (lastMsg.content && typeof lastMsg.content === "string") {
+                lastMsg.content = lastMsg.content + "\n\n" + request.instructions;
+            }
+        }
+        const fireworksRequest = {
             model: request.model || this.defaultModel,
-            contents,
+            messages,
         };
-        // Add system instruction if provided
-        if (request.system) {
-            geminiRequest.config = {
-                ...geminiRequest.config,
-                systemInstruction: request.system,
-            };
-        }
-        // Append instructions to the last user message if provided
-        if (request.instructions && contents.length > 0) {
-            const lastContent = contents[contents.length - 1];
-            if (lastContent.role === "user" && lastContent.parts) {
-                const lastPart = lastContent.parts[lastContent.parts.length - 1];
-                if (lastPart.text) {
-                    lastPart.text = lastPart.text + "\n\n" + request.instructions;
-                }
-            }
+        if (request.user) {
+            fireworksRequest.user = request.user;
         }
-        const hasUserTools = !!(request.tools && request.tools.length > 0);
-        const useNativeCombo = Boolean(request.format) &&
-            hasUserTools &&
-            this.supportsStructuredOutputCombo(geminiRequest.model);
-        // When tools+format are combined and the model does not support the native
-        // combo, inject the legacy `structured_output` fake tool here so the model
-        // is forced to call it before its final answer.
-        const allTools = request.tools
-            ? [...request.tools]
-            : [];
-        if (request.format && hasUserTools && !useNativeCombo) {
-            log$1.log.warn(`[GoogleAdapter] Using legacy structured_output tool fallback for model ${geminiRequest.model}; native responseJsonSchema + tools combo is only available on Gemini 3.`);
+        // Fireworks rejects `response_format` combined with `tools` ("You cannot
+        // specify response format and function call at the same time"), so a
+        // request with both preemptively uses the structured_output tool
+        // emulation — same approach as Gemini 2.5.
+        const hasCallerTools = Boolean(request.tools?.length);
+        const useFallbackStructuredOutput = Boolean(request.format) &&
+            (hasCallerTools ||
+                !this.supportsStructuredOutput(fireworksRequest.model));
+        // On a corrective retry turn (the model answered a format request with
+        // prose), offer only the structured_output tool so the demanded call is
+        // the sole option.
+        const allTools = request.tools && !request.structuredOutputRetry ? [...request.tools] : [];
+        if (useFallbackStructuredOutput && request.format) {
+            log$1.log.warn(hasCallerTools
+                ? `[FireworksAdapter] Fireworks does not support response_format combined with tools; using structured_output tool emulation for model ${fireworksRequest.model}.`
+                : `[FireworksAdapter] Using legacy structured_output tool fallback for model ${fireworksRequest.model}; native response_format previously rejected for this model.`);
             allTools.push({
-                name: STRUCTURED_OUTPUT_TOOL_NAME$1,
-                description: "Output a structured JSON object, " +
-                    "use this before your final response to give structured outputs to the user",
+                name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+                description: "REQUIRED: You MUST call this tool to provide your final response. " +
+                    "After gathering all necessary information (including results from other tools), " +
+                    "call this tool with the structured data to complete the request.",
+                parameters: request.format,
+            });
+        }
+        if (allTools.length > 0) {
+            fireworksRequest.tools = allTools.map((tool) => ({
+                type: "function",
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.parameters,
+                },
+            }));
+            // Use "auto" for tool_choice - not all Fireworks models support "required"
+            // The structured_output tool prompt already emphasizes it must be called
+            fireworksRequest.tool_choice = "auto";
+        }
+        // Native structured output: send schema as `response_format`. The legacy
+        // tool-emulation path is engaged only as a runtime fallback for models the
+        // API has flagged as not supporting native json_schema.
+        if (request.format && !useFallbackStructuredOutput) {
+            fireworksRequest.response_format = {
+                type: "json_schema",
+                json_schema: {
+                    name: STRUCTURED_OUTPUT_SCHEMA_NAME$1,
+                    schema: request.format,
+                    strict: true,
+                },
+            };
+        }
+        if (request.providerOptions) {
+            Object.assign(fireworksRequest, request.providerOptions);
+        }
+        // Normalized reasoning effort -> reasoning_effort. Fireworks accepts the
+        // param on every model and no-ops where unsupported, so no per-model
+        // gating. First-class effort wins over providerOptions.
+        if (request.effort) {
+            const mapping = toFireworksEffort(request.effort);
+            if (mapping.papered) {
+                log$1.log.debug(paperedEffortMessage({
+                    model: fireworksRequest.model,
+                    provider: this.name,
+                    requested: request.effort,
+                    value: mapping.value,
+                }));
+            }
+            fireworksRequest.reasoning_effort = mapping.value;
+        }
+        // First-class temperature takes precedence over providerOptions
+        if (request.temperature !== undefined) {
+            fireworksRequest.temperature =
+                request.temperature;
+        }
+        // Strip temperature for models the runtime has cached as rejecting it
+        const requestRecord = fireworksRequest;
+        if (requestRecord.temperature !== undefined &&
+            !this.supportsTemperature(fireworksRequest.model)) {
+            delete requestRecord.temperature;
+        }
+        return fireworksRequest;
+    }
+    formatTools(toolkit, 
+    // outputSchema is part of the interface contract but Fireworks uses native
+    // `response_format` (set in buildRequest); the legacy fake-tool injection
+    // happens in buildRequest only as a runtime fallback.
+    _outputSchema) {
+        return toolkit.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        }));
+    }
+    formatOutputSchema(schema) {
+        let jsonSchema;
+        // Check if schema is already a JsonObject — either the OpenAI-style
+        // `{ type: "json_schema", ... }` envelope or a bare `{ type: "object", properties }` node
+        if ((typeof schema === "object" &&
+            schema !== null &&
+            !Array.isArray(schema) &&
+            schema.type === "json_schema") ||
+            isJsonSchema$1(schema)) {
+            jsonSchema = structuredClone(schema);
+            jsonSchema.type = "object"; // Normalize type
+        }
+        else {
+            // Convert NaturalSchema to JSON schema through Zod. Re-spread into a
+            // plain object to drop Zod v4's non-enumerable `~standard` marker.
+            const zodSchema = schema instanceof v4.z.ZodType
+                ? schema
+                : naturalZodSchema(schema);
+            jsonSchema = { ...v4.z.toJSONSchema(zodSchema) };
+        }
+        // Remove $schema property (can cause issues with some providers)
+        if (jsonSchema.$schema) {
+            delete jsonSchema.$schema;
+        }
+        // Strict json_schema response_format requires additionalProperties: false
+        // on every object.
+        enforceAdditionalPropertiesFalse$1(jsonSchema);
+        return jsonSchema;
+    }
+    //
+    // API Execution
+    //
+    async executeRequest(client, request, signal) {
+        const fireworks = client;
+        const fireworksRequest = request;
+        const wantsStructuredOutput = Boolean(fireworksRequest.response_format);
+        try {
+            const response = (await fireworks.chatCompletion(this.toWireBody(fireworksRequest), signal ? { signal } : undefined));
+            if (wantsStructuredOutput) {
+                response.__jaypieStructuredOutput = true;
+            }
+            return response;
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return undefined;
+            // If the model rejected `temperature`, cache it and retry without the param.
+            const requestRecord = fireworksRequest;
+            if (requestRecord.temperature !== undefined &&
+                isTemperatureDeprecationError$2(error)) {
+                this.rememberModelRejectsTemperature(fireworksRequest.model);
+                const retryRequest = { ...fireworksRequest };
+                delete retryRequest.temperature;
+                const response = (await fireworks.chatCompletion(this.toWireBody(retryRequest), signal ? { signal } : undefined));
+                if (wantsStructuredOutput) {
+                    response.__jaypieStructuredOutput = true;
+                }
+                return response;
+            }
+            // If the model rejected `response_format`, cache it and retry with the
+            // legacy fake-tool emulation path.
+            if (wantsStructuredOutput && isStructuredOutputUnsupportedError$1(error)) {
+                const model = fireworksRequest.model;
+                this.rememberModelRejectsStructuredOutput(model);
+                log$1.log.warn(`[FireworksAdapter] Model ${model} rejected native response_format; falling back to legacy structured_output tool emulation.`);
+                const fallbackRequest = this.toFallbackStructuredOutputRequest(fireworksRequest);
+                return (await fireworks.chatCompletion(this.toWireBody(fallbackRequest), signal ? { signal } : undefined));
+            }
+            throw error;
+        }
+    }
+    /**
+     * Serialize the internal request into the OpenAI-compatible wire body for
+     * Fireworks' Chat Completions endpoint. Top-level fields (model, tools,
+     * tool_choice, response_format, reasoning_effort, user, temperature, and any
+     * providerOptions) are already wire-shaped (snake_case); only messages carry
+     * camelCase tool fields that must become snake_case on the wire.
+     */
+    toWireBody(fireworksRequest) {
+        return {
+            ...fireworksRequest,
+            messages: fireworksRequest.messages.map(messageToWire$1),
+        };
+    }
+    /**
+     * Rebuild a structured-output request without `response_format`, swapping in
+     * the legacy fake-tool emulation. Used as a runtime fallback when a model
+     * rejects native json_schema.
+     */
+    toFallbackStructuredOutputRequest(request) {
+        if (!request.response_format ||
+            request.response_format.type !== "json_schema") {
+            return request;
+        }
+        const { response_format, ...rest } = request;
+        const fallbackRequest = { ...rest };
+        const schema = response_format.json_schema.schema;
+        const fakeTool = {
+            type: "function",
+            function: {
+                name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+                description: "REQUIRED: You MUST call this tool to provide your final response. " +
+                    "After gathering all necessary information (including results from other tools), " +
+                    "call this tool with the structured data to complete the request.",
+                parameters: schema,
+            },
+        };
+        fallbackRequest.tools = [...(fallbackRequest.tools ?? []), fakeTool];
+        fallbackRequest.tool_choice = "auto";
+        return fallbackRequest;
+    }
+    async *executeStreamRequest(client, request, signal) {
+        const fireworks = client;
+        const fireworksRequest = request;
+        // streamChatCompletion adds `stream: true` + `stream_options.include_usage`
+        // and yields decoded SSE chunks in OpenAI-compatible (snake_case) shape.
+        const stream = fireworks.streamChatCompletion(this.toWireBody(fireworksRequest), signal ? { signal } : undefined);
+        // Track current tool call being built
+        let currentToolCall = null;
+        // Track usage for final chunk
+        let inputTokens = 0;
+        let outputTokens = 0;
+        const model = fireworksRequest.model || this.defaultModel;
+        for await (const chunk of stream) {
+            const typedChunk = chunk;
+            const choices = typedChunk.choices;
+            if (choices && choices.length > 0) {
+                const delta = choices[0].delta;
+                // Handle text content
+                if (delta?.content) {
+                    yield {
+                        type: exports.LlmStreamChunkType.Text,
+                        content: delta.content,
+                    };
+                }
+                // Handle tool calls
+                if (delta?.tool_calls && delta.tool_calls.length > 0) {
+                    for (const toolCallDelta of delta.tool_calls) {
+                        if (toolCallDelta.id) {
+                            // New tool call starting
+                            if (currentToolCall) {
+                                // Emit the previous tool call
+                                yield {
+                                    type: exports.LlmStreamChunkType.ToolCall,
+                                    toolCall: {
+                                        id: currentToolCall.id,
+                                        name: currentToolCall.name,
+                                        arguments: currentToolCall.arguments,
+                                    },
+                                };
+                            }
+                            currentToolCall = {
+                                id: toolCallDelta.id,
+                                name: toolCallDelta.function?.name || "",
+                                arguments: toolCallDelta.function?.arguments || "",
+                            };
+                        }
+                        else if (currentToolCall) {
+                            // Continuing existing tool call
+                            if (toolCallDelta.function?.name) {
+                                currentToolCall.name += toolCallDelta.function.name;
+                            }
+                            if (toolCallDelta.function?.arguments) {
+                                currentToolCall.arguments += toolCallDelta.function.arguments;
+                            }
+                        }
+                    }
+                }
+                // Check for finish reason
+                if (choices[0].finish_reason) {
+                    // Emit any pending tool call
+                    if (currentToolCall) {
+                        yield {
+                            type: exports.LlmStreamChunkType.ToolCall,
+                            toolCall: {
+                                id: currentToolCall.id,
+                                name: currentToolCall.name,
+                                arguments: currentToolCall.arguments,
+                            },
+                        };
+                        currentToolCall = null;
+                    }
+                }
+            }
+            // Extract usage if present (usually in the final chunk)
+            if (typedChunk.usage) {
+                inputTokens =
+                    typedChunk.usage.prompt_tokens || typedChunk.usage.promptTokens || 0;
+                outputTokens =
+                    typedChunk.usage.completion_tokens ||
+                        typedChunk.usage.completionTokens ||
+                        0;
+            }
+        }
+        // Emit done chunk with final usage
+        yield {
+            type: exports.LlmStreamChunkType.Done,
+            usage: [
+                {
+                    input: inputTokens,
+                    output: outputTokens,
+                    reasoning: 0,
+                    total: inputTokens + outputTokens,
+                    provider: this.name,
+                    model,
+                },
+            ],
+        };
+    }
+    //
+    // Response Parsing
+    //
+    parseResponse(response, _options) {
+        const fireworksResponse = response;
+        const choice = fireworksResponse.choices[0];
+        const content = this.extractContent(fireworksResponse);
+        const hasToolCalls = this.hasToolCalls(fireworksResponse);
+        const stopReason = choice?.finishReason ?? choice?.finish_reason ?? undefined;
+        return {
+            content,
+            hasToolCalls,
+            stopReason,
+            usage: this.extractUsage(fireworksResponse, fireworksResponse.model),
+            raw: fireworksResponse,
+        };
+    }
+    extractToolCalls(response) {
+        const fireworksResponse = response;
+        const toolCalls = [];
+        const choice = fireworksResponse.choices[0];
+        if (!choice?.message?.toolCalls) {
+            return toolCalls;
+        }
+        for (const toolCall of choice.message.toolCalls) {
+            toolCalls.push({
+                callId: toolCall.id,
+                name: toolCall.function.name,
+                arguments: toolCall.function.arguments,
+                raw: toolCall,
+            });
+        }
+        return toolCalls;
+    }
+    extractUsage(response, model) {
+        const fireworksResponse = response;
+        if (!fireworksResponse.usage) {
+            return {
+                input: 0,
+                output: 0,
+                reasoning: 0,
+                total: 0,
+                provider: this.name,
+                model,
+            };
+        }
+        const usage = fireworksResponse.usage;
+        return {
+            input: usage.promptTokens || usage.prompt_tokens || 0,
+            output: usage.completionTokens || usage.completion_tokens || 0,
+            reasoning: usage.completionTokensDetails?.reasoningTokens || 0,
+            total: usage.totalTokens || usage.total_tokens || 0,
+            provider: this.name,
+            model,
+        };
+    }
+    //
+    // Tool Result Handling
+    //
+    formatToolResult(toolCall, result) {
+        return {
+            role: "tool",
+            toolCallId: toolCall.callId,
+            content: result.output,
+        };
+    }
+    appendToolResult(request, toolCall, result) {
+        const fireworksRequest = request;
+        const toolCallRaw = toolCall.raw;
+        // Add assistant message with the tool call
+        fireworksRequest.messages.push({
+            role: "assistant",
+            content: null,
+            toolCalls: [toolCallRaw],
+        });
+        // Add tool result message
+        fireworksRequest.messages.push(this.formatToolResult(toolCall, result));
+        return fireworksRequest;
+    }
+    //
+    // History Management
+    //
+    responseToHistoryItems(response) {
+        const fireworksResponse = response;
+        const historyItems = [];
+        const choice = fireworksResponse.choices[0];
+        if (!choice?.message) {
+            return historyItems;
+        }
+        // Check if this is a tool use response
+        if (choice.message.toolCalls && choice.message.toolCalls.length > 0) {
+            // Don't add to history yet - will be added after tool execution
+            return historyItems;
+        }
+        // Extract text content for non-tool responses
+        if (choice.message.content) {
+            const historyItem = {
+                content: choice.message.content,
+                role: exports.LlmMessageRole.Assistant,
+                type: exports.LlmMessageType.Message,
+            };
+            // Preserve reasoning if present. Fireworks reasoning models return it in
+            // reasoning_content; some routes use reasoning.
+            const reasoning = choice.message.reasoning_content ?? choice.message.reasoning;
+            if (reasoning) {
+                historyItem.reasoning = reasoning;
+            }
+            historyItems.push(historyItem);
+        }
+        return historyItems;
+    }
+    //
+    // Error Classification
+    //
+    classifyError(error) {
+        // Shared first pass: retryable structured-output timeouts (#422),
+        // quota exhaustion, and billing failures classify the same across providers.
+        const shared = classifyProviderError(error);
+        if (shared)
+            return shared;
+        // Check if error has a status code (HTTP error)
+        const errorWithStatus = error;
+        const statusCode = errorWithStatus.status || errorWithStatus.statusCode;
+        if (statusCode) {
+            // Rate limit error
+            if (statusCode === RATE_LIMIT_STATUS_CODE$1) {
+                return {
+                    error,
+                    category: exports.ErrorCategory.RateLimit,
+                    shouldRetry: false,
+                    suggestedDelayMs: 60000,
+                };
+            }
+            // Retryable errors (server errors, timeouts, etc.)
+            if (RETRYABLE_STATUS_CODES$2.includes(statusCode)) {
+                return {
+                    error,
+                    category: exports.ErrorCategory.Retryable,
+                    shouldRetry: true,
+                };
+            }
+            // Client errors (4xx except 429) are unrecoverable
+            if (statusCode >= 400 && statusCode < 500) {
+                return {
+                    error,
+                    category: exports.ErrorCategory.Unrecoverable,
+                    shouldRetry: false,
+                };
+            }
+        }
+        // Check error message for rate limit indicators
+        const errorMessage = error instanceof Error ? error.message.toLowerCase() : "";
+        if (errorMessage.includes("rate limit") ||
+            errorMessage.includes("too many requests")) {
+            return {
+                error,
+                category: exports.ErrorCategory.RateLimit,
+                shouldRetry: false,
+                suggestedDelayMs: 60000,
+            };
+        }
+        // Check for transient network errors (ECONNRESET, etc.)
+        if (isTransientNetworkError(error)) {
+            return {
+                error,
+                category: exports.ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
+        // Unknown error - treat as potentially retryable
+        return {
+            error,
+            category: exports.ErrorCategory.Unknown,
+            shouldRetry: true,
+        };
+    }
+    //
+    // Provider-Specific Features
+    //
+    isComplete(response) {
+        const fireworksResponse = response;
+        const choice = fireworksResponse.choices[0];
+        // Complete if no tool calls
+        if (!choice?.message?.toolCalls?.length) {
+            return true;
+        }
+        return false;
+    }
+    hasStructuredOutput(response) {
+        const fireworksResponse = response;
+        // Native path: executeRequest annotates the response when we sent
+        // `response_format`, so we can detect intent statelessly.
+        if (fireworksResponse.__jaypieStructuredOutput) {
+            return this.extractStructuredOutput(response) !== undefined;
+        }
+        // Fallback path: legacy fake-tool emulation, kept for models that the
+        // runtime has cached as not supporting native `response_format`.
+        const choice = fireworksResponse.choices[0];
+        if (!choice?.message?.toolCalls?.length) {
+            return false;
+        }
+        // Check if the last tool call is structured_output
+        const lastToolCall = choice.message.toolCalls[choice.message.toolCalls.length - 1];
+        return lastToolCall?.function?.name === STRUCTURED_OUTPUT_TOOL_NAME$2;
+    }
+    extractStructuredOutput(response) {
+        const fireworksResponse = response;
+        if (fireworksResponse.__jaypieStructuredOutput) {
+            const choice = fireworksResponse.choices[0];
+            const content = choice?.message?.content;
+            if (typeof content !== "string" || content.length === 0) {
+                return undefined;
+            }
+            try {
+                return JSON.parse(content);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        // Fallback path: legacy fake-tool emulation
+        const choice = fireworksResponse.choices[0];
+        if (!choice?.message?.toolCalls?.length) {
+            return undefined;
+        }
+        const lastToolCall = choice.message.toolCalls[choice.message.toolCalls.length - 1];
+        if (lastToolCall?.function?.name === STRUCTURED_OUTPUT_TOOL_NAME$2) {
+            try {
+                return JSON.parse(lastToolCall.function.arguments);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    //
+    // Private Helpers
+    //
+    hasToolCalls(response) {
+        const choice = response.choices[0];
+        return (choice?.message?.toolCalls?.length ?? 0) > 0;
+    }
+    extractContent(response) {
+        // Check for structured output first
+        if (this.hasStructuredOutput(response)) {
+            return this.extractStructuredOutput(response);
+        }
+        const choice = response.choices[0];
+        return choice?.message?.content ?? undefined;
+    }
+    convertMessagesToFireworks(messages, system) {
+        const fireworksMessages = [];
+        // Add system message if provided
+        if (system) {
+            fireworksMessages.push({
+                role: "system",
+                content: system,
+            });
+        }
+        for (const msg of messages) {
+            const message = msg;
+            // Handle different message types
+            if (message.role === "system") {
+                fireworksMessages.push({
+                    role: "system",
+                    content: message.content,
+                });
+            }
+            else if (message.role === "user") {
+                fireworksMessages.push({
+                    role: "user",
+                    content: convertContentToFireworks(message.content),
+                });
+            }
+            else if (message.role === "assistant") {
+                const assistantMsg = {
+                    role: "assistant",
+                    content: message.content || null,
+                };
+                // Include toolCalls if present (check both camelCase and snake_case for compatibility)
+                if (message.toolCalls) {
+                    assistantMsg.toolCalls = message.toolCalls;
+                }
+                else if (message.tool_calls) {
+                    assistantMsg.toolCalls = message.tool_calls;
+                }
+                fireworksMessages.push(assistantMsg);
+            }
+            else if (message.role === "tool") {
+                fireworksMessages.push({
+                    role: "tool",
+                    toolCallId: message.toolCallId || message.tool_call_id,
+                    content: message.content,
+                });
+            }
+            else if (message.type === exports.LlmMessageType.Message) {
+                // Handle internal message format
+                const role = message.role?.toLowerCase();
+                if (role === "assistant") {
+                    fireworksMessages.push({
+                        role: "assistant",
+                        content: message.content,
+                    });
+                }
+                else {
+                    fireworksMessages.push({
+                        role: "user",
+                        content: convertContentToFireworks(message.content),
+                    });
+                }
+            }
+            else if (message.type === exports.LlmMessageType.FunctionCall) {
+                fireworksMessages.push({
+                    role: "assistant",
+                    content: null,
+                    toolCalls: [
+                        {
+                            id: message.call_id,
+                            type: "function",
+                            function: {
+                                name: message.name,
+                                arguments: message.arguments || "{}",
+                            },
+                        },
+                    ],
+                });
+            }
+            else if (message.type === exports.LlmMessageType.FunctionCallOutput) {
+                fireworksMessages.push({
+                    role: "tool",
+                    toolCallId: message.call_id,
+                    content: message.output || "",
+                });
+            }
+        }
+        return fireworksMessages;
+    }
+}
+// Export singleton instance
+const fireworksAdapter = new FireworksAdapter();
+
+//
+//
+// Constants
+//
+const STRUCTURED_OUTPUT_TOOL_NAME$1 = "structured_output";
+// Gemini 3 family supports combining tools (function calling) with native
+// structured output via `responseJsonSchema`. Earlier Gemini families
+// (including 2.5 thinking) do not support the combo and fall back to the
+// legacy `structured_output` fake-tool emulation.
+const GEMINI_3_PATTERN = /^gemini-3/;
+// Reasoning-effort control differs by generation: Gemini 3.x takes the
+// `thinkingLevel` enum, Gemini 2.5 takes an integer `thinkingBudget`. Sending
+// the wrong one errors, and models outside these families have no thinking
+// control, so effort is only applied when one of these matches.
+const GEMINI_25_PATTERN = /^gemini-2\.5/;
+/**
+ * Detect 4xx errors that indicate the model itself does not support the
+ * `responseJsonSchema` + tools combo. Triggers the runtime fallback to the
+ * fake-tool emulation path. Other 400s propagate.
+ */
+function isStructuredOutputComboUnsupportedError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    const status = err.status ?? err.code;
+    if (status !== 400)
+        return false;
+    const messages = [err.message, err.error?.message].filter((m) => typeof m === "string");
+    return messages.some((m) => /response[_ ]?json[_ ]?schema|response[_ ]?schema|response[_ ]?mime|function[_ ]?call|tools/i.test(m));
+}
+// Gemini uses HTTP status codes for error classification
+// Documented at: https://ai.google.dev/api/rest/v1beta/Status
+const RETRYABLE_STATUS_CODES$1 = [
+    408, // Request Timeout
+    429, // Too Many Requests (Rate Limit)
+    500, // Internal Server Error
+    502, // Bad Gateway
+    503, // Service Unavailable
+    504, // Gateway Timeout
+];
+const NOT_RETRYABLE_STATUS_CODES = [
+    400, // Bad Request
+    401, // Unauthorized
+    403, // Forbidden
+    404, // Not Found
+    409, // Conflict
+    422, // Unprocessable Entity
+];
+//
+//
+// Main
+//
+/**
+ * GoogleAdapter implements the ProviderAdapter interface for Google's Gemini API.
+ * It handles request building, response parsing, and error classification
+ * specific to Gemini's generateContent API.
+ */
+class GoogleAdapter extends BaseProviderAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = PROVIDER.GOOGLE.NAME;
+        this.defaultModel = PROVIDER.GOOGLE.DEFAULT;
+        // Session-level cache of Gemini 3 models observed to reject the native
+        // `responseJsonSchema` + tools combo. When a model is in this set,
+        // buildRequest engages the legacy fake-tool path instead.
+        this.runtimeNoStructuredOutputComboModels = new Set();
+    }
+    rememberModelRejectsStructuredOutputCombo(model) {
+        this.runtimeNoStructuredOutputComboModels.add(model);
+    }
+    clearRuntimeNoStructuredOutputComboModels() {
+        this.runtimeNoStructuredOutputComboModels.clear();
+    }
+    supportsStructuredOutputCombo(model) {
+        if (this.runtimeNoStructuredOutputComboModels.has(model))
+            return false;
+        return GEMINI_3_PATTERN.test(model);
+    }
+    //
+    // Request Building
+    //
+    buildRequest(request) {
+        // Convert messages to Gemini format (Content[])
+        const contents = this.convertMessagesToContents(request.messages);
+        const geminiRequest = {
+            model: request.model || this.defaultModel,
+            contents,
+        };
+        // Add system instruction if provided
+        if (request.system) {
+            geminiRequest.config = {
+                ...geminiRequest.config,
+                systemInstruction: request.system,
+            };
+        }
+        // Append instructions to the last user message if provided
+        if (request.instructions && contents.length > 0) {
+            const lastContent = contents[contents.length - 1];
+            if (lastContent.role === "user" && lastContent.parts) {
+                const lastPart = lastContent.parts[lastContent.parts.length - 1];
+                if (lastPart.text) {
+                    lastPart.text = lastPart.text + "\n\n" + request.instructions;
+                }
+            }
+        }
+        const hasUserTools = !!(request.tools && request.tools.length > 0);
+        const useNativeCombo = Boolean(request.format) &&
+            hasUserTools &&
+            this.supportsStructuredOutputCombo(geminiRequest.model);
+        // When tools+format are combined and the model does not support the native
+        // combo, inject the legacy `structured_output` fake tool here so the model
+        // is forced to call it before its final answer.
+        const allTools = request.tools
+            ? [...request.tools]
+            : [];
+        if (request.format && hasUserTools && !useNativeCombo) {
+            log$1.log.warn(`[GoogleAdapter] Using legacy structured_output tool fallback for model ${geminiRequest.model}; native responseJsonSchema + tools combo is only available on Gemini 3.`);
+            allTools.push({
+                name: STRUCTURED_OUTPUT_TOOL_NAME$1,
+                description: "Output a structured JSON object, " +
+                    "use this before your final response to give structured outputs to the user",
                 parameters: request.format,
             });
         }
@@ -6038,8 +6944,8 @@ async function withLlmObsSpan(options, fn) {
         if (started) {
             throw error;
         }
-        getLogger$6().warn("[llmobs] span emission failed");
-        getLogger$6().var({ error });
+        getLogger$7().warn("[llmobs] span emission failed");
+        getLogger$7().var({ error });
         return fn();
     }
 }
@@ -6055,8 +6961,8 @@ function annotateLlmObs(annotation) {
         sdk.annotate(undefined, annotation);
     }
     catch (error) {
-        getLogger$6().warn("[llmobs] annotate failed");
-        getLogger$6().var({ error });
+        getLogger$7().warn("[llmobs] annotate failed");
+        getLogger$7().var({ error });
     }
 }
 /**
@@ -6093,8 +6999,8 @@ function openLlmObsSpan(options) {
                     sdk.annotate(capturedSpan, annotation);
                 }
                 catch (error) {
-                    getLogger$6().warn("[llmobs] annotate failed");
-                    getLogger$6().var({ error });
+                    getLogger$7().warn("[llmobs] annotate failed");
+                    getLogger$7().var({ error });
                 }
             },
             finish: () => {
@@ -6107,8 +7013,8 @@ function openLlmObsSpan(options) {
         };
     }
     catch (error) {
-        getLogger$6().warn("[llmobs] span emission failed");
-        getLogger$6().var({ error });
+        getLogger$7().warn("[llmobs] span emission failed");
+        getLogger$7().var({ error });
         return null;
     }
 }
@@ -6586,7 +7492,7 @@ async function emitProgress({ event, onProgress, }) {
         await onProgress(event);
     }
     catch (error) {
-        const log = getLogger$6();
+        const log = getLogger$7();
         log.warn(`[operate] onProgress callback threw on "${event.type}" event`);
         log.var({ error });
     }
@@ -6836,7 +7742,7 @@ function matchesCaughtError(reason, caught) {
  * (e.g. undici `TypeError: terminated`) emitted between attempts.
  */
 function createStaleRejectionGuard() {
-    const log = getLogger$6();
+    const log = getLogger$7();
     const caughtErrors = new Set();
     let listener;
     return {
@@ -7023,7 +7929,7 @@ class RetryExecutor {
      * @throws BadGatewayError if all retries are exhausted or error is not retryable
      */
     async execute(operation, options) {
-        const log = getLogger$6();
+        const log = getLogger$7();
         let attempt = 0;
         // Guard against stale rejections firing on a subsequent microtask after
         // the retry layer has already caught the originating error: undici socket
@@ -7117,6 +8023,31 @@ function createErrorClassifier(adapter) {
         },
     };
 }
+/**
+ * Attempt to read a prose response as the structured payload itself: parse the
+ * text (stripping a Markdown code fence if present) and return the object, or
+ * undefined when the text is not a JSON object.
+ */
+function tryParseJsonObject(text) {
+    let candidate = text.trim();
+    const fence = candidate.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/);
+    if (fence) {
+        candidate = fence[1].trim();
+    }
+    if (!candidate.startsWith("{")) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(candidate);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Not JSON; caller falls through to the corrective-turn path.
+    }
+    return undefined;
+}
 //
 //
 // Main
@@ -7141,7 +8072,7 @@ class OperateLoop {
      * Execute the operate loop for multi-turn conversations with tool calling.
      */
     async execute(input, options = {}) {
-        const log = getLogger$6();
+        const log = getLogger$7();
         // Log what was passed to operate
         log.trace("[operate] Starting operate loop");
         log.trace.var({ "operate.input": input });
@@ -7185,6 +8116,7 @@ class OperateLoop {
                     messages: state.currentInput,
                     model: modelName,
                     providerOptions: options.providerOptions,
+                    structuredOutputRetry: state.structuredOutputRetry,
                     system: options.system,
                     temperature: options.temperature,
                     tools: state.formattedTools,
@@ -7296,7 +8228,7 @@ class OperateLoop {
         };
     }
     async executeOneTurn(request, state, context, options) {
-        const log = getLogger$6();
+        const log = getLogger$7();
         // Create error classifier from adapter
         const errorClassifier = createErrorClassifier(this.adapter);
         // Create retry executor for this turn
@@ -7588,6 +8520,42 @@ class OperateLoop {
                 return true; // Continue to next turn
             }
         }
+        // Format contract enforcement: the loop is about to complete but the
+        // model answered with prose instead of structured output.
+        if (state.formattedFormat && typeof parsed.content === "string") {
+            // First salvage attempt: the text may be the JSON itself (with or
+            // without a code fence).
+            const salvaged = tryParseJsonObject(parsed.content);
+            if (salvaged) {
+                state.responseBuilder.setContent(this.applyFormatArrayDefaults(salvaged, options));
+                state.responseBuilder.complete();
+                for (const item of this.adapter.responseToHistoryItems(parsed.raw)) {
+                    state.responseBuilder.appendToHistory(item);
+                }
+                return false; // Stop loop
+            }
+            // Corrective turn: for adapters whose structured output rides a tool
+            // emulation, take another turn offering only the structured_output tool
+            // and demand it be called. Bounded by maxTurns.
+            if (this.adapter.supportsStructuredOutputRetry &&
+                state.currentTurn < state.maxTurns) {
+                log.warn(`[operate] Model returned text despite format on turn ${state.currentTurn}; retrying with structured_output tool only`);
+                for (const item of this.adapter.responseToHistoryItems(parsed.raw)) {
+                    state.currentInput.push(item);
+                    state.responseBuilder.appendToHistory(item);
+                }
+                const corrective = {
+                    content: "You must provide your final answer by calling the structured_output tool " +
+                        "with arguments matching the required schema. Do not respond with text.",
+                    role: exports.LlmMessageRole.User,
+                    type: exports.LlmMessageType.Message,
+                };
+                state.currentInput.push(corrective);
+                state.responseBuilder.appendToHistory(corrective);
+                state.structuredOutputRetry = true;
+                return true; // Continue to corrective turn
+            }
+        }
         // No tool calls or no toolkit - we're done
         state.responseBuilder.setContent(this.applyFormatArrayDefaults(parsed.content, options));
         state.responseBuilder.complete();
@@ -7762,7 +8730,7 @@ class StreamLoop {
      * Yields stream chunks as they become available.
      */
     async *execute(input, options = {}) {
-        const log = getLogger$6();
+        const log = getLogger$7();
         // Verify adapter supports streaming
         if (!this.adapter.executeStreamRequest) {
             throw new errors.BadGatewayError(`Provider ${this.adapter.name} does not support streaming`);
@@ -7890,7 +8858,7 @@ class StreamLoop {
         };
     }
     async *executeOneStreamingTurn(request, state, context, options) {
-        const log = getLogger$6();
+        const log = getLogger$7();
         // Build provider-specific request
         const providerRequest = this.adapter.buildRequest(request);
         // Execute beforeEachModelRequest hook
@@ -8047,7 +9015,7 @@ class StreamLoop {
         return { shouldContinue: false };
     }
     async *processToolCalls(toolCalls, state, context) {
-        const log = getLogger$6();
+        const log = getLogger$7();
         for (const toolCall of toolCalls) {
             state.toolCallNames.push(toolCall.name);
             // Resolved once per call; never throws (undefined when tool has no message)
@@ -8330,10 +9298,10 @@ class AnthropicClient {
 }
 
 // Logger
-const getLogger$5 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const getLogger$6 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient$5({ apiKey, } = {}) {
-    const logger = getLogger$5();
+async function initializeClient$6({ apiKey, } = {}) {
+    const logger = getLogger$6();
     const resolvedApiKey = apiKey || (await aws.getEnvSecret("ANTHROPIC_API_KEY"));
     if (!resolvedApiKey) {
         throw new errors.ConfigurationError("The application could not resolve the required API key: ANTHROPIC_API_KEY");
@@ -8343,12 +9311,12 @@ async function initializeClient$5({ apiKey, } = {}) {
     return client;
 }
 // Message formatting functions
-function formatSystemMessage$2(systemPrompt, { data, placeholders } = {}) {
+function formatSystemMessage$3(systemPrompt, { data, placeholders } = {}) {
     return placeholders?.system === false
         ? systemPrompt
         : kit.placeholders(systemPrompt, data);
 }
-function formatUserMessage$3(message, { data, placeholders } = {}) {
+function formatUserMessage$4(message, { data, placeholders } = {}) {
     const content = placeholders?.message === false
         ? message
         : kit.placeholders(message, data);
@@ -8357,11 +9325,11 @@ function formatUserMessage$3(message, { data, placeholders } = {}) {
         content,
     };
 }
-function prepareMessages$3(message, { data, placeholders } = {}) {
-    const logger = getLogger$5();
+function prepareMessages$4(message, { data, placeholders } = {}) {
+    const logger = getLogger$6();
     const messages = [];
     // Add user message (necessary for all requests)
-    const userMessage = formatUserMessage$3(message, { data, placeholders });
+    const userMessage = formatUserMessage$4(message, { data, placeholders });
     messages.push(userMessage);
     logger.trace(`User message: ${userMessage.content.length} characters`);
     return messages;
@@ -8443,7 +9411,7 @@ async function createStructuredCompletion$1(client, messages, model, responseSch
 // Main class implementation
 class AnthropicProvider {
     constructor(model = PROVIDER.ANTHROPIC.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$5();
+        this.log = getLogger$6();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -8452,7 +9420,7 @@ class AnthropicProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient$5({ apiKey: this.apiKey });
+        this._client = await initializeClient$6({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -8480,12 +9448,12 @@ class AnthropicProvider {
     // Main send method
     async send(message, options) {
         const client = await this.getClient();
-        const messages = prepareMessages$3(message, options || {});
+        const messages = prepareMessages$4(message, options || {});
         const modelToUse = options?.model || this.model;
         // Process system message if provided
         let systemMessage;
         if (options?.system) {
-            systemMessage = formatSystemMessage$2(options.system, {
+            systemMessage = formatSystemMessage$3(options.system, {
                 data: options.data,
                 placeholders: options.placeholders,
             });
@@ -8539,9 +9507,9 @@ async function loadSdk() {
         throw new errors.ConfigurationError("@aws-sdk/client-bedrock-runtime is required but not installed. Run: npm install @aws-sdk/client-bedrock-runtime");
     }
 }
-const getLogger$4 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
-async function initializeClient$4({ region, } = {}) {
-    const logger = getLogger$4();
+const getLogger$5 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+async function initializeClient$5({ region, } = {}) {
+    const logger = getLogger$5();
     const resolvedRegion = region || process.env.AWS_REGION || "us-east-1";
     const sdk = await loadSdk();
     const client = new sdk.BedrockRuntimeClient({ region: resolvedRegion });
@@ -8551,7 +9519,7 @@ async function initializeClient$4({ region, } = {}) {
 
 class BedrockProvider {
     constructor(model = PROVIDER.BEDROCK.DEFAULT, { region } = {}) {
-        this.log = getLogger$4();
+        this.log = getLogger$5();
         this.conversationHistory = [];
         this.model = model;
         this.region = region;
@@ -8559,7 +9527,7 @@ class BedrockProvider {
     async getClient() {
         if (this._client)
             return this._client;
-        this._client = await initializeClient$4({ region: this.region });
+        this._client = await initializeClient$5({ region: this.region });
         return this._client;
     }
     async getOperateLoop() {
@@ -8608,6 +9576,278 @@ class BedrockProvider {
     }
 }
 
+/**
+ * HTTP error carrying the upstream status and parsed API message. The
+ * FireworksAdapter classifies errors by reading `.status` / `.statusCode` and
+ * `.message` / `.error.message`.
+ */
+class FireworksHttpError extends Error {
+    constructor(status, message, error) {
+        super(message);
+        this.name = "FireworksHttpError";
+        this.status = status;
+        this.statusCode = status;
+        this.error = error;
+    }
+}
+//
+//
+// Helpers
+//
+/**
+ * Normalize the snake_case wire response into the camelCase shape the adapter
+ * readers expect. Only protocol fields are touched — user content (schema
+ * property names, tool argument JSON) is left untouched.
+ */
+function normalizeResponse$1(json) {
+    const choices = json.choices;
+    if (Array.isArray(choices)) {
+        for (const choice of choices) {
+            if (choice.finish_reason !== undefined &&
+                choice.finishReason === undefined) {
+                choice.finishReason = choice.finish_reason;
+            }
+            const message = choice.message;
+            if (message?.tool_calls !== undefined &&
+                message.toolCalls === undefined) {
+                message.toolCalls = message.tool_calls;
+            }
+        }
+    }
+    const usage = json.usage;
+    if (usage) {
+        if (usage.promptTokens === undefined)
+            usage.promptTokens = usage.prompt_tokens;
+        if (usage.completionTokens === undefined) {
+            usage.completionTokens = usage.completion_tokens;
+        }
+        if (usage.totalTokens === undefined)
+            usage.totalTokens = usage.total_tokens;
+        const details = usage.completion_tokens_details;
+        if (details?.reasoning_tokens !== undefined &&
+            !usage.completionTokensDetails) {
+            usage.completionTokensDetails = {
+                reasoningTokens: details.reasoning_tokens,
+            };
+        }
+    }
+    return json;
+}
+//
+//
+// Main
+//
+/**
+ * Minimal `fetch`-based client for Fireworks AI's OpenAI-compatible Chat
+ * Completions endpoint. The adapter only needs a single POST (streaming and
+ * non-streaming), header auth, and HTTP error surfacing.
+ */
+class FireworksClient {
+    constructor({ apiKey, baseURL = PROVIDER.FIREWORKS.BASE_URL, }) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+    }
+    headers() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+        };
+    }
+    async toError(response) {
+        let message = `Fireworks request failed with status ${response.status}`;
+        let error;
+        try {
+            const body = (await response.json());
+            if (body?.error?.message) {
+                message = body.error.message;
+                error = body.error;
+            }
+        }
+        catch {
+            // Non-JSON error body; keep the status-based message.
+        }
+        return new FireworksHttpError(response.status, message, error);
+    }
+    async chatCompletion(body, { signal } = {}) {
+        const response = await fetch(`${this.baseURL}/chat/completions`, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!response.ok)
+            throw await this.toError(response);
+        const json = (await response.json());
+        return normalizeResponse$1(json);
+    }
+    async *streamChatCompletion(body, { signal } = {}) {
+        const response = await fetch(`${this.baseURL}/chat/completions`, {
+            method: "POST",
+            headers: { ...this.headers(), Accept: "text/event-stream" },
+            // OpenAI-style streams only include usage when explicitly requested.
+            body: JSON.stringify({
+                ...body,
+                stream: true,
+                stream_options: { include_usage: true },
+            }),
+            signal,
+        });
+        if (!response.ok)
+            throw await this.toError(response);
+        if (!response.body)
+            return;
+        yield* parseSseStream(response.body);
+    }
+}
+
+// Logger
+const getLogger$4 = () => log$1.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient$4({ apiKey, } = {}) {
+    const logger = getLogger$4();
+    const resolvedApiKey = apiKey || (await aws.getEnvSecret(PROVIDER.FIREWORKS.API_KEY));
+    if (!resolvedApiKey) {
+        throw new errors.ConfigurationError("The application could not resolve the requested keys");
+    }
+    const client = new FireworksClient({ apiKey: resolvedApiKey });
+    logger.trace("Initialized Fireworks client");
+    return client;
+}
+// Get default model from environment or constants
+function getDefaultModel$1() {
+    return process.env.FIREWORKS_MODEL || PROVIDER.FIREWORKS.DEFAULT;
+}
+function formatSystemMessage$2(systemPrompt, { data, placeholders } = {}) {
+    const content = placeholders?.system === false
+        ? systemPrompt
+        : kit.placeholders(systemPrompt, data);
+    return {
+        role: "system",
+        content,
+    };
+}
+function formatUserMessage$3(message, { data, placeholders } = {}) {
+    const content = placeholders?.message === false
+        ? message
+        : kit.placeholders(message, data);
+    return {
+        role: "user",
+        content,
+    };
+}
+function prepareMessages$3(message, { system, data, placeholders } = {}) {
+    const logger = getLogger$4();
+    const messages = [];
+    if (system) {
+        const systemMessage = formatSystemMessage$2(system, { data, placeholders });
+        messages.push(systemMessage);
+        logger.trace(`System message: ${systemMessage.content?.length} characters`);
+    }
+    const userMessage = formatUserMessage$3(message, { data, placeholders });
+    messages.push(userMessage);
+    logger.trace(`User message: ${userMessage.content?.length} characters`);
+    return messages;
+}
+
+class FireworksProvider {
+    constructor(model = getDefaultModel$1(), { apiKey } = {}) {
+        this.log = getLogger$4();
+        this.conversationHistory = [];
+        this.model = model;
+        this.apiKey = apiKey;
+    }
+    async getClient() {
+        if (this._client) {
+            return this._client;
+        }
+        this._client = await initializeClient$4({ apiKey: this.apiKey });
+        return this._client;
+    }
+    async getOperateLoop() {
+        if (this._operateLoop) {
+            return this._operateLoop;
+        }
+        const client = await this.getClient();
+        this._operateLoop = createOperateLoop({
+            adapter: fireworksAdapter,
+            client,
+        });
+        return this._operateLoop;
+    }
+    async getStreamLoop() {
+        if (this._streamLoop) {
+            return this._streamLoop;
+        }
+        const client = await this.getClient();
+        this._streamLoop = createStreamLoop({
+            adapter: fireworksAdapter,
+            client,
+        });
+        return this._streamLoop;
+    }
+    async send(message, options) {
+        const client = await this.getClient();
+        const messages = prepareMessages$3(message, options);
+        const modelToUse = options?.model || this.model;
+        // OpenAI-compatible Chat Completions body; messages are already wire-shaped.
+        const response = await client.chatCompletion({
+            model: modelToUse,
+            messages,
+        });
+        const choices = response.choices;
+        const rawContent = choices?.[0]?.message?.content;
+        // Extract text content - content could be string or array of content items
+        const content = typeof rawContent === "string"
+            ? rawContent
+            : Array.isArray(rawContent)
+                ? rawContent
+                    .filter((item) => item.type === "text")
+                    .map((item) => item.text)
+                    .join("")
+                : "";
+        this.log.trace(`Assistant reply: ${content?.length || 0} characters`);
+        // If structured output was requested, try to parse the response
+        if (options?.response && content) {
+            try {
+                return JSON.parse(content);
+            }
+            catch {
+                return content || "";
+            }
+        }
+        return content || "";
+    }
+    async operate(input, options = {}) {
+        const operateLoop = await this.getOperateLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute operate loop
+        const response = await operateLoop.execute(input, mergedOptions);
+        // Update conversation history with the new history from the response
+        if (response.history && response.history.length > 0) {
+            this.conversationHistory = response.history;
+        }
+        return response;
+    }
+    async *stream(input, options = {}) {
+        const streamLoop = await this.getStreamLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute stream loop
+        yield* streamLoop.execute(input, mergedOptions);
+    }
+}
+
 //
 //
 // Constants
@@ -9521,6 +10761,10 @@ class Llm {
                 });
             case PROVIDER.BEDROCK.NAME:
                 return new BedrockProvider(model || PROVIDER.BEDROCK.DEFAULT);
+            case PROVIDER.FIREWORKS.NAME:
+                return new FireworksProvider(model || PROVIDER.FIREWORKS.DEFAULT, {
+                    apiKey,
+                });
             case PROVIDER.GOOGLE.NAME:
                 return new GoogleProvider(model || PROVIDER.GOOGLE.DEFAULT, {
                     apiKey,
@@ -9816,7 +11060,7 @@ const roll = {
     },
     type: "function",
     call: ({ number = 1, sides = 6 } = {}) => {
-        const log = getLogger$6();
+        const log = getLogger$7();
         const rng = random$1();
         const rolls = [];
         let total = 0;
@@ -10015,6 +11259,7 @@ const toolkit = new JaypieToolkit(tools);
 });
 
 exports.BedrockProvider = BedrockProvider;
+exports.FireworksProvider = FireworksProvider;
 exports.GeminiProvider = GoogleProvider;
 exports.GoogleProvider = GoogleProvider;
 exports.JaypieToolkit = JaypieToolkit;