edsger 0.76.0 → 0.78.0

package/dist/phases/bug-fixing/prompts.js

@@ -1,9 +0,0 @@
-import { resolveSkill } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createBugFixingSystemPrompt = async (_config, projectDir) => {
-    const skill = await resolveSkill('phase/bug-fixing', { projectDir });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/bug-fixing');
-    }
-    return `${skill.prompt}\n\n${OUTPUT_CONTRACTS['bug-fixing']}`;
-};

package/dist/phases/chat-processor/context.d.ts

@@ -1,38 +0,0 @@
-/**
- * Build context for the chat AI processor.
- * Fetches issue state, user stories, test cases, and recent chat history.
- */
-import type { ChatMessage } from '../../types/index.js';
-export interface ChatProcessorContext {
-    issueId: string;
-    productId: string;
-    issueDescription: string;
-    issueStatus: string;
-    executionMode: string;
-    workflow: {
-        phase: string;
-        status: string;
-    }[];
-    userStories: {
-        id: string;
-        title: string;
-        description: string;
-        status: string;
-    }[];
-    testCases: {
-        id: string;
-        name: string;
-        description: string;
-        is_critical: boolean;
-    }[];
-    recentChatMessages: ChatMessage[];
-    channelId: string;
-}
-/**
- * Build the full context for the chat AI to process a message.
- */
-export declare function buildChatContext(issueId: string, channelId: string, verbose?: boolean): Promise<ChatProcessorContext>;
-/**
- * Format context into a string for the AI system prompt.
- */
-export declare function formatContextForAI(context: ChatProcessorContext): string;

package/dist/phases/chat-processor/context.js

@@ -1,91 +0,0 @@
-/**
- * Build context for the chat AI processor.
- * Fetches issue state, user stories, test cases, and recent chat history.
- */
-import { listChatMessages } from '../../api/chat.js';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-/**
- * Build the full context for the chat AI to process a message.
- */
-export async function buildChatContext(issueId, channelId, verbose) {
-    // Fetch issue, user stories, and test cases in parallel
-    const [issueResult, storiesResult, testCasesResult, recentMessages] = await Promise.all([
-        callMcpEndpoint('issues/get', {
-            issue_id: issueId,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }),
-        callMcpEndpoint('user_stories/list', {
-            issue_id: issueId,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }),
-        callMcpEndpoint('test_cases/list', {
-            issue_id: issueId,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }),
-        listChatMessages(channelId, { limit: 20 }, verbose),
-    ]);
-    const issue = issueResult?.issues?.[0] || {};
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const userStories = (storiesResult?.user_stories || []).map((s) => ({
-        id: s.id,
-        title: s.title,
-        description: s.description,
-        status: s.status,
-    }));
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const testCases = (testCasesResult?.test_cases || []).map((t) => ({
-        id: t.id,
-        name: t.name,
-        description: t.description,
-        is_critical: t.is_critical,
-    }));
-    return {
-        issueId,
-        productId: issue.product_id || '',
-        issueDescription: `${issue.name || 'Unknown'}: ${issue.description || 'No description'}`,
-        issueStatus: issue.status || 'unknown',
-        executionMode: issue.execution_mode || 'unknown',
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        workflow: (issue.workflow || []).map((p) => ({
-            phase: p.phase,
-            status: p.status,
-        })),
-        userStories,
-        testCases,
-        recentChatMessages: recentMessages,
-        channelId,
-    };
-}
-/**
- * Format context into a string for the AI system prompt.
- */
-export function formatContextForAI(context) {
-    const parts = [
-        `## Issue: ${context.issueDescription}`,
-        `**Status:** ${context.issueStatus}`,
-        `**Execution Mode:** ${context.executionMode}`,
-        '',
-        '## Workflow Phases',
-        ...context.workflow.map((p) => `- ${p.phase}: ${p.status}`),
-        '',
-        `## User Stories (${context.userStories.length})`,
-    ];
-    if (context.userStories.length > 0) {
-        for (const story of context.userStories) {
-            parts.push(`- [${story.status}] ${story.title}: ${story.description.slice(0, 100)}`);
-        }
-    }
-    else {
-        parts.push('- (none yet)');
-    }
-    parts.push('', `## Test Cases (${context.testCases.length})`);
-    if (context.testCases.length > 0) {
-        for (const tc of context.testCases) {
-            parts.push(`- ${tc.is_critical ? '[CRITICAL] ' : ''}${tc.name}: ${tc.description.slice(0, 100)}`);
-        }
-    }
-    else {
-        parts.push('- (none yet)');
-    }
-    return parts.join('\n');
-}

package/dist/phases/chat-processor/index.d.ts

@@ -1,49 +0,0 @@
-/**
- * Chat processor — the AI brain for handling chat messages.
- *
- * Uses Claude Agent SDK session resumption for conversation continuity.
- * Each channel maintains a persistent session ID. New messages resume
- * the same session so the AI naturally remembers the full conversation
- * history without re-stuffing context into the prompt each time.
- *
- * Two modes of operation:
- * 1. processHumanMessages() — Respond to human messages (resumes session)
- * 2. processPhaseCompletion() — Generate next-step suggestions (resumes session)
- */
-import type { ChatMessage, EdsgerConfig } from '../../types/index.js';
-/**
- * Get the stored session ID for a channel, if any.
- */
-export declare function getChannelSessionId(channelId: string): string | undefined;
-/**
- * Clear a channel's session (e.g., on issue reset).
- */
-export declare function clearChannelSession(channelId: string): void;
-/**
- * Process one or more human messages by resuming the channel's session.
- * On first call: creates a new session with full context in the system prompt.
- * On subsequent calls: resumes the session — AI already has conversation history.
- *
- * Returns the session ID (callers should track this if needed).
- */
-export declare function processHumanMessages(messages: ChatMessage[], issueId: string, config: EdsgerConfig, verbose?: boolean, repoPath?: string): Promise<string | undefined>;
-/**
- * Process one or more human messages from a product channel.
- * Same session resumption pattern as issue chat, but uses
- * product context, product prompt, and product tools.
- */
-export declare function processProductHumanMessages(messages: ChatMessage[], productId: string, config: EdsgerConfig, verbose?: boolean): Promise<string | undefined>;
-/**
- * Process a phase completion event: analyze output and suggest next steps.
- * Resumes the same channel session so AI has full conversation context.
- */
-export interface ProcessPhaseCompletionOptions {
-    issueId: string;
-    phase: string;
-    summary: string;
-    phaseOutput: unknown;
-    config: EdsgerConfig;
-    verbose?: boolean;
-    repoPath?: string;
-}
-export declare function processPhaseCompletion(opts: ProcessPhaseCompletionOptions): Promise<void>;

package/dist/phases/chat-processor/index.js

@@ -1,482 +0,0 @@
-/**
- * Chat processor — the AI brain for handling chat messages.
- *
- * Uses Claude Agent SDK session resumption for conversation continuity.
- * Each channel maintains a persistent session ID. New messages resume
- * the same session so the AI naturally remembers the full conversation
- * history without re-stuffing context into the prompt each time.
- *
- * Two modes of operation:
- * 1. processHumanMessages() — Respond to human messages (resumes session)
- * 2. processPhaseCompletion() — Generate next-step suggestions (resumes session)
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { getIssueChannel, listChatMessages, markMessageProcessed, sendAiMessage, sendSystemMessage, } from '../../api/chat.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { buildChatContext, formatContextForAI } from './context.js';
-import { buildProductChatContext, formatProductContextForAI, } from './product-context.js';
-import { PRODUCT_CHAT_RESPONSE_PROMPT } from './product-prompts.js';
-import { createProductChatMcpServer } from './product-tools.js';
-import { buildNextStepAdvisorMessage, CHAT_RESPONSE_PROMPT, NEXT_STEP_ADVISOR_PROMPT, } from './prompts.js';
-import { createChatMcpServer } from './tools.js';
-// ============================================================
-// Session Management
-// ============================================================
-// channelId → SDK session ID (persisted to disk by the SDK)
-const channelSessions = new Map();
-/**
- * Get the stored session ID for a channel, if any.
- */
-export function getChannelSessionId(channelId) {
-    return channelSessions.get(channelId);
-}
-/**
- * Clear a channel's session (e.g., on issue reset).
- */
-export function clearChannelSession(channelId) {
-    channelSessions.delete(channelId);
-}
-// ============================================================
-// Message Processing
-// ============================================================
-/**
- * Process one or more human messages by resuming the channel's session.
- * On first call: creates a new session with full context in the system prompt.
- * On subsequent calls: resumes the session — AI already has conversation history.
- *
- * Returns the session ID (callers should track this if needed).
- */
-export async function processHumanMessages(messages, issueId, config, verbose, repoPath) {
-    if (messages.length === 0) {
-        return undefined;
-    }
-    const channelId = messages[0].channel_id;
-    const existingSessionId = channelSessions.get(channelId);
-    if (verbose) {
-        logInfo(`Processing ${messages.length} message(s) for channel ${channelId}${existingSessionId
-            ? ` (resuming session ${existingSessionId})`
-            : ' (new session)'}`);
-    }
-    try {
-        // Build the user prompt — just the message content
-        const messageParts = messages.map((m, i) => {
-            if (messages.length === 1) {
-                return m.content;
-            }
-            return `[Message ${i + 1} from ${m.sender_name}]: ${m.content}`;
-        });
-        const userPrompt = messageParts.join('\n\n');
-        // On first message: include full context + chat history so the session
-        // starts informed (covers CLI restart where in-memory session is lost).
-        // On resume: just send the new message — the session already has context.
-        let fullPrompt;
-        if (!existingSessionId) {
-            const context = await buildChatContext(issueId, channelId, verbose);
-            const contextStr = formatContextForAI(context);
-            // Load recent chat history so the AI has conversational continuity
-            const recentMessages = await listChatMessages(channelId, { limit: 30 }, verbose);
-            // Exclude the messages we're about to process (they'll be in userPrompt)
-            const currentIds = new Set(messages.map((m) => m.id));
-            const historyMessages = recentMessages.filter((m) => !currentIds.has(m.id));
-            let historySection = '';
-            if (historyMessages.length > 0) {
-                const historyLines = historyMessages.map((m) => {
-                    const nonAiRole = m.sender_type === 'system' ? 'System' : m.sender_name || 'User';
-                    const role = m.sender_type === 'ai' ? 'AI' : nonAiRole;
-                    return `[${role}]: ${m.content}`;
-                });
-                historySection = [
-                    `## Previous Chat History`,
-                    `The following is the recent conversation history in this channel. Continue the conversation naturally.`,
-                    '',
-                    ...historyLines,
-                    '',
-                ].join('\n');
-            }
-            fullPrompt = [
-                `## Current Issue Context`,
-                contextStr,
-                '',
-                `## Channel ID: ${channelId}`,
-                `## Issue ID: ${issueId}`,
-                `## Product ID: ${context.productId}`,
-                '',
-                historySection,
-                `## Human Message`,
-                userPrompt,
-                '',
-                `Respond to this message. Use tools if you need to take actions. Always respond in the chat using the send_chat_message tool.`,
-            ].join('\n');
-        }
-        else {
-            fullPrompt = userPrompt;
-        }
-        // Run the agent (with resume if we have a session)
-        const result = await runChatAgent({
-            systemPrompt: CHAT_RESPONSE_PROMPT,
-            userPrompt: fullPrompt,
-            config,
-            resumeSessionId: existingSessionId,
-            verbose,
-            cwd: repoPath,
-        });
-        // Store the session ID for future resumption
-        if (result.sessionId) {
-            channelSessions.set(channelId, result.sessionId);
-        }
-        // If the agent didn't send a message via tools, send the response text
-        const sentViaTool = result.toolsUsed.has('mcp__edsger-chat__send_chat_message');
-        if (result.text && !sentViaTool) {
-            await sendAiMessage(channelId, result.text, {
-                in_response_to: messages[messages.length - 1].id,
-            });
-        }
-        // Mark all messages as processed
-        for (const message of messages) {
-            await markMessageProcessed(message.id, verbose);
-        }
-        if (verbose) {
-            logInfo(`All ${messages.length} message(s) processed successfully`);
-        }
-        return result.sessionId;
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        logError(`Failed to process messages: ${msg}`);
-        // If resume fails (e.g., corrupted session), clear and retry without resume
-        if (existingSessionId) {
-            logInfo(`Clearing session ${existingSessionId} and retrying without resume`);
-            channelSessions.delete(channelId);
-            return processHumanMessages(messages, issueId, config, verbose, repoPath);
-        }
-        // Send error message to chat
-        try {
-            await sendAiMessage(channelId, `Sorry, I encountered an error processing your message: ${msg}`, {
-                error: true,
-            });
-        }
-        catch {
-            // Ignore error sending error message
-        }
-        // Mark all as processed to avoid infinite retry loops
-        for (const message of messages) {
-            await markMessageProcessed(message.id, verbose);
-        }
-        return undefined;
-    }
-}
-/**
- * Process one or more human messages from a product channel.
- * Same session resumption pattern as issue chat, but uses
- * product context, product prompt, and product tools.
- */
-export async function processProductHumanMessages(messages, productId, config, verbose) {
-    if (messages.length === 0) {
-        return undefined;
-    }
-    const channelId = messages[0].channel_id;
-    const existingSessionId = channelSessions.get(channelId);
-    if (verbose) {
-        logInfo(`Processing ${messages.length} product message(s) for channel ${channelId}${existingSessionId
-            ? ` (resuming session ${existingSessionId})`
-            : ' (new session)'}`);
-    }
-    try {
-        // Build the user prompt
-        const messageParts = messages.map((m, i) => {
-            if (messages.length === 1) {
-                return m.content;
-            }
-            return `[Message ${i + 1} from ${m.sender_name}]: ${m.content}`;
-        });
-        const userPrompt = messageParts.join('\n\n');
-        let fullPrompt;
-        if (!existingSessionId) {
-            const context = await buildProductChatContext(productId, channelId, verbose);
-            const contextStr = formatProductContextForAI(context);
-            // Load recent chat history
-            const recentMessages = await listChatMessages(channelId, { limit: 30 }, verbose);
-            const currentIds = new Set(messages.map((m) => m.id));
-            const historyMessages = recentMessages.filter((m) => !currentIds.has(m.id));
-            let historySection = '';
-            if (historyMessages.length > 0) {
-                const historyLines = historyMessages.map((m) => {
-                    const nonAiRole = m.sender_type === 'system' ? 'System' : m.sender_name || 'User';
-                    const role = m.sender_type === 'ai' ? 'AI' : nonAiRole;
-                    return `[${role}]: ${m.content}`;
-                });
-                historySection = [
-                    `## Previous Chat History`,
-                    `The following is the recent conversation history in this channel. Continue the conversation naturally.`,
-                    '',
-                    ...historyLines,
-                    '',
-                ].join('\n');
-            }
-            fullPrompt = [
-                `## Current Product Context`,
-                contextStr,
-                '',
-                `## Channel ID: ${channelId}`,
-                `## Product ID: ${productId}`,
-                '',
-                historySection,
-                `## Human Message`,
-                userPrompt,
-                '',
-                `Respond to this message. Use tools if you need to take actions. Always respond in the chat using the send_chat_message tool.`,
-            ].join('\n');
-        }
-        else {
-            fullPrompt = userPrompt;
-        }
-        // Run the agent with product tools (no cwd — product chat doesn't operate on a repo)
-        const result = await runProductChatAgent(PRODUCT_CHAT_RESPONSE_PROMPT, fullPrompt, config, existingSessionId, verbose);
-        if (result.sessionId) {
-            channelSessions.set(channelId, result.sessionId);
-        }
-        const sentViaTool = result.toolsUsed.has('mcp__edsger-product-chat__send_chat_message');
-        if (result.text && !sentViaTool) {
-            await sendAiMessage(channelId, result.text, {
-                in_response_to: messages[messages.length - 1].id,
-            });
-        }
-        for (const message of messages) {
-            await markMessageProcessed(message.id, verbose);
-        }
-        if (verbose) {
-            logInfo(`All ${messages.length} product message(s) processed successfully`);
-        }
-        return result.sessionId;
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        logError(`Failed to process product messages: ${msg}`);
-        if (existingSessionId) {
-            logInfo(`Clearing session ${existingSessionId} and retrying without resume`);
-            channelSessions.delete(channelId);
-            return processProductHumanMessages(messages, productId, config, verbose);
-        }
-        try {
-            await sendAiMessage(channelId, `Sorry, I encountered an error processing your message: ${msg}`, {
-                error: true,
-            });
-        }
-        catch {
-            // Ignore error sending error message
-        }
-        for (const message of messages) {
-            await markMessageProcessed(message.id, verbose);
-        }
-        return undefined;
-    }
-}
-export async function processPhaseCompletion(opts) {
-    const { issueId, phase, summary, phaseOutput, config, verbose, repoPath } = opts;
-    if (verbose) {
-        logInfo(`Processing phase completion: ${phase} for issue ${issueId}`);
-    }
-    try {
-        // Get or create the issue's channel
-        const channel = await getIssueChannel(issueId, verbose);
-        const channelId = channel.id;
-        const existingSessionId = channelSessions.get(channelId);
-        // Step 1: Write system message (factual, immediate)
-        await sendSystemMessage(channelId, `Phase "${phase}" completed.`, { phase, status: 'completed', summary }, verbose);
-        // Step 2: Build the advisor prompt
-        const context = await buildChatContext(issueId, channelId, verbose);
-        const recentMessages = await listChatMessages(channelId, { limit: 10 }, verbose);
-        const remainingPhases = context.workflow
-            .filter((p) => p.status === 'pending')
-            .map((p) => p.phase);
-        const advisorMessage = buildNextStepAdvisorMessage({
-            issueDescription: context.issueDescription,
-            completedPhase: phase,
-            summary,
-            phaseOutput,
-            remainingPhases,
-            userStoriesCount: context.userStories.length,
-            testCasesCount: context.testCases.length,
-            recentChatMessages: recentMessages.map((m) => ({
-                sender_type: m.sender_type,
-                content: m.content,
-            })),
-        });
-        // If this is the first interaction on this channel, include full context
-        let fullPrompt;
-        if (!existingSessionId) {
-            const contextStr = formatContextForAI(context);
-            fullPrompt = [
-                `## Current Issue Context`,
-                contextStr,
-                '',
-                `## Channel ID: ${channelId}`,
-                `## Issue ID: ${issueId}`,
-                `## Product ID: ${context.productId}`,
-                '',
-                advisorMessage,
-                '',
-                `Analyze the completed phase and suggest next steps. Use the provide_options tool to present actionable choices to the user.`,
-            ].join('\n');
-        }
-        else {
-            fullPrompt = [
-                advisorMessage,
-                '',
-                `Analyze the completed phase and suggest next steps. Use the provide_options tool to present actionable choices to the user.`,
-            ].join('\n');
-        }
-        // Use NEXT_STEP_ADVISOR_PROMPT for the system prompt on new sessions,
-        // but on resume the system prompt from the original session persists.
-        // We still pass the advisor prompt — the SDK will use it for new sessions
-        // and ignore it for resumed ones (system prompt is fixed at session creation).
-        const result = await runChatAgent({
-            systemPrompt: existingSessionId
-                ? CHAT_RESPONSE_PROMPT
-                : NEXT_STEP_ADVISOR_PROMPT,
-            userPrompt: fullPrompt,
-            config,
-            resumeSessionId: existingSessionId,
-            verbose,
-            cwd: repoPath,
-        });
-        // Store session ID
-        if (result.sessionId) {
-            channelSessions.set(channelId, result.sessionId);
-        }
-        // If the agent didn't send a message via tools, send the raw response
-        const sentMessage = result.toolsUsed.has('mcp__edsger-chat__send_chat_message');
-        const sentOptions = result.toolsUsed.has('mcp__edsger-chat__provide_options');
-        if (result.text && !sentMessage && !sentOptions) {
-            await sendAiMessage(channelId, result.text, {
-                phase_completion_suggestion: true,
-                phase,
-            });
-        }
-        if (verbose) {
-            logInfo(`Phase completion processed for ${phase}`);
-        }
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        logError(`Failed to process phase completion for ${phase}: ${msg}`);
-    }
-}
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
-async function* prompt(userContent) {
-    yield userMessage(userContent);
-}
-async function runChatAgent(opts) {
-    const { systemPrompt, userPrompt, config: _config, resumeSessionId, verbose, cwd, } = opts;
-    let lastAssistantResponse = '';
-    const toolUsed = new Set();
-    let sessionId;
-    // Create the in-process MCP server with our chat tools
-    const chatMcpServer = createChatMcpServer();
-    for await (const message of query({
-        prompt: prompt(userPrompt),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 20,
-            permissionMode: 'bypassPermissions',
-            mcpServers: {
-                'edsger-chat': chatMcpServer,
-            },
-            ...(cwd ? { cwd } : {}),
-            ...(resumeSessionId ? { resume: resumeSessionId } : {}),
-        },
-    })) {
-        // Capture session ID from any message
-        if (message.session_id && !sessionId) {
-            sessionId = message.session_id;
-        }
-        if (message.type === 'assistant' && message.message?.content) {
-            for (const content of message.message.content) {
-                if (content.type === 'text') {
-                    lastAssistantResponse += `${content.text}\n`;
-                    logDebug(`🤖 ${content.text}`, verbose);
-                }
-                else if (content.type === 'tool_use') {
-                    toolUsed.add(content.name);
-                    logDebug(`🔧 Tool: ${content.name}`, verbose);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            if (verbose) {
-                logInfo(`Chat agent completed: ${message.subtype}`);
-            }
-        }
-    }
-    return {
-        text: lastAssistantResponse.trim(),
-        sessionId,
-        toolsUsed: toolUsed,
-    };
-}
-/**
- * Run the Claude Agent SDK with product chat MCP tools.
- * Same as runChatAgent but uses product-level tools instead of issue-level tools.
- * No cwd parameter since product chat doesn't operate on a specific repo.
- */
-async function runProductChatAgent(systemPrompt, userPrompt, config, resumeSessionId, verbose) {
-    let lastAssistantResponse = '';
-    const toolUsed = new Set();
-    let sessionId;
-    const productChatMcpServer = createProductChatMcpServer();
-    for await (const message of query({
-        prompt: prompt(userPrompt),
-        options: {
-            systemPrompt: {
-                type: 'preset',
-                preset: 'claude_code',
-                append: systemPrompt,
-            },
-            model: DEFAULT_MODEL,
-            maxTurns: 20,
-            permissionMode: 'bypassPermissions',
-            mcpServers: {
-                'edsger-product-chat': productChatMcpServer,
-            },
-            ...(resumeSessionId ? { resume: resumeSessionId } : {}),
-        },
-    })) {
-        if (message.session_id && !sessionId) {
-            sessionId = message.session_id;
-        }
-        if (message.type === 'assistant' && message.message?.content) {
-            for (const content of message.message.content) {
-                if (content.type === 'text') {
-                    lastAssistantResponse += `${content.text}\n`;
-                    logDebug(`🤖 ${content.text}`, verbose);
-                }
-                else if (content.type === 'tool_use') {
-                    toolUsed.add(content.name);
-                    logDebug(`🔧 Tool: ${content.name}`, verbose);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            if (verbose) {
-                logInfo(`Product chat agent completed: ${message.subtype}`);
-            }
-        }
-    }
-    return {
-        text: lastAssistantResponse.trim(),
-        sessionId,
-        toolsUsed: toolUsed,
-    };
-}