@discomedia/utils 1.0.25 → 1.0.26

package/dist/index.mjs

@@ -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,
@@ -18357,5 +18505,5 @@ const disco = {
     },
 };
 
-export { AlpacaMarketDataAPI, AlpacaTradingAPI, disco };
+export { AlpacaMarketDataAPI, AlpacaTradingAPI, disco, isOpenRouterModel };
 //# sourceMappingURL=index.mjs.map