illuma-agents 1.0.53 → 1.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "illuma-agents",
-  "version": "1.0.53",
+  "version": "1.0.55",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",

package/src/graphs/Graph.ts

@@ -764,30 +764,51 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     }
 
     // Use withStructuredOutput to bind the schema
+    // Always use includeRaw: true internally so we can debug what's returned
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const structuredModel = (model as any).withStructuredOutput(schema, {
       name,
       method,
-      includeRaw,
+      includeRaw: true, // Always true internally for debugging
       strict: structuredOutputConfig.strict !== false,
     });
 
+    console.log('[Graph] Structured output config:', {
+      name,
+      method,
+      provider,
+      schemaKeys: Object.keys(schema),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      modelName: (model as any).model || (model as any).modelId || 'unknown',
+    });
+
     let lastError: Error | undefined;
     let attempts = 0;
 
     while (attempts <= maxRetries) {
       try {
         const result = await structuredModel.invoke(finalMessages, config);
+        
+        // Debug: log what we got back
+        console.log('[Graph] Structured output raw result type:', typeof result);
+        if (result?.raw) {
+          const rawMsg = result.raw;
+          console.log('[Graph] Raw message content type:', typeof rawMsg?.content);
+          console.log('[Graph] Raw message tool_calls:', rawMsg?.tool_calls?.length ?? 0);
+          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));
+          }
+        }
 
-        // Handle includeRaw response format
-        if (includeRaw && result.raw && result.parsed) {
+        // Handle response - we always use includeRaw internally
+        if (result?.raw && result?.parsed !== undefined) {
           return {
             structuredResponse: result.parsed as Record<string, unknown>,
             rawMessage: result.raw as AIMessageChunk,
           };
         }
 
-        // Direct response
+        // Fallback for models that don't support includeRaw
         return {
           structuredResponse: result as Record<string, unknown>,
         };
@@ -1189,9 +1210,26 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             : undefined;
           this.cleanupSignalListener();
 
-          // Return both the structured response and the raw message
+          // CRITICAL: Create a clean message WITHOUT tool_calls for structured output
+          // The rawMessage contains a tool_call for the structured output schema (e.g., "response"),
+          // which would cause the graph router to send it to the tool node, failing with
+          // "Tool 'response' not found". We need to return a clean AI message that ends the graph.
+          let cleanMessage: AIMessageChunk | undefined;
+          if (rawMessage) {
+            // Create a new AIMessageChunk with the structured response as JSON content
+            // but WITHOUT the tool_calls that would trigger tool execution
+            cleanMessage = new AIMessageChunk({
+              content: JSON.stringify(structuredResponse, null, 2),
+              id: rawMessage.id,
+              response_metadata: rawMessage.response_metadata,
+              usage_metadata: rawMessage.usage_metadata,
+              // Explicitly exclude tool_calls to prevent routing to tool node
+            });
+          }
+
+          // Return the clean message (no tool_calls) so the graph ends here
           return {
-            messages: rawMessage ? [rawMessage] : [],
+            messages: cleanMessage ? [cleanMessage] : [],
             structuredResponse,
           };
         } catch (structuredError) {

package/src/llm/bedrock/index.ts

@@ -101,6 +101,24 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
     this.promptCache = fields?.promptCache ?? false;
     this.applicationInferenceProfile = fields?.applicationInferenceProfile;
     this.serviceTier = fields?.serviceTier;
+
+    // Fix: Force supportsToolChoiceValues for Claude models
+    // The parent constructor checks `model.includes('claude-3')` but this fails when:
+    // 1. Using applicationInferenceProfile ARNs (arn:aws:bedrock:...)
+    // 2. Using different naming conventions (claude-4, claude-opus-4, etc.)
+    // We need to ensure tool_choice is properly set for withStructuredOutput to work
+    const modelName = (fields?.model ?? '').toLowerCase();
+    const profileName = (fields?.applicationInferenceProfile ?? '').toLowerCase();
+    const isClaudeModel =
+      modelName.includes('claude') ||
+      modelName.includes('anthropic') ||
+      profileName.includes('claude') ||
+      profileName.includes('anthropic');
+
+    if (isClaudeModel && !this.supportsToolChoiceValues?.length) {
+      // Claude models support all tool choice values
+      this.supportsToolChoiceValues = ['auto', 'any', 'tool'];
+    }
   }
 
   static lc_name(): string {