illuma-agents 1.0.17 → 1.0.19

package/src/graphs/Graph.ts

@@ -57,7 +57,10 @@ import {
   joinKeys,
   sleep,
 } from '@/utils';
-import { buildContextAnalytics, type ContextAnalytics } from '@/utils/contextAnalytics';
+import {
+  buildContextAnalytics,
+  type ContextAnalytics,
+} from '@/utils/contextAnalytics';
 import { getChatModelClass, manualToolStreamProviders } from '@/llm/providers';
 import { ToolNode as CustomToolNode, toolsCondition } from '@/tools/ToolNode';
 import { ChatOpenAI, AzureChatOpenAI } from '@/llm/openai';
@@ -214,7 +217,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
   /**
    * Estimates a human-friendly description of the conversation timeframe based on message count.
    * Uses rough heuristics to provide context about how much history is available.
-   * 
+   *
    * @param messageCount - Number of messages in the remaining context
    * @returns A friendly description like "the last few minutes", "the past hour", etc.
    */
@@ -224,7 +227,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     // - Normal chat: ~10-15 messages per hour
     // - Slow/thoughtful chat: ~5-8 messages per hour
     // We use a middle estimate of ~12 messages per hour
-    
+
     if (messageCount <= 5) {
       return 'just the last few exchanges';
     } else if (messageCount <= 15) {
@@ -712,7 +715,8 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
           content: `[SESSION_CONTEXT]\n${agentContext.dynamicContext}`,
         });
         const ackMessage = new AIMessageChunk({
-          content: 'Understood. I have noted the session context including the current date/time (CST) and will apply it appropriately.',
+          content:
+            'Understood. I have noted the session context including the current date/time (CST) and will apply it appropriately.',
         });
         messages = [dynamicContextMessage, ackMessage, ...messages];
       }
@@ -745,7 +749,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       this.config = config;
 
       let messagesToUse = messages;
-      
+
       if (
         !agentContext.pruneMessages &&
         agentContext.tokenCounter &&
@@ -829,7 +833,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
        * Handle edge case: when switching from a non-thinking agent to a thinking-enabled agent,
        * convert AI messages with tool calls to HumanMessages to avoid thinking block requirements.
        * This is required by Anthropic/Bedrock when thinking is enabled.
-       * 
+       *
        * IMPORTANT: This MUST happen BEFORE cache control is applied.
        * If we add cachePoint to an AI message first, then convert that AI message to a HumanMessage,
        * the cachePoint is lost. By converting first, we ensure cache control is applied to the
@@ -873,7 +877,10 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         // Both Claude and Nova models support cachePoint in system and messages
         // (Llama, Titan, and other models do NOT support cachePoint)
         const modelId = bedrockOptions?.model?.toLowerCase() ?? '';
-        const supportsCaching = modelId.includes('claude') || modelId.includes('anthropic') || modelId.includes('nova');
+        const supportsCaching =
+          modelId.includes('claude') ||
+          modelId.includes('anthropic') ||
+          modelId.includes('nova');
         if (bedrockOptions?.promptCache === true && supportsCaching) {
           finalMessages = addBedrockCacheControl<BaseMessage>(finalMessages);
         }
@@ -909,10 +916,17 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       }
 
       // Get model info for analytics
-      const bedrockOpts = agentContext.clientOptions as t.BedrockAnthropicClientOptions | undefined;
-      const modelId = bedrockOpts?.model || (agentContext.clientOptions as t.AnthropicClientOptions | undefined)?.modelName;
-      const thinkingConfig = bedrockOpts?.additionalModelRequestFields?.['thinking'] || 
-                             (agentContext.clientOptions as t.AnthropicClientOptions | undefined)?.thinking;
+      const bedrockOpts = agentContext.clientOptions as
+        | t.BedrockAnthropicClientOptions
+        | undefined;
+      const modelId =
+        bedrockOpts?.model ||
+        (agentContext.clientOptions as t.AnthropicClientOptions | undefined)
+          ?.modelName;
+      const thinkingConfig =
+        bedrockOpts?.additionalModelRequestFields?.['thinking'] ||
+        (agentContext.clientOptions as t.AnthropicClientOptions | undefined)
+          ?.thinking;
 
       // Build and emit context analytics for traces
       const contextAnalytics = buildContextAnalytics(finalMessages, {
@@ -921,10 +935,10 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         instructionTokens: agentContext.instructionTokens,
         indexTokenCountMap: agentContext.indexTokenCountMap,
       });
-      
+
       // Store for retrieval via getContextAnalytics() after run completes
       this.lastContextAnalytics = contextAnalytics;
-      
+
       await safeDispatchCustomEvent(
         GraphEvents.ON_CONTEXT_ANALYTICS,
         {
@@ -949,8 +963,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         );
       } catch (primaryError) {
         // Check if this is a "input too long" error from Bedrock/Anthropic
-        const errorMessage = (primaryError as Error)?.message?.toLowerCase() ?? '';
-        const isInputTooLongError = 
+        const errorMessage =
+          (primaryError as Error).message.toLowerCase() ?? '';
+        const isInputTooLongError =
           errorMessage.includes('too long') ||
           errorMessage.includes('input is too long') ||
           errorMessage.includes('context length') ||
@@ -960,41 +975,50 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
 
         // Log when we detect the error
         if (isInputTooLongError) {
-          console.warn('[Graph] Detected input too long error:', errorMessage.substring(0, 200));
+          console.warn(
+            '[Graph] Detected input too long error:',
+            errorMessage.substring(0, 200)
+          );
           console.warn('[Graph] Checking emergency pruning conditions:', {
             hasPruneMessages: !!agentContext.pruneMessages,
             hasTokenCounter: !!agentContext.tokenCounter,
             maxContextTokens: agentContext.maxContextTokens,
-            indexTokenMapKeys: Object.keys(agentContext.indexTokenCountMap).length
+            indexTokenMapKeys: Object.keys(agentContext.indexTokenCountMap)
+              .length,
           });
         }
 
         // If input too long and we have pruning capability OR tokenCounter, retry with progressively more aggressive pruning
         // Note: We can create emergency pruneMessages dynamically if we have tokenCounter and maxContextTokens
-        const canPrune = agentContext.tokenCounter && agentContext.maxContextTokens;
+        const canPrune =
+          agentContext.tokenCounter && agentContext.maxContextTokens;
         if (isInputTooLongError && canPrune) {
           // Progressive reduction: 50% -> 25% -> 10% of original context
           const reductionLevels = [0.5, 0.25, 0.1];
-          
+
           for (const reductionFactor of reductionLevels) {
             if (result) break; // Exit if we got a result
-            
-            const reducedMaxTokens = Math.floor(agentContext.maxContextTokens! * reductionFactor);
+
+            const reducedMaxTokens = Math.floor(
+              agentContext.maxContextTokens! * reductionFactor
+            );
             console.warn(
               `[Graph] Input too long. Retrying with ${reductionFactor * 100}% context (${reducedMaxTokens} tokens)...`
             );
-            
+
             // Build fresh indexTokenCountMap if missing/incomplete
             // This is needed when messages were dynamically added without updating the token map
             let tokenMapForPruning = agentContext.indexTokenCountMap;
             if (Object.keys(tokenMapForPruning).length < messages.length) {
-              console.warn('[Graph] Building fresh token count map for emergency pruning...');
+              console.warn(
+                '[Graph] Building fresh token count map for emergency pruning...'
+              );
               tokenMapForPruning = {};
               for (let i = 0; i < messages.length; i++) {
                 tokenMapForPruning[i] = agentContext.tokenCounter!(messages[i]);
               }
             }
-            
+
             const emergencyPrune = createPruneMessages({
               startIndex: this.startIndex,
               provider: agentContext.provider,
@@ -1011,15 +1035,18 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
 
             // Skip if we can't fit any messages
             if (reducedMessages.length === 0) {
-              console.warn(`[Graph] Cannot fit any messages at ${reductionFactor * 100}% reduction, trying next level...`);
+              console.warn(
+                `[Graph] Cannot fit any messages at ${reductionFactor * 100}% reduction, trying next level...`
+              );
               continue;
             }
 
             // Calculate how many messages were pruned and estimate context timeframe
             const prunedCount = finalMessages.length - reducedMessages.length;
             const remainingCount = reducedMessages.length;
-            const estimatedContextDescription = this.getContextTimeframeDescription(remainingCount);
-            
+            const estimatedContextDescription =
+              this.getContextTimeframeDescription(remainingCount);
+
             // Inject a personalized context message to inform the agent about pruning
             const pruneNoticeMessage = new HumanMessage({
               content: `[CONTEXT NOTICE]
@@ -1027,11 +1054,11 @@ Our conversation has grown quite long, so I've focused on ${estimatedContextDesc
 
 If I seem to be missing something we discussed earlier, just give me a quick reminder and I'll pick right back up! I'm still fully engaged and ready to help with whatever you need.`,
             });
-            
+
             // Insert the notice after the system message (if any) but before conversation
             const hasSystemMessage = reducedMessages[0]?.getType() === 'system';
             const insertIndex = hasSystemMessage ? 1 : 0;
-            
+
             // Create new array with the pruning notice
             const messagesWithNotice = [
               ...reducedMessages.slice(0, insertIndex),
@@ -1059,9 +1086,13 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
                 | t.BedrockAnthropicClientOptions
                 | undefined;
               const modelId = bedrockOptions?.model?.toLowerCase() ?? '';
-              const supportsCaching = modelId.includes('claude') || modelId.includes('anthropic') || modelId.includes('nova');
+              const supportsCaching =
+                modelId.includes('claude') ||
+                modelId.includes('anthropic') ||
+                modelId.includes('nova');
               if (bedrockOptions?.promptCache === true && supportsCaching) {
-                retryMessages = addBedrockCacheControl<BaseMessage>(retryMessages);
+                retryMessages =
+                  addBedrockCacheControl<BaseMessage>(retryMessages);
               }
             }
 
@@ -1076,18 +1107,26 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
                 config
               );
               // Success with reduced context
-              console.info(`[Graph] ✅ Retry successful at ${reductionFactor * 100}% with ${reducedMessages.length} messages (reduced from ${finalMessages.length})`);
+              console.info(
+                `[Graph] ✅ Retry successful at ${reductionFactor * 100}% with ${reducedMessages.length} messages (reduced from ${finalMessages.length})`
+              );
             } catch (retryError) {
-              const retryErrorMsg = (retryError as Error)?.message?.toLowerCase() ?? '';
-              const stillTooLong = 
+              const retryErrorMsg =
+                (retryError as Error).message.toLowerCase() ?? '';
+              const stillTooLong =
                 retryErrorMsg.includes('too long') ||
                 retryErrorMsg.includes('context length') ||
                 retryErrorMsg.includes('validationexception');
-              
+
               if (stillTooLong && reductionFactor > 0.1) {
-                console.warn(`[Graph] Still too long at ${reductionFactor * 100}%, trying more aggressive pruning...`);
+                console.warn(
+                  `[Graph] Still too long at ${reductionFactor * 100}%, trying more aggressive pruning...`
+                );
               } else {
-                console.error(`[Graph] Retry at ${reductionFactor * 100}% failed:`, (retryError as Error)?.message);
+                console.error(
+                  `[Graph] Retry at ${reductionFactor * 100}% failed:`,
+                  (retryError as Error).message
+                );
               }
             }
           }

package/src/index.ts

@@ -13,6 +13,7 @@ export * from './tools/Calculator';
 export * from './tools/CodeExecutor';
 export * from './tools/ProgrammaticToolCalling';
 export * from './tools/ToolSearchRegex';
+export * from './tools/BrowserTools';
 export * from './tools/handlers';
 export * from './tools/search';