call-ai 0.4.1 → 0.6.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/api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Core API implementation for call-ai
+ */
+import { CallAIOptions, Message } from "./types";
+/**
+ * Make an AI API call with the given options
+ * @param prompt User prompt as string or an array of message objects
+ * @param options Configuration options including optional schema for structured output
+ * @returns A Promise that resolves to the complete response string when streaming is disabled,
+ *          or an AsyncGenerator that yields partial responses when streaming is enabled
+ */
+export declare function callAI(prompt: string | Message[], options?: CallAIOptions): Promise<string> | AsyncGenerator<string, string, unknown>;

package/dist/api.js

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAI = callAI;
+const strategies_1 = require("./strategies");
+/**
+ * Make an AI API call with the given options
+ * @param prompt User prompt as string or an array of message objects
+ * @param options Configuration options including optional schema for structured output
+ * @returns A Promise that resolves to the complete response string when streaming is disabled,
+ *          or an AsyncGenerator that yields partial responses when streaming is enabled
+ */
+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);
+    // 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) {
+        return handleApiError(error, "Streaming buffer error");
+    }
+}
+/**
+ * Standardized API error handler
+ */
+function handleApiError(error, context) {
+    console.error(`[callAI:${context}]:`, error);
+    return JSON.stringify({
+        error: String(error),
+        message: `Sorry, I couldn't process that request: ${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 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 = (0, strategies_1.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,
+    };
+    // Support for multimodal content (like images)
+    if (options.modalities && options.modalities.length > 0) {
+        requestParams.modalities = options.modalities;
+    }
+    // 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(requestParams),
+    };
+    return { apiKey, model, endpoint, requestOptions, schemaStrategy };
+}
+/**
+ * Internal implementation for non-streaming API calls
+ */
+async function callAINonStreaming(prompt, options = {}) {
+    try {
+        const { endpoint, requestOptions, model, schemaStrategy } = prepareRequestParams(prompt, options);
+        const response = await fetch(endpoint, requestOptions);
+        let result;
+        // For Claude, use text() instead of json() to avoid potential hanging
+        if (/claude/i.test(model)) {
+            try {
+                result = await extractClaudeResponse(response);
+            }
+            catch (error) {
+                return handleApiError(error, "Claude API response processing failed");
+            }
+        }
+        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",
+            });
+        }
+        // Extract content from the response
+        const content = extractContent(result, schemaStrategy);
+        // Process the content based on model type
+        return schemaStrategy.processResponse(content);
+    }
+    catch (error) {
+        return handleApiError(error, "Non-streaming API call");
+    }
+}
+/**
+ * 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;
+                }
+            }
+        }
+    }
+    // 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 || "";
+    }
+    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) {
+        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) {
+        console.error(`Failed to parse Claude response as JSON:`, err);
+        throw new Error(`Failed to parse Claude response as JSON: ${err}`);
+    }
+}
+/**
+ * Internal implementation for streaming API calls
+ */
+async function* callAIStreaming(prompt, options = {}) {
+    try {
+        const { endpoint, requestOptions, model, schemaStrategy } = prepareRequestParams(prompt, { ...options, stream: true });
+        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 completeText = "";
+        let chunkCount = 0;
+        let toolCallsAssembled = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            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: ")) {
+                    // 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()) {
+                            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(`[callAIStreaming] Error parsing JSON chunk:`, e);
+                    }
+                }
+            }
+        }
+        // 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) {
+        return handleApiError(error, "Streaming API call");
+    }
+}

package/dist/index.d.ts

@@ -1,55 +1,7 @@
 /**
  * call-ai: A lightweight library for making AI API calls
  */
-export type Message = {
-    role: 'user' | 'system' | 'assistant';
-    content: string;
-};
-export interface Schema {
-    /**
-     * Optional schema name - will be sent to OpenRouter if provided
-     * If not specified, defaults to "result"
-     */
-    name?: string;
-    /**
-     * Properties defining the structure of your schema
-     */
-    properties: Record<string, any>;
-    /**
-     * Fields that are required in the response (defaults to all properties)
-     */
-    required?: string[];
-    /**
-     * Whether to allow fields not defined in properties (defaults to false)
-     */
-    additionalProperties?: boolean;
-    /**
-     * Any additional schema properties to pass through
-     */
-    [key: string]: any;
-}
-export interface CallAIOptions {
-    apiKey?: string;
-    model?: string;
-    endpoint?: string;
-    stream?: boolean;
-    schema?: Schema | null;
-    [key: string]: any;
-}
-export interface AIResponse {
-    text: string;
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-    model: string;
-}
-/**
- * Make an AI API call with the given options
- * @param prompt User prompt as string or an array of message objects
- * @param options Configuration options including optional schema for structured output
- * @returns A Promise that resolves to the complete response string when streaming is disabled,
- *          or an AsyncGenerator that yields partial responses when streaming is enabled
- */
-export declare function callAI(prompt: string | Message[], options?: CallAIOptions): Promise<string> | AsyncGenerator<string, string, unknown>;
+export * from "./types";
+export { callAI } from "./api";
+export * from "./strategies";
+export * from "./utils";

package/dist/index.js

@@ -2,131 +2,27 @@
 /**
  * call-ai: A lightweight library for making AI API calls
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callAI = callAI;
-/**
- * Make an AI API call with the given options
- * @param prompt User prompt as string or an array of message objects
- * @param options Configuration options including optional schema for structured output
- * @returns A Promise that resolves to the complete response string when streaming is disabled,
- *          or an AsyncGenerator that yields partial responses when streaming is enabled
- */
-function callAI(prompt, options = {}) {
-    // Handle non-streaming mode (default)
-    if (options.stream !== true) {
-        return callAINonStreaming(prompt, options);
-    }
-    // Handle streaming mode
-    return callAIStreaming(prompt, options);
-}
-/**
- * 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');
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    // Handle both string prompts and message arrays for backward compatibility
-    const messages = Array.isArray(prompt)
-        ? prompt
-        : [{ role: 'user', content: prompt }];
-    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: {
-                        // Always include name, with default "result" if not provided in schema
-                        name: schema.name || "result",
-                        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)))
-                    }
-                }
-            })
-        })
-    };
-    return { apiKey, model, endpoint, requestOptions };
-}
-/**
- * Internal implementation for non-streaming API calls
- */
-async function callAINonStreaming(prompt, options = {}) {
-    try {
-        const { endpoint, requestOptions } = prepareRequestParams(prompt, options);
-        const response = await fetch(endpoint, requestOptions);
-        const result = await response.json();
-        const content = result.choices[0]?.message?.content || '';
-        return content;
-    }
-    catch (error) {
-        console.error("AI call failed:", error);
-        return JSON.stringify({
-            error,
-            message: "Sorry, I couldn't process that request."
-        });
-    }
-}
-/**
- * Internal implementation for streaming API calls
- */
-async function* callAIStreaming(prompt, options = {}) {
-    try {
-        const { endpoint, requestOptions } = prepareRequestParams(prompt, { ...options, stream: true });
-        const response = await fetch(endpoint, requestOptions);
-        // Handle streaming response
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let text = '';
-        while (true) {
-            const { done, value } = await reader.read();
-            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]'))
-                        continue;
-                    try {
-                        const json = JSON.parse(line.replace('data: ', ''));
-                        const content = json.choices[0]?.delta?.content || '';
-                        text += content;
-                        yield text;
-                    }
-                    catch (e) {
-                        console.error("Error parsing chunk:", e);
-                    }
-                }
-            }
-        }
-        return text;
-    }
-    catch (error) {
-        console.error("AI call failed:", error);
-        return JSON.stringify({
-            error,
-            message: "Sorry, I couldn't process that request."
-        });
-    }
-}
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAI = void 0;
+// Export public types
+__exportStar(require("./types"), exports);
+// Export API function
+var api_1 = require("./api");
+Object.defineProperty(exports, "callAI", { enumerable: true, get: function () { return api_1.callAI; } });
+// Export strategies and utilities for advanced use cases
+__exportStar(require("./strategies"), exports);
+__exportStar(require("./utils"), exports);

package/dist/strategies/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Strategy exports
+ */
+export * from "./model-strategies";
+export * from "./strategy-selector";

package/dist/strategies/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Strategy exports
+ */
+__exportStar(require("./model-strategies"), exports);
+__exportStar(require("./strategy-selector"), exports);

package/dist/strategies/model-strategies.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Model strategies for different AI models
+ */
+import { ModelStrategy } from "../types";
+/**
+ * OpenAI/GPT strategy for handling JSON schema
+ */
+export declare const openAIStrategy: ModelStrategy;
+/**
+ * Gemini strategy for handling JSON schema (similar to OpenAI)
+ */
+export declare const geminiStrategy: ModelStrategy;
+/**
+ * Claude strategy using tool mode for structured output
+ */
+export declare const claudeStrategy: ModelStrategy;
+/**
+ * System message approach for other models (Llama, DeepSeek, etc.)
+ */
+export declare const systemMessageStrategy: ModelStrategy;
+/**
+ * Default strategy for models without schema
+ */
+export declare const defaultStrategy: ModelStrategy;

package/dist/strategies/model-strategies.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultStrategy = exports.systemMessageStrategy = exports.claudeStrategy = exports.geminiStrategy = exports.openAIStrategy = void 0;
+const utils_1 = require("../utils");
+/**
+ * OpenAI/GPT strategy for handling JSON schema
+ */
+exports.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 = (0, utils_1.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)
+ */
+exports.geminiStrategy = {
+    name: "gemini",
+    prepareRequest: exports.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
+ */
+exports.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.)
+ */
+exports.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
+ */
+exports.defaultStrategy = {
+    name: "default",
+    prepareRequest: () => ({}),
+    processResponse: (content) => typeof content === "string" ? content : JSON.stringify(content),
+};

package/dist/strategies/strategy-selector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Strategy selection logic for different AI models
+ */
+import { Schema, SchemaStrategy } from "../types";
+/**
+ * Choose the appropriate schema strategy based on model and schema
+ */
+export declare function chooseSchemaStrategy(model: string | undefined, schema: Schema | null): SchemaStrategy;

package/dist/strategies/strategy-selector.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseSchemaStrategy = chooseSchemaStrategy;
+const model_strategies_1 = require("./model-strategies");
+/**
+ * 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: model_strategies_1.defaultStrategy.prepareRequest,
+            processResponse: model_strategies_1.defaultStrategy.processResponse,
+            shouldForceStream: false,
+        };
+    }
+    // Check for Claude models
+    if (/claude/i.test(resolvedModel)) {
+        return {
+            strategy: "tool_mode",
+            model: resolvedModel,
+            prepareRequest: model_strategies_1.claudeStrategy.prepareRequest,
+            processResponse: model_strategies_1.claudeStrategy.processResponse,
+            shouldForceStream: !!model_strategies_1.claudeStrategy.shouldForceStream,
+        };
+    }
+    // Check for Gemini models
+    if (/gemini/i.test(resolvedModel)) {
+        return {
+            strategy: "json_schema",
+            model: resolvedModel,
+            prepareRequest: model_strategies_1.geminiStrategy.prepareRequest,
+            processResponse: model_strategies_1.geminiStrategy.processResponse,
+            shouldForceStream: !!model_strategies_1.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: model_strategies_1.systemMessageStrategy.prepareRequest,
+            processResponse: model_strategies_1.systemMessageStrategy.processResponse,
+            shouldForceStream: !!model_strategies_1.systemMessageStrategy.shouldForceStream,
+        };
+    }
+    // Check for OpenAI models
+    if (/openai|gpt/i.test(resolvedModel)) {
+        return {
+            strategy: "json_schema",
+            model: resolvedModel,
+            prepareRequest: model_strategies_1.openAIStrategy.prepareRequest,
+            processResponse: model_strategies_1.openAIStrategy.processResponse,
+            shouldForceStream: !!model_strategies_1.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: model_strategies_1.systemMessageStrategy.prepareRequest,
+            processResponse: model_strategies_1.systemMessageStrategy.processResponse,
+            shouldForceStream: !!model_strategies_1.systemMessageStrategy.shouldForceStream,
+        };
+    }
+    // Default to system message approach for unknown models with schema
+    return {
+        strategy: "system_message",
+        model: resolvedModel,
+        prepareRequest: model_strategies_1.systemMessageStrategy.prepareRequest,
+        processResponse: model_strategies_1.systemMessageStrategy.processResponse,
+        shouldForceStream: !!model_strategies_1.systemMessageStrategy.shouldForceStream,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Type definitions for call-ai
+ */
+/**
+ * Content types for multimodal messages
+ */
+export type ContentItem = {
+    type: "text" | "image_url";
+    text?: string;
+    image_url?: {
+        url: string;
+    };
+};
+/**
+ * Message type supporting both simple string content and multimodal content
+ */
+export type Message = {
+    role: "user" | "system" | "assistant";
+    content: string | ContentItem[];
+};
+export interface Schema {
+    /**
+     * Optional schema name - will be sent to OpenRouter if provided
+     * If not specified, defaults to "result"
+     */
+    name?: string;
+    /**
+     * Properties defining the structure of your schema
+     */
+    properties: Record<string, any>;
+    /**
+     * Fields that are required in the response (defaults to all properties)
+     */
+    required?: string[];
+    /**
+     * Whether to allow fields not defined in properties (defaults to false)
+     */
+    additionalProperties?: boolean;
+    /**
+     * Any additional schema properties to pass through
+     */
+    [key: string]: any;
+}
+/**
+ * Strategy interface for handling different model types
+ */
+export interface ModelStrategy {
+    name: string;
+    prepareRequest: (schema: Schema | null, messages: Message[]) => any;
+    processResponse: (content: string | any) => string;
+    shouldForceStream?: boolean;
+}
+/**
+ * Schema strategies for different model types
+ */
+export type SchemaStrategyType = "json_schema" | "tool_mode" | "system_message" | "none";
+/**
+ * Strategy selection result
+ */
+export interface SchemaStrategy {
+    strategy: SchemaStrategyType;
+    model: string;
+    prepareRequest: ModelStrategy["prepareRequest"];
+    processResponse: ModelStrategy["processResponse"];
+    shouldForceStream: boolean;
+}
+export interface CallAIOptions {
+    /**
+     * API key for authentication
+     */
+    apiKey?: string;
+    /**
+     * Model ID to use for the request
+     */
+    model?: string;
+    /**
+     * API endpoint to send the request to
+     */
+    endpoint?: string;
+    /**
+     * Whether to stream the response
+     */
+    stream?: boolean;
+    /**
+     * Schema for structured output
+     */
+    schema?: Schema | null;
+    /**
+     * Modalities to enable in the response (e.g., ["image", "text"])
+     * Used for multimodal models that can generate images
+     */
+    modalities?: string[];
+    /**
+     * Any additional options to pass to the API
+     */
+    [key: string]: any;
+}
+export interface AIResponse {
+    text: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    model: string;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for call-ai
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Utility functions for call-ai
+ */
+/**
+ * Recursively adds additionalProperties: false to all object types in a schema
+ * This is needed for OpenAI's strict schema validation in streaming mode
+ */
+export declare function recursivelyAddAdditionalProperties(schema: any): any;

package/dist/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Utility functions for call-ai
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recursivelyAddAdditionalProperties = recursivelyAddAdditionalProperties;
+/**
+ * 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.4.1",
+  "version": "0.6.0",
   "description": "Lightweight library for making AI API calls with streaming support",
   "main": "dist/index.js",
   "browser": "dist/index.js",
@@ -16,12 +16,6 @@
   "bugs": {
     "url": "https://github.com/fireproof-storage/call-ai/issues"
   },
-  "scripts": {
-    "build": "tsc",
-    "test": "jest",
-    "prepublishOnly": "npm run build",
-    "typecheck": "tsc --noEmit"
-  },
   "keywords": [
     "ai",
     "llm",
@@ -36,11 +30,23 @@
   "devDependencies": {
     "@types/jest": "^29.5.3",
     "@types/node": "^20.4.2",
+    "@types/node-fetch": "^2.6.12",
+    "dotenv": "^16.4.7",
     "jest": "^29.6.1",
+    "node-fetch": "^3.3.2",
+    "prettier": "^3.5.3",
     "ts-jest": "^29.1.1",
     "typescript": "^5.1.6"
   },
   "engines": {
     "node": ">=14.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:integration": "jest --testMatch=\"**/test/integration.test.ts\" --testPathIgnorePatterns=''",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "coverage": "jest --coverage"
   }
-}
+}