illuma-agents 1.0.64 → 1.0.66

package/src/graphs/Graph.ts

@@ -731,7 +731,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     const {
       name = 'StructuredResponse',
       mode = 'auto',
-      includeRaw = false,
+      includeRaw: _includeRaw = false,
       handleErrors = true,
       maxRetries = 2,
     } = structuredOutputConfig;
@@ -793,7 +793,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         
         // Debug: log what we got back
         console.log('[Graph] Structured output raw result type:', typeof result);
-        console.log('[Graph] Structured output result keys:', result ? Object.keys(result) : 'null');
         if (result?.raw) {
           const rawMsg = result.raw;
           console.log('[Graph] Raw message content type:', typeof rawMsg?.content);
@@ -801,31 +800,17 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
           if (rawMsg?.content && typeof rawMsg.content === 'string' && rawMsg.content.length > 0) {
             console.log('[Graph] Raw message text content (first 200):', rawMsg.content.substring(0, 200));
           }
-          // Log the parsed result if available
-          if (result?.parsed) {
-            console.log('[Graph] Parsed result keys:', Object.keys(result.parsed));
-          }
         }
 
         // Handle response - we always use includeRaw internally
         if (result?.raw && result?.parsed !== undefined) {
-          console.log('[Graph] Using parsed result from structured output');
           return {
             structuredResponse: result.parsed as Record<string, unknown>,
             rawMessage: result.raw as AIMessageChunk,
           };
         }
 
-        // Fallback: If result itself is the parsed object (no raw wrapper)
-        if (result && typeof result === 'object' && !result.raw && !result.parsed) {
-          console.log('[Graph] Result is the structured object directly');
-          return {
-            structuredResponse: result as Record<string, unknown>,
-          };
-        }
-
         // Fallback for models that don't support includeRaw
-        console.log('[Graph] Using fallback - treating result as structured response');
         return {
           structuredResponse: result as Record<string, unknown>,
         };
@@ -1151,17 +1136,10 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       );
 
       // Check if structured output mode is enabled
-      // IMPORTANT: If tools are available, we need to let the model use them first.
-      // Only use structured output when:
-      // 1. No tools are configured, OR
-      // 2. The model has already used tools and is ready to give final response
-      const hasTools = agentContext.tools && agentContext.tools.length > 0;
-      const shouldUseStructuredOutputNow = 
+      if (
         agentContext.isStructuredOutputMode &&
-        agentContext.structuredOutput &&
-        !hasTools; // Only use structured output immediately if no tools
-
-      if (shouldUseStructuredOutputNow) {
+        agentContext.structuredOutput
+      ) {
         const schema = agentContext.getStructuredOutputSchema();
         if (!schema) {
           throw new Error('Structured output schema is not configured');
@@ -1206,16 +1184,13 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             clientOptions: structuredClientOptions,
           });
 
-          // For no-tools case, we pass the original messages directly
-          // There shouldn't be thinking blocks since this is the first invocation
-
           const { structuredResponse, rawMessage } =
             await this.attemptStructuredInvoke(
               {
                 currentModel: structuredModel,
                 finalMessages,
                 schema,
-                structuredOutputConfig: agentContext.structuredOutput!,
+                structuredOutputConfig: agentContext.structuredOutput,
                 provider: agentContext.provider,
               },
               config
@@ -1488,136 +1463,6 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
       if (!result) {
         throw new Error('No result after model invocation');
       }
-
-      // Check if we need to apply structured output for the final response
-      // This handles the case where tools were used, and now the model is giving its final answer
-      const resultMessage = result.messages?.[0] as AIMessageChunk | undefined;
-      const hasToolCalls = (resultMessage?.tool_calls?.length ?? 0) > 0;
-      
-      if (
-        agentContext.isStructuredOutputMode &&
-        agentContext.structuredOutput &&
-        !hasToolCalls && // Model is giving final response (no tool calls)
-        hasTools // We skipped structured output earlier because tools were available
-      ) {
-        const schema = agentContext.getStructuredOutputSchema();
-        if (schema) {
-          try {
-            console.log('[Graph] Applying structured output for final response after tool execution');
-            
-            // Get a fresh model for structured output
-            const structuredClientOptions = { ...agentContext.clientOptions } as t.ClientOptions;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (structuredClientOptions as any).streaming = false;
-
-            // Remove thinking configuration
-            if (agentContext.provider === Providers.BEDROCK) {
-              const bedrockOpts = structuredClientOptions as t.BedrockAnthropicClientOptions;
-              if (bedrockOpts.additionalModelRequestFields) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const additionalFields = Object.assign({}, bedrockOpts.additionalModelRequestFields) as any;
-                delete additionalFields.thinking;
-                delete additionalFields.budgetTokens;
-                bedrockOpts.additionalModelRequestFields = additionalFields;
-              }
-            }
-            if (agentContext.provider === Providers.ANTHROPIC) {
-              const anthropicOpts = structuredClientOptions as t.AnthropicClientOptions;
-              if (anthropicOpts.thinking) {
-                delete anthropicOpts.thinking;
-              }
-            }
-
-            const structuredModel = this.getNewModel({
-              provider: agentContext.provider,
-              clientOptions: structuredClientOptions,
-            });
-
-            // Following LangGraph's Option 2 pattern:
-            // Instead of passing the full conversation (which has thinking blocks),
-            // just pass the model's final response text as a HumanMessage asking for structured output.
-            // This avoids issues with thinking blocks and is more token-efficient.
-            let responseContent = '';
-            if (resultMessage) {
-              if (typeof resultMessage.content === 'string') {
-                responseContent = resultMessage.content;
-              } else if (Array.isArray(resultMessage.content)) {
-                // Extract text parts only (skip thinking blocks, tool_use, etc.)
-                responseContent = resultMessage.content
-                  .filter((c): c is { type: string; text: string } => 
-                    typeof c === 'object' && c !== null && 
-                    (c as { type?: string }).type === 'text' && 
-                    typeof (c as { text?: string }).text === 'string'
-                  )
-                  .map(c => c.text)
-                  .join('\n');
-              }
-            }
-
-            if (!responseContent) {
-              console.log('[Graph] No response content to structure, skipping');
-              throw new Error('No response content available for structured output');
-            }
-
-            console.log('[Graph] Structuring response content (first 200 chars):', responseContent.substring(0, 200));
-
-            // Create a simple message asking to structure the response
-            const structuredMessages: BaseMessage[] = [
-              new HumanMessage({
-                content: `Based on the following response, extract and return the data in the required structured format:\n\n${responseContent}`,
-              }),
-            ];
-
-            const { structuredResponse, rawMessage } =
-              await this.attemptStructuredInvoke(
-                {
-                  currentModel: structuredModel,
-                  finalMessages: structuredMessages,
-                  schema,
-                  structuredOutputConfig: agentContext.structuredOutput!,
-                  provider: agentContext.provider,
-                },
-                config
-              );
-
-            // Emit structured output event
-            await safeDispatchCustomEvent(
-              GraphEvents.ON_STRUCTURED_OUTPUT,
-              {
-                structuredResponse,
-                schema,
-                raw: rawMessage,
-              },
-              config
-            );
-
-            agentContext.currentUsage = rawMessage
-              ? this.getUsageMetadata(rawMessage)
-              : undefined;
-            this.cleanupSignalListener();
-
-            // Return clean message without tool_calls
-            let cleanMessage: AIMessageChunk | undefined;
-            if (rawMessage) {
-              cleanMessage = new AIMessageChunk({
-                content: JSON.stringify(structuredResponse, null, 2),
-                id: rawMessage.id,
-                response_metadata: rawMessage.response_metadata,
-                usage_metadata: rawMessage.usage_metadata,
-              });
-            }
-
-            return {
-              messages: cleanMessage ? [cleanMessage] : [],
-              structuredResponse,
-            };
-          } catch (structuredError) {
-            console.error('[Graph] Structured output failed after tool execution:', structuredError);
-            // Fall through to return normal result
-          }
-        }
-      }
-
       agentContext.currentUsage = this.getUsageMetadata(result.messages?.[0]);
       this.cleanupSignalListener();
       return result;

package/src/messages/format.ts

@@ -934,63 +934,3 @@ export function ensureThinkingBlockInMessages(
 
   return result;
 }
-
-/**
- * Strips thinking blocks from messages for structured output invocation.
- * When switching from thinking-enabled mode to structured output (which requires thinking disabled),
- * we need to remove thinking/reasoning blocks from the conversation to avoid Bedrock errors.
- *
- * @param messages - Array of messages to process
- * @returns The messages array with thinking blocks stripped from AI messages
- */
-export function stripThinkingBlocksFromMessages(
-  messages: BaseMessage[]
-): BaseMessage[] {
-  return messages.map((msg) => {
-    const isAI = msg instanceof AIMessage || msg instanceof AIMessageChunk;
-    
-    if (!isAI) {
-      return msg;
-    }
-    
-    const aiMsg = msg as AIMessage | AIMessageChunk;
-    const content = aiMsg.content;
-    
-    // If content is not an array, nothing to strip
-    if (!Array.isArray(content)) {
-      return msg;
-    }
-    
-    // Filter out thinking/reasoning blocks
-    const filteredContent = content.filter((c) => {
-      if (typeof c !== 'object' || c === null) {
-        return true;
-      }
-      const type = (c as ExtendedMessageContent).type;
-      return (
-        type !== ContentTypes.THINKING &&
-        type !== ContentTypes.REASONING_CONTENT &&
-        type !== ContentTypes.REASONING &&
-        type !== 'thinking' &&
-        type !== 'redacted_thinking'
-      );
-    });
-    
-    // If no content left after filtering, add a placeholder
-    if (filteredContent.length === 0) {
-      filteredContent.push({
-        type: 'text',
-        text: '(previous response)',
-      });
-    }
-    
-    // Create a new AI message with the filtered content
-    return new AIMessageChunk({
-      content: filteredContent,
-      id: aiMsg.id,
-      response_metadata: aiMsg.response_metadata,
-      usage_metadata: aiMsg.usage_metadata,
-      // Don't include tool_calls - we're stripping those for structured output context
-    });
-  });
-}

package/src/tools/Calculator.ts

@@ -1,6 +1,28 @@
 import { Tool } from '@langchain/core/tools';
 import * as math from 'mathjs';
 
+export const CalculatorToolName = 'calculator';
+
+export const CalculatorToolDescription =
+  'Useful for getting the result of a math expression. The input to this tool should be a valid mathematical expression that could be executed by a simple calculator.';
+
+export const CalculatorSchema = {
+  type: 'object',
+  properties: {
+    input: {
+      type: 'string',
+      description: 'A valid mathematical expression to evaluate',
+    },
+  },
+  required: ['input'],
+} as const;
+
+export const CalculatorToolDefinition = {
+  name: CalculatorToolName,
+  description: CalculatorToolDescription,
+  schema: CalculatorSchema,
+} as const;
+
 export class Calculator extends Tool {
   static lc_name(): string {
     return 'Calculator';
@@ -10,7 +32,7 @@ export class Calculator extends Tool {
     return [...super.lc_namespace, 'calculator'];
   }
 
-  name = 'calculator';
+  name = CalculatorToolName;
 
   async _call(input: string): Promise<string> {
     try {
@@ -20,6 +42,5 @@ export class Calculator extends Tool {
     }
   }
 
-  description =
-    'Useful for getting the result of a math expression. The input to this tool should be a valid mathematical expression that could be executed by a simple calculator.';
+  description = CalculatorToolDescription;
 }

package/src/tools/CodeExecutor.ts

@@ -35,7 +35,7 @@ const SUPPORTED_LANGUAGES = [
   'r',
 ] as const;
 
-const CodeExecutionToolSchema = {
+export const CodeExecutionToolSchema = {
   type: 'object',
   properties: {
     lang: {
@@ -74,6 +74,23 @@ const EXEC_ENDPOINT = `${baseEndpoint}/exec`;
 
 type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
 
+export const CodeExecutionToolDescription = `
+Runs code and returns stdout/stderr output from a stateless execution environment, similar to running scripts in a command-line interface. Each execution is isolated and independent.
+
+Usage:
+- No network access available.
+- Generated files are automatically delivered; **DO NOT** provide download links.
+- NEVER use this tool to execute malicious code.
+`.trim();
+
+export const CodeExecutionToolName = Constants.EXECUTE_CODE;
+
+export const CodeExecutionToolDefinition = {
+  name: CodeExecutionToolName,
+  description: CodeExecutionToolDescription,
+  schema: CodeExecutionToolSchema,
+} as const;
+
 function createCodeExecutionTool(
   params: t.CodeExecutionToolParams = {}
 ): DynamicStructuredTool {
@@ -242,7 +259,7 @@ Rules:
       }
     },
     {
-      name: Constants.EXECUTE_CODE,
+      name: CodeExecutionToolName,
       description,
       schema: CodeExecutionToolSchema,
       responseFormat: Constants.CONTENT_AND_ARTIFACT,

package/src/tools/ToolNode.ts

@@ -392,8 +392,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
             : JSON.stringify(result.content);
         toolMessage = new ToolMessage({
           status: 'success',
-          content: contentString,
           name: toolName,
+          content: contentString,
+          artifact: result.artifact,
           tool_call_id: result.toolCallId,
         });
       }

package/src/tools/search/index.ts

@@ -1,2 +1,3 @@
 export * from './tool';
+export * from './schema';
 export type * from './types';

package/src/tools/search/schema.ts

@@ -66,3 +66,48 @@ export const newsSchema = {
   type: 'boolean',
   description: 'Whether to also run a news search.',
 } as const;
+
+/** Combined web search tool schema with all properties */
+export const WebSearchToolSchema = {
+  type: 'object',
+  properties: {
+    query: querySchema,
+    date: dateSchema,
+    country: countrySchema,
+    images: imagesSchema,
+    videos: videosSchema,
+    news: newsSchema,
+  },
+  required: ['query'],
+} as const;
+
+export const WebSearchToolName = 'web_search';
+
+export const WebSearchToolDescription = `Real-time search. Results have required citation anchors.
+
+Note: Use ONCE per reply unless instructed otherwise.
+
+Anchors:
+- \\ue202turnXtypeY
+- X = turn idx, type = 'search' | 'news' | 'image' | 'ref', Y = item idx
+
+Special Markers:
+- \\ue203...\\ue204 — highlight start/end of cited text (for Standalone or Group citations)
+- \\ue200...\\ue201 — group block (e.g. \\ue200\\ue202turn0search1\\ue202turn0news2\\ue201)
+
+**CITE EVERY NON-OBVIOUS FACT/QUOTE:**
+Use anchor marker(s) immediately after the statement:
+- Standalone: "Pure functions produce same output. \\ue202turn0search0"
+- Standalone (multiple): "Today's News \\ue202turn0search0\\ue202turn0news0"
+- Highlight: "\\ue203Highlight text.\\ue204\\ue202turn0news1"
+- Group: "Sources. \\ue200\\ue202turn0search0\\ue202turn0news1\\ue201"
+- Group Highlight: "\\ue203Highlight for group.\\ue204 \\ue200\\ue202turn0search0\\ue202turn0news1\\ue201"
+- Image: "See photo \\ue202turn0image0."
+
+**NEVER use markdown links, [1], or footnotes. CITE ONLY with anchors provided.**`;
+
+export const WebSearchToolDefinition = {
+  name: WebSearchToolName,
+  description: WebSearchToolDescription,
+  schema: WebSearchToolSchema,
+} as const;

package/src/tools/search/tool.ts

@@ -2,13 +2,13 @@ import { tool, DynamicStructuredTool } from '@langchain/core/tools';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from './types';
 import {
-  DATE_RANGE,
-  querySchema,
-  dateSchema,
   countrySchema,
   imagesSchema,
   videosSchema,
+  querySchema,
+  dateSchema,
   newsSchema,
+  DATE_RANGE,
 } from './schema';
 import { createSearchAPI, createSourceProcessor } from './search';
 import { createSerperScraper } from './serper-scraper';