illuma-agents 1.0.64 → 1.0.66

package/dist/cjs/graphs/Graph.cjs

@@ -454,7 +454,7 @@ class StandardGraph extends Graph {
                 `Please use a model that supports JSON schema output (e.g., OpenAI GPT-4, Anthropic Claude, Google Gemini) ` +
                 `or disable structured output for this agent.`);
         }
-        const { name = 'StructuredResponse', mode = 'auto', includeRaw = false, handleErrors = true, maxRetries = 2, } = structuredOutputConfig;
+        const { name = 'StructuredResponse', mode = 'auto', includeRaw: _includeRaw = false, handleErrors = true, maxRetries = 2, } = structuredOutputConfig;
         // Determine the method based on mode and provider
         // - 'tool' / 'functionCalling': Use tool calling (works with OpenAI, Bedrock)
         // - 'provider' / 'jsonMode': Use native JSON mode (OpenAI, Anthropic direct - NOT Bedrock)
@@ -509,7 +509,6 @@ 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);
@@ -517,28 +516,15 @@ 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,
                 };
@@ -780,15 +766,8 @@ class StandardGraph extends Graph {
                 analytics: contextAnalytics$1,
             }, config);
             // 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 = agentContext.isStructuredOutputMode &&
-                agentContext.structuredOutput &&
-                !hasTools; // Only use structured output immediately if no tools
-            if (shouldUseStructuredOutputNow) {
+            if (agentContext.isStructuredOutputMode &&
+                agentContext.structuredOutput) {
                 const schema = agentContext.getStructuredOutputSchema();
                 if (!schema) {
                     throw new Error('Structured output schema is not configured');
@@ -827,8 +806,6 @@ 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,
@@ -1040,112 +1017,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];
-            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,
-                        });
-                        // 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) => 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: structuredMessages,
-                            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;