@discomedia/utils 1.0.25 → 1.0.27

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.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 = () => {
@@ -7042,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;
     }
 }
@@ -7586,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,
@@ -7595,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}`);
     }
 }
 
@@ -7820,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,
@@ -14650,6 +14679,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) {
@@ -15349,6 +15390,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
@@ -15984,5 +16076,5 @@ const disco = {
     },
 };
 
-export { AlpacaMarketDataAPI, AlpacaTradingAPI, disco };
+export { AlpacaMarketDataAPI, AlpacaTradingAPI, disco, isOpenRouterModel };
 //# sourceMappingURL=index-frontend.mjs.map