jazz-ai 0.2.2 → 0.4.3

package/dist/core/agent/agent-runner.js

@@ -2,87 +2,367 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRunner = void 0;
 exports.executeTool = executeTool;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const effect_1 = require("effect");
+const agent_1 = require("../../constants/agent");
 const config_1 = require("../../services/config");
+const stream_detector_1 = require("../../services/llm/stream-detector");
 const types_1 = require("../../services/llm/types");
 const logger_1 = require("../../services/logger");
 const markdown_renderer_1 = require("../utils/markdown-renderer");
+const output_renderer_1 = require("../utils/output-renderer");
+const tool_formatter_1 = require("../utils/tool-formatter");
 const agent_prompt_1 = require("./agent-prompt");
 const tool_registry_1 = require("./tools/tool-registry");
 const agent_run_tracker_1 = require("./tracking/agent-run-tracker");
 const tool_config_1 = require("./utils/tool-config");
+const MAX_MESSAGES = 100;
+const MAX_RETRIES = 3;
+const STREAM_CREATION_TIMEOUT = effect_1.Duration.minutes(2);
+const DEFERRED_RESPONSE_TIMEOUT = effect_1.Duration.seconds(15);
+/**
+ * Default display configuration (applies to both modes)
+ */
+const DEFAULT_DISPLAY_CONFIG = {
+    showThinking: true,
+    showToolExecution: true,
+    mode: "normal",
+};
+/**
+ * Initialize common agent run context (tools, messages, tracker)
+ */
+function initializeAgentRun(options) {
+    return effect_1.Effect.gen(function* () {
+        const { agent, userInput, conversationId, userId } = options;
+        const toolRegistry = yield* tool_registry_1.ToolRegistryTag;
+        const actualConversationId = conversationId || `conv-${Date.now()}`;
+        const history = options.conversationHistory || [];
+        const agentType = agent.config.agentType;
+        const provider = agent.config.llmProvider;
+        const model = agent.config.llmModel;
+        const runTracker = (0, agent_run_tracker_1.createAgentRunTracker)({
+            agent,
+            conversationId: actualConversationId,
+            ...(userId ? { userId } : {}),
+            provider,
+            model,
+            reasoningEffort: agent.config.reasoningEffort ?? "disable",
+            maxIterations: options.maxIterations ?? agent_1.MAX_AGENT_STEPS,
+        });
+        // Get and validate tools
+        const allToolNames = yield* toolRegistry.listTools();
+        const agentToolNames = (0, tool_config_1.normalizeToolConfig)(agent.config.tools, {
+            agentId: agent.id,
+        });
+        const invalidTools = agentToolNames.filter((toolName) => !allToolNames.includes(toolName));
+        if (invalidTools.length > 0) {
+            return yield* effect_1.Effect.fail(new Error(`Agent ${agent.id} references non-existent tools: ${invalidTools.join(", ")}`));
+        }
+        // Expand tool names to include approval execute tools
+        const expandedToolNameSet = new Set(agentToolNames);
+        for (const toolName of agentToolNames) {
+            const tool = yield* toolRegistry.getTool(toolName);
+            if (tool.approvalExecuteToolName) {
+                expandedToolNameSet.add(tool.approvalExecuteToolName);
+            }
+        }
+        const expandedToolNames = Array.from(expandedToolNameSet);
+        const allTools = yield* toolRegistry.getToolDefinitions();
+        const tools = Array.from(allTools.filter((tool) => expandedToolNames.includes(tool.function.name)));
+        // Build tool descriptions map
+        const availableTools = {};
+        for (const tool of tools) {
+            availableTools[tool.function.name] = tool.function.description;
+        }
+        // Build messages
+        const messages = yield* agent_prompt_1.agentPromptBuilder.buildAgentMessages(agentType, {
+            agentName: agent.name,
+            agentDescription: agent.description || "",
+            userInput,
+            conversationHistory: history,
+            toolNames: expandedToolNames,
+            availableTools,
+        });
+        const context = {
+            agentId: agent.id,
+            conversationId: actualConversationId,
+            ...(userId ? { userId } : {}),
+        };
+        return {
+            agent,
+            actualConversationId,
+            context,
+            tools,
+            expandedToolNames,
+            messages,
+            runTracker,
+            provider,
+            model,
+        };
+    });
+}
+/**
+ * Execute a single tool call and return result
+ */
+function executeToolCall(toolCall, context, displayConfig, renderer, runTracker, logger, agentId, conversationId) {
+    return effect_1.Effect.gen(function* () {
+        if (toolCall.type !== "function") {
+            return { result: null, success: false };
+        }
+        const { name, arguments: argsString } = toolCall.function;
+        (0, agent_run_tracker_1.recordToolInvocation)(runTracker, name);
+        const toolStartTime = Date.now();
+        try {
+            // Parse arguments
+            let parsed;
+            try {
+                parsed = JSON.parse(argsString);
+            }
+            catch (parseError) {
+                throw new Error(`Invalid JSON in tool arguments: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+            }
+            const args = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : {};
+            // Emit tool execution start
+            if (displayConfig.showToolExecution) {
+                if (renderer) {
+                    yield* renderer.handleEvent({
+                        type: "tool_execution_start",
+                        toolName: name,
+                        toolCallId: toolCall.id,
+                        arguments: args,
+                    });
+                }
+                else {
+                    const argsStr = output_renderer_1.OutputRenderer.formatToolArguments(name, args);
+                    process.stdout.write(`\n${chalk_1.default.cyan("⚙️")}  Executing tool: ${chalk_1.default.cyan(name)}${argsStr}...`);
+                }
+            }
+            // Execute tool
+            const result = yield* executeTool(name, args, context);
+            const toolDuration = Date.now() - toolStartTime;
+            const resultString = JSON.stringify(result.result);
+            // Emit tool execution complete
+            if (displayConfig.showToolExecution) {
+                if (renderer) {
+                    yield* renderer.handleEvent({
+                        type: "tool_execution_complete",
+                        toolCallId: toolCall.id,
+                        result: resultString,
+                        durationMs: toolDuration,
+                    });
+                }
+                else {
+                    if (result.success) {
+                        const summary = output_renderer_1.OutputRenderer.formatToolResult(name, resultString);
+                        process.stdout.write(` ${chalk_1.default.green("✓")}${summary ? ` ${summary}` : ""} ${chalk_1.default.dim(`(${toolDuration}ms)`)}\n`);
+                    }
+                    else {
+                        const errorMsg = result.error || "Tool execution failed";
+                        process.stdout.write(` ${chalk_1.default.red("✗")} ${chalk_1.default.red(`(${errorMsg})`)} ${chalk_1.default.dim(`(${toolDuration}ms)`)}\n`);
+                    }
+                }
+            }
+            return { result: result.result, success: result.success };
+        }
+        catch (error) {
+            // Fail fast on missing tools
+            if (error instanceof Error && error.message.startsWith("Tool not found")) {
+                throw error;
+            }
+            const toolDuration = Date.now() - toolStartTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Emit error
+            if (displayConfig.showToolExecution) {
+                if (renderer) {
+                    yield* renderer.handleEvent({
+                        type: "tool_execution_complete",
+                        toolCallId: toolCall.id,
+                        result: `Error: ${errorMessage}`,
+                        durationMs: toolDuration,
+                    });
+                }
+                else {
+                    process.stdout.write(` ${chalk_1.default.red("✗")} ${chalk_1.default.red(`(${errorMessage})`)} ${chalk_1.default.dim(`(${toolDuration}ms)`)}\n`);
+                }
+            }
+            (0, agent_run_tracker_1.recordToolError)(runTracker, name, error);
+            yield* logger.error("Tool execution failed", {
+                agentId,
+                conversationId,
+                toolName: name,
+                toolCallId: toolCall.id,
+                error: errorMessage,
+            });
+            return { result: { error: errorMessage }, success: false };
+        }
+    });
+}
+/**
+ * Execute all tool calls and return results
+ */
+function executeToolCalls(toolCalls, context, displayConfig, renderer, runTracker, logger, agentId, conversationId, agentName) {
+    return effect_1.Effect.gen(function* () {
+        const toolResults = {};
+        const toolNames = toolCalls.map((tc) => tc.function.name);
+        // Show tools detected
+        if (displayConfig.showToolExecution) {
+            if (renderer) {
+                yield* renderer.handleEvent({
+                    type: "tools_detected",
+                    toolNames,
+                    agentName,
+                });
+            }
+            else {
+                const tools = toolNames.join(", ");
+                console.log(`\n${chalk_1.default.yellow("🔧")} ${chalk_1.default.yellow(agentName)} is using tools: ${chalk_1.default.cyan(tools)}\n`);
+            }
+        }
+        // Log tool details
+        const toolDetails = [];
+        for (const toolCall of toolCalls) {
+            if (toolCall.type === "function") {
+                const { name, arguments: argsString } = toolCall.function;
+                try {
+                    const parsed = JSON.parse(argsString);
+                    const args = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                        ? parsed
+                        : {};
+                    const argsText = (0, tool_formatter_1.formatToolArguments)(name, args, { style: "plain" });
+                    toolDetails.push(argsText ? `${name} ${argsText}` : name);
+                }
+                catch {
+                    toolDetails.push(name);
+                }
+            }
+        }
+        const toolsList = toolDetails.join(", ");
+        yield* logger.info(`${agentName} is using tools: ${toolsList}`);
+        // Execute each tool
+        for (const toolCall of toolCalls) {
+            const { result } = yield* executeToolCall(toolCall, context, displayConfig, renderer, runTracker, logger, agentId, conversationId);
+            toolResults[toolCall.function.name] = result;
+        }
+        return toolResults;
+    });
+}
+/**
+ * Trim message history to prevent unbounded growth.
+ * Always preserves the system message (first message) and keeps the most recent messages.
+ */
+function trimMessages(messages, logger, agentId, conversationId) {
+    if (messages.length > MAX_MESSAGES) {
+        // Always preserve the system message (first message) as it contains important context
+        const systemMessage = messages[0];
+        if (systemMessage) {
+            // Keep system message + most recent (MAX_MESSAGES - 1) messages
+            const recentMessages = messages.slice(-(MAX_MESSAGES - 1));
+            messages.length = 0;
+            messages.push(systemMessage, ...recentMessages);
+        }
+        return logger.warn("Message history trimmed to prevent memory issues", {
+            agentId,
+            conversationId,
+            maxMessages: MAX_MESSAGES,
+            trimmedCount: messages.length,
+        });
+    }
+    return effect_1.Effect.void;
+}
+/**
+ * Ensure messages array is never empty
+ */
+function ensureMessagesNotEmpty(messages, userInput, logger, agentId, conversationId, iteration) {
+    if (messages.length === 0) {
+        return effect_1.Effect.gen(function* () {
+            yield* logger.warn("messagesToSend was empty; using fallback single user message", {
+                agentId,
+                conversationId,
+                iteration,
+            });
+            return [
+                {
+                    role: "user",
+                    content: userInput && userInput.trim().length > 0 ? userInput : "Continue",
+                },
+            ];
+        });
+    }
+    return effect_1.Effect.succeed(messages);
+}
 class AgentRunner {
     /**
      * Run an agent conversation
      */
     static run(options) {
         return effect_1.Effect.gen(function* () {
-            const { agent, userInput, conversationId, userId, maxIterations = 8 } = options;
             // Get services
-            const llmService = yield* types_1.LLMServiceTag;
-            const toolRegistry = yield* tool_registry_1.ToolRegistryTag;
             const configService = yield* config_1.AgentConfigService;
-            const logger = yield* logger_1.LoggerServiceTag;
             const appConfig = yield* configService.appConfig;
-            // Generate a conversation ID if not provided
-            const actualConversationId = conversationId || `conv-${Date.now()}`;
-            // Use provided history if available to preserve context across turns
-            const history = options.conversationHistory || [];
-            const agentType = agent.config.agentType;
-            const provider = agent.config.llmProvider;
-            const model = agent.config.llmModel;
-            const runTracker = (0, agent_run_tracker_1.createAgentRunTracker)({
-                agent,
-                conversationId: actualConversationId,
-                ...(userId ? { userId } : {}),
-                provider,
-                model,
-                reasoningEffort: agent.config.reasoningEffort ?? "disable",
-                maxIterations,
-            });
-            // Get available tools for this specific agent
-            const allToolNames = yield* toolRegistry.listTools();
-            const agentToolNames = (0, tool_config_1.normalizeToolConfig)(agent.config.tools, {
-                agentId: agent.id,
-            });
-            // Validate that all agent tools exist in the registry
-            const invalidTools = agentToolNames.filter((toolName) => !allToolNames.includes(toolName));
-            if (invalidTools.length > 0) {
-                return yield* effect_1.Effect.fail(new Error(`Agent ${agent.id} references non-existent tools: ${invalidTools.join(", ")}`));
-            }
-            // Automatically include approval follow-up tools (e.g., execute-* variants)
-            const expandedToolNameSet = new Set(agentToolNames);
-            for (const toolName of agentToolNames) {
-                const tool = yield* toolRegistry.getTool(toolName);
-                if (tool.approvalExecuteToolName) {
-                    expandedToolNameSet.add(tool.approvalExecuteToolName);
-                }
+            // Determine if streaming should be enabled
+            const streamDetection = (0, stream_detector_1.shouldEnableStreaming)(appConfig, options.stream !== undefined ? { stream: options.stream } : {});
+            // Get display config with defaults (applies to both modes)
+            const displayConfig = {
+                showThinking: appConfig.output?.showThinking ?? DEFAULT_DISPLAY_CONFIG.showThinking,
+                showToolExecution: appConfig.output?.showToolExecution ?? DEFAULT_DISPLAY_CONFIG.showToolExecution,
+                mode: appConfig.output?.mode ?? DEFAULT_DISPLAY_CONFIG.mode,
+                colorProfile: appConfig.output?.colorProfile,
+            };
+            // Check if we should show metrics (from logging config)
+            const showMetrics = appConfig.logging?.showMetrics ?? false;
+            // Get streaming config with defaults (streaming-specific)
+            const streamingConfig = {
+                ...(appConfig.output?.streaming?.enabled !== undefined
+                    ? { enabled: appConfig.output.streaming.enabled }
+                    : {}),
+                ...(appConfig.output?.streaming?.progressiveMarkdown !== undefined
+                    ? { progressiveMarkdown: appConfig.output.streaming.progressiveMarkdown }
+                    : {}),
+                ...(appConfig.output?.streaming?.textBufferMs !== undefined
+                    ? { textBufferMs: appConfig.output.streaming.textBufferMs }
+                    : {}),
+            };
+            if (streamDetection.shouldStream) {
+                return yield* AgentRunner.runWithStreaming(options, displayConfig, streamingConfig, showMetrics);
             }
-            const expandedToolNames = Array.from(expandedToolNameSet);
-            // Get tool definitions for only the agent's specified tools
-            const allTools = yield* toolRegistry.getToolDefinitions();
-            const tools = allTools.filter((tool) => expandedToolNames.includes(tool.function.name));
-            // Build a map of available tool descriptions for prompt clarity
-            const availableTools = {};
-            for (const tool of tools) {
-                availableTools[tool.function.name] = tool.function.description;
+            else {
+                return yield* AgentRunner.runWithoutStreaming(options, displayConfig, showMetrics);
             }
-            // Build messages for the agent with only its specified tools and descriptions
-            const messages = yield* agent_prompt_1.agentPromptBuilder.buildAgentMessages(agentType, {
+        });
+    }
+    /**
+     * Streaming implementation that processes LLM responses in real-time.
+     */
+    static runWithStreaming(options, displayConfig, streamingConfig, showMetrics) {
+        return effect_1.Effect.gen(function* () {
+            const { agent, userInput, maxIterations = agent_1.MAX_AGENT_STEPS } = options;
+            const llmService = yield* types_1.LLMServiceTag;
+            const logger = yield* logger_1.LoggerServiceTag;
+            // Initialize common context
+            const runContext = yield* initializeAgentRun(options);
+            const { actualConversationId, context, tools, messages, runTracker, provider, model } = runContext;
+            // Create renderer
+            const normalizedStreamingConfig = {
+                enabled: true, // Always enabled in streaming mode
+                ...(streamingConfig.progressiveMarkdown !== undefined && {
+                    progressiveMarkdown: streamingConfig.progressiveMarkdown,
+                }),
+                ...(streamingConfig.textBufferMs !== undefined && {
+                    textBufferMs: streamingConfig.textBufferMs,
+                }),
+            };
+            const rendererConfig = {
+                displayConfig,
+                streamingConfig: normalizedStreamingConfig,
+                showMetrics,
                 agentName: agent.name,
-                agentDescription: agent.description,
-                userInput,
-                conversationHistory: history,
-                toolNames: expandedToolNames,
-                availableTools,
-            });
-            // Create execution context
-            const context = {
-                agentId: agent.id,
-                conversationId: actualConversationId,
-                ...(userId ? { userId } : {}),
+                reasoningEffort: agent.config.reasoningEffort,
             };
-            // Run the agent loop
+            const renderer = new output_renderer_1.OutputRenderer(rendererConfig);
+            // Run agent loop
             const currentMessages = [...messages];
             let response = {
                 content: "",
@@ -90,84 +370,212 @@ class AgentRunner {
             };
             let finished = false;
             let iterationsUsed = 0;
-            // Memory safeguard: prevent unbounded message growth
-            const MAX_MESSAGES = 100;
-            // Determine the LLM provider and model to use
             for (let i = 0; i < maxIterations; i++) {
                 yield* effect_1.Effect.sync(() => (0, agent_run_tracker_1.beginIteration)(runTracker, i + 1));
                 try {
-                    // Log user-friendly progress for info level
+                    // Log thinking indicator
                     if (i === 0) {
-                        const message = markdown_renderer_1.MarkdownRenderer.formatThinking(agent.name, true);
-                        yield* logger.info(message, {
-                            agentId: agent.id,
-                            conversationId: actualConversationId,
-                            iteration: i + 1,
-                        });
+                        yield* logger.info(markdown_renderer_1.MarkdownRenderer.formatThinking(agent.name, true));
                     }
                     else {
-                        const message = markdown_renderer_1.MarkdownRenderer.formatThinking(agent.name, false);
-                        yield* logger.info(message, {
-                            agentId: agent.id,
-                            conversationId: actualConversationId,
-                            iteration: i + 1,
-                        });
+                        yield* logger.info(markdown_renderer_1.MarkdownRenderer.formatThinking(agent.name, false));
                     }
-                    // Log LLM request in debug mode
-                    if (appConfig.logging.level === "debug") {
-                        yield* logger.debug("LLM request", {
-                            agentId: agent.id,
-                            conversationId: actualConversationId,
-                            iteration: i + 1,
-                            provider,
-                            model,
-                            messageCount: currentMessages.length,
-                            messages: currentMessages,
-                            tools: tools.map((t) => ({
-                                name: t.function.name,
-                                description: t.function.description,
-                            })),
-                        });
+                    // Ensure messages are not empty
+                    const messagesToSend = yield* ensureMessagesNotEmpty(currentMessages, userInput, logger, agent.id, actualConversationId, i + 1);
+                    // Create streaming completion with retry and fallback
+                    const llmOptions = {
+                        model,
+                        messages: messagesToSend,
+                        tools,
+                        toolChoice: "auto",
+                        reasoning_effort: agent.config.reasoningEffort ?? "disable",
+                    };
+                    const completionRef = yield* effect_1.Ref.make(undefined);
+                    const pendingToolCalls = [];
+                    const streamingResult = yield* effect_1.Effect.retry(effect_1.Effect.gen(function* () {
+                        try {
+                            return yield* llmService.createStreamingChatCompletion(provider, llmOptions);
+                        }
+                        catch (error) {
+                            (0, agent_run_tracker_1.recordLLMRetry)(runTracker, error);
+                            throw error;
+                        }
+                    }), effect_1.Schedule.exponential("1 second").pipe(effect_1.Schedule.intersect(effect_1.Schedule.recurs(MAX_RETRIES)), effect_1.Schedule.whileInput((error) => error instanceof types_1.LLMRateLimitError))).pipe(effect_1.Effect.timeout(STREAM_CREATION_TIMEOUT), effect_1.Effect.catchAll(() => effect_1.Effect.gen(function* () {
+                        yield* logger.warn("Streaming failed, falling back to non-streaming mode");
+                        const fallback = yield* llmService.createChatCompletion(provider, llmOptions);
+                        return {
+                            stream: effect_1.Stream.empty,
+                            response: effect_1.Effect.succeed(fallback),
+                            cancel: effect_1.Effect.void,
+                        };
+                    })));
+                    // Process stream events
+                    const streamFiber = yield* effect_1.Effect.fork(effect_1.Stream.runForEach(streamingResult.stream, (event) => effect_1.Effect.gen(function* () {
+                        yield* renderer.handleEvent(event);
+                        if (event.type === "tool_call") {
+                            pendingToolCalls.push(event.toolCall);
+                        }
+                        if (event.type === "complete") {
+                            yield* effect_1.Ref.set(completionRef, event.response);
+                            if (event.metrics?.firstTokenLatencyMs) {
+                                (0, agent_run_tracker_1.recordFirstTokenLatency)(runTracker, event.metrics.firstTokenLatencyMs);
+                            }
+                        }
+                        if (event.type === "error" && !event.recoverable) {
+                            yield* streamingResult.cancel;
+                        }
+                    })));
+                    // Wait for stream completion - the stream is cancelled on completion event
+                    // so the fiber should complete naturally without needing a timeout
+                    const streamExit = yield* effect_1.Fiber.await(streamFiber);
+                    // Get completion from stream or fallback
+                    let completion;
+                    if (effect_1.Exit.isFailure(streamExit)) {
+                        yield* streamingResult.cancel;
+                        const error = effect_1.Cause.failureOption(streamExit.cause);
+                        if (effect_1.Option.isSome(error)) {
+                            yield* logger.warn("Stream processing failed, using fallback");
+                            completion = yield* llmService.createChatCompletion(provider, llmOptions);
+                        }
+                        else {
+                            const fromRef = yield* effect_1.Ref.get(completionRef);
+                            if (fromRef) {
+                                completion = fromRef;
+                            }
+                            else {
+                                completion = yield* streamingResult.response.pipe(effect_1.Effect.timeout(DEFERRED_RESPONSE_TIMEOUT), effect_1.Effect.catchAll(() => effect_1.Effect.gen(function* () {
+                                    yield* streamingResult.cancel;
+                                    return yield* llmService.createChatCompletion(provider, llmOptions);
+                                })));
+                            }
+                        }
                     }
-                    // Call the LLM with retry logic for rate limit errors
-                    let messagesToSend = currentMessages;
-                    // Secondary safety: ensure messagesToSend is never empty
-                    if (messagesToSend.length === 0) {
-                        // Fallback to a single user message if everything else failed
-                        messagesToSend = [
-                            {
-                                role: "user",
-                                content: userInput && userInput.trim().length > 0 ? userInput : "Continue",
-                            },
-                        ];
-                        yield* logger.warn("messagesToSend was empty; using fallback single user message", {
-                            agentId: agent.id,
-                            conversationId: actualConversationId,
-                            iteration: i + 1,
-                        });
+                    else {
+                        const fromRef = yield* effect_1.Ref.get(completionRef);
+                        if (fromRef) {
+                            completion = fromRef;
+                        }
+                        else {
+                            completion = yield* streamingResult.response.pipe(effect_1.Effect.timeout(DEFERRED_RESPONSE_TIMEOUT), effect_1.Effect.catchAll(() => effect_1.Effect.gen(function* () {
+                                yield* streamingResult.cancel;
+                                return yield* llmService.createChatCompletion(provider, llmOptions);
+                            })));
+                        }
+                    }
+                    if (completion.usage) {
+                        (0, agent_run_tracker_1.recordLLMUsage)(runTracker, completion.usage);
+                    }
+                    // Add assistant response to conversation
+                    currentMessages.push({
+                        role: "assistant",
+                        content: completion.content,
+                        ...(completion.toolCalls
+                            ? {
+                                tool_calls: completion.toolCalls.map((tc) => ({
+                                    id: tc.id,
+                                    type: tc.type,
+                                    function: { name: tc.function.name, arguments: tc.function.arguments },
+                                })),
+                            }
+                            : {}),
+                    });
+                    yield* trimMessages(currentMessages, logger, agent.id, actualConversationId);
+                    // Handle tool calls
+                    if (completion.toolCalls && completion.toolCalls.length > 0) {
+                        const toolResults = yield* executeToolCalls(completion.toolCalls, context, displayConfig, renderer, runTracker, logger, agent.id, actualConversationId, agent.name);
+                        // Add tool results to conversation
+                        for (const toolCall of completion.toolCalls) {
+                            if (toolCall.type === "function") {
+                                const result = toolResults[toolCall.function.name];
+                                currentMessages.push({
+                                    role: "tool",
+                                    name: toolCall.function.name,
+                                    content: JSON.stringify(result),
+                                    tool_call_id: toolCall.id,
+                                });
+                            }
+                        }
+                        response = { ...response, toolCalls: completion.toolCalls, toolResults };
+                        continue;
+                    }
+                    // No tool calls - final response
+                    response = { ...response, content: completion.content };
+                    yield* logger.info(markdown_renderer_1.MarkdownRenderer.formatCompletion(agent.name));
+                    iterationsUsed = i + 1;
+                    finished = true;
+                    break;
+                }
+                finally {
+                    yield* effect_1.Effect.sync(() => (0, agent_run_tracker_1.completeIteration)(runTracker));
+                }
+            }
+            // Post-loop cleanup
+            if (!finished) {
+                iterationsUsed = maxIterations;
+                yield* logger.warn(markdown_renderer_1.MarkdownRenderer.formatWarning(agent.name, `reached maximum iterations (${maxIterations}) - type 'resume' to continue`));
+            }
+            else if (!response.content?.trim() && !response.toolCalls) {
+                yield* logger.warn(markdown_renderer_1.MarkdownRenderer.formatWarning(agent.name, "model returned an empty response"));
+            }
+            // Finalize run asynchronously
+            yield* (0, agent_run_tracker_1.finalizeAgentRun)(runTracker, { iterationsUsed, finished }).pipe(effect_1.Effect.catchAll((error) => logger.warn("Failed to write agent token usage log", { error: error.message })), effect_1.Effect.fork, effect_1.Effect.asVoid);
+            return { ...response, messages: currentMessages };
+        });
+    }
+    /**
+     * Non-streaming implementation that waits for complete LLM responses before rendering.
+     */
+    static runWithoutStreaming(options, displayConfig, showMetrics) {
+        return effect_1.Effect.gen(function* () {
+            const { agent, userInput, maxIterations = agent_1.MAX_AGENT_STEPS } = options;
+            const llmService = yield* types_1.LLMServiceTag;
+            const logger = yield* logger_1.LoggerServiceTag;
+            // Initialize common context
+            const runContext = yield* initializeAgentRun(options);
+            const { actualConversationId, context, tools, messages, runTracker, provider, model } = runContext;
+            // Run agent loop
+            const currentMessages = [...messages];
+            let response = {
+                content: "",
+                conversationId: actualConversationId,
+            };
+            let finished = false;
+            let iterationsUsed = 0;
+            for (let i = 0; i < maxIterations; i++) {
+                yield* effect_1.Effect.sync(() => (0, agent_run_tracker_1.beginIteration)(runTracker, i + 1));
+                try {
+                    // Log thinking indicator
+                    if (displayConfig.showThinking) {
+                        if (i === 0) {
+                            yield* logger.info(markdown_renderer_1.MarkdownRenderer.formatThinking(agent.name, true));
+                        }
+                        else {
+                            yield* logger.info(markdown_renderer_1.MarkdownRenderer.formatThinking(agent.name, false));
+                        }
                     }
-                    const maxRetries = 3;
+                    // Ensure messages are not empty
+                    const messagesToSend = yield* ensureMessagesNotEmpty(currentMessages, userInput, logger, agent.id, actualConversationId, i + 1);
+                    // Create non-streaming completion with retry
+                    const llmOptions = {
+                        model,
+                        messages: messagesToSend,
+                        tools,
+                        toolChoice: "auto",
+                        reasoning_effort: agent.config.reasoningEffort ?? "disable",
+                    };
                     const completion = yield* effect_1.Effect.retry(effect_1.Effect.gen(function* () {
-                        const llmOptions = {
-                            model,
-                            messages: messagesToSend,
-                            tools,
-                            toolChoice: "auto",
-                            reasoning_effort: agent.config.reasoningEffort ?? "disable",
-                        };
                         try {
-                            const result = yield* llmService.createChatCompletion(provider, llmOptions);
-                            return result;
+                            return yield* llmService.createChatCompletion(provider, llmOptions);
                         }
                         catch (error) {
                             (0, agent_run_tracker_1.recordLLMRetry)(runTracker, error);
                             throw error;
                         }
-                    }), effect_1.Schedule.exponential("1 second").pipe(effect_1.Schedule.intersect(effect_1.Schedule.recurs(maxRetries)), effect_1.Schedule.whileInput((error) => error instanceof types_1.LLMRateLimitError)));
+                    }), effect_1.Schedule.exponential("1 second").pipe(effect_1.Schedule.intersect(effect_1.Schedule.recurs(MAX_RETRIES)), effect_1.Schedule.whileInput((error) => error instanceof types_1.LLMRateLimitError)));
                     if (completion.usage) {
                         (0, agent_run_tracker_1.recordLLMUsage)(runTracker, completion.usage);
                     }
-                    // Add the assistant's response to the conversation (including tool calls, if any)
+                    // Add assistant response to conversation
                     currentMessages.push({
                         role: "assistant",
                         content: completion.content,
@@ -181,142 +589,53 @@ class AgentRunner {
                             }
                             : {}),
                     });
-                    // Memory safeguard: trim messages if they exceed the limit
-                    if (currentMessages.length > MAX_MESSAGES) {
-                        // Keep the system message and the most recent messages
-                        const systemMessage = currentMessages[0];
-                        if (systemMessage) {
-                            const recentMessages = currentMessages.slice(-(MAX_MESSAGES - 1));
-                            currentMessages.length = 0;
-                            currentMessages.push(systemMessage, ...recentMessages);
-                        }
-                        yield* logger.warn("Message history trimmed to prevent memory issues", {
-                            agentId: agent.id,
-                            conversationId: actualConversationId,
-                            maxMessages: MAX_MESSAGES,
-                            trimmedCount: currentMessages.length,
-                        });
-                    }
-                    // Log assistant response if log level is debug
-                    if (appConfig.logging.level === "debug") {
-                        yield* logger.debug("LLM response received", {
-                            agentId: agent.id,
-                            conversationId: actualConversationId,
-                            iteration: i + 1,
-                            model: completion.model,
-                            content: completion.content,
-                            toolCalls: completion.toolCalls?.map((tc) => ({
-                                id: tc.id,
-                                name: tc.function.name,
-                                arguments: tc.function.arguments,
-                            })),
-                            usage: completion.usage,
-                        });
+                    yield* trimMessages(currentMessages, logger, agent.id, actualConversationId);
+                    // Format content - always use markdown since LLMs output markdown
+                    let formattedContent = completion.content;
+                    if (formattedContent) {
+                        formattedContent = markdown_renderer_1.MarkdownRenderer.render(formattedContent);
                     }
-                    // Check if the model wants to call a tool
+                    // Handle tool calls
                     if (completion.toolCalls && completion.toolCalls.length > 0) {
-                        const toolResults = {};
-                        // Log user-friendly tool execution info
-                        const toolNames = completion.toolCalls.map((tc) => tc.function.name);
-                        const message = markdown_renderer_1.MarkdownRenderer.formatToolExecution(agent.name, toolNames);
-                        yield* logger.info(message, {
-                            agentId: agent.id,
-                            conversationId: actualConversationId,
-                            toolCount: completion.toolCalls.length,
-                            tools: toolNames,
-                        });
-                        // Execute each tool call
+                        const toolResults = yield* executeToolCalls(completion.toolCalls, context, displayConfig, null, // No renderer for non-streaming
+                        runTracker, logger, agent.id, actualConversationId, agent.name);
+                        // Add tool results to conversation
                         for (const toolCall of completion.toolCalls) {
                             if (toolCall.type === "function") {
-                                const { name, arguments: argsString } = toolCall.function;
-                                (0, agent_run_tracker_1.recordToolInvocation)(runTracker, name);
-                                try {
-                                    // Parse the arguments safely with proper error handling
-                                    let parsed;
-                                    try {
-                                        parsed = JSON.parse(argsString);
-                                    }
-                                    catch (parseError) {
-                                        throw new Error(`Invalid JSON in tool arguments: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
-                                    }
-                                    const args = parsed && typeof parsed === "object" && !Array.isArray(parsed)
-                                        ? parsed
-                                        : {};
-                                    // Log tool call arguments in debug mode
-                                    yield* logger.debug("Tool call arguments", {
-                                        agentId: agent.id,
-                                        conversationId: actualConversationId,
-                                        toolName: name,
-                                        toolCallId: toolCall.id,
-                                        arguments: args,
-                                        rawArguments: argsString,
-                                    });
-                                    // Execute the tool
-                                    const result = yield* executeTool(name, args, context);
-                                    // Log tool execution result in debug mode
-                                    yield* logger.debug("Tool execution result", {
-                                        agentId: agent.id,
-                                        conversationId: actualConversationId,
-                                        toolName: name,
-                                        toolCallId: toolCall.id,
-                                        arguments: args,
-                                        result: result.result,
-                                    });
-                                    // Add the tool result to the conversation
-                                    currentMessages.push({
-                                        role: "tool",
-                                        name,
-                                        content: JSON.stringify(result.result),
-                                        tool_call_id: toolCall.id,
-                                    });
-                                    // Store the tool result
-                                    toolResults[name] = result.result;
-                                }
-                                catch (error) {
-                                    // If the tool does not exist, rethrow to fail fast (never mock missing tools)
-                                    if (error instanceof Error && error.message.startsWith("Tool not found")) {
-                                        throw error;
-                                    }
-                                    // Log the tool execution error for debugging
-                                    const errorMessage = error instanceof Error ? error.message : String(error);
-                                    (0, agent_run_tracker_1.recordToolError)(runTracker, name, error);
-                                    yield* logger.error("Tool execution failed", {
-                                        agentId: agent.id,
-                                        conversationId: actualConversationId,
-                                        toolName: name,
-                                        toolCallId: toolCall.id,
-                                        error: errorMessage,
-                                    });
-                                    // Include the tool execution error in the conversation
-                                    currentMessages.push({
-                                        role: "tool",
-                                        name,
-                                        content: `Error: ${errorMessage}`,
-                                        tool_call_id: toolCall.id,
-                                    });
-                                    // Store the error
-                                    toolResults[name] = {
-                                        error: errorMessage,
-                                    };
-                                }
+                                const result = toolResults[toolCall.function.name];
+                                currentMessages.push({
+                                    role: "tool",
+                                    name: toolCall.function.name,
+                                    content: JSON.stringify(result),
+                                    tool_call_id: toolCall.id,
+                                });
                             }
                         }
-                        // Update the response with tool results
                         response = { ...response, toolCalls: completion.toolCalls, toolResults };
-                        // Continue the conversation with the tool results
                         continue;
                     }
-                    // No tool calls, we have the final response
-                    response = { ...response, content: completion.content };
-                    // Log completion
-                    const completionMessage = markdown_renderer_1.MarkdownRenderer.formatCompletion(agent.name);
-                    yield* logger.info(completionMessage, {
-                        agentId: agent.id,
-                        conversationId: actualConversationId,
-                        totalIterations: i + 1,
-                        hasContent: !!completion.content,
-                    });
-                    // Mark loop as finished and break
+                    // No tool calls - final response
+                    response = { ...response, content: formattedContent };
+                    // Display final response
+                    if (formattedContent && formattedContent.trim().length > 0) {
+                        console.log();
+                        console.log(markdown_renderer_1.MarkdownRenderer.formatAgentResponse(agent.name, formattedContent));
+                        console.log();
+                    }
+                    yield* logger.info(markdown_renderer_1.MarkdownRenderer.formatCompletion(agent.name));
+                    // Show metrics if enabled
+                    if (showMetrics && completion.usage) {
+                        const parts = [];
+                        if (completion.usage.totalTokens)
+                            parts.push(`Total: ${completion.usage.totalTokens} tokens`);
+                        if (completion.usage.promptTokens)
+                            parts.push(`Prompt: ${completion.usage.promptTokens}`);
+                        if (completion.usage.completionTokens)
+                            parts.push(`Completion: ${completion.usage.completionTokens}`);
+                        if (parts.length > 0) {
+                            yield* logger.info(`[${parts.join(" | ")}]`);
+                        }
+                    }
                     iterationsUsed = i + 1;
                     finished = true;
                     break;
@@ -325,35 +644,16 @@ class AgentRunner {
                     yield* effect_1.Effect.sync(() => (0, agent_run_tracker_1.completeIteration)(runTracker));
                 }
             }
-            // Post-loop diagnostics
+            // Post-loop cleanup
             if (!finished) {
                 iterationsUsed = maxIterations;
-                const warningMessage = markdown_renderer_1.MarkdownRenderer.formatWarning(agent.name, `reached maximum iterations (${maxIterations})`);
-                yield* logger.warn(warningMessage, {
-                    agentId: agent.id,
-                    conversationId: actualConversationId,
-                    maxIterations,
-                });
+                yield* logger.warn(markdown_renderer_1.MarkdownRenderer.formatWarning(agent.name, `reached maximum iterations (${maxIterations}) - type 'resume' to continue`));
             }
-            else if ((!response.content || response.content.trim().length === 0) &&
-                !response.toolCalls) {
-                const emptyMessage = markdown_renderer_1.MarkdownRenderer.formatWarning(agent.name, "model returned an empty response");
-                yield* logger.warn(emptyMessage, {
-                    agentId: agent.id,
-                    conversationId: actualConversationId,
-                    totalIterations: iterationsUsed,
-                });
+            else if (!response.content?.trim() && !response.toolCalls) {
+                yield* logger.warn(markdown_renderer_1.MarkdownRenderer.formatWarning(agent.name, "model returned an empty response"));
             }
-            yield* (0, agent_run_tracker_1.finalizeAgentRun)(runTracker, {
-                iterationsUsed,
-                finished,
-            }).pipe(effect_1.Effect.catchAll((error) => logger.warn("Failed to write agent token usage log", {
-                agentId: agent.id,
-                conversationId: actualConversationId,
-                error: error.message,
-            })));
-            // Optionally persist conversation history via a storage layer in the future
-            // Return the full message history from this turn so callers can persist it
+            // Finalize run asynchronously
+            yield* (0, agent_run_tracker_1.finalizeAgentRun)(runTracker, { iterationsUsed, finished }).pipe(effect_1.Effect.catchAll((error) => logger.warn("Failed to write agent token usage log", { error: error.message })), effect_1.Effect.fork, effect_1.Effect.asVoid);
             return { ...response, messages: currentMessages };
         });
     }