@discomedia/utils 1.0.25 → 1.0.27

package/dist/index.cjs

@@ -1021,8 +1021,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
@@ -1114,29 +1134,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.
@@ -1350,51 +1372,47 @@ function pLimit(concurrency) {
 	let activeCount = 0;
 
 	const resumeNext = () => {
+		// Process the next queued function if we're under the concurrency limit
 		if (activeCount < concurrency && queue.size > 0) {
-			queue.dequeue()();
-			// Since `pendingCount` has been decreased by one, increase `activeCount` by one.
 			activeCount++;
+			queue.dequeue()();
 		}
 	};
 
 	const next = () => {
 		activeCount--;
-
 		resumeNext();
 	};
 
 	const run = async (function_, resolve, arguments_) => {
+		// Execute the function and capture the result promise
 		const result = (async () => function_(...arguments_))();
 
+		// Resolve immediately with the promise (don't wait for completion)
 		resolve(result);
 
+		// Wait for the function to complete (success or failure)
+		// We catch errors here to prevent unhandled rejections,
+		// but the original promise rejection is preserved for the caller
 		try {
 			await result;
 		} catch {}
 
+		// Decrement active count and process next queued function
 		next();
 	};
 
 	const enqueue = (function_, resolve, arguments_) => {
-		// Queue `internalResolve` instead of the `run` function
-		// to preserve asynchronous context.
-		new Promise(internalResolve => {
+		// Queue the internal resolve function instead of the run function
+		// to preserve the asynchronous execution context.
+		new Promise(internalResolve => { // eslint-disable-line promise/param-names
 			queue.enqueue(internalResolve);
-		}).then(
-			run.bind(undefined, function_, resolve, arguments_),
-		);
-
-		(async () => {
-			// This function needs to wait until the next microtask before comparing
-			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
-			// after the `internalResolve` function is dequeued and called. The comparison in the if-statement
-			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
-			await Promise.resolve();
-
-			if (activeCount < concurrency) {
-				resumeNext();
-			}
-		})();
+		}).then(run.bind(undefined, function_, resolve, arguments_)); // eslint-disable-line promise/prefer-await-to-then
+
+		// Start processing immediately if we haven't reached the concurrency limit
+		if (activeCount < concurrency) {
+			resumeNext();
+		}
 	};
 
 	const generator = (function_, ...arguments_) => new Promise(resolve => {
@@ -1428,6 +1446,12 @@ function pLimit(concurrency) {
 				});
 			},
 		},
+		map: {
+			async value(array, function_) {
+				const promises = array.map(value => this(function_, value));
+				return Promise.all(promises);
+			},
+		},
 	});
 
 	return generator;
@@ -2370,7 +2394,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 = () => {
@@ -9165,7 +9189,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;
     }
 }
@@ -9709,7 +9734,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,
@@ -9718,7 +9749,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}`);
     }
 }
 
@@ -9943,14 +9975,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,
@@ -10005,6 +10038,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.
  *
@@ -16964,6 +17113,18 @@ Websocket example
    this.log(`Received trade update: event ${update.event} for an order to ${update.order.side} ${update.order.qty} of ${update.order.symbol}`);
   });
   alpacaAPI.connectWebsocket(); // necessary to connect to the WebSocket
+
+Portfolio History examples
+  // Get standard portfolio history
+  const portfolioHistory = await alpacaAPI.getPortfolioHistory({
+    timeframe: '1D',
+    period: '1M'
+  });
+
+  // Get daily portfolio history with current day included (if available from hourly data)
+  const dailyHistory = await alpacaAPI.getPortfolioDailyHistory({
+    period: '1M'
+  });
 */
 class AlpacaTradingAPI {
     static new(credentials) {
@@ -17663,6 +17824,57 @@ class AlpacaTradingAPI {
         const response = await this.makeRequest(`/account/portfolio/history?${queryParams.toString()}`);
         return response;
     }
+    /**
+     * Get portfolio daily history for the account, ensuring the most recent day is included
+     * by combining daily and hourly history if needed.
+     *
+     * This function performs two API calls:
+     * 1. Retrieves daily portfolio history
+     * 2. Retrieves hourly portfolio history to check for more recent data
+     *
+     * If hourly history has timestamps more recent than the last timestamp in daily history,
+     * it appends one additional day to the daily history using the most recent hourly values.
+     *
+     * @param params Parameters for the portfolio history request (same as getPortfolioHistory except timeframe is forced to '1D')
+     * @returns Portfolio history data with daily timeframe, including the most recent day if available from hourly data
+     */
+    async getPortfolioDailyHistory(params) {
+        // Get daily history
+        const dailyParams = { ...params, timeframe: '1D' };
+        const dailyHistory = await this.getPortfolioHistory(dailyParams);
+        // Get hourly history for the last day to check for more recent data
+        const hourlyParams = { timeframe: '1H', period: '1D' };
+        const hourlyHistory = await this.getPortfolioHistory(hourlyParams);
+        // If no hourly history, return daily as-is
+        if (!hourlyHistory.timestamp || hourlyHistory.timestamp.length === 0) {
+            return dailyHistory;
+        }
+        // Get the last timestamp from daily history
+        const lastDailyTimestamp = dailyHistory.timestamp[dailyHistory.timestamp.length - 1];
+        // Check if hourly history has more recent data
+        const recentHourlyData = hourlyHistory.timestamp
+            .map((timestamp, index) => ({ timestamp, index }))
+            .filter(({ timestamp }) => timestamp > lastDailyTimestamp);
+        // If no more recent hourly data, return daily history as-is
+        if (recentHourlyData.length === 0) {
+            return dailyHistory;
+        }
+        // Get the most recent hourly data point
+        const mostRecentHourly = recentHourlyData[recentHourlyData.length - 1];
+        const mostRecentIndex = mostRecentHourly.index;
+        // Calculate the timestamp for the new daily entry (most recent day + 1 day worth of seconds)
+        const oneDayInSeconds = 24 * 60 * 60;
+        const newDailyTimestamp = mostRecentHourly.timestamp + oneDayInSeconds;
+        // Create a new daily history entry with the most recent hourly values
+        const updatedDailyHistory = {
+            ...dailyHistory,
+            timestamp: [...dailyHistory.timestamp, newDailyTimestamp],
+            equity: [...dailyHistory.equity, hourlyHistory.equity[mostRecentIndex]],
+            profit_loss: [...dailyHistory.profit_loss, hourlyHistory.profit_loss[mostRecentIndex]],
+            profit_loss_pct: [...dailyHistory.profit_loss_pct, hourlyHistory.profit_loss_pct[mostRecentIndex]],
+        };
+        return updatedDailyHistory;
+    }
     /**
      * Get option contracts based on specified parameters
      * @param params Parameters to filter option contracts
@@ -18314,6 +18526,7 @@ const disco = {
         call: makeLLMCall,
         seek: makeDeepseekCall,
         images: makeImagesCall,
+        open: makeOpenRouterCall,
     },
     polygon: {
         fetchTickerInfo: fetchTickerInfo,
@@ -18362,4 +18575,5 @@ const disco = {
 exports.AlpacaMarketDataAPI = AlpacaMarketDataAPI;
 exports.AlpacaTradingAPI = AlpacaTradingAPI;
 exports.disco = disco;
+exports.isOpenRouterModel = isOpenRouterModel;
 //# sourceMappingURL=index.cjs.map