call-ai 0.1.5 → 0.2.0

package/README.md

@@ -17,13 +17,24 @@ pnpm add call-ai
 ```typescript
 import { callAI } from 'call-ai';
 
-// Basic usage with string prompt
-const response = callAI('Explain quantum computing in simple terms', null, {
+// Basic usage with string prompt (non-streaming by default)
+const response = await callAI('Explain quantum computing in simple terms', {
   apiKey: 'your-api-key',
   model: 'gpt-4'
 });
 
-for await (const chunk of response) {
+// The response is the complete text
+console.log(response);
+
+// With streaming enabled (returns an AsyncGenerator)
+const generator = callAI('Tell me a story', {
+  apiKey: 'your-api-key',
+  model: 'gpt-4',
+  stream: true
+});
+
+// Process streaming updates
+for await (const chunk of generator) {
   console.log(chunk); // Streaming updates as they arrive
 }
 
@@ -33,20 +44,12 @@ const messages = [
   { role: 'user', content: 'Explain quantum computing in simple terms' }
 ];
 
-const response = callAI(messages, null, {
+const response = await callAI(messages, {
   apiKey: 'your-api-key',
   model: 'gpt-4'
 });
 
-// Non-streaming mode
-// With stream: false, the function returns the full string directly (not a generator)
-const result = await callAI('Write a short poem', null, {
-  apiKey: 'your-api-key',
-  model: 'gpt-4',
-  stream: false
-});
-
-console.log(result);
+console.log(response);
 
 // Using schema for structured output
 const schema = {
@@ -58,9 +61,9 @@ const schema = {
   required: ['title', 'summary']
 };
 
-const response = await callAI('Summarize the benefits of exercise', schema, {
+const response = await callAI('Summarize the benefits of exercise', {
   apiKey: 'your-api-key',
-  stream: false
+  schema: schema
 });
 
 const structuredOutput = JSON.parse(response);
@@ -69,7 +72,7 @@ console.log(structuredOutput.title);
 
 ## Features
 
-- 🔄 Streaming responses via AsyncGenerator
+- 🔄 Streaming responses via AsyncGenerator when `stream: true`
 - 🧩 Structured JSON outputs with schema validation
 - 🔌 Compatible with OpenRouter and OpenAI API formats
 - 📝 Support for message arrays with system, user, and assistant roles
@@ -94,13 +97,13 @@ You can provide your API key in three ways:
 
 1. Directly in the options:
 ```typescript
-const response = callAI('Hello', null, { apiKey: 'your-api-key' });
+const response = await callAI('Hello', { apiKey: 'your-api-key' });
 ```
 
 2. Set globally in the browser:
 ```typescript
 window.CALLAI_API_KEY = 'your-api-key';
-const response = callAI('Hello');
+const response = await callAI('Hello');
 ```
 
 3. Use environment variables in Node.js (with a custom implementation):
@@ -108,18 +111,17 @@ const response = callAI('Hello');
 // Example of environment variable integration
 import { callAI } from 'call-ai';
 const apiKey = process.env.OPENAI_API_KEY || process.env.OPENROUTER_API_KEY;
-const response = callAI('Hello', null, { apiKey });
+const response = await callAI('Hello', { apiKey });
 ```
 
 ## API
 
 ```typescript
 // Main function
-async function* callAI(
+function callAI(
   prompt: string | Message[],
-  schema: Schema | null = null,
-  options: Record<string, any> = {}
-): AsyncGenerator<string, string, unknown>
+  options?: CallAIOptions
+): Promise<string> | AsyncGenerator<string, string, unknown>
 
 // Types
 type Message = {
@@ -133,6 +135,15 @@ interface Schema {
   required?: string[];
   additionalProperties?: boolean;
 }
+
+interface CallAIOptions {
+  apiKey?: string;
+  model?: string;
+  endpoint?: string;
+  stream?: boolean;
+  schema?: Schema | null;
+  [key: string]: any;
+}
 ```
 
 ### Options
@@ -140,7 +151,8 @@ interface Schema {
 * `apiKey`: Your API key (can also be set via window.CALLAI_API_KEY)
 * `model`: Model identifier (default: 'openrouter/auto')
 * `endpoint`: API endpoint (default: 'https://openrouter.ai/api/v1/chat/completions')
-* `stream`: Enable streaming responses (default: true)
+* `stream`: Enable streaming responses (default: false)
+* `schema`: Optional JSON schema for structured output
 * Any other options are passed directly to the API (temperature, max_tokens, etc.)
 
 ## License

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export interface CallAIOptions {
     model?: string;
     endpoint?: string;
     stream?: boolean;
+    schema?: Schema | null;
     [key: string]: any;
 }
 export interface AIResponse {
@@ -27,13 +28,11 @@ export interface AIResponse {
     };
     model: string;
 }
-/**
- * Helper function for making OpenAI-compatible AI calls
- */
 /**
  * Make an AI API call with the given options
  * @param prompt User prompt as string or an array of message objects
- * @param schema Optional JSON schema for structured output
- * @param options Configuration options
+ * @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[], schema?: Schema | null, options?: Record<string, any>): AsyncGenerator<string, string, unknown>;
+export declare function callAI(prompt: string | Message[], options?: CallAIOptions): Promise<string> | AsyncGenerator<string, string, unknown>;

package/dist/index.js

@@ -4,66 +4,93 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callAI = callAI;
-/**
- * Helper function for making OpenAI-compatible AI calls
- */
 /**
  * Make an AI API call with the given options
  * @param prompt User prompt as string or an array of message objects
- * @param schema Optional JSON schema for structured output
- * @param options Configuration options
+ * @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
  */
-async function* callAI(prompt, schema = null, options = {}) {
-    try {
-        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';
-        if (!apiKey) {
-            throw new Error('API key is required. Provide it via options.apiKey or set window.CALLAI_API_KEY');
-        }
-        // 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 !== false, // Default to streaming
-                messages: messages,
-                // For schema requests, add provider requirement to ensure JSON schema support
-                ...(schema && { provider: { require_parameters: true } }),
-                // Pass through any additional options like temperature, but exclude internal keys
-                ...Object.fromEntries(Object.entries(options).filter(([key]) => !['apiKey', 'model', 'endpoint'].includes(key))),
-                // Handle schema if provided
-                ...(schema && { response_format: {
-                        type: 'json_schema',
-                        json_schema: {
-                            name: schema.name || 'response',
-                            strict: true,
-                            schema: {
-                                type: 'object',
-                                properties: schema.properties || {},
-                                required: schema.required || Object.keys(schema.properties || {}),
-                                additionalProperties: schema.additionalProperties !== undefined
-                                    ? schema.additionalProperties
-                                    : false
-                            }
+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');
+    }
+    // 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,
+            // For schema requests, add provider requirement to ensure JSON schema support
+            ...(schema && { provider: { require_parameters: true } }),
+            // 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: {
+                        name: schema.name || 'response',
+                        strict: true,
+                        schema: {
+                            type: 'object',
+                            properties: schema.properties || {},
+                            required: schema.required || Object.keys(schema.properties || {}),
+                            additionalProperties: schema.additionalProperties !== undefined
+                                ? schema.additionalProperties
+                                : false
                         }
-                    } })
-            })
-        };
+                    }
+                } })
+        })
+    };
+    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 "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);
-        // For non-streaming responses, return the full result
-        if (options.stream === false) {
-            const result = await response.json();
-            const content = result.choices[0]?.message?.content || '';
-            return content;
-        }
         // Handle streaming response
         const reader = response.body.getReader();
         const decoder = new TextDecoder();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "call-ai",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "Lightweight library for making AI API calls with streaming support",
   "main": "dist/index.js",
   "browser": "dist/index.js",