@discomedia/utils 1.0.25 → 1.0.26

package/dist/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.0.25",
+  "version": "1.0.26",
   "author": "Disco Media",
   "description": "Utility functions used in Disco Media apps",
   "always-build-npm": true,
@@ -33,7 +33,7 @@
   },
   "dependencies": {
     "dotenv": "^17.2.1",
-    "openai": "^5.12.1",
+    "openai": "^5.12.2",
     "p-limit": "^6.2.0",
     "tslib": "^2.8.1",
     "ws": "^8.18.3"

package/dist/test.js

@@ -1019,8 +1019,28 @@ function dateTimeForGS(date) {
         .replace(/\./g, '/');
 }
 
+/**
+ * Type guard to check if a model is an OpenRouter model
+ */
+function isOpenRouterModel(model) {
+    const openRouterModels = [
+        'openai/gpt-5',
+        'openai/gpt-5-mini',
+        'openai/gpt-5-nano',
+        'openai/gpt-oss-120b',
+        'z.ai/glm-4.5',
+        'z.ai/glm-4.5-air',
+        'google/gemini-2.5-flash',
+        'google/gemini-2.5-flash-lite',
+        'deepseek/deepseek-r1-0528',
+        'deepseek/deepseek-chat-v3-0324',
+    ];
+    return openRouterModels.includes(model);
+}
+
 var Types = /*#__PURE__*/Object.freeze({
-    __proto__: null
+    __proto__: null,
+    isOpenRouterModel: isOpenRouterModel
 });
 
 // Utility function for debug logging
@@ -1112,29 +1132,31 @@ function hideApiKeyFromurl(url) {
  * @returns Structured error details.
  */
 function extractErrorDetails(error, response) {
-    if (error.name === 'TypeError' && error.message.includes('fetch')) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    const errName = error instanceof Error ? error.name : 'Error';
+    if (errName === 'TypeError' && errMsg.includes('fetch')) {
         return { type: 'NETWORK_ERROR', reason: 'Network connectivity issue', status: null };
     }
-    if (error.message.includes('HTTP error: 429')) {
-        const match = error.message.match(/RATE_LIMIT: 429:(\d+)/);
+    if (errMsg.includes('HTTP error: 429')) {
+        const match = errMsg.match(/RATE_LIMIT: 429:(\d+)/);
         const retryAfter = match ? parseInt(match[1]) : undefined;
         return { type: 'RATE_LIMIT', reason: 'Rate limit exceeded', status: 429, retryAfter };
     }
-    if (error.message.includes('HTTP error: 401') || error.message.includes('AUTH_ERROR: 401')) {
+    if (errMsg.includes('HTTP error: 401') || errMsg.includes('AUTH_ERROR: 401')) {
         return { type: 'AUTH_ERROR', reason: 'Authentication failed - invalid API key', status: 401 };
     }
-    if (error.message.includes('HTTP error: 403') || error.message.includes('AUTH_ERROR: 403')) {
+    if (errMsg.includes('HTTP error: 403') || errMsg.includes('AUTH_ERROR: 403')) {
         return { type: 'AUTH_ERROR', reason: 'Access forbidden - insufficient permissions', status: 403 };
     }
-    if (error.message.includes('SERVER_ERROR:')) {
-        const status = parseInt(error.message.split('SERVER_ERROR: ')[1]) || 500;
+    if (errMsg.includes('SERVER_ERROR:')) {
+        const status = parseInt(errMsg.split('SERVER_ERROR: ')[1]) || 500;
         return { type: 'SERVER_ERROR', reason: `Server error (${status})`, status };
     }
-    if (error.message.includes('CLIENT_ERROR:')) {
-        const status = parseInt(error.message.split('CLIENT_ERROR: ')[1]) || 400;
+    if (errMsg.includes('CLIENT_ERROR:')) {
+        const status = parseInt(errMsg.split('CLIENT_ERROR: ')[1]) || 400;
         return { type: 'CLIENT_ERROR', reason: `Client error (${status})`, status };
     }
-    return { type: 'UNKNOWN', reason: error.message || 'Unknown error', status: null };
+    return { type: 'UNKNOWN', reason: errMsg || 'Unknown error', status: null };
 }
 /**
  * Fetches a resource with intelligent retry logic for handling transient errors.
@@ -2368,7 +2390,7 @@ const safeJSON = (text) => {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const VERSION = '5.12.1'; // x-release-please-version
+const VERSION = '5.12.2'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const isRunningInBrowser = () => {
@@ -9163,7 +9185,8 @@ function fixBrokenJson(jsonStr) {
         return parse();
     }
     catch (error) {
-        console.error(`Error parsing JSON at position ${index}: ${error.message}`);
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Error parsing JSON at position ${index}: ${msg}`);
         return null;
     }
 }
@@ -9707,7 +9730,13 @@ async function makeImagesCall(prompt, options = {}) {
         const enhancedResponse = {
             ...response,
             usage: {
-                ...response.usage,
+                // OpenAI Images response may not include usage details per image; preserve if present
+                ...(response.usage ?? {
+                    input_tokens: 0,
+                    input_tokens_details: { image_tokens: 0, text_tokens: 0 },
+                    output_tokens: 0,
+                    total_tokens: 0,
+                }),
                 provider: 'openai',
                 model: 'gpt-image-1',
                 cost,
@@ -9716,7 +9745,8 @@ async function makeImagesCall(prompt, options = {}) {
         return enhancedResponse;
     }
     catch (error) {
-        throw new Error(`OpenAI Images API call failed: ${error.message}`);
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`OpenAI Images API call failed: ${message}`);
     }
 }
 
@@ -9941,14 +9971,15 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
         const completion = await createDeepseekCompletion(content, responseFormat, mergedOptions);
         // Handle tool calls similarly to OpenAI
         if (completion.tool_calls && completion.tool_calls.length > 0) {
+            const fnCalls = completion.tool_calls
+                .filter((tc) => tc.type === 'function')
+                .map((tc) => ({
+                id: tc.id,
+                name: tc.function.name,
+                arguments: JSON.parse(tc.function.arguments),
+            }));
             return {
-                response: {
-                    tool_calls: completion.tool_calls.map((tc) => ({
-                        id: tc.id,
-                        name: tc.function.name,
-                        arguments: JSON.parse(tc.function.arguments),
-                    })),
-                },
+                response: { tool_calls: fnCalls },
                 usage: {
                     prompt_tokens: completion.usage.prompt_tokens,
                     completion_tokens: completion.usage.completion_tokens,
@@ -10003,6 +10034,122 @@ const makeDeepseekCall = async (content, responseFormat = 'json', options = {})
     }
 };
 
+// llm-openrouter.ts
+// Map our ContextMessage to OpenAI chat message
+function mapContextToMessages(context) {
+    return context.map((msg) => {
+        const role = msg.role === 'developer' ? 'system' : msg.role;
+        return { role, content: msg.content };
+    });
+}
+function toOpenRouterModel(model) {
+    if (model && model.includes('/'))
+        return model;
+    const base = normalizeModelName(model || DEFAULT_MODEL);
+    return `openai/${base}`;
+}
+// Normalize model name for pricing
+function normalizeModelForPricing(model) {
+    if (!model)
+        return { provider: 'openai', coreModel: normalizeModelName(DEFAULT_MODEL) };
+    const [maybeProvider, maybeModel] = model.includes('/') ? model.split('/') : ['openai', model];
+    const provider = (maybeProvider === 'deepseek' ? 'deepseek' : 'openai');
+    const coreModel = normalizeModelName(maybeModel || model);
+    return { provider, coreModel };
+}
+/**
+ * Make a call through OpenRouter using the OpenAI Chat Completions-compatible API.
+ * Supports: JSON mode, model selection, message history, and tools.
+ */
+async function makeOpenRouterCall(input, options = {}) {
+    const { apiKey = process.env.OPENROUTER_API_KEY, model, responseFormat = 'text', tools, toolChoice, context, developerPrompt, temperature = 0.2, max_tokens, top_p, frequency_penalty, presence_penalty, stop, seed, referer = process.env.OPENROUTER_SITE_URL, title = process.env.OPENROUTER_SITE_NAME, } = options;
+    if (!apiKey) {
+        throw new Error('OpenRouter API key is not provided and OPENROUTER_API_KEY is not set');
+    }
+    const client = new OpenAI({
+        apiKey,
+        baseURL: 'https://openrouter.ai/api/v1',
+        defaultHeaders: {
+            ...(referer ? { 'HTTP-Referer': referer } : {}),
+            ...(title ? { 'X-Title': title } : {}),
+        },
+    });
+    const messages = [];
+    if (developerPrompt && developerPrompt.trim()) {
+        messages.push({ role: 'system', content: developerPrompt });
+    }
+    if (context && context.length > 0) {
+        messages.push(...mapContextToMessages(context));
+    }
+    messages.push({ role: 'user', content: input });
+    // Configure response_format
+    let response_format;
+    let parsingFormat = 'text';
+    if (responseFormat === 'json') {
+        response_format = { type: 'json_object' };
+        parsingFormat = 'json';
+    }
+    else if (typeof responseFormat === 'object') {
+        response_format = { type: 'json_object' };
+        parsingFormat = responseFormat;
+    }
+    const modelId = toOpenRouterModel(model);
+    const completion = await client.chat.completions.create({
+        model: modelId,
+        messages,
+        response_format,
+        tools,
+        tool_choice: toolChoice,
+        temperature,
+        max_tokens,
+        top_p,
+        frequency_penalty,
+        presence_penalty,
+        stop,
+        seed,
+    });
+    const choice = completion.choices && completion.choices.length > 0 ? completion.choices[0] : undefined;
+    const message = (choice && 'message' in choice ? choice.message : undefined);
+    const { provider: pricingProvider, coreModel } = normalizeModelForPricing(modelId);
+    const promptTokens = completion.usage?.prompt_tokens ?? 0;
+    const completionTokens = completion.usage?.completion_tokens ?? 0;
+    const cost = calculateCost(pricingProvider, coreModel, promptTokens, completionTokens);
+    // Tool calls branch: return empty string response and expose tool_calls on LLMResponse
+    const hasToolCalls = Array.isArray(message?.tool_calls) && message.tool_calls.length > 0;
+    if (hasToolCalls) {
+        const usageModel = isOpenRouterModel(modelId) ? modelId : DEFAULT_MODEL;
+        return {
+            response: '',
+            usage: {
+                prompt_tokens: promptTokens,
+                completion_tokens: completionTokens,
+                provider: 'openrouter',
+                model: usageModel,
+                cost,
+            },
+            tool_calls: message.tool_calls,
+        };
+    }
+    const rawText = typeof message?.content === 'string' ? message.content : '';
+    const parsed = await parseResponse(rawText, parsingFormat);
+    if (parsed === null) {
+        throw new Error('Failed to parse OpenRouter response');
+    }
+    // Ensure the model value conforms to LLMModel; otherwise fall back to DEFAULT_MODEL
+    const usageModel = isOpenRouterModel(modelId) ? modelId : DEFAULT_MODEL;
+    return {
+        response: parsed,
+        usage: {
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            provider: 'openrouter',
+            model: usageModel,
+            cost,
+        },
+        ...(hasToolCalls ? { tool_calls: message.tool_calls } : {}),
+    };
+}
+
 /**
  * A class to measure performance of code execution.
  *
@@ -18312,6 +18459,7 @@ const disco = {
         call: makeLLMCall,
         seek: makeDeepseekCall,
         images: makeImagesCall,
+        open: makeOpenRouterCall,
     },
     polygon: {
         fetchTickerInfo: fetchTickerInfo,
@@ -18358,46 +18506,6 @@ const disco = {
 };
 
 // Test file for context functionality
-async function testLLM() {
-    //const models: LLMModel[] = ['gpt-5', 'gpt-5-mini', 'gpt-5-nano'];
-    const models = ['gpt-5-nano'];
-    for (const model of models) {
-        console.log(`\nTesting model: ${model}`);
-        // // 1. Basic call
-        // try {
-        //   const basic = await disco.llm.call('What is the capital of France?', { model });
-        //   if (!basic || !basic.response) {
-        //     throw new Error('No response from LLM');
-        //   }
-        //   console.log(`Response: ${basic.response}`);
-        // } catch (e) {
-        //   console.error(`  Basic call error:`, e);
-        // }
-        // // 2. JSON call
-        // try {
-        //   const jsonPrompt = 'Return a JSON object with keys country and capital for France.';
-        //   const json = await disco.llm.call(jsonPrompt, { model, responseFormat: 'json' });
-        //   if (!json || !json.response) {
-        //     throw new Error('No response from LLM');
-        //   }
-        //   console.log
-        // } catch (e) {
-        //   console.error(`  JSON call error:`, e);
-        // }
-        // 3. Web search
-        try {
-            const searchPrompt = 'What is the latest news about artificial intelligence? Respond with 3 sentences max.';
-            const tool = await disco.llm.call(searchPrompt, { model, useWebSearch: true });
-            if (!tool || !tool.response) {
-                throw new Error('No response from LLM');
-            }
-            console.log(`Response: ${tool.response}`);
-        }
-        catch (e) {
-            console.error(`  Web search error:`, e);
-        }
-    }
-}
 // testGetTradingDate();
 // testGetTradingStartAndEndDates();
 // testGetLastFullTradingDate();
@@ -18406,5 +18514,84 @@ async function testLLM() {
 // testGetNextMarketDay();
 // testCountTradingDays();
 // testGetPreviousMarketDay();
-testLLM();
+// OpenRouter tests (requires OPENROUTER_API_KEY)
+async function testOpenRouter() {
+    if (!process.env.OPENROUTER_API_KEY) {
+        console.log('Skipping OpenRouter tests: OPENROUTER_API_KEY not set');
+        return;
+    }
+    const models = [
+        'openai/gpt-5-nano', // inexpensive, tool-capable
+        'google/gemini-2.5-flash-lite',
+        'deepseek/deepseek-chat-v3-0324',
+    ];
+    for (const model of models) {
+        console.log(`\n--- Testing OpenRouter model: ${model} ---`);
+        // 1) JSON mode
+        try {
+            const prompt = 'Return a JSON object with keys country and capital for France.';
+            const jsonRes = await disco.llm.open(prompt, { model, responseFormat: 'json' });
+            console.log('\n[OpenRouter] JSON mode test');
+            console.log('  Response:', jsonRes.response);
+            console.log('  Usage:', jsonRes.usage);
+        }
+        catch (e) {
+            console.error('  OpenRouter JSON mode error:', e);
+        }
+        // 2) Model history (context)
+        try {
+            const context = [
+                { role: 'user', content: 'What is the capital of Germany?' },
+                { role: 'assistant', content: 'Berlin.' },
+            ];
+            const followup = 'Remind me what you said earlier in one word.';
+            const histRes = await disco.llm.open(followup, { model, context });
+            console.log('\n[OpenRouter] History test');
+            console.log('  Response:', histRes.response);
+        }
+        catch (e) {
+            console.error('  OpenRouter history error:', e);
+        }
+        // 3) Tool calling
+        try {
+            const tools = [
+                {
+                    type: 'function',
+                    function: {
+                        name: 'add',
+                        description: 'Add two integers and return the sum',
+                        parameters: {
+                            type: 'object',
+                            properties: {
+                                a: { type: 'integer' },
+                                b: { type: 'integer' },
+                            },
+                            required: ['a', 'b'],
+                        },
+                    },
+                },
+            ];
+            const toolPrompt = 'Please add 2 and 3. If tools are available, call the add function.';
+            const toolRes = await disco.llm.open(toolPrompt, { model, tools, toolChoice: 'auto' });
+            console.log('\n[OpenRouter] Tools test');
+            if (toolRes.tool_calls && toolRes.tool_calls.length > 0) {
+                const summarized = toolRes.tool_calls
+                    .filter((tc) => tc.type === 'function')
+                    .map((tc) => ({
+                    id: tc.id,
+                    name: tc.function.name,
+                    arguments: tc.function.arguments,
+                }));
+                console.log('  Tool calls:', summarized);
+            }
+            else {
+                console.log('  No tool calls. Model replied:', toolRes.response);
+            }
+        }
+        catch (e) {
+            console.error('  OpenRouter tools error:', e);
+        }
+    }
+}
+testOpenRouter();
 //# sourceMappingURL=test.js.map