illuma-agents 1.0.62 → 1.0.64

package/dist/cjs/graphs/Graph.cjs

@@ -509,6 +509,7 @@ class StandardGraph extends Graph {
                 const result = await structuredModel.invoke(finalMessages, config);
                 // 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);
@@ -516,15 +517,28 @@ class StandardGraph extends Graph {
                     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,
                         rawMessage: result.raw,
                     };
                 }
+                // 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,
+                    };
+                }
                 // Fallback for models that don't support includeRaw
+                console.log('[Graph] Using fallback - treating result as structured response');
                 return {
                     structuredResponse: result,
                 };
@@ -813,6 +827,8 @@ class StandardGraph extends Graph {
                         provider: agentContext.provider,
                         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,
@@ -1062,14 +1078,39 @@ If I seem to be missing something we discussed earlier, just give me a quick rem
                             provider: agentContext.provider,
                             clientOptions: structuredClientOptions,
                         });
-                        // Include the current result in the messages so the model knows what it just said
-                        const messagesWithResult = [...finalMessages];
+                        // 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) {
-                            messagesWithResult.push(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) => typeof c === 'object' && c !== null &&
+                                    c.type === 'text' &&
+                                    typeof c.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 = [
+                            new messages.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: messagesWithResult,
+                            finalMessages: structuredMessages,
                             schema,
                             structuredOutputConfig: agentContext.structuredOutput,
                             provider: agentContext.provider,