agent-orcha 0.0.4 → 0.0.7

package/dist/lib/agents/agent-executor.d.ts

@@ -1,18 +1,29 @@
-import type { AgentDefinition, AgentInstance } from './types.js';
-import type { ToolRegistry } from '../tools/tool-registry.js';
-import type { ConversationStore } from '../memory/conversation-store.js';
+import type { AgentDefinition, AgentInstance } from './types.ts';
+import type { ToolRegistry } from '../tools/tool-registry.ts';
+import type { ConversationStore } from '../memory/conversation-store.ts';
+import type { SkillLoader } from '../skills/skill-loader.ts';
+import type { MemoryManager } from '../memory/memory-manager.ts';
+import type { IntegrationAccessor } from '../integrations/types.ts';
 export declare class AgentExecutor {
     private toolRegistry;
     private conversationStore;
-    constructor(toolRegistry: ToolRegistry, conversationStore: ConversationStore);
+    private skillLoader?;
+    private memoryManager?;
+    private integrations?;
+    constructor(toolRegistry: ToolRegistry, conversationStore: ConversationStore, skillLoader?: SkillLoader, memoryManager?: MemoryManager, integrations?: IntegrationAccessor);
     createInstance(definition: AgentDefinition): Promise<AgentInstance>;
     private invoke;
     private parseInvokeOptions;
     private invokeWithTools;
     private invokeWithoutTools;
     private formatUserMessage;
+    private buildUserContent;
     private stream;
     private buildMessagesWithHistory;
+    private buildStoredMessage;
+    private extractToolSummariesFromMessages;
+    private normalizeMemoryConfig;
+    private buildMemoryPrompt;
     private extractStructuredOutput;
 }
 //# sourceMappingURL=agent-executor.d.ts.map

package/dist/lib/agents/agent-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-executor.d.ts","sourceRoot":"","sources":["../../../lib/agents/agent-executor.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAmC,MAAM,YAAY,CAAC;AAElG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAIzE,qBAAa,aAAa;IACxB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,iBAAiB,CAAoB;gBAEjC,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,iBAAiB;IAKtE,cAAc,CAAC,UAAU,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;YAe3D,MAAM;IAgBpB,OAAO,CAAC,kBAAkB;YAgBZ,eAAe;YAgHf,kBAAkB;IA2DhC,OAAO,CAAC,iBAAiB;YAmBV,MAAM;IAiHrB,OAAO,CAAC,wBAAwB;IA4BhC,OAAO,CAAC,uBAAuB;CAyChC"}
+{"version":3,"file":"agent-executor.d.ts","sourceRoot":"","sources":["../../../lib/agents/agent-executor.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAsD,MAAM,YAAY,CAAC;AAErH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAapE,qBAAa,aAAa;IACxB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,YAAY,CAAC,CAAsB;gBAE/B,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,WAAW,CAAC,EAAE,WAAW,EAAE,aAAa,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,EAAE,mBAAmB;IAQpK,cAAc,CAAC,UAAU,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,CAAC;YA8D3D,MAAM;IAgBpB,OAAO,CAAC,kBAAkB;YAkBZ,eAAe;YAmIf,kBAAkB;IAyEhC,OAAO,CAAC,iBAAiB;IAmBzB,OAAO,CAAC,gBAAgB;YAcT,MAAM;IAiNrB,OAAO,CAAC,wBAAwB;IAyBhC,OAAO,CAAC,kBAAkB;IAiB1B,OAAO,CAAC,gCAAgC;IA8BxC,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,iBAAiB;IAwBzB,OAAO,CAAC,uBAAuB;CAyChC"}

package/dist/lib/agents/agent-executor.js

@@ -1,24 +1,82 @@
-import { createAgent } from "langchain";
-import { HumanMessage, AIMessage } from '@langchain/core/messages';
-import { LLMFactory } from '../llm/llm-factory.js';
-import { StructuredOutputWrapper } from './structured-output-wrapper.js';
-import { logger } from '../logger.js';
+import { createReActAgent } from "./react-loop.js";
+import { humanMessage, aiMessage, contentToText } from "../types/llm-types.js";
+import { LLMFactory } from "../llm/llm-factory.js";
+import { createMemorySaveTool } from "../tools/built-in/memory-save.tool.js";
+import { createIntegrationTools } from "../tools/built-in/integration-tools.js";
+import { StructuredOutputWrapper } from "./structured-output-wrapper.js";
+import { logLLMCallStart, logLLMCallEnd } from "../llm/llm-call-logger.js";
+import { logger } from "../logger.js";
+function isAbortError(err) {
+    if (err instanceof DOMException && err.name === 'AbortError')
+        return true;
+    if (err instanceof Error && err.name === 'AbortError')
+        return true;
+    return false;
+}
 export class AgentExecutor {
     toolRegistry;
     conversationStore;
-    constructor(toolRegistry, conversationStore) {
+    skillLoader;
+    memoryManager;
+    integrations;
+    constructor(toolRegistry, conversationStore, skillLoader, memoryManager, integrations) {
         this.toolRegistry = toolRegistry;
         this.conversationStore = conversationStore;
+        this.skillLoader = skillLoader;
+        this.memoryManager = memoryManager;
+        this.integrations = integrations;
     }
     async createInstance(definition) {
-        let llm = LLMFactory.create(definition.llm);
+        // Resolve skills and augment system prompt if configured
+        let augmentedDefinition = definition;
+        if (definition.skills && this.skillLoader) {
+            const content = this.skillLoader.resolveForAgent(definition.skills);
+            if (content) {
+                augmentedDefinition = {
+                    ...definition,
+                    prompt: {
+                        ...definition.prompt,
+                        system: `${definition.prompt.system}\n\n${content}`,
+                    },
+                };
+            }
+        }
+        // Resolve memory and augment system prompt if configured
+        const memoryConfig = this.normalizeMemoryConfig(definition.memory);
+        if (memoryConfig && this.memoryManager) {
+            const memoryContent = await this.memoryManager.load(definition.name);
+            const memoryPrompt = this.buildMemoryPrompt(memoryContent, memoryConfig.maxLines);
+            augmentedDefinition = {
+                ...augmentedDefinition,
+                prompt: {
+                    ...augmentedDefinition.prompt,
+                    system: `${augmentedDefinition.prompt.system}\n\n${memoryPrompt}`,
+                },
+            };
+        }
+        let llm = LLMFactory.create(augmentedDefinition.llm);
         // Wrap LLM with structured output if configured
-        llm = StructuredOutputWrapper.wrapLLM(llm, definition.output);
-        const tools = await this.toolRegistry.resolveTools(definition.tools);
+        llm = StructuredOutputWrapper.wrapLLM(llm, augmentedDefinition.output);
+        const tools = await this.toolRegistry.resolveTools(augmentedDefinition.tools);
+        // Auto-inject memory tool if configured
+        if (memoryConfig && this.memoryManager) {
+            tools.push(createMemorySaveTool(this.memoryManager, definition.name, memoryConfig.maxLines));
+            logger.info(`[AgentExecutor] Auto-injected save_memory tool for agent: ${definition.name}`);
+        }
+        // Auto-inject integration tools if agent has integrations configured
+        if (definition.integrations?.length && this.integrations) {
+            const existingNames = new Set(tools.map((t) => t.name));
+            const integrationTools = createIntegrationTools(this.integrations, definition.name)
+                .filter((t) => !existingNames.has(t.name));
+            if (integrationTools.length > 0) {
+                tools.push(...integrationTools);
+                logger.info(`[AgentExecutor] Auto-injected ${integrationTools.length} integration tools for agent: ${definition.name}`);
+            }
+        }
         return {
-            definition,
-            invoke: async (input) => this.invoke(definition, llm, tools, input),
-            stream: (input) => this.stream(definition, llm, tools, input),
+            definition: augmentedDefinition,
+            invoke: async (input) => this.invoke(augmentedDefinition, llm, tools, input),
+            stream: (input) => this.stream(augmentedDefinition, llm, tools, input),
         };
     }
     async invoke(definition, llm, tools, input) {
@@ -36,6 +94,7 @@ export class AgentExecutor {
             return {
                 input: options.input,
                 sessionId: options.sessionId,
+                signal: options.signal,
             };
         }
         // Otherwise treat as direct input
@@ -43,26 +102,37 @@ export class AgentExecutor {
     }
     async invokeWithTools(definition, llm, tools, input, startTime, sessionId) {
         try {
-            const agent = createAgent({
+            const agent = createReActAgent({
                 model: llm,
                 tools,
                 systemPrompt: definition.prompt.system,
             });
-            const userMessage = this.formatUserMessage(definition, input);
-            const messages = this.buildMessagesWithHistory(userMessage, sessionId);
-            logger.info(`[Agent: ${definition.name}] Invoking with ${tools.length} tools...`);
-            logger.info(`[Agent: ${definition.name}] User message: ${userMessage.substring(0, 100)}...`);
+            const userText = this.formatUserMessage(definition, input);
+            const userContent = this.buildUserContent(userText, input);
+            const messages = this.buildMessagesWithHistory(userContent, sessionId);
+            const caller = `Agent: ${definition.name}`;
             if (sessionId) {
-                logger.info(`[Agent: ${definition.name}] Using session: ${sessionId} with ${messages.length} messages`);
+                logger.info(`[${caller}] Using session: ${sessionId}`);
             }
-            // Increase recursion limit to prevent premature termination
-            // Default is 25, increase to 50 for complex workflows
+            const { startTime: llmStart, stats } = logLLMCallStart({
+                caller,
+                systemPrompt: definition.prompt.system,
+                messages,
+                tools,
+            });
+            logger.info(`[${caller}] Reaching LLM provider...`);
             const result = await agent.invoke({
                 messages,
             }, {
-                recursionLimit: 50,
+                recursionLimit: definition.maxIterations ?? 200,
+                signal: undefined,
+            });
+            const lastMsg = result.messages?.[result.messages.length - 1];
+            const responseContent = lastMsg && 'content' in lastMsg ? contentToText(lastMsg.content) : '';
+            logLLMCallEnd(caller, llmStart, stats, {
+                contentLength: responseContent.length,
+                messageCount: result.messages?.length ?? 0,
             });
-            logger.info(`[Agent: ${definition.name}] Got ${result.messages?.length ?? 0} messages`);
             if (!result.messages || result.messages.length === 0) {
                 logger.warn(`[Agent: ${definition.name}] No messages returned`);
                 return {
@@ -83,7 +153,7 @@ export class AgentExecutor {
             }
             else if (typeof lastMessage === 'object' && lastMessage !== null) {
                 if ('content' in lastMessage) {
-                    output = String(lastMessage.content);
+                    output = contentToText(lastMessage.content);
                 }
                 else {
                     output = JSON.stringify(lastMessage);
@@ -92,9 +162,11 @@ export class AgentExecutor {
             else {
                 output = String(lastMessage);
             }
-            // Store AI response in session
+            // Extract tool call summaries from the message chain and store with response
             if (sessionId && typeof output === 'string') {
-                this.conversationStore.addMessage(sessionId, new AIMessage(output));
+                const toolSummaries = this.extractToolSummariesFromMessages(result.messages);
+                const storedMessage = this.buildStoredMessage(output, toolSummaries);
+                this.conversationStore.addMessage(sessionId, aiMessage(storedMessage));
             }
             if (typeof output === 'string' && (!output || output === 'null' || output === 'undefined')) {
                 logger.warn(`[Agent: ${definition.name}] Empty output, last message:`, lastMessage);
@@ -122,9 +194,12 @@ export class AgentExecutor {
             };
         }
         catch (error) {
-            logger.error(`[Agent: ${definition.name}] Error:`, error);
+            const errorMsg = isAbortError(error)
+                ? 'Request was aborted'
+                : (error instanceof Error ? error.message : String(error));
+            logger.error(`[Agent: ${definition.name}] Error: ${errorMsg}`);
             return {
-                output: `Agent error: ${error instanceof Error ? error.message : String(error)}`,
+                output: `Agent error: ${errorMsg}`,
                 metadata: {
                     duration: Date.now() - startTime,
                     toolCalls: [],
@@ -135,30 +210,41 @@ export class AgentExecutor {
         }
     }
     async invokeWithoutTools(definition, llm, input, startTime, sessionId) {
-        const userMessage = this.formatUserMessage(definition, input);
+        const userText = this.formatUserMessage(definition, input);
+        const userContent = this.buildUserContent(userText, input);
         // Build messages with history for session-based conversations
         const messageHistory = sessionId ? this.conversationStore.getMessages(sessionId) : [];
         const allMessages = [
-            new HumanMessage(definition.prompt.system),
+            { role: 'system', content: definition.prompt.system },
             ...messageHistory,
-            new HumanMessage(userMessage),
+            humanMessage(userContent),
         ];
-        // Store user message in session before invoking
+        // Store user message in session before invoking (text only — no base64 in memory)
         if (sessionId) {
-            this.conversationStore.addMessage(sessionId, new HumanMessage(userMessage));
+            this.conversationStore.addMessage(sessionId, humanMessage(userText));
         }
+        const caller = `Agent: ${definition.name}`;
+        const { startTime: llmStart, stats } = logLLMCallStart({
+            caller,
+            systemPrompt: definition.prompt.system,
+            messages: allMessages,
+        });
+        logger.info(`[${caller}] Reaching LLM provider...`);
         const result = await llm.invoke(allMessages);
+        logLLMCallEnd(caller, llmStart, stats, {
+            contentLength: result.content.length,
+        });
         let output;
         // Handle structured output
         if (definition.output?.format === 'structured') {
             output = this.extractStructuredOutput(result);
         }
         else {
-            output = String(result.content);
+            output = contentToText(result.content);
         }
         // Store AI response in session
         if (sessionId && typeof output === 'string') {
-            this.conversationStore.addMessage(sessionId, new AIMessage(output));
+            this.conversationStore.addMessage(sessionId, aiMessage(output));
         }
         // Validate structured output if applicable
         let structuredOutputValid;
@@ -195,122 +281,286 @@ export class AgentExecutor {
         })
             .join('\n');
     }
+    buildUserContent(text, input) {
+        const attachments = input.attachments;
+        if (!Array.isArray(attachments) || attachments.length === 0)
+            return text;
+        const parts = [];
+        if (text)
+            parts.push({ type: 'text', text });
+        for (const att of attachments) {
+            if (att && typeof att.data === 'string' && typeof att.mediaType === 'string') {
+                parts.push({ type: 'image', data: att.data, mediaType: att.mediaType });
+            }
+        }
+        return parts.length > 0 ? parts : text;
+    }
     async *stream(definition, llm, tools, input) {
-        const { input: actualInput, sessionId } = this.parseInvokeOptions(input);
+        const { input: actualInput, sessionId, signal } = this.parseInvokeOptions(input);
         if (tools.length > 0) {
-            const agent = createAgent({
+            const agent = createReActAgent({
                 model: llm,
                 tools,
                 systemPrompt: definition.prompt.system,
             });
-            const userMessage = this.formatUserMessage(definition, actualInput);
-            const messages = this.buildMessagesWithHistory(userMessage, sessionId);
-            const eventStream = await agent.streamEvents({ messages }, {
+            const userText = this.formatUserMessage(definition, actualInput);
+            const userContent = this.buildUserContent(userText, actualInput);
+            const messages = this.buildMessagesWithHistory(userContent, sessionId);
+            const caller = `Agent: ${definition.name}`;
+            const { startTime: llmStart, stats } = logLLMCallStart({
+                caller,
+                systemPrompt: definition.prompt.system,
+                messages,
+                tools,
+            });
+            logger.info(`[${caller}] Reaching LLM provider...`);
+            const eventStream = agent.streamEvents({ messages }, {
                 version: 'v2',
+                recursionLimit: definition.maxIterations ?? 200,
+                signal,
             });
             let accumulatedOutput = '';
             let finalMessage = null;
-            for await (const event of eventStream) {
-                if (event.event === 'on_chat_model_stream') {
-                    const chunk = event.data.chunk;
-                    if (chunk.content) {
-                        accumulatedOutput += chunk.content;
-                        yield { type: 'content', content: chunk.content };
+            let totalInputTokens = 0;
+            let totalOutputTokens = 0;
+            const toolCallSummaries = [];
+            const pendingToolCalls = new Map();
+            try {
+                for await (const event of eventStream) {
+                    if (event.event === 'on_chat_model_stream') {
+                        const chunk = event.data.chunk;
+                        const text = contentToText(chunk.content ?? '');
+                        if (text) {
+                            accumulatedOutput += text;
+                            yield { type: 'content', content: text };
+                        }
+                        if (chunk.reasoning) {
+                            yield { type: 'thinking', content: chunk.reasoning };
+                        }
+                    }
+                    else if (event.event === 'on_chat_model_end') {
+                        finalMessage = event.data.output;
+                        const um = event.data.output?.usage_metadata;
+                        if (um) {
+                            totalInputTokens += um.input_tokens || 0;
+                            totalOutputTokens += um.output_tokens || 0;
+                        }
+                    }
+                    else if (event.event === 'on_tool_start') {
+                        pendingToolCalls.set(event.run_id, { tool: event.name, input: event.data.input });
+                        yield {
+                            type: 'tool_start',
+                            tool: event.name,
+                            input: event.data.input,
+                            runId: event.run_id,
+                        };
+                    }
+                    else if (event.event === 'on_tool_end') {
+                        const pending = pendingToolCalls.get(event.run_id);
+                        toolCallSummaries.push({
+                            tool: event.name,
+                            input: pending?.input ?? null,
+                            output: event.data.output,
+                        });
+                        pendingToolCalls.delete(event.run_id);
+                        yield {
+                            type: 'tool_end',
+                            tool: event.name,
+                            output: event.data.output,
+                            runId: event.run_id,
+                        };
+                    }
+                    else if (event.event === 'on_react_iteration') {
+                        yield { type: 'react_iteration', ...event.data };
                     }
                 }
-                else if (event.event === 'on_chat_model_end') {
-                    // Capture the final message for structured output extraction
-                    finalMessage = event.data.output;
-                }
-                else if (event.event === 'on_tool_start') {
-                    yield {
-                        type: 'tool_start',
-                        tool: event.name,
-                        input: event.data.input,
-                        runId: event.run_id,
-                    };
-                }
-                else if (event.event === 'on_tool_end') {
-                    yield {
-                        type: 'tool_end',
-                        tool: event.name,
-                        output: event.data.output,
-                        runId: event.run_id,
-                    };
+            }
+            catch (streamError) {
+                const errorMsg = isAbortError(streamError)
+                    ? 'Request was aborted'
+                    : (streamError instanceof Error ? streamError.message : String(streamError));
+                logger.error(`[Agent: ${definition.name}] Stream error: ${errorMsg}`);
+                yield { type: 'error', error: errorMsg };
+                // Still store what we have so far
+                if (sessionId && (accumulatedOutput || toolCallSummaries.length > 0)) {
+                    const partialMessage = this.buildStoredMessage(accumulatedOutput || '(agent encountered an error)', toolCallSummaries);
+                    this.conversationStore.addMessage(sessionId, aiMessage(partialMessage));
                 }
+                return;
             }
+            logLLMCallEnd(caller, llmStart, stats, {
+                contentLength: accumulatedOutput.length,
+            });
+            // Build the message to store: text response + tool call summaries
+            const storedMessage = this.buildStoredMessage(accumulatedOutput, toolCallSummaries);
             // Handle structured output
             if (definition.output?.format === 'structured' && finalMessage) {
                 const structuredOutput = this.extractStructuredOutput(finalMessage);
                 yield { type: 'result', output: structuredOutput };
-                // Store structured output as JSON string in session
                 if (sessionId) {
-                    this.conversationStore.addMessage(sessionId, new AIMessage(JSON.stringify(structuredOutput)));
+                    this.conversationStore.addMessage(sessionId, aiMessage(JSON.stringify(structuredOutput)));
                 }
             }
-            else if (sessionId && accumulatedOutput) {
-                // Store AI response in session after streaming completes
-                this.conversationStore.addMessage(sessionId, new AIMessage(accumulatedOutput));
+            else if (sessionId && storedMessage) {
+                this.conversationStore.addMessage(sessionId, aiMessage(storedMessage));
+            }
+            // Yield usage stats if available
+            if (totalInputTokens > 0 || totalOutputTokens > 0) {
+                yield {
+                    type: 'usage',
+                    input_tokens: totalInputTokens,
+                    output_tokens: totalOutputTokens,
+                    total_tokens: totalInputTokens + totalOutputTokens,
+                };
             }
         }
         else {
-            const userMessage = this.formatUserMessage(definition, actualInput);
+            const userText = this.formatUserMessage(definition, actualInput);
+            const userContent = this.buildUserContent(userText, actualInput);
             // Build messages with history for session-based conversations
             const messageHistory = sessionId ? this.conversationStore.getMessages(sessionId) : [];
             const allMessages = [
-                new HumanMessage(definition.prompt.system),
+                { role: 'system', content: definition.prompt.system },
                 ...messageHistory,
-                new HumanMessage(userMessage),
+                humanMessage(userContent),
             ];
-            // Store user message in session before streaming
+            // Store user message in session before streaming (text only — no base64 in memory)
             if (sessionId) {
-                this.conversationStore.addMessage(sessionId, new HumanMessage(userMessage));
+                this.conversationStore.addMessage(sessionId, humanMessage(userText));
             }
-            const stream = await llm.stream(allMessages);
+            const caller = `Agent: ${definition.name}`;
+            const { startTime: llmStart, stats } = logLLMCallStart({
+                caller,
+                systemPrompt: definition.prompt.system,
+                messages: allMessages,
+            });
+            logger.info(`[${caller}] Reaching LLM provider...`);
+            const stream = llm.stream(allMessages, { signal });
             let accumulatedOutput = '';
             let finalChunk = null;
             for await (const chunk of stream) {
                 finalChunk = chunk;
-                if (typeof chunk.content === 'string') {
+                if (typeof chunk.content === 'string' && chunk.content) {
                     accumulatedOutput += chunk.content;
                     yield { type: 'content', content: chunk.content };
                 }
+                if (chunk.reasoning) {
+                    yield { type: 'thinking', content: chunk.reasoning };
+                }
             }
+            logLLMCallEnd(caller, llmStart, stats, {
+                contentLength: accumulatedOutput.length,
+            });
             // Handle structured output
             if (definition.output?.format === 'structured' && finalChunk) {
                 const structuredOutput = this.extractStructuredOutput(finalChunk);
                 yield { type: 'result', output: structuredOutput };
                 // Store structured output as JSON string in session
                 if (sessionId) {
-                    this.conversationStore.addMessage(sessionId, new AIMessage(JSON.stringify(structuredOutput)));
+                    this.conversationStore.addMessage(sessionId, aiMessage(JSON.stringify(structuredOutput)));
                 }
             }
             else if (sessionId && accumulatedOutput) {
                 // Store AI response in session after streaming completes
-                this.conversationStore.addMessage(sessionId, new AIMessage(accumulatedOutput));
+                this.conversationStore.addMessage(sessionId, aiMessage(accumulatedOutput));
+            }
+            // Yield usage stats from the final chunk if available
+            const um = finalChunk?.usage_metadata;
+            if (um) {
+                yield {
+                    type: 'usage',
+                    input_tokens: um.input_tokens ?? 0,
+                    output_tokens: um.output_tokens ?? 0,
+                    total_tokens: um.total_tokens ?? 0,
+                };
             }
         }
     }
-    buildMessagesWithHistory(userMessage, sessionId) {
+    buildMessagesWithHistory(userContent, sessionId) {
         const messages = [];
         // Add history from store
         if (sessionId && this.conversationStore.hasSession(sessionId)) {
             const history = this.conversationStore.getMessages(sessionId);
             for (const msg of history) {
-                messages.push({
-                    role: msg._getType() === 'human' ? 'user' : 'assistant',
-                    content: String(msg.content),
-                });
+                messages.push(msg);
             }
         }
-        // Add current user message
-        messages.push({ role: 'user', content: userMessage });
-        // Store user message
+        // Add current user message (with attachments if present)
+        messages.push(humanMessage(userContent));
+        // Store user message (text only — no base64 in memory)
         if (sessionId) {
-            this.conversationStore.addMessage(sessionId, new HumanMessage(userMessage));
+            this.conversationStore.addMessage(sessionId, humanMessage(contentToText(userContent)));
         }
         return messages;
     }
+    buildStoredMessage(textResponse, toolSummaries) {
+        if (toolSummaries.length === 0)
+            return textResponse;
+        const summaryLines = toolSummaries.map((tc) => {
+            const inputStr = typeof tc.input === 'string' ? tc.input : JSON.stringify(tc.input);
+            const outputStr = typeof tc.output === 'string' ? tc.output : JSON.stringify(tc.output);
+            // Truncate to keep token usage reasonable
+            const truncated = (s, max) => s.length > max ? s.slice(0, max) + '...' : s;
+            return `[Tool: ${tc.tool}] Input: ${truncated(inputStr, 200)} → Output: ${truncated(outputStr, 500)}`;
+        });
+        return `${textResponse}\n\n<tool_history>\n${summaryLines.join('\n')}\n</tool_history>`;
+    }
+    extractToolSummariesFromMessages(messages) {
+        const summaries = [];
+        if (!messages)
+            return summaries;
+        // Collect tool call inputs from AI messages (tool_calls array)
+        const toolCallInputs = new Map();
+        for (const msg of messages) {
+            if (msg.role === 'ai' && Array.isArray(msg.tool_calls)) {
+                for (const tc of msg.tool_calls) {
+                    toolCallInputs.set(tc.id, { name: tc.name, args: tc.args });
+                }
+            }
+        }
+        // Match tool messages to their inputs
+        for (const msg of messages) {
+            if (msg.role === 'tool') {
+                const callInfo = toolCallInputs.get(msg.tool_call_id);
+                summaries.push({
+                    tool: msg.name ?? callInfo?.name ?? 'unknown',
+                    input: callInfo?.args ?? null,
+                    output: msg.content ?? null,
+                });
+            }
+        }
+        return summaries;
+    }
+    normalizeMemoryConfig(raw) {
+        if (!raw)
+            return null;
+        if (typeof raw === 'boolean')
+            return raw ? { enabled: true, maxLines: 100 } : null;
+        if (!raw.enabled)
+            return null;
+        return { enabled: true, maxLines: raw.maxLines ?? 100 };
+    }
+    buildMemoryPrompt(content, maxLines) {
+        const memoryBlock = content
+            ? `<long_term_memory>\n${content}\n</long_term_memory>`
+            : '<long_term_memory>\n(empty - no memories saved yet)\n</long_term_memory>';
+        const instructions = `<memory_instructions>
+You have long-term memory that persists across conversations.
+
+The content inside <long_term_memory> above is your current saved memory.
+
+You have a "save_memory" tool to update your memory. When you call it, provide the COMPLETE updated memory content (it replaces the entire file, it does not append).
+
+Guidelines for using your memory:
+- Save important facts, user preferences, decisions, and key context worth remembering
+- Keep entries concise: use short bullet points, not full paragraphs
+- Remove outdated or irrelevant entries when saving to keep memory focused
+- Do not save trivial or easily re-derivable information
+- Organize entries by topic or category when it helps clarity
+- Your memory is limited to approximately ${maxLines} lines, so prioritize what matters most
+</memory_instructions>`;
+        return `${memoryBlock}\n\n${instructions}`;
+    }
     extractStructuredOutput(message) {
         try {
             // If message is already an object, return it