call-ai 0.3.1 → 0.5.0

package/README.md

@@ -109,15 +109,45 @@ for await (const chunk of generator) {
 
 ## Supported LLM Providers
 
-By default, call-ai uses the OpenRouter API which provides access to multiple LLM models. You can also configure it to use other providers with OpenAI-compatible APIs:
+Call-AI supports all models available through OpenRouter, including:
 
-- [OpenRouter](https://openrouter.ai/) (default)
-- [OpenAI](https://openai.com/)
-- [Anthropic Claude](https://www.anthropic.com/) (via OpenRouter)
-- [Mistral](https://mistral.ai/) (via OpenRouter)
-- Any API with OpenAI-compatible endpoints
+- OpenAI models (GPT-4, GPT-3.5, etc.)
+- Anthropic Claude
+- Gemini
+- Llama 3
+- Mistral
+- And many more
 
-See [llms.txt](./llms.txt) for a full list of compatible models.
+## Choosing a model
+
+Different LLMs have different strengths when working with structured data. Based on our testing, here's a guide to help you choose the right model for your schema needs:
+
+### Schema Complexity Guide
+
+| Model Family | Grade | Simple Flat Schema | Complex Flat Schema | Nested Schema | Best For |
+|--------------|-------|-------------------|---------------------|---------------|----------|
+| OpenAI       | A     | ✅ Excellent      | ✅ Excellent        | ✅ Excellent  | Most reliable for all schema types |
+| Gemini       | A     | ✅ Excellent      | ✅ Excellent        | ✅ Good       | Good all-around performance, especially with flat schemas |
+| Claude       | B     | ✅ Excellent      | ⚠️ Good (occasional JSON errors) | ✅ Good | Simple schemas, robust handling of complex prompts |
+| Llama 3      | C     | ✅ Good           | ✅ Good             | ❌ Poor       | Simpler flat schemas, may struggle with nested structures |
+| Deepseek     | C     | ✅ Good           | ✅ Good             | ❌ Poor       | Basic flat schemas only |
+
+### Schema Structure Recommendations
+
+1. **Flat schemas perform better across all models**. If you need maximum compatibility, avoid deeply nested structures.
+
+2. **Field names matter**. Some models have preferences for certain property naming patterns:
+   - Use simple, common naming patterns like `name`, `type`, `items`, `price` 
+   - Avoid deeply nested object hierarchies (more than 2 levels deep)
+   - Keep array items simple (strings or flat objects)
+
+3. **Model-specific considerations**:
+   - **OpenAI models**: Best overall schema adherence and handle complex nesting well
+   - **Claude models**: Great for simple schemas, occasional JSON formatting issues with complex structures
+   - **Gemini models**: Good general performance, handles array properties well
+   - **Llama/Mistral/Deepseek**: Strong with flat schemas, but often ignore nesting structure and provide their own organization
+
+4. **For mission-critical applications** requiring schema adherence, use OpenAI models or implement fallback mechanisms.
 
 ## Setting API Keys
 
@@ -201,6 +231,15 @@ MIT or Apache-2.0, at your option
 5. Run type checking: `npm run typecheck`
 6. Create a pull request
 
+### Integration Tests
+
+The project includes integration tests that make real API calls to verify functionality with actual LLM models:
+
+1. Copy `.env.example` to `.env` and add your OpenRouter API key
+2. Run integration tests: `npm run test:integration`
+
+Note: Integration tests are excluded from the normal test suite to avoid making API calls during CI/CD. They require a valid API key to execute and will be skipped if no key is provided.
+
 ### Release Process
 
 This library uses GitHub Actions to automate the release process:

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export type Message = {
 export interface Schema {
     /**
      * Optional schema name - will be sent to OpenRouter if provided
+     * If not specified, defaults to "result"
      */
     name?: string;
     /**

package/dist/index.js

@@ -4,6 +4,253 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callAI = callAI;
+/**
+ * OpenAI/GPT strategy for handling JSON schema
+ */
+const openAIStrategy = {
+    name: 'openai',
+    prepareRequest: (schema, messages) => {
+        if (!schema)
+            return {};
+        // Process schema for JSON schema approach
+        const requiredFields = schema.required || Object.keys(schema.properties || {});
+        const processedSchema = recursivelyAddAdditionalProperties({
+            type: 'object',
+            properties: schema.properties || {},
+            required: requiredFields,
+            additionalProperties: schema.additionalProperties !== undefined
+                ? schema.additionalProperties
+                : false,
+            // Copy any additional schema properties
+            ...Object.fromEntries(Object.entries(schema).filter(([key]) => !['name', 'properties', 'required', 'additionalProperties'].includes(key)))
+        });
+        return {
+            response_format: {
+                type: 'json_schema',
+                json_schema: {
+                    name: schema.name || "result",
+                    strict: true,
+                    schema: processedSchema
+                }
+            }
+        };
+    },
+    processResponse: (content) => {
+        if (typeof content !== 'string') {
+            return JSON.stringify(content);
+        }
+        return content;
+    }
+};
+/**
+ * Gemini strategy for handling JSON schema (similar to OpenAI)
+ */
+const geminiStrategy = {
+    name: 'gemini',
+    prepareRequest: openAIStrategy.prepareRequest,
+    processResponse: (content) => {
+        if (typeof content !== 'string') {
+            return JSON.stringify(content);
+        }
+        // Try to extract JSON from content if it might be wrapped
+        const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) ||
+            content.match(/```\s*([\s\S]*?)\s*```/) ||
+            content.match(/\{[\s\S]*\}/) ||
+            [null, content];
+        return jsonMatch[1] || content;
+    }
+};
+/**
+ * Claude strategy using tool mode for structured output
+ */
+const claudeStrategy = {
+    name: 'anthropic',
+    shouldForceStream: true,
+    prepareRequest: (schema, messages) => {
+        if (!schema)
+            return {};
+        // Process schema for tool use - format for OpenRouter/Claude
+        const processedSchema = {
+            type: 'object',
+            properties: schema.properties || {},
+            required: schema.required || Object.keys(schema.properties || {}),
+            additionalProperties: schema.additionalProperties !== undefined
+                ? schema.additionalProperties
+                : false,
+        };
+        return {
+            tools: [{
+                    type: 'function',
+                    function: {
+                        name: schema.name || 'generate_structured_data',
+                        description: 'Generate data according to the required schema',
+                        parameters: processedSchema
+                    }
+                }],
+            tool_choice: {
+                type: 'function',
+                function: {
+                    name: schema.name || 'generate_structured_data'
+                }
+            }
+        };
+    },
+    processResponse: (content) => {
+        // Handle tool use response
+        if (typeof content === 'object') {
+            if (content.type === 'tool_use') {
+                return JSON.stringify(content.input);
+            }
+            // Handle newer tool_calls format
+            if (content.tool_calls && Array.isArray(content.tool_calls) && content.tool_calls.length > 0) {
+                const toolCall = content.tool_calls[0];
+                if (toolCall.function && toolCall.function.arguments) {
+                    try {
+                        // Try to parse as JSON first
+                        return toolCall.function.arguments;
+                    }
+                    catch (e) {
+                        // Return as is if not valid JSON
+                        return JSON.stringify(toolCall.function.arguments);
+                    }
+                }
+            }
+            return JSON.stringify(content);
+        }
+        if (typeof content !== 'string') {
+            return JSON.stringify(content);
+        }
+        // Try to extract JSON from content if it might be wrapped
+        const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) ||
+            content.match(/```\s*([\s\S]*?)\s*```/) ||
+            content.match(/\{[\s\S]*\}/) ||
+            [null, content];
+        return jsonMatch[1] || content;
+    }
+};
+/**
+ * System message approach for other models (Llama, DeepSeek, etc.)
+ */
+const systemMessageStrategy = {
+    name: 'system_message',
+    prepareRequest: (schema, messages) => {
+        if (!schema)
+            return { messages };
+        // Check if there's already a system message
+        const hasSystemMessage = messages.some(m => m.role === 'system');
+        if (!hasSystemMessage) {
+            // Build a schema description
+            const schemaProperties = Object.entries(schema.properties || {})
+                .map(([key, value]) => {
+                const type = value.type || 'string';
+                const description = value.description ? ` // ${value.description}` : '';
+                return `  "${key}": ${type}${description}`;
+            })
+                .join(',\n');
+            const systemMessage = {
+                role: 'system',
+                content: `Please return your response as JSON following this schema exactly:\n{\n${schemaProperties}\n}\nDo not include any explanation or text outside of the JSON object.`
+            };
+            // Return modified messages array with system message prepended
+            return { messages: [systemMessage, ...messages] };
+        }
+        return { messages };
+    },
+    processResponse: (content) => {
+        if (typeof content !== 'string') {
+            return JSON.stringify(content);
+        }
+        // Try to extract JSON from content if it might be wrapped
+        const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) ||
+            content.match(/```\s*([\s\S]*?)\s*```/) ||
+            content.match(/\{[\s\S]*\}/) ||
+            [null, content];
+        return jsonMatch[1] || content;
+    }
+};
+/**
+ * Default strategy for models without schema
+ */
+const defaultStrategy = {
+    name: 'default',
+    prepareRequest: () => ({}),
+    processResponse: (content) => typeof content === 'string' ? content : JSON.stringify(content)
+};
+/**
+ * Choose the appropriate schema strategy based on model and schema
+ */
+function chooseSchemaStrategy(model, schema) {
+    // Default model if not provided
+    const resolvedModel = model || (schema ? 'openai/gpt-4o' : 'openrouter/auto');
+    // No schema case - use default strategy
+    if (!schema) {
+        return {
+            strategy: 'none',
+            model: resolvedModel,
+            prepareRequest: defaultStrategy.prepareRequest,
+            processResponse: defaultStrategy.processResponse,
+            shouldForceStream: false
+        };
+    }
+    // Check for Claude models
+    if (/claude/i.test(resolvedModel)) {
+        return {
+            strategy: 'tool_mode',
+            model: resolvedModel,
+            prepareRequest: claudeStrategy.prepareRequest,
+            processResponse: claudeStrategy.processResponse,
+            shouldForceStream: !!claudeStrategy.shouldForceStream
+        };
+    }
+    // Check for Gemini models
+    if (/gemini/i.test(resolvedModel)) {
+        return {
+            strategy: 'json_schema',
+            model: resolvedModel,
+            prepareRequest: geminiStrategy.prepareRequest,
+            processResponse: geminiStrategy.processResponse,
+            shouldForceStream: !!geminiStrategy.shouldForceStream
+        };
+    }
+    // Check for GPT-4 Turbo models - use system message approach
+    if (/gpt-4-turbo/i.test(resolvedModel)) {
+        return {
+            strategy: 'system_message',
+            model: resolvedModel,
+            prepareRequest: systemMessageStrategy.prepareRequest,
+            processResponse: systemMessageStrategy.processResponse,
+            shouldForceStream: !!systemMessageStrategy.shouldForceStream
+        };
+    }
+    // Check for OpenAI models
+    if (/openai|gpt/i.test(resolvedModel)) {
+        return {
+            strategy: 'json_schema',
+            model: resolvedModel,
+            prepareRequest: openAIStrategy.prepareRequest,
+            processResponse: openAIStrategy.processResponse,
+            shouldForceStream: !!openAIStrategy.shouldForceStream
+        };
+    }
+    // Check for other specific models that need system message approach
+    if (/llama-3|deepseek/i.test(resolvedModel)) {
+        return {
+            strategy: 'system_message',
+            model: resolvedModel,
+            prepareRequest: systemMessageStrategy.prepareRequest,
+            processResponse: systemMessageStrategy.processResponse,
+            shouldForceStream: !!systemMessageStrategy.shouldForceStream
+        };
+    }
+    // Default to system message approach for unknown models with schema
+    return {
+        strategy: 'system_message',
+        model: resolvedModel,
+        prepareRequest: systemMessageStrategy.prepareRequest,
+        processResponse: systemMessageStrategy.processResponse,
+        shouldForceStream: !!systemMessageStrategy.shouldForceStream
+    };
+}
 /**
  * Make an AI API call with the given options
  * @param prompt User prompt as string or an array of message objects
@@ -12,59 +259,98 @@ exports.callAI = callAI;
  *          or an AsyncGenerator that yields partial responses when streaming is enabled
  */
 function callAI(prompt, options = {}) {
-    // Handle non-streaming mode (default)
+    // Check if we need to force streaming based on model strategy
+    const schemaStrategy = chooseSchemaStrategy(options.model, options.schema || null);
+    // Handle special case: Claude with tools requires streaming
+    if (!options.stream && schemaStrategy.shouldForceStream) {
+        // Buffer streaming results into a single response
+        return bufferStreamingResults(prompt, options);
+    }
+    // Handle normal non-streaming mode
     if (options.stream !== true) {
         return callAINonStreaming(prompt, options);
     }
     // Handle streaming mode
     return callAIStreaming(prompt, options);
 }
+/**
+ * Buffer streaming results into a single response for cases where
+ * we need to use streaming internally but the caller requested non-streaming
+ */
+async function bufferStreamingResults(prompt, options) {
+    // Create a copy of options with streaming enabled
+    const streamingOptions = {
+        ...options,
+        stream: true
+    };
+    try {
+        // Get streaming generator
+        const generator = callAIStreaming(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++;
+        }
+        return finalResult;
+    }
+    catch (error) {
+        console.error("[bufferStreamingResults] Streaming buffer error:", error);
+        return JSON.stringify({
+            error: String(error),
+            message: "Error while processing streaming response: " + String(error)
+        });
+    }
+}
 /**
  * Prepare request parameters common to both streaming and non-streaming calls
  */
 function prepareRequestParams(prompt, options) {
     const apiKey = options.apiKey || (typeof window !== 'undefined' ? window.CALLAI_API_KEY : null);
-    const model = options.model || 'openrouter/auto';
-    const endpoint = options.endpoint || 'https://openrouter.ai/api/v1/chat/completions';
     const schema = options.schema || null;
     if (!apiKey) {
         throw new Error('API key is required. Provide it via options.apiKey or set window.CALLAI_API_KEY');
     }
+    // Select the appropriate strategy based on model and schema
+    const schemaStrategy = chooseSchemaStrategy(options.model, schema);
+    const model = schemaStrategy.model;
+    const endpoint = options.endpoint || '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
+    const requestParams = {
+        model: model,
+        stream: options.stream === true,
+        messages: messages,
+    };
+    // 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 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;
+        }
+    });
     const requestOptions = {
         method: 'POST',
         headers: {
             'Authorization': `Bearer ${apiKey}`,
             'Content-Type': 'application/json'
         },
-        body: JSON.stringify({
-            model: model,
-            stream: options.stream === true,
-            messages: messages,
-            // Pass through any additional options like temperature, but exclude internal keys
-            ...Object.fromEntries(Object.entries(options).filter(([key]) => !['apiKey', 'model', 'endpoint', 'stream', 'schema'].includes(key))),
-            // Handle schema if provided
-            ...(schema && {
-                response_format: {
-                    type: 'json_schema',
-                    json_schema: {
-                        // Include name if provided
-                        ...(schema.name && { name: schema.name }),
-                        type: 'object',
-                        properties: schema.properties || {},
-                        required: schema.required || Object.keys(schema.properties || {}),
-                        additionalProperties: schema.additionalProperties !== undefined
-                            ? schema.additionalProperties
-                            : false,
-                        // Copy any additional schema properties (excluding properties we've already handled)
-                        ...Object.fromEntries(Object.entries(schema).filter(([key]) => !['name', 'properties', 'required', 'additionalProperties'].includes(key)))
-                    }
-                }
-            })
-        })
+        body: JSON.stringify(requestParams)
     };
     return { apiKey, model, endpoint, requestOptions };
 }
@@ -73,15 +359,95 @@ function prepareRequestParams(prompt, options) {
  */
 async function callAINonStreaming(prompt, options = {}) {
     try {
-        const { endpoint, requestOptions } = prepareRequestParams(prompt, options);
+        const { endpoint, requestOptions, model } = prepareRequestParams(prompt, options);
+        const schemaStrategy = chooseSchemaStrategy(model, options.schema || null);
         const response = await fetch(endpoint, requestOptions);
-        const result = await response.json();
-        const content = result.choices[0]?.message?.content || '';
-        return content;
+        let result;
+        // For Claude, use text() instead of json() to avoid potential hanging
+        if (/claude/i.test(model)) {
+            // Create a timeout wrapper for text() to prevent hanging
+            try {
+                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) {
+                    console.error(`Text extraction timed out or failed:`, textError);
+                    return JSON.stringify({
+                        error: true,
+                        message: "Claude response text extraction timed out. This is likely an issue with the Claude API's response format."
+                    });
+                }
+                try {
+                    result = JSON.parse(textResponse);
+                }
+                catch (err) {
+                    console.error(`Failed to parse Claude response as JSON:`, err);
+                    throw new Error(`Failed to parse Claude response as JSON: ${err}`);
+                }
+            }
+            catch (error) {
+                console.error(`Claude text extraction error:`, error);
+                return JSON.stringify({
+                    error: true,
+                    message: `Claude API response processing failed: ${error}`
+                });
+            }
+        }
+        else {
+            result = await response.json();
+        }
+        // Handle error responses
+        if (result.error) {
+            console.error("API returned an error:", result.error);
+            return JSON.stringify({
+                error: result.error,
+                message: result.error.message || "API returned an error"
+            });
+        }
+        // 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;
+                    }
+                }
+            }
+        }
+        // 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');
+            }
+            content = result.choices[0]?.message?.content || '';
+        }
+        // Process the content based on model type
+        return schemaStrategy.processResponse(content);
     }
     catch (error) {
         console.error("AI call failed:", error);
-        return "Sorry, I couldn't process that request.";
+        return JSON.stringify({
+            error,
+            message: "Sorry, I couldn't process that request."
+        });
     }
 }
 /**
@@ -89,38 +455,202 @@ async function callAINonStreaming(prompt, options = {}) {
  */
 async function* callAIStreaming(prompt, options = {}) {
     try {
-        const { endpoint, requestOptions } = prepareRequestParams(prompt, { ...options, stream: true });
+        const { endpoint, requestOptions, model } = prepareRequestParams(prompt, { ...options, stream: true });
+        const schemaStrategy = chooseSchemaStrategy(model, options.schema || null);
         const response = await fetch(endpoint, requestOptions);
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`API Error: ${response.status} ${response.statusText}`, errorText);
+            throw new Error(`API returned error ${response.status}: ${response.statusText}`);
+        }
         // 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 text = '';
+        let completeText = '';
+        let chunkCount = 0;
+        let toolCallsAssembled = '';
         while (true) {
             const { done, value } = await reader.read();
-            if (done)
+            if (done) {
                 break;
+            }
             const chunk = decoder.decode(value);
             const lines = chunk.split('\n').filter(line => line.trim() !== '');
             for (const line of lines) {
                 if (line.startsWith('data: ')) {
-                    if (line.includes('[DONE]'))
+                    // Skip [DONE] marker or OPENROUTER PROCESSING lines
+                    if (line.includes('[DONE]') || line.includes('OPENROUTER PROCESSING')) {
                         continue;
+                    }
                     try {
-                        const json = JSON.parse(line.replace('data: ', ''));
-                        const content = json.choices[0]?.delta?.content || '';
-                        text += content;
-                        yield text;
+                        const jsonLine = line.replace('data: ', '');
+                        if (!jsonLine.trim()) {
+                            continue;
+                        }
+                        chunkCount++;
+                        // Parse the JSON chunk
+                        const json = JSON.parse(jsonLine);
+                        // 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) {
-                        console.error("Error parsing chunk:", e);
+                        console.error(`[callAIStreaming] Error parsing JSON chunk:`, e);
                     }
                 }
             }
         }
-        return text;
+        // 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);
     }
     catch (error) {
-        console.error("AI call failed:", error);
-        return "Sorry, I couldn't process that request.";
+        console.error("[callAIStreaming] AI call failed:", error);
+        return JSON.stringify({
+            error: String(error),
+            message: "Sorry, I couldn't process that request."
+        });
+    }
+}
+/**
+ * Recursively adds additionalProperties: false to all object types in a schema
+ * This is needed for OpenAI's strict schema validation in streaming mode
+ */
+function recursivelyAddAdditionalProperties(schema) {
+    // Clone to avoid modifying the original
+    const result = { ...schema };
+    // If this is an object type, ensure it has additionalProperties: false
+    if (result.type === 'object') {
+        // Set additionalProperties if not already set
+        if (result.additionalProperties === undefined) {
+            result.additionalProperties = false;
+        }
+        // Process nested properties if they exist
+        if (result.properties) {
+            result.properties = { ...result.properties };
+            // Set required if not already set - OpenAI requires this for all nested objects
+            if (result.required === undefined) {
+                result.required = Object.keys(result.properties);
+            }
+            // Check each property
+            Object.keys(result.properties).forEach(key => {
+                const prop = result.properties[key];
+                // If property is an object or array type, recursively process it
+                if (prop && typeof prop === 'object') {
+                    result.properties[key] = recursivelyAddAdditionalProperties(prop);
+                    // For nested objects, ensure they also have all properties in their required field
+                    if (prop.type === 'object' && prop.properties) {
+                        prop.required = Object.keys(prop.properties);
+                    }
+                }
+            });
+        }
+    }
+    // Handle nested objects in arrays
+    if (result.type === 'array' && result.items && typeof result.items === 'object') {
+        result.items = recursivelyAddAdditionalProperties(result.items);
+        // If array items are objects, ensure they have all properties in required
+        if (result.items.type === 'object' && result.items.properties) {
+            result.items.required = Object.keys(result.items.properties);
+        }
     }
+    return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "call-ai",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Lightweight library for making AI API calls with streaming support",
   "main": "dist/index.js",
   "browser": "dist/index.js",
@@ -19,6 +19,7 @@
   "scripts": {
     "build": "tsc",
     "test": "jest",
+    "test:integration": "jest --testMatch=\"**/test/integration.test.ts\" --testPathIgnorePatterns=''",
     "prepublishOnly": "npm run build",
     "typecheck": "tsc --noEmit"
   },
@@ -36,6 +37,7 @@
   "devDependencies": {
     "@types/jest": "^29.5.3",
     "@types/node": "^20.4.2",
+    "dotenv": "^16.4.7",
     "jest": "^29.6.1",
     "ts-jest": "^29.1.1",
     "typescript": "^5.1.6"