illuma-agents 1.0.59 → 1.0.61

package/dist/cjs/graphs/Graph.cjs

@@ -502,13 +502,11 @@ class StandardGraph extends Graph {
         });
         let lastError;
         let attempts = 0;
-        // Create a silent config for structured output - we don't want tool call events
-        // to be emitted for the synthetic "response" tool used by withStructuredOutput()
-        // This prevents the UI from showing a fake tool call
-        const silentConfig = config ? { ...config, callbacks: undefined } : undefined;
         while (attempts <= maxRetries) {
             try {
-                const result = await structuredModel.invoke(finalMessages, silentConfig);
+                // Note: We pass the original config here. The stream aggregator will filter out
+                // the synthetic "response" tool call events from withStructuredOutput()
+                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) {
@@ -768,8 +766,15 @@ class StandardGraph extends Graph {
                 analytics: contextAnalytics$1,
             }, config);
             // Check if structured output mode is enabled
-            if (agentContext.isStructuredOutputMode &&
-                agentContext.structuredOutput) {
+            // 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 = agentContext.isStructuredOutputMode &&
+                agentContext.structuredOutput &&
+                !hasTools; // Only use structured output immediately if no tools
+            if (shouldUseStructuredOutputNow) {
                 const schema = agentContext.getStructuredOutputSchema();
                 if (!schema) {
                     throw new Error('Structured output schema is not configured');
@@ -1019,6 +1024,87 @@ 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];
+            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 };
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        structuredClientOptions.streaming = false;
+                        // Remove thinking configuration
+                        if (agentContext.provider === _enum.Providers.BEDROCK) {
+                            const bedrockOpts = structuredClientOptions;
+                            if (bedrockOpts.additionalModelRequestFields) {
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                const additionalFields = Object.assign({}, bedrockOpts.additionalModelRequestFields);
+                                delete additionalFields.thinking;
+                                delete additionalFields.budgetTokens;
+                                bedrockOpts.additionalModelRequestFields = additionalFields;
+                            }
+                        }
+                        if (agentContext.provider === _enum.Providers.ANTHROPIC) {
+                            const anthropicOpts = structuredClientOptions;
+                            if (anthropicOpts.thinking) {
+                                delete anthropicOpts.thinking;
+                            }
+                        }
+                        const structuredModel = this.getNewModel({
+                            provider: agentContext.provider,
+                            clientOptions: structuredClientOptions,
+                        });
+                        // Include the current result in the messages so the model knows what it just said
+                        const messagesWithResult = [...finalMessages];
+                        if (resultMessage) {
+                            messagesWithResult.push(resultMessage);
+                        }
+                        const { structuredResponse, rawMessage } = await this.attemptStructuredInvoke({
+                            currentModel: structuredModel,
+                            finalMessages: messagesWithResult,
+                            schema,
+                            structuredOutputConfig: agentContext.structuredOutput,
+                            provider: agentContext.provider,
+                        }, config);
+                        // Emit structured output event
+                        await events.safeDispatchCustomEvent(_enum.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;
+                        if (rawMessage) {
+                            cleanMessage = new messages.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;