call-ai 0.8.4 → 0.8.5-dev-preview

package/dist/api.js

@@ -1,7 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMeta = void 0;
 exports.callAI = callAI;
 const strategies_1 = require("./strategies");
+const response_metadata_1 = require("./response-metadata");
+Object.defineProperty(exports, "getMeta", { enumerable: true, get: function () { return response_metadata_1.getMeta; } });
+const key_management_1 = require("./key-management");
+const error_handling_1 = require("./error-handling");
+const api_core_1 = require("./api-core");
+const non_streaming_1 = require("./non-streaming");
+const streaming_1 = require("./streaming");
 // Import package version for debugging
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const PACKAGE_VERSION = require("../package.json").version;
@@ -18,6 +26,9 @@ const FALLBACK_MODEL = "openrouter/auto";
 function callAI(prompt, options = {}) {
     // Check if we need to force streaming based on model strategy
     const schemaStrategy = (0, strategies_1.chooseSchemaStrategy)(options.model, options.schema || null);
+    if (!options.max_tokens) {
+        options.max_tokens = 100000;
+    }
     // Handle special case: Claude with tools requires streaming
     if (!options.stream && schemaStrategy.shouldForceStream) {
         // Buffer streaming results into a single response
@@ -32,7 +43,9 @@ function callAI(prompt, options = {}) {
     const streamPromise = (async () => {
         // Do setup and validation before returning the generator
         const { endpoint, requestOptions, model, schemaStrategy } = prepareRequestParams(prompt, { ...options, stream: true });
-        if (options.debug) {
+        // Use either explicit debug option or global debug flag
+        const debug = options.debug || key_management_1.globalDebug;
+        if (debug) {
             console.log(`[callAI:${PACKAGE_VERSION}] Making fetch request to: ${endpoint}`);
             console.log(`[callAI:${PACKAGE_VERSION}] With model: ${model}`);
             console.log(`[callAI:${PACKAGE_VERSION}] Request headers:`, JSON.stringify(requestOptions.headers));
@@ -90,7 +103,7 @@ function callAI(prompt, options = {}) {
                 let isInvalidModel = false;
                 try {
                     // Check if this is an invalid model error
-                    const modelCheckResult = await checkForInvalidModelError(clonedResponse, model, false, options.skipRetry, options.debug);
+                    const modelCheckResult = await (0, error_handling_1.checkForInvalidModelError)(clonedResponse, model, options.debug);
                     isInvalidModel = modelCheckResult.isInvalidModel;
                     if (isInvalidModel) {
                         if (options.debug) {
@@ -208,7 +221,7 @@ function callAI(prompt, options = {}) {
         if (options.debug) {
             console.log(`[callAI:${PACKAGE_VERSION}] Response OK, creating streaming generator`);
         }
-        return createStreamingGenerator(response, options, schemaStrategy, model);
+        return (0, streaming_1.createStreamingGenerator)(response, options, schemaStrategy, model);
     })();
     // For backward compatibility with v0.6.x where users didn't await the result
     if (process.env.NODE_ENV !== "production") {
@@ -218,7 +231,7 @@ function callAI(prompt, options = {}) {
     }
     // Create a proxy object that acts both as a Promise and an AsyncGenerator for backward compatibility
     // @ts-ignore - We're deliberately implementing a proxy with dual behavior
-    return createBackwardCompatStreamingProxy(streamPromise);
+    return (0, api_core_1.createBackwardCompatStreamingProxy)(streamPromise);
 }
 /**
  * Buffer streaming results into a single response for cases where
@@ -233,157 +246,54 @@ async function bufferStreamingResults(prompt, options) {
     try {
         // Get streaming generator
         const generator = (await callAI(prompt, streamingOptions));
-        // Buffer all chunks
-        let finalResult = "";
-        let chunkCount = 0;
-        for await (const chunk of generator) {
-            finalResult = chunk; // Each chunk contains the full accumulated text
-            chunkCount++;
+        // For Claude JSON responses, take only the last chunk (the final processed result)
+        // For all other cases, concatenate chunks as before
+        const isClaudeJson = /claude/.test(options.model || "") && options.schema;
+        if (isClaudeJson) {
+            // For Claude with JSON schema, we only want the last yielded value
+            // which will be the complete, properly processed JSON
+            let lastChunk = "";
+            for await (const chunk of generator) {
+                // Replace the last chunk entirely instead of concatenating
+                lastChunk = chunk;
+            }
+            return lastChunk;
+        }
+        else {
+            // For all other cases, concatenate chunks
+            let result = "";
+            for await (const chunk of generator) {
+                result += chunk;
+            }
+            return result;
         }
-        return finalResult;
     }
     catch (error) {
-        handleApiError(error, "Streaming buffer error", options.debug);
+        // Handle errors with standard API error handling
+        await (0, error_handling_1.handleApiError)(error, "Buffered streaming", options.debug, {
+            apiKey: options.apiKey,
+            endpoint: options.endpoint,
+            skipRefresh: options.skipRefresh,
+            refreshToken: options.refreshToken,
+            updateRefreshToken: options.updateRefreshToken,
+        });
+        // If we get here, key was refreshed successfully, retry the operation with the new key
+        // Retry with the refreshed key
+        return bufferStreamingResults(prompt, {
+            ...options,
+            apiKey: key_management_1.keyStore.current || undefined, // Use the refreshed key from keyStore
+        });
     }
+    // This line should never be reached, but it satisfies the linter by ensuring
+    // all code paths return a value
+    throw new Error("Unexpected code path in bufferStreamingResults");
 }
 /**
  * Standardized API error handler
  */
-/**
- * Create a proxy that acts both as a Promise and an AsyncGenerator for backward compatibility
- * @internal This is for internal use only, not part of public API
- */
-function createBackwardCompatStreamingProxy(promise) {
-    // Create a proxy that forwards methods to the Promise or AsyncGenerator as appropriate
-    return new Proxy({}, {
-        get(target, prop) {
-            // First check if it's an AsyncGenerator method (needed for for-await)
-            if (prop === "next" ||
-                prop === "throw" ||
-                prop === "return" ||
-                prop === Symbol.asyncIterator) {
-                // Create wrapper functions that await the Promise first
-                if (prop === Symbol.asyncIterator) {
-                    return function () {
-                        return {
-                            // Implement async iterator that gets the generator first
-                            async next(value) {
-                                try {
-                                    const generator = await promise;
-                                    return generator.next(value);
-                                }
-                                catch (error) {
-                                    // Turn Promise rejection into iterator result with error thrown
-                                    return Promise.reject(error);
-                                }
-                            },
-                        };
-                    };
-                }
-                // Methods like next, throw, return
-                return async function (value) {
-                    const generator = await promise;
-                    return generator[prop](value);
-                };
-            }
-            // Then check if it's a Promise method
-            if (prop === "then" || prop === "catch" || prop === "finally") {
-                return promise[prop].bind(promise);
-            }
-            return undefined;
-        },
-    });
-}
-/**
- * Standardized API error handler
- */
-function handleApiError(error, context, debug = false) {
-    if (debug) {
-        console.error(`[callAI:${context}]:`, error);
-    }
-    throw new Error(`${context}: ${String(error)}`);
-}
-/**
- * Helper to check if an error indicates invalid model and handle fallback
- */
-async function checkForInvalidModelError(response, model, isRetry, skipRetry = false, debug = false) {
-    // Skip retry immediately if skipRetry is true or if we're already retrying
-    if (skipRetry || isRetry) {
-        return { isInvalidModel: false };
-    }
-    // We want to check all 4xx errors, not just 400
-    if (response.status < 400 || response.status >= 500) {
-        return { isInvalidModel: false };
-    }
-    // Clone the response so we can read the body
-    const clonedResponse = response.clone();
-    try {
-        const errorData = await clonedResponse.json();
-        if (debug) {
-            console.log(`[callAI:${PACKAGE_VERSION}] Checking for invalid model error:`, {
-                model,
-                statusCode: response.status,
-                errorData,
-            });
-        }
-        // Common patterns for invalid model errors across different providers
-        const invalidModelPatterns = [
-            "not a valid model",
-            "model .* does not exist",
-            "invalid model",
-            "unknown model",
-            "no provider was found",
-            "fake-model", // For our test case
-            "does-not-exist", // For our test case
-        ];
-        // Check if error message contains any of our patterns
-        let errorMessage = "";
-        if (errorData.error && errorData.error.message) {
-            errorMessage = errorData.error.message.toLowerCase();
-        }
-        else if (errorData.message) {
-            errorMessage = errorData.message.toLowerCase();
-        }
-        else {
-            errorMessage = JSON.stringify(errorData).toLowerCase();
-        }
-        // Test the error message against each pattern
-        const isInvalidModel = invalidModelPatterns.some((pattern) => errorMessage.includes(pattern.toLowerCase()));
-        if (isInvalidModel && debug) {
-            console.warn(`[callAI:${PACKAGE_VERSION}] Model ${model} not valid, will retry with ${FALLBACK_MODEL}`);
-        }
-        return { isInvalidModel, errorData };
-    }
-    catch (parseError) {
-        // If we can't parse the response as JSON, try to read it as text
-        if (debug) {
-            console.error("Failed to parse error response as JSON:", parseError);
-        }
-        try {
-            const textResponse = await response.clone().text();
-            if (debug) {
-                console.log("Error response as text:", textResponse);
-            }
-            // Even if it's not JSON, check if it contains any of our known patterns
-            const lowerText = textResponse.toLowerCase();
-            const isInvalidModel = lowerText.includes("invalid model") ||
-                lowerText.includes("not exist") ||
-                lowerText.includes("fake-model");
-            if (isInvalidModel) {
-                if (debug) {
-                    console.warn(`[callAI:${PACKAGE_VERSION}] Detected invalid model in text response for ${model}`);
-                }
-            }
-            return { isInvalidModel, errorData: { text: textResponse } };
-        }
-        catch (textError) {
-            if (debug) {
-                console.error("Failed to read error response as text:", textError);
-            }
-            return { isInvalidModel: false };
-        }
-    }
-}
+// createBackwardCompatStreamingProxy is imported from api-core.ts
+// handleApiError is imported from error-handling.ts
+// checkForInvalidModelError is imported from error-handling.ts
 /**
  * Prepare request parameters common to both streaming and non-streaming calls
  */
@@ -400,48 +310,59 @@ function prepareRequestParams(prompt, options) {
     // Get custom chat API origin if set
     const customChatOrigin = options.chatUrl ||
         (typeof window !== "undefined" ? window.CALLAI_CHAT_URL : null) ||
-        (typeof process !== "undefined" && process.env ? process.env.CALLAI_CHAT_URL : null);
+        (typeof process !== "undefined" && process.env
+            ? process.env.CALLAI_CHAT_URL
+            : null);
     // Use custom origin or default OpenRouter URL
     const endpoint = options.endpoint ||
-        (customChatOrigin ? `${customChatOrigin}/api/v1/chat/completions` : "https://openrouter.ai/api/v1/chat/completions");
+        (customChatOrigin
+            ? `${customChatOrigin}/api/v1/chat/completions`
+            : "https://openrouter.ai/api/v1/chat/completions");
     // Handle both string prompts and message arrays for backward compatibility
     const messages = Array.isArray(prompt)
         ? prompt
         : [{ role: "user", content: prompt }];
-    // Build request parameters
+    // Common parameters for both streaming and non-streaming
     const requestParams = {
-        model: model,
-        stream: options.stream === true,
-        messages: messages,
+        model,
+        messages,
+        temperature: options.temperature !== undefined ? options.temperature : 0.7,
+        top_p: options.topP !== undefined ? options.topP : 1,
+        max_tokens: options.maxTokens || 2048,
+        stream: options.stream !== undefined ? options.stream : false,
     };
-    // Support for multimodal content (like images)
-    if (options.modalities && options.modalities.length > 0) {
-        requestParams.modalities = options.modalities;
+    // Add optional parameters if specified
+    if (options.stop) {
+        // Handle both single string and array of stop sequences
+        requestParams.stop = Array.isArray(options.stop)
+            ? options.stop
+            : [options.stop];
     }
-    // Apply the strategy's request preparation
-    const strategyParams = schemaStrategy.prepareRequest(schema, messages);
-    // If the strategy returns custom messages, use those instead
-    if (strategyParams.messages) {
-        requestParams.messages = strategyParams.messages;
+    // Add response_format parameter for models that support JSON output
+    if (options.responseFormat === "json") {
+        requestParams.response_format = { type: "json_object" };
     }
-    // Add all other strategy parameters
-    Object.entries(strategyParams).forEach(([key, value]) => {
-        if (key !== "messages") {
-            requestParams[key] = value;
-        }
-    });
-    // Add any other options provided, but exclude internal keys
-    Object.entries(options).forEach(([key, value]) => {
-        if (!["apiKey", "model", "endpoint", "stream", "schema"].includes(key)) {
-            requestParams[key] = value;
-        }
-    });
+    // Add schema structure if provided (for function calling/JSON mode)
+    if (schema) {
+        // Apply schema-specific parameters using the selected strategy
+        Object.assign(requestParams, schemaStrategy.prepareRequest(schema, messages));
+    }
+    // HTTP headers for the request
+    const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "HTTP-Referer": options.referer || "https://vibes.diy",
+        "X-Title": options.title || "Vibes",
+    };
+    // Add any additional headers
+    if (options.headers) {
+        Object.assign(headers, options.headers);
+    }
+    // Build the requestOptions object for fetch
     const requestOptions = {
         method: "POST",
         headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "HTTP-Referer": "https://vibes.diy",
-            "X-Title": "Vibes",
+            ...headers,
             "Content-Type": "application/json",
         },
         body: JSON.stringify(requestParams),
@@ -459,25 +380,40 @@ function prepareRequestParams(prompt, options) {
  */
 async function callAINonStreaming(prompt, options = {}, isRetry = false) {
     try {
+        // Start timing for metadata
+        const startTime = Date.now();
+        // Create metadata object
+        const meta = {
+            model: options.model || "unknown",
+            timing: {
+                startTime: startTime,
+            },
+        };
         const { endpoint, requestOptions, model, schemaStrategy } = prepareRequestParams(prompt, options);
         const response = await fetch(endpoint, requestOptions);
+        // We don't store the raw Response object in metadata anymore
         // Handle HTTP errors, with potential fallback for invalid model
         if (!response.ok || response.status >= 400) {
-            const { isInvalidModel } = await checkForInvalidModelError(response, model, isRetry, options.skipRetry, options.debug);
+            const { isInvalidModel } = await (0, error_handling_1.checkForInvalidModelError)(response, model, options.debug);
             if (isInvalidModel) {
                 // Retry with fallback model
                 return callAINonStreaming(prompt, { ...options, model: FALLBACK_MODEL }, true);
             }
-            throw new Error(`HTTP error! Status: ${response.status}`);
+            // Create a proper error object with the status code preserved
+            const error = new Error(`HTTP error! Status: ${response.status}`);
+            // Add status code as a property of the error object
+            error.status = response.status;
+            error.statusCode = response.status; // Add statusCode for compatibility with different error patterns
+            throw error;
         }
         let result;
         // For Claude, use text() instead of json() to avoid potential hanging
         if (/claude/i.test(model)) {
             try {
-                result = await extractClaudeResponse(response);
+                result = await (0, non_streaming_1.extractClaudeResponse)(response);
             }
             catch (error) {
-                handleApiError(error, "Claude API response processing failed", options.debug);
+                (0, error_handling_1.handleApiError)(error, "Claude API response processing failed", options.debug);
             }
         }
         else {
@@ -508,309 +444,41 @@ async function callAINonStreaming(prompt, options = {}, isRetry = false) {
             });
         }
         // Extract content from the response
-        const content = extractContent(result, schemaStrategy);
-        // Process the content based on model type
-        return schemaStrategy.processResponse(content);
-    }
-    catch (error) {
-        handleApiError(error, "Non-streaming API call", options.debug);
-    }
-}
-/**
- * Extract content from API response accounting for different formats
- */
-function extractContent(result, schemaStrategy) {
-    // Find tool use content or normal content
-    let content;
-    // Extract tool use content if necessary
-    if (schemaStrategy.strategy === "tool_mode" &&
-        result.stop_reason === "tool_use") {
-        // Try to find tool_use block in different response formats
-        if (result.content && Array.isArray(result.content)) {
-            const toolUseBlock = result.content.find((block) => block.type === "tool_use");
-            if (toolUseBlock) {
-                content = toolUseBlock;
-            }
-        }
-        if (!content && result.choices && Array.isArray(result.choices)) {
-            const choice = result.choices[0];
-            if (choice.message && Array.isArray(choice.message.content)) {
-                const toolUseBlock = choice.message.content.find((block) => block.type === "tool_use");
-                if (toolUseBlock) {
-                    content = toolUseBlock;
-                }
-            }
+        const content = (0, non_streaming_1.extractContent)(result, schemaStrategy);
+        // Store the raw response data for user access
+        if (result) {
+            // Store the parsed JSON result from the API call
+            meta.rawResponse = result;
         }
-    }
-    // If no tool use content was found, use the standard message content
-    if (!content) {
-        if (!result.choices || !result.choices.length) {
-            throw new Error("Invalid response format from API");
+        // Update model info
+        meta.model = model;
+        // Update timing info
+        if (meta.timing) {
+            meta.timing.endTime = Date.now();
+            meta.timing.duration = meta.timing.endTime - meta.timing.startTime;
         }
-        content = result.choices[0]?.message?.content || "";
-    }
-    return content;
-}
-/**
- * Extract response from Claude API with timeout handling
- */
-async function extractClaudeResponse(response) {
-    let textResponse;
-    const textPromise = response.text();
-    const timeoutPromise = new Promise((_resolve, reject) => {
-        setTimeout(() => {
-            reject(new Error("Text extraction timed out after 5 seconds"));
-        }, 5000);
-    });
-    try {
-        textResponse = (await Promise.race([
-            textPromise,
-            timeoutPromise,
-        ]));
-    }
-    catch (textError) {
-        // Always log timeout errors
-        console.error(`Text extraction timed out or failed:`, textError);
-        throw new Error("Claude response text extraction timed out. This is likely an issue with the Claude API's response format.");
-    }
-    try {
-        return JSON.parse(textResponse);
-    }
-    catch (err) {
-        // Always log JSON parsing errors
-        console.error(`Failed to parse Claude response as JSON:`, err);
-        throw new Error(`Failed to parse Claude response as JSON: ${err}`);
-    }
-}
-/**
- * Generator factory function for streaming API calls
- * This is called after the fetch is made and response is validated
- *
- * Note: Even though we checked response.ok before creating this generator,
- * we need to be prepared for errors that may occur during streaming. Some APIs
- * return a 200 OK initially but then deliver error information in the stream.
- */
-async function* createStreamingGenerator(response, options, schemaStrategy, model) {
-    if (options.debug) {
-        console.log(`[callAI:${PACKAGE_VERSION}] Starting streaming generator with model: ${model}`);
-        console.log(`[callAI:${PACKAGE_VERSION}] Response status:`, response.status);
-        console.log(`[callAI:${PACKAGE_VERSION}] Response type:`, response.type);
-        console.log(`[callAI:${PACKAGE_VERSION}] Response Content-Type:`, response.headers.get("content-type"));
-    }
-    try {
-        // Handle streaming response
-        if (!response.body) {
-            throw new Error("Response body is undefined - API endpoint may not support streaming");
-        }
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let completeText = "";
-        let chunkCount = 0;
-        let toolCallsAssembled = "";
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                if (options.debug) {
-                    console.log(`[callAI:${PACKAGE_VERSION}] Stream done=true after ${chunkCount} chunks`);
-                    console.log(`[callAI-streaming:complete v${PACKAGE_VERSION}] Stream finished after ${chunkCount} chunks`);
-                }
-                break;
-            }
-            // Increment chunk counter before processing
-            chunkCount++;
-            const chunk = decoder.decode(value);
-            if (options.debug) {
-                console.log(`[callAI:${PACKAGE_VERSION}] Raw chunk #${chunkCount} (${chunk.length} bytes):`, chunk.length > 200 ? chunk.substring(0, 200) + "..." : chunk);
-            }
-            const lines = chunk.split("\n").filter((line) => line.trim() !== "");
-            if (options.debug) {
-                console.log(`[callAI:${PACKAGE_VERSION}] Chunk #${chunkCount} contains ${lines.length} non-empty lines`);
-            }
-            for (const line of lines) {
-                if (options.debug) {
-                    console.log(`[callAI:${PACKAGE_VERSION}] Processing line:`, line.length > 100 ? line.substring(0, 100) + "..." : line);
-                }
-                if (line.startsWith("data: ")) {
-                    let data = line.slice(6);
-                    if (data === "[DONE]") {
-                        if (options.debug) {
-                            console.log(`[callAI:${PACKAGE_VERSION}] Received [DONE] marker`);
-                        }
-                        break;
-                    }
-                    if (options.debug) {
-                        console.log(`[callAI:raw] ${line}`);
-                    }
-                    // Skip [DONE] marker or OPENROUTER PROCESSING lines
-                    if (line.includes("[DONE]") ||
-                        line.includes("OPENROUTER PROCESSING")) {
-                        continue;
-                    }
-                    try {
-                        const jsonLine = line.replace("data: ", "");
-                        if (!jsonLine.trim()) {
-                            if (options.debug) {
-                                console.log(`[callAI:${PACKAGE_VERSION}] Empty JSON line after data: prefix`);
-                            }
-                            continue;
-                        }
-                        if (options.debug) {
-                            console.log(`[callAI:${PACKAGE_VERSION}] JSON line (first 100 chars):`, jsonLine.length > 100
-                                ? jsonLine.substring(0, 100) + "..."
-                                : jsonLine);
-                        }
-                        // Parse the JSON chunk
-                        let json;
-                        try {
-                            json = JSON.parse(jsonLine);
-                            if (options.debug) {
-                                console.log(`[callAI:${PACKAGE_VERSION}] Parsed JSON:`, JSON.stringify(json).substring(0, 1000));
-                            }
-                        }
-                        catch (parseError) {
-                            if (options.debug) {
-                                console.error(`[callAI:${PACKAGE_VERSION}] JSON parse error:`, parseError);
-                            }
-                            continue;
-                        }
-                        // Enhanced error detection - check for BOTH error and json.error
-                        // Some APIs return 200 OK but then deliver errors in the stream
-                        if (json.error || (typeof json === "object" && "error" in json)) {
-                            if (options.debug) {
-                                console.error(`[callAI:${PACKAGE_VERSION}] Detected error in streaming response:`, json);
-                            }
-                            // Create a detailed error object similar to our HTTP error handling
-                            const errorMessage = json.error?.message ||
-                                json.error?.toString() ||
-                                JSON.stringify(json.error || json);
-                            const detailedError = new Error(`API streaming error: ${errorMessage}`);
-                            // Add error metadata
-                            detailedError.status = json.error?.status || 400;
-                            detailedError.statusText =
-                                json.error?.type || "Bad Request";
-                            detailedError.details = JSON.stringify(json.error || json);
-                            console.error(`[callAI:${PACKAGE_VERSION}] Throwing stream error:`, detailedError);
-                            throw detailedError;
-                        }
-                        // Handle tool use response - Claude with schema cases
-                        const isClaudeWithSchema = /claude/i.test(model) && schemaStrategy.strategy === "tool_mode";
-                        if (isClaudeWithSchema) {
-                            // Claude streaming tool calls - need to assemble arguments
-                            if (json.choices && json.choices.length > 0) {
-                                const choice = json.choices[0];
-                                // Handle finish reason tool_calls
-                                if (choice.finish_reason === "tool_calls") {
-                                    try {
-                                        // Parse the assembled JSON
-                                        completeText = toolCallsAssembled;
-                                        yield completeText;
-                                        continue;
-                                    }
-                                    catch (e) {
-                                        console.error("[callAIStreaming] Error parsing assembled tool call:", e);
-                                    }
-                                }
-                                // Assemble tool_calls arguments from delta
-                                if (choice.delta && choice.delta.tool_calls) {
-                                    const toolCall = choice.delta.tool_calls[0];
-                                    if (toolCall &&
-                                        toolCall.function &&
-                                        toolCall.function.arguments !== undefined) {
-                                        toolCallsAssembled += toolCall.function.arguments;
-                                        // We don't yield here to avoid partial JSON
-                                    }
-                                }
-                            }
-                        }
-                        // Handle tool use response - old format
-                        if (isClaudeWithSchema &&
-                            (json.stop_reason === "tool_use" || json.type === "tool_use")) {
-                            // First try direct tool use object format
-                            if (json.type === "tool_use") {
-                                completeText = schemaStrategy.processResponse(json);
-                                yield completeText;
-                                continue;
-                            }
-                            // Extract the tool use content
-                            if (json.content && Array.isArray(json.content)) {
-                                const toolUseBlock = json.content.find((block) => block.type === "tool_use");
-                                if (toolUseBlock) {
-                                    completeText = schemaStrategy.processResponse(toolUseBlock);
-                                    yield completeText;
-                                    continue;
-                                }
-                            }
-                            // Find tool_use in assistant's content blocks
-                            if (json.choices && Array.isArray(json.choices)) {
-                                const choice = json.choices[0];
-                                if (choice.message && Array.isArray(choice.message.content)) {
-                                    const toolUseBlock = choice.message.content.find((block) => block.type === "tool_use");
-                                    if (toolUseBlock) {
-                                        completeText = schemaStrategy.processResponse(toolUseBlock);
-                                        yield completeText;
-                                        continue;
-                                    }
-                                }
-                                // Handle case where the tool use is in the delta
-                                if (choice.delta && Array.isArray(choice.delta.content)) {
-                                    const toolUseBlock = choice.delta.content.find((block) => block.type === "tool_use");
-                                    if (toolUseBlock) {
-                                        completeText = schemaStrategy.processResponse(toolUseBlock);
-                                        yield completeText;
-                                        continue;
-                                    }
-                                }
-                            }
-                        }
-                        // Extract content from the delta
-                        if (json.choices?.[0]?.delta?.content !== undefined) {
-                            const content = json.choices[0].delta.content || "";
-                            // Treat all models the same - yield as content arrives
-                            completeText += content;
-                            yield schemaStrategy.processResponse(completeText);
-                        }
-                        // Handle message content format (non-streaming deltas)
-                        else if (json.choices?.[0]?.message?.content !== undefined) {
-                            const content = json.choices[0].message.content || "";
-                            completeText += content;
-                            yield schemaStrategy.processResponse(completeText);
-                        }
-                        // Handle content blocks for Claude/Anthropic response format
-                        else if (json.choices?.[0]?.message?.content &&
-                            Array.isArray(json.choices[0].message.content)) {
-                            const contentBlocks = json.choices[0].message.content;
-                            // Find text or tool_use blocks
-                            for (const block of contentBlocks) {
-                                if (block.type === "text") {
-                                    completeText += block.text || "";
-                                }
-                                else if (isClaudeWithSchema && block.type === "tool_use") {
-                                    completeText = schemaStrategy.processResponse(block);
-                                    break; // We found what we need
-                                }
-                            }
-                            yield schemaStrategy.processResponse(completeText);
-                        }
-                    }
-                    catch (e) {
-                        if (options.debug) {
-                            console.error(`[callAIStreaming] Error parsing JSON chunk:`, e);
-                        }
-                    }
-                }
-            }
-        }
-        // We no longer need special error handling here as errors are thrown immediately
-        // No extra error handling needed here - errors are thrown immediately
-        // If we have assembled tool calls but haven't yielded them yet
-        if (toolCallsAssembled && (!completeText || completeText.length === 0)) {
-            return toolCallsAssembled;
-        }
-        // Ensure the final return has proper, processed content
-        return schemaStrategy.processResponse(completeText);
+        // Process the content based on model type
+        const processedContent = schemaStrategy.processResponse(content);
+        // Box the string for WeakMap storage
+        const boxed = (0, response_metadata_1.boxString)(processedContent);
+        response_metadata_1.responseMetadata.set(boxed, meta);
+        return processedContent;
     }
     catch (error) {
-        // Standardize error handling
-        handleApiError(error, "Streaming API call", options.debug);
+        await (0, error_handling_1.handleApiError)(error, "Non-streaming API call", options.debug, {
+            apiKey: options.apiKey,
+            endpoint: options.endpoint,
+            skipRefresh: options.skipRefresh,
+            refreshToken: options.refreshToken,
+            updateRefreshToken: options.updateRefreshToken,
+        });
+        // If we get here, key was refreshed successfully, retry the operation with the new key
+        // Retry with the refreshed key
+        return callAINonStreaming(prompt, {
+            ...options,
+            apiKey: key_management_1.keyStore.current || undefined, // Use the refreshed key from keyStore
+        }, true); // Set isRetry to true
     }
+    // This line will never be reached, but it satisfies the linter
+    throw new Error("Unexpected code path in callAINonStreaming");
 }