@discomedia/utils 1.0.24 → 1.0.26

package/dist/index-frontend.mjs

@@ -12,8 +12,28 @@ import require$$0$4 from 'fs';
 import require$$1$1 from 'path';
 import require$$2$1 from 'os';
 
+/**
+ * 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
 });
 
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
@@ -247,7 +267,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.0'; // 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 = () => {
@@ -1880,8 +1900,119 @@ let Messages$1 = class Messages extends APIResource {
     }
 };
 
-function isRunnableFunctionWithParse(fn) {
-    return typeof fn.parse === 'function';
+function isChatCompletionFunctionTool(tool) {
+    return tool !== undefined && 'function' in tool && tool.function !== undefined;
+}
+function isAutoParsableResponseFormat(response_format) {
+    return response_format?.['$brand'] === 'auto-parseable-response-format';
+}
+function isAutoParsableTool$1(tool) {
+    return tool?.['$brand'] === 'auto-parseable-tool';
+}
+function maybeParseChatCompletion(completion, params) {
+    if (!params || !hasAutoParseableInput$1(params)) {
+        return {
+            ...completion,
+            choices: completion.choices.map((choice) => {
+                assertToolCallsAreChatCompletionFunctionToolCalls(choice.message.tool_calls);
+                return {
+                    ...choice,
+                    message: {
+                        ...choice.message,
+                        parsed: null,
+                        ...(choice.message.tool_calls ?
+                            {
+                                tool_calls: choice.message.tool_calls,
+                            }
+                            : undefined),
+                    },
+                };
+            }),
+        };
+    }
+    return parseChatCompletion(completion, params);
+}
+function parseChatCompletion(completion, params) {
+    const choices = completion.choices.map((choice) => {
+        if (choice.finish_reason === 'length') {
+            throw new LengthFinishReasonError();
+        }
+        if (choice.finish_reason === 'content_filter') {
+            throw new ContentFilterFinishReasonError();
+        }
+        assertToolCallsAreChatCompletionFunctionToolCalls(choice.message.tool_calls);
+        return {
+            ...choice,
+            message: {
+                ...choice.message,
+                ...(choice.message.tool_calls ?
+                    {
+                        tool_calls: choice.message.tool_calls?.map((toolCall) => parseToolCall$1(params, toolCall)) ?? undefined,
+                    }
+                    : undefined),
+                parsed: choice.message.content && !choice.message.refusal ?
+                    parseResponseFormat(params, choice.message.content)
+                    : null,
+            },
+        };
+    });
+    return { ...completion, choices };
+}
+function parseResponseFormat(params, content) {
+    if (params.response_format?.type !== 'json_schema') {
+        return null;
+    }
+    if (params.response_format?.type === 'json_schema') {
+        if ('$parseRaw' in params.response_format) {
+            const response_format = params.response_format;
+            return response_format.$parseRaw(content);
+        }
+        return JSON.parse(content);
+    }
+    return null;
+}
+function parseToolCall$1(params, toolCall) {
+    const inputTool = params.tools?.find((inputTool) => isChatCompletionFunctionTool(inputTool) && inputTool.function?.name === toolCall.function.name); // TS doesn't narrow based on isChatCompletionTool
+    return {
+        ...toolCall,
+        function: {
+            ...toolCall.function,
+            parsed_arguments: isAutoParsableTool$1(inputTool) ? inputTool.$parseRaw(toolCall.function.arguments)
+                : inputTool?.function.strict ? JSON.parse(toolCall.function.arguments)
+                    : null,
+        },
+    };
+}
+function shouldParseToolCall(params, toolCall) {
+    if (!params || !('tools' in params) || !params.tools) {
+        return false;
+    }
+    const inputTool = params.tools?.find((inputTool) => isChatCompletionFunctionTool(inputTool) && inputTool.function?.name === toolCall.function.name);
+    return (isChatCompletionFunctionTool(inputTool) &&
+        (isAutoParsableTool$1(inputTool) || inputTool?.function.strict || false));
+}
+function hasAutoParseableInput$1(params) {
+    if (isAutoParsableResponseFormat(params.response_format)) {
+        return true;
+    }
+    return (params.tools?.some((t) => isAutoParsableTool$1(t) || (t.type === 'function' && t.function.strict === true)) ?? false);
+}
+function assertToolCallsAreChatCompletionFunctionToolCalls(toolCalls) {
+    for (const toolCall of toolCalls || []) {
+        if (toolCall.type !== 'function') {
+            throw new OpenAIError(`Currently only \`function\` tool calls are supported; Received \`${toolCall.type}\``);
+        }
+    }
+}
+function validateInputTools(tools) {
+    for (const tool of tools ?? []) {
+        if (tool.type !== 'function') {
+            throw new OpenAIError(`Currently only \`function\` tool types support auto-parsing; Received \`${tool.type}\``);
+        }
+        if (tool.function.strict !== true) {
+            throw new OpenAIError(`The \`${tool.function.name}\` tool is not marked with \`strict: true\`. Only strict function tools can be auto-parsed`);
+        }
+    }
 }
 
 const isAssistantMessage = (message) => {
@@ -2075,104 +2206,8 @@ _EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedProm
     return this._emit('error', new OpenAIError(String(error)));
 };
 
-function isAutoParsableResponseFormat(response_format) {
-    return response_format?.['$brand'] === 'auto-parseable-response-format';
-}
-function isAutoParsableTool$1(tool) {
-    return tool?.['$brand'] === 'auto-parseable-tool';
-}
-function maybeParseChatCompletion(completion, params) {
-    if (!params || !hasAutoParseableInput$1(params)) {
-        return {
-            ...completion,
-            choices: completion.choices.map((choice) => ({
-                ...choice,
-                message: {
-                    ...choice.message,
-                    parsed: null,
-                    ...(choice.message.tool_calls ?
-                        {
-                            tool_calls: choice.message.tool_calls,
-                        }
-                        : undefined),
-                },
-            })),
-        };
-    }
-    return parseChatCompletion(completion, params);
-}
-function parseChatCompletion(completion, params) {
-    const choices = completion.choices.map((choice) => {
-        if (choice.finish_reason === 'length') {
-            throw new LengthFinishReasonError();
-        }
-        if (choice.finish_reason === 'content_filter') {
-            throw new ContentFilterFinishReasonError();
-        }
-        return {
-            ...choice,
-            message: {
-                ...choice.message,
-                ...(choice.message.tool_calls ?
-                    {
-                        tool_calls: choice.message.tool_calls?.map((toolCall) => parseToolCall$1(params, toolCall)) ?? undefined,
-                    }
-                    : undefined),
-                parsed: choice.message.content && !choice.message.refusal ?
-                    parseResponseFormat(params, choice.message.content)
-                    : null,
-            },
-        };
-    });
-    return { ...completion, choices };
-}
-function parseResponseFormat(params, content) {
-    if (params.response_format?.type !== 'json_schema') {
-        return null;
-    }
-    if (params.response_format?.type === 'json_schema') {
-        if ('$parseRaw' in params.response_format) {
-            const response_format = params.response_format;
-            return response_format.$parseRaw(content);
-        }
-        return JSON.parse(content);
-    }
-    return null;
-}
-function parseToolCall$1(params, toolCall) {
-    const inputTool = params.tools?.find((inputTool) => inputTool.function?.name === toolCall.function.name);
-    return {
-        ...toolCall,
-        function: {
-            ...toolCall.function,
-            parsed_arguments: isAutoParsableTool$1(inputTool) ? inputTool.$parseRaw(toolCall.function.arguments)
-                : inputTool?.function.strict ? JSON.parse(toolCall.function.arguments)
-                    : null,
-        },
-    };
-}
-function shouldParseToolCall(params, toolCall) {
-    if (!params) {
-        return false;
-    }
-    const inputTool = params.tools?.find((inputTool) => inputTool.function?.name === toolCall.function.name);
-    return isAutoParsableTool$1(inputTool) || inputTool?.function.strict || false;
-}
-function hasAutoParseableInput$1(params) {
-    if (isAutoParsableResponseFormat(params.response_format)) {
-        return true;
-    }
-    return (params.tools?.some((t) => isAutoParsableTool$1(t) || (t.type === 'function' && t.function.strict === true)) ?? false);
-}
-function validateInputTools(tools) {
-    for (const tool of tools ?? []) {
-        if (tool.type !== 'function') {
-            throw new OpenAIError(`Currently only \`function\` tool types support auto-parsing; Received \`${tool.type}\``);
-        }
-        if (tool.function.strict !== true) {
-            throw new OpenAIError(`The \`${tool.function.name}\` tool is not marked with \`strict: true\`. Only strict function tools can be auto-parsed`);
-        }
-    }
+function isRunnableFunctionWithParse(fn) {
+    return typeof fn.parse === 'function';
 }
 
 var _AbstractChatCompletionRunner_instances, _AbstractChatCompletionRunner_getFinalContent, _AbstractChatCompletionRunner_getFinalMessage, _AbstractChatCompletionRunner_getFinalFunctionToolCall, _AbstractChatCompletionRunner_getFinalFunctionToolCallResult, _AbstractChatCompletionRunner_calculateTotalUsage, _AbstractChatCompletionRunner_validateParams, _AbstractChatCompletionRunner_stringifyFunctionCallResult;
@@ -2298,7 +2333,7 @@ class AbstractChatCompletionRunner extends EventStream {
     async _runTools(client, params, options) {
         const role = 'tool';
         const { tool_choice = 'auto', stream, ...restParams } = params;
-        const singleFunctionToCall = typeof tool_choice !== 'string' && tool_choice?.function?.name;
+        const singleFunctionToCall = typeof tool_choice !== 'string' && tool_choice.type === 'function' && tool_choice?.function?.name;
         const { maxChatCompletions = DEFAULT_MAX_CHAT_COMPLETIONS } = options || {};
         // TODO(someday): clean this logic up
         const inputTools = params.tools.map((tool) => {
@@ -2416,7 +2451,7 @@ _AbstractChatCompletionRunner_instances = new WeakSet(), _AbstractChatCompletion
     for (let i = this.messages.length - 1; i >= 0; i--) {
         const message = this.messages[i];
         if (isAssistantMessage(message) && message?.tool_calls?.length) {
-            return message.tool_calls.at(-1)?.function;
+            return message.tool_calls.filter((x) => x.type === 'function').at(-1)?.function;
         }
     }
     return;
@@ -2894,7 +2929,7 @@ class ChatCompletionStream extends AbstractChatCompletionRunner {
             throw new Error('tool call snapshot missing `type`');
         }
         if (toolCallSnapshot.type === 'function') {
-            const inputTool = __classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.tools?.find((tool) => tool.type === 'function' && tool.function.name === toolCallSnapshot.function.name);
+            const inputTool = __classPrivateFieldGet(this, _ChatCompletionStream_params, "f")?.tools?.find((tool) => isChatCompletionFunctionTool(tool) && tool.function.name === toolCallSnapshot.function.name); // TS doesn't narrow based on isChatCompletionTool
             this._emit('tool_calls.function.arguments.done', {
                 name: toolCallSnapshot.function.name,
                 index: toolCallIndex,
@@ -6704,7 +6739,7 @@ OpenAI.Evals = Evals;
 OpenAI.Containers = Containers;
 
 // llm-openai-config.ts
-const DEFAULT_MODEL$1 = 'gpt-4.1-mini';
+const DEFAULT_MODEL = 'gpt-4.1-mini';
 /** Token costs in USD per 1M tokens. Last updated Feb 2025. */
 const openAiModelCosts = {
     'gpt-4o': {
@@ -6743,6 +6778,18 @@ const openAiModelCosts = {
         inputCost: 0.1 / 1_000_000,
         outputCost: 0.4 / 1_000_000,
     },
+    'gpt-5': {
+        inputCost: 1.25 / 1_000_000,
+        outputCost: 10 / 1_000_000,
+    },
+    'gpt-5-mini': {
+        inputCost: 0.25 / 1_000_000,
+        outputCost: 2 / 1_000_000,
+    },
+    'gpt-5-nano': {
+        inputCost: 0.05 / 1_000_000,
+        outputCost: 0.4 / 1_000_000,
+    },
     'o4-mini': {
         inputCost: 1.1 / 1_000_000,
         outputCost: 4.4 / 1_000_000,
@@ -6810,7 +6857,6 @@ function calculateCost(provider, model, inputTokens, outputTokens, reasoningToke
     return inputCost + outputCost + reasoningCost;
 }
 
-const DEFAULT_MODEL = 'gpt-4.1-mini';
 /**
  * Fix a broken JSON string by attempting to extract and parse valid JSON content. This function is very lenient and will attempt to fix many types of JSON errors, including unbalanced brackets, missing or extra commas, improperly escaped $ signs, unquoted strings, trailing commas, missing closing brackets or braces, etc.
  * @param {string} jsonStr - The broken JSON string to fix
@@ -7016,7 +7062,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;
     }
 }
@@ -7055,9 +7102,7 @@ function initializeOpenAI(apiKey) {
     });
 }
 /**
- * Fixes broken JSON by sending it to the OpenAI GPT-4.1-mini model as a chat completion.
- * The GPT-4.1-mini model is a large language model that can understand and generate code,
- * including JSON. The returned JSON is the fixed version of the input JSON.
+ * Fixes broken JSON by sending it to OpenAI to fix it.
  * If the model fails to return valid JSON, an error is thrown.
  * @param jsonStr - the broken JSON to fix
  * @param apiKey - the OpenAI API key to use, or undefined to use the value of the OPENAI_API_KEY environment variable
@@ -7201,8 +7246,11 @@ const isSupportedModel = (model) => {
         'o3-mini',
         'gpt-4.1',
         'gpt-4.1-mini',
-        'o4-mini',
         'gpt-4.1-nano',
+        'gpt-5',
+        'gpt-5-mini',
+        'gpt-5-nano',
+        'o4-mini',
         'o3',
     ].includes(model);
 };
@@ -7213,8 +7261,9 @@ const isSupportedModel = (model) => {
  */
 function supportsTemperature(model) {
     // Reasoning models don't support temperature
-    const reasoningModels = ['o1', 'o1-mini', 'o3-mini', 'o4-mini', 'o3'];
-    return !reasoningModels.includes(model);
+    // GPT-5 models also do not support temperature
+    const reasoningAndGPT5Models = ['o1', 'o1-mini', 'o3-mini', 'o4-mini', 'o3', 'gpt-5', 'gpt-5-mini', 'gpt-5-nano'];
+    return !reasoningAndGPT5Models.includes(model);
 }
 /**
  * Checks if the given model is a reasoning model. Reasoning models have different tool choice constraints.
@@ -7225,6 +7274,15 @@ function isReasoningModel(model) {
     const reasoningModels = ['o1', 'o1-mini', 'o3-mini', 'o4-mini', 'o3'];
     return reasoningModels.includes(model);
 }
+/**
+ * Checks if the given model is a GPT-5 model. GPT-5 models don't support tool_choice other than 'auto'.
+ * @param model The model to check.
+ * @returns True if the model is a GPT-5 model, false otherwise.
+ */
+function isGPT5Model(model) {
+    const gpt5Models = ['gpt-5', 'gpt-5-mini', 'gpt-5-nano'];
+    return gpt5Models.includes(model);
+}
 /**
  * Makes a call to OpenAI's Responses API for more advanced use cases with built-in tools.
  *
@@ -7252,7 +7310,7 @@ function isReasoningModel(model) {
  * @throws Error if the API call fails
  */
 const makeResponsesAPICall = async (input, options = {}) => {
-    const normalizedModel = normalizeModelName(options.model || DEFAULT_MODEL$1);
+    const normalizedModel = normalizeModelName(options.model || DEFAULT_MODEL);
     const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
     if (!apiKey) {
         throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
@@ -7363,7 +7421,7 @@ const makeResponsesAPICall = async (input, options = {}) => {
  * });
  */
 async function makeLLMCall(input, options = {}) {
-    const { apiKey, model = DEFAULT_MODEL$1, responseFormat = 'text', tools, useCodeInterpreter = false, useWebSearch = false, imageBase64, imageDetail = 'high', context, } = options;
+    const { apiKey, model = DEFAULT_MODEL, responseFormat = 'text', tools, useCodeInterpreter = false, useWebSearch = false, imageBase64, imageDetail = 'high', context, } = options;
     // Validate model
     const normalizedModel = normalizeModelName(model);
     if (!isSupportedModel(normalizedModel)) {
@@ -7455,8 +7513,8 @@ async function makeLLMCall(input, options = {}) {
     }
     if (useWebSearch) {
         responsesOptions.tools = [{ type: 'web_search_preview' }];
-        // For reasoning models, we can't force tool choice - they only support 'auto'
-        if (!isReasoningModel(normalizedModel)) {
+        // For reasoning models and GPT-5 models, we can't force tool choice - they only support 'auto'
+        if (!isReasoningModel(normalizedModel) && !isGPT5Model(normalizedModel)) {
             responsesOptions.tool_choice = { type: 'web_search_preview' };
         }
     }
@@ -7549,7 +7607,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,
@@ -7558,7 +7622,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}`);
     }
 }
 
@@ -7783,14 +7848,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,
@@ -15947,5 +16013,5 @@ const disco = {
     },
 };
 
-export { AlpacaMarketDataAPI, AlpacaTradingAPI, disco };
+export { AlpacaMarketDataAPI, AlpacaTradingAPI, disco, isOpenRouterModel };
 //# sourceMappingURL=index-frontend.mjs.map