@northflare/runner 0.0.13 → 0.0.16

package/dist/components/claude-manager.js

@@ -1,783 +0,0 @@
-"use strict";
-/**
- * ClaudeManager - Manages Claude conversations using claude-code-sdk-ts
- *
- * This component handles stateful conversation lifecycle management, maintaining
- * persistent conversation instances indexed by taskId. It integrates with the
- * Claude SDK to manage sessions, handle MCP server configurations, and coordinate
- * with the orchestrator for authentication and notifications.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClaudeManager = void 0;
-const claude_code_sdk_ts_1 = require("@botanicastudios/claude-code-sdk-ts");
-const status_line_1 = require("../utils/status-line");
-const console_1 = require("../utils/console");
-const expand_env_1 = require("../utils/expand-env");
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-class ClaudeManager {
-    runner;
-    repositoryManager;
-    constructor(runner, repositoryManager) {
-        this.runner = runner;
-        this.repositoryManager = repositoryManager;
-        // Log debug mode status
-        if (process.env["DEBUG"] === "true") {
-            console_1.console.log("[ClaudeManager] DEBUG MODE ENABLED - Claude SDK will log verbose output");
-        }
-        // Note: MCP host configuration is passed from orchestrator
-        // Runner does not define its own MCP tools
-        this.setupInternalMcpServer();
-    }
-    setupInternalMcpServer() {
-        // Runner does not define its own MCP tools
-        // All MCP tool configuration is passed from orchestrator in conversation config
-    }
-    async startConversation(conversationObjectType, conversationObjectId, config, initialMessages, conversationData) {
-        // Returns conversation context
-        // Greenfield: conversationData.id is required as the authoritative DB conversation ID
-        if (!conversationData?.id) {
-            throw new Error("startConversation requires conversationData with a valid conversation.id");
-        }
-        // Use sessionId from config if resuming, or agentSessionId from conversationData if available
-        const agentSessionId = config.sessionId || conversationData.agentSessionId || "";
-        const conversationId = conversationData.id;
-        const context = {
-            conversationId,
-            agentSessionId, // Will be updated by onSessionId callback for new conversations
-            conversationObjectType,
-            conversationObjectId,
-            taskId: conversationObjectType === "Task" ? conversationObjectId : undefined,
-            workspaceId: config.workspaceId,
-            status: "starting",
-            config,
-            startedAt: new Date(),
-            lastActivityAt: new Date(),
-            // Add conversation details if provided
-            model: conversationData?.model || "sonnet",
-            globalInstructions: conversationData?.globalInstructions || "",
-            workspaceInstructions: conversationData?.workspaceInstructions || "",
-            permissionsMode: conversationData?.permissionsMode || "all",
-        };
-        // Store with conversation.id as the key
-        this.runner.activeConversations_.set(conversationId, context);
-        console_1.console.log(`[ClaudeManager] Stored conversation context:`, {
-            conversationId,
-            agentSessionId: context.agentSessionId,
-            conversationObjectType: context.conversationObjectType,
-            conversationObjectId: context.conversationObjectId,
-            mapSize: this.runner.activeConversations_.size,
-            allKeys: Array.from(this.runner.activeConversations_.keys()),
-        });
-        const workspaceId = config.workspaceId;
-        // Checkout repository if specified
-        let workspacePath;
-        // Check if this is a local workspace by looking for runnerRepoPath in config
-        if (config.runnerRepoPath) {
-            // Local workspace - use the provided path directly
-            workspacePath = config.runnerRepoPath;
-            console_1.console.log(`Using local workspace path: ${workspacePath}`);
-            // For task conversations in local workspaces, create a local task handle
-            if (conversationObjectType === "Task") {
-                const taskHandle = await this.repositoryManager.createLocalTaskHandle(conversationObjectId, workspacePath);
-                // Store task handle information in context for later use
-                context.taskHandle = taskHandle;
-            }
-        }
-        else if (conversationObjectType === "Task" &&
-            config.repository &&
-            workspaceId) {
-            // Use task-specific worktree for task conversations
-            console_1.console.log(`[ClaudeManager] Creating task worktree with repository config:`, {
-                conversationObjectId,
-                workspaceId,
-                repository: config.repository,
-                hasUrl: !!config.repository.url,
-                url: config.repository.url,
-                branch: config.repository.branch,
-                type: config.repository.type,
-            });
-            // Check if repository.url is missing
-            if (!config.repository.url) {
-                throw new Error(`Repository URL is missing in config for task ${conversationObjectId}. Repository config: ${JSON.stringify(config.repository)}`);
-            }
-            const taskHandle = await this.repositoryManager.createTaskWorktree(conversationObjectId, workspaceId, config.repository.url, config.repository.branch, config.githubToken);
-            workspacePath = taskHandle.worktreePath;
-            // Store task handle information in context for later use
-            context.taskHandle = taskHandle;
-        }
-        else if (config.repository && workspaceId) {
-            // Check if it's a local repository
-            if (config.repository.type === "local" && config.repository.localPath) {
-                // Use the local path directly
-                workspacePath = config.repository.localPath;
-                console_1.console.log(`Using local repository path: ${workspacePath}`);
-            }
-            else {
-                // Fall back to workspace-based checkout for non-task conversations
-                workspacePath = await this.repositoryManager.checkoutRepository(workspaceId, config.repository.url, config.repository.branch, config.githubToken);
-            }
-        }
-        else if (workspaceId) {
-            workspacePath = await this.repositoryManager.getWorkspacePath(workspaceId);
-        }
-        else {
-            // Default workspace path when no workspaceId is provided
-            workspacePath = process.cwd();
-        }
-        // Fetch GitHub tokens from orchestrator API if we have a workspaceId
-        const githubToken = workspaceId
-            ? await this.fetchGithubTokens(workspaceId)
-            : undefined;
-        // Generate TOOL_TOKEN for MCP tools authentication
-        let toolToken;
-        if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
-            const runnerToken = process.env["CLAUDETTE_RUNNER_TOKEN"];
-            const runnerUid = this.runner.getRunnerUid();
-            if (runnerToken && runnerUid && context.conversationId) {
-                // Sign JWT with runner's token
-                toolToken = jsonwebtoken_1.default.sign({
-                    conversationId: context.conversationId,
-                    runnerUid: runnerUid,
-                }, runnerToken, {
-                    expiresIn: "60m", // 60 minutes expiry
-                });
-                console_1.console.log("[ClaudeManager] Generated TOOL_TOKEN for MCP authentication");
-            }
-            else {
-                console_1.console.warn("[ClaudeManager] Unable to generate TOOL_TOKEN - missing required data");
-            }
-        }
-        // Build claude conversation
-        const builder = (0, claude_code_sdk_ts_1.claude)()
-            .withExecutable(require.resolve("@anthropic-ai/claude-code/cli.js"))
-            .withEnv({
-            ANTHROPIC_API_KEY: config.anthropicApiKey || "",
-            ...(githubToken && { GITHUB_TOKEN: githubToken }),
-        })
-            .withModel(context.model)
-            .inDirectory(workspacePath)
-            .skipPermissions(); // Runner manages permissions
-        // Enable debug logging when DEBUG is set
-        if (process.env["DEBUG"] === "true") {
-            console_1.console.log("[ClaudeManager] Enabling claude-code-sdk debug logging");
-            console_1.console.log("[ClaudeManager] CLI path:", require.resolve("@anthropic-ai/claude-code/cli.js"));
-            console_1.console.log("[ClaudeManager] Working directory:", workspacePath);
-            console_1.console.log("[ClaudeManager] Model:", context.model);
-            const debugLogger = new claude_code_sdk_ts_1.ConsoleLogger(claude_code_sdk_ts_1.LogLevel.TRACE, "[Claude SDK]");
-            builder.withLogger(debugLogger);
-            // Also enable debug mode on the CLI connection to capture stderr/stdout
-            builder.debug(true);
-        }
-        // Add session ID if resuming
-        if (config.sessionId) {
-            builder.withSessionId(config.sessionId);
-        }
-        // Configure MCP servers from orchestrator
-        if (config.mcpServers) {
-            console_1.console.log("[ClaudeManager] MCP servers configuration:", JSON.stringify(config.mcpServers, null, 2));
-            // Pass MCP configuration directly from orchestrator to Claude SDK
-            // The runner does not define or modify MCP tools
-            const expandedMcpServers = (0, expand_env_1.expandEnv)(config.mcpServers, {
-                TOOL_TOKEN: toolToken,
-            });
-            builder.withMCP(expandedMcpServers);
-        }
-        // Append system prompts if we have conversation instructions
-        if (context.globalInstructions || context.workspaceInstructions) {
-            const combinedInstructions = [
-                context.globalInstructions,
-                context.workspaceInstructions,
-            ]
-                .filter(Boolean)
-                .join("\n\n");
-            if (combinedInstructions) {
-                builder.appendSystemPrompt(combinedInstructions);
-            }
-        }
-        // Apply read-only restrictions if requested
-        if (context.permissionsMode === "read") {
-            builder.denyTools("Write", "Edit", "MultiEdit", "Bash", "KillBash", "NotebookEdit", "ExitPlanMode");
-            console_1.console.log("[ClaudeManager] Applied read-only mode tool restrictions");
-        }
-        // Set up process completion handler
-        builder.onProcessComplete(async (exitCode, error) => {
-            // Exit code 143 (SIGTERM) is expected when we stop a conversation
-            const isExpectedTermination = exitCode === 143 &&
-                (context.status === "stopped" || context.status === "stopping");
-            if ((error || exitCode !== 0) && !isExpectedTermination) {
-                // Log detailed error information
-                console_1.console.error(`[ClaudeManager] Claude process failed`, {
-                    exitCode,
-                    errorMessage: error?.message,
-                    errorStack: error?.stack,
-                    conversationId: context.conversationId,
-                    agentSessionId: context.agentSessionId,
-                    workspacePath,
-                    model: context.model,
-                    conversationStatus: context.status,
-                });
-                // Create a more detailed error message
-                const errorMessage = error?.message || `Process exited with code ${exitCode}`;
-                const errorDetails = {
-                    exitCode,
-                    errorStack: error?.stack,
-                    workspacePath,
-                    model: context.model,
-                    sessionId: context.agentSessionId,
-                    conversationId: context.conversationId,
-                    conversationStatus: context.status,
-                    timestamp: new Date().toISOString(),
-                };
-                await this.runner.notify("error.report", {
-                    conversationId: context.conversationId,
-                    conversationObjectType: context.conversationObjectType,
-                    conversationObjectId: context.conversationObjectId,
-                    agentSessionId: context.agentSessionId,
-                    errorType: "process_exit",
-                    message: errorMessage,
-                    details: errorDetails,
-                });
-            }
-            else if (isExpectedTermination) {
-                console_1.console.log(`[ClaudeManager] Claude process terminated as expected (conversation.stop)`, {
-                    exitCode,
-                    conversationId: context.conversationId,
-                    agentSessionId: context.agentSessionId,
-                    conversationStatus: context.status,
-                });
-            }
-            // Notify orchestrator that conversation ended
-            await this.runner.notify("conversation.end", {
-                conversationId: context.conversationId,
-                conversationObjectType: context.conversationObjectType,
-                conversationObjectId: context.conversationObjectId,
-                agentSessionId: context.agentSessionId,
-                isError: exitCode !== 0,
-                errorMessage: error?.message,
-            });
-            // Clean up conversation from active conversations
-            console_1.console.log(`[ClaudeManager] Removing conversation from active map:`, {
-                conversationId: context.conversationId,
-                agentSessionId: context.agentSessionId,
-                mapSizeBefore: this.runner.activeConversations_.size,
-            });
-            this.runner.activeConversations_.delete(context.conversationId);
-            // Update status line
-            status_line_1.statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-        });
-        // Create conversation instance
-        const conversation = builder.asConversation();
-        // Store conversation instance in context for reuse
-        context.conversation = conversation;
-        // Set up session ID callback - this is where we get the real agentSessionId
-        conversation.onSessionId(async (agentSessionId) => {
-            if (!agentSessionId)
-                return;
-            // Check if this is a new session ID
-            const oldSessionId = context.agentSessionId;
-            if (oldSessionId !== agentSessionId) {
-                // Update context with new session ID
-                context.agentSessionId = agentSessionId;
-                context.status = "active";
-                // Note: We don't need to update the Map key since we're using conversation.id now
-                // Notify orchestrator of session change
-                await this.runner.notify("agentSessionId.changed", {
-                    conversationId: context.conversationId,
-                    conversationObjectType,
-                    conversationObjectId,
-                    oldAgentSessionId: oldSessionId,
-                    newAgentSessionId: agentSessionId,
-                });
-            }
-        });
-        // Set up streaming message handler
-        const messageHandler = async (message, sessionId) => {
-            await this.handleStreamedMessage(context, message, sessionId);
-        };
-        conversation.stream(messageHandler);
-        // Note: Error handling is done via process completion handler
-        // The Claude SDK doesn't have an onError method on conversations
-        // Send initial messages
-        try {
-            for (const message of initialMessages) {
-                const initialText = this.normalizeToText(message.content);
-                conversation.send({
-                    type: "text",
-                    text: initialText,
-                });
-            }
-            console_1.console.log(`Started conversation for ${conversationObjectType} ${conversationObjectId} in workspace ${workspacePath}`);
-            // Return the conversation context directly
-            return context;
-        }
-        catch (error) {
-            // Handle startup errors
-            await this._handleConversationError(context, error);
-            throw error;
-        }
-    }
-    async stopConversation(agentSessionId, context) {
-        if (context && context.conversation) {
-            context.status = "stopping";
-            try {
-                // Mark conversation as stopped BEFORE ending to prevent race conditions
-                context.status = "stopped";
-                // Properly end the conversation using the SDK
-                await context.conversation.end();
-            }
-            catch (error) {
-                console_1.console.error(`Error ending conversation ${agentSessionId}:`, error);
-            }
-            // Clean up conversation reference
-            delete context.conversation;
-        }
-        console_1.console.log(`Stopped conversation ${agentSessionId} for ${context.conversationObjectType} ${context.conversationObjectId}`);
-    }
-    async resumeConversation(conversationObjectType, conversationObjectId, agentSessionId, config, conversationData, resumeMessage) {
-        console_1.console.log(`[ClaudeManager] Resuming conversation ${agentSessionId}`);
-        // Resume is handled by starting a new conversation with the existing session ID
-        const context = await this.startConversation(conversationObjectType, conversationObjectId, { ...config, sessionId: agentSessionId }, [], // Don't send initial messages
-        conversationData);
-        // After starting the conversation with the sessionId, we need to send a message
-        // to actually trigger the Claude process to continue
-        if (context.conversation) {
-            try {
-                // Use the provided resume message or default to system instruction
-                const messageToSend = resumeMessage ||
-                    "<system-instructions>Please continue</system-instructions>";
-                console_1.console.log(`[ClaudeManager] Sending resume message to conversation ${agentSessionId}`);
-                context.conversation.send({
-                    type: "text",
-                    text: messageToSend,
-                });
-            }
-            catch (error) {
-                console_1.console.error(`[ClaudeManager] Error sending resume message:`, error);
-            }
-        }
-        return context.agentSessionId;
-    }
-    async sendUserMessage(conversationId, content, config, conversationObjectType, conversationObjectId, conversation) {
-        console_1.console.log(`[ClaudeManager] sendUserMessage called with:`, {
-            conversationId,
-            conversationObjectType,
-            conversationObjectId,
-            hasConfig: !!config,
-            hasConversation: !!conversation,
-            activeConversations: this.runner.activeConversations_.size,
-        });
-        // Find by conversationId only
-        let context = this.runner.getConversationContext(conversationId);
-        console_1.console.log(`[ClaudeManager] Lookup by conversationId result:`, {
-            found: !!context,
-            conversationId: context?.conversationId,
-            agentSessionId: context?.agentSessionId,
-        });
-        if (!context && conversation) {
-            // Use provided conversation details
-            try {
-                const conversationDetails = conversation;
-                // For task conversations, fetch the task config to get repository information
-                let taskConfig = {};
-                if (conversationDetails.objectType === "Task" ||
-                    conversationDetails.objectType === "task") {
-                    try {
-                        const taskConfigResponse = await this.runner.sendToOrchestrator({
-                            jsonrpc: "2.0",
-                            id: `task-config-${Date.now()}`,
-                            method: "task.getConfig",
-                            params: { taskId: conversationDetails.objectId },
-                        });
-                        if (taskConfigResponse?.result) {
-                            taskConfig = taskConfigResponse.result;
-                            console_1.console.log(`[ClaudeManager] Fetched task config with repository:`, {
-                                hasRepository: !!taskConfigResponse.result.repository,
-                                repositoryType: taskConfigResponse.result.repository?.type,
-                                repositoryPath: taskConfigResponse.result.repository?.localPath,
-                                hasAccessKey: !!taskConfigResponse.result.accessKey,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        console_1.console.error(`[ClaudeManager] Failed to fetch task config:`, error);
-                    }
-                }
-                // Bind to existing session if present; do not send a resume message here
-                const startConfig = {
-                    anthropicApiKey: config?.anthropicApiKey || process.env["ANTHROPIC_API_KEY"] || "",
-                    model: conversationDetails.model,
-                    systemPrompt: config?.systemPrompt,
-                    permissionsMode: conversationDetails.permissionsMode,
-                    accessKey: taskConfig?.accessKey || config?.accessKey || "",
-                    workspaceId: conversationDetails.workspaceId,
-                    ...taskConfig,
-                    ...config,
-                    ...(conversationDetails.agentSessionId
-                        ? { sessionId: conversationDetails.agentSessionId }
-                        : {}),
-                };
-                // Start the SDK conversation (no initial messages); this attaches to existing session when provided
-                await this.startConversation(conversationDetails.objectType, conversationDetails.objectId, startConfig, [], conversationDetails);
-                // Refresh context after start/resume
-                context = this.runner.getConversationContext(conversationId);
-            }
-            catch (error) {
-                console_1.console.error(`Failed to fetch conversation ${conversationId}:`, error);
-            }
-        }
-        if (!context) {
-            throw new Error(`No active or fetchable conversation found for ${conversationId}`);
-        }
-        try {
-            // Send immediately when a conversation instance exists; no need to wait for "active"
-            if (!context.conversation) {
-                throw new Error(`No conversation instance found for conversation ${context.conversationId}`);
-            }
-            // Guard: Don't send messages if conversation is stopped or stopping
-            const conversationStatus = context.status;
-            if (conversationStatus === "stopped" ||
-                conversationStatus === "stopping") {
-                console_1.console.warn(`Attempted to send message to stopped/stopping conversation ${context.conversationId}`, {
-                    status: context.status,
-                    conversationObjectType: context.conversationObjectType,
-                    conversationObjectId: context.conversationObjectId,
-                });
-                return;
-            }
-            // Normalize arbitrary content into a plain string for the CLI
-            const normalizedText = this.normalizeToText(content);
-            if (process.env["DEBUG"] === "true") {
-                console_1.console.log("[ClaudeManager] Normalized follow-up content", {
-                    originalType: typeof content,
-                    isArray: Array.isArray(content) || undefined,
-                    normalizedPreview: typeof normalizedText === "string"
-                        ? normalizedText.slice(0, 160)
-                        : String(normalizedText).slice(0, 160),
-                });
-            }
-            console_1.console.log("[ClaudeManager] Normalized follow-up content", typeof normalizedText, normalizedText);
-            context.conversation.send({
-                type: "text",
-                text: normalizedText,
-            });
-            // Update last activity timestamp
-            context.lastActivityAt = new Date();
-            console_1.console.log(`Sent user message to conversation ${context.conversationId} (agentSessionId: ${context.agentSessionId}, status: ${context.status})`);
-        }
-        catch (error) {
-            // Handle errors properly
-            await this._handleConversationError(context, error);
-            throw error; // Re-throw to maintain the same behavior
-        }
-    }
-    async fetchGithubTokens(workspaceId) {
-        try {
-            const response = await fetch(`${this.runner.config_.orchestratorUrl}/api/runner/tokens?workspaceId=${workspaceId}`, {
-                method: "GET",
-                headers: {
-                    Authorization: `Bearer ${process.env["CLAUDETTE_RUNNER_TOKEN"]}`,
-                },
-            });
-            if (!response.ok) {
-                console_1.console.error(`Failed to fetch GitHub tokens: ${response.status}`);
-                return undefined;
-            }
-            const data = (await response.json());
-            return data.githubToken;
-        }
-        catch (error) {
-            console_1.console.error("Error fetching GitHub tokens:", error);
-            return undefined;
-        }
-    }
-    async _handleConversationError(context, error) {
-        const errorType = this.classifyError(error);
-        // Notify orchestrator
-        await this.runner.notify("error.report", {
-            conversationId: context.conversationId,
-            conversationObjectType: context.conversationObjectType,
-            conversationObjectId: context.conversationObjectId,
-            agentSessionId: context.agentSessionId,
-            errorType,
-            message: error.message,
-            details: {
-                stack: error.stack,
-                timestamp: new Date(),
-            },
-        });
-        // Conversation continues on error - no automatic cleanup
-        console_1.console.error(`Conversation error for ${context.conversationObjectType} ${context.conversationObjectId}:`, error);
-    }
-    classifyError(error) {
-        if (error.message.includes("process exited")) {
-            return "process_exit";
-        }
-        else if (error.message.includes("model")) {
-            return "model_error";
-        }
-        else if (error.message.includes("tool")) {
-            return "tool_error";
-        }
-        else if (error.message.includes("permission")) {
-            return "permission_error";
-        }
-        else if (error.message.includes("timeout")) {
-            return "timeout_error";
-        }
-        return "unknown_error";
-    }
-    /**
-     * Normalize arbitrary content shapes into a plain string for the CLI
-     */
-    normalizeToText(value) {
-        if (typeof value === "string")
-            return value;
-        if (value == null)
-            return "";
-        if (typeof value === "object") {
-            // Common simple shapes
-            if (typeof value.text === "string")
-                return value.text;
-            if (typeof value.text === "object" &&
-                value.text &&
-                typeof value.text.text === "string")
-                return value.text.text;
-            if (typeof value.content === "string")
-                return value.content;
-            // Array of blocks: [{ type: 'text', text: '...' }, ...]
-            if (Array.isArray(value)) {
-                const texts = value
-                    .map((b) => b && b.type === "text" && typeof b.text === "string" ? b.text : null)
-                    .filter((t) => !!t);
-                if (texts.length)
-                    return texts.join(" ");
-            }
-            // Nested message shapes
-            if (typeof value.message === "object" &&
-                value.message &&
-                typeof value.message.text === "string") {
-                return value.message.text;
-            }
-        }
-        try {
-            return JSON.stringify(value);
-        }
-        catch {
-            return String(value);
-        }
-    }
-    async handleStreamedMessage(context, message, sessionId) {
-        // Guard: Don't process messages if conversation is stopped or stopping
-        const status = context.status;
-        if (status === "stopped" || status === "stopping") {
-            console_1.console.log(`Ignoring message for stopped/stopping conversation ${context.conversationId}`, {
-                status: context.status,
-                messageType: message.type,
-            });
-            return;
-        }
-        try {
-            console_1.console.log(`Received streamed message for ${context.conversationObjectType} ${context.conversationObjectId}`, {
-                type: message.type,
-            });
-            // Build structured content based on message type
-            let messageType = message.type;
-            let subtype;
-            let structuredContent = {};
-            let isError = false;
-            // Extract content based on message type
-            switch (message.type) {
-                case "assistant": {
-                    const assistantMsg = message;
-                    if (assistantMsg.content) {
-                        // Extract text content from content blocks
-                        const textBlocks = assistantMsg.content.filter((b) => b.type === "text");
-                        const textContent = textBlocks.map((b) => b.text).join("");
-                        // Extract tool calls
-                        const toolUseBlocks = assistantMsg.content.filter((b) => b.type === "tool_use");
-                        const toolCalls = toolUseBlocks.length > 0
-                            ? toolUseBlocks.map((b) => ({
-                                id: b.id,
-                                name: b.name,
-                                arguments: b.input,
-                            }))
-                            : undefined;
-                        structuredContent = {
-                            text: textContent,
-                            toolCalls,
-                            timestamp: new Date().toISOString(),
-                        };
-                    }
-                    break;
-                }
-                case "thinking": {
-                    // Map thinking to assistant with subtype
-                    messageType = "assistant";
-                    subtype = "thinking";
-                    const thinkingMsg = message;
-                    structuredContent = {
-                        text: thinkingMsg.content || "",
-                        timestamp: new Date().toISOString(),
-                    };
-                    break;
-                }
-                case "tool_use": {
-                    // Tool call request - map to assistant
-                    messageType = "assistant";
-                    subtype = "tool_use";
-                    const toolUseMsg = message;
-                    structuredContent = {
-                        toolCalls: [
-                            {
-                                id: toolUseMsg.id,
-                                name: toolUseMsg.name,
-                                arguments: toolUseMsg.input,
-                            },
-                        ],
-                        timestamp: new Date().toISOString(),
-                    };
-                    break;
-                }
-                case "tool_result": {
-                    // Tool execution result - map to tool_result
-                    messageType = "tool_result";
-                    subtype = "tool_result";
-                    const toolResultMsg = message;
-                    structuredContent = {
-                        toolResults: [
-                            {
-                                toolCallId: toolResultMsg.tool_use_id,
-                                result: toolResultMsg.content,
-                                isError: toolResultMsg.is_error || false,
-                            },
-                        ],
-                        timestamp: new Date().toISOString(),
-                    };
-                    break;
-                }
-                case "result": {
-                    const resultMsg = message;
-                    structuredContent = {
-                        text: resultMsg.content || resultMsg.result || "",
-                        timestamp: new Date().toISOString(),
-                    };
-                    break;
-                }
-                case "user": {
-                    const userMsg = message;
-                    // Check if content is already an array (e.g., tool results)
-                    if (Array.isArray(userMsg.content)) {
-                        // Check if this is a tool result by examining content
-                        const hasToolResult = userMsg.content.some((item) => item && typeof item === "object" && item.type === "tool_result");
-                        if (hasToolResult) {
-                            // This is a tool result - change message type
-                            messageType = "tool_result";
-                            subtype = "tool_result";
-                        }
-                        // Pass the array directly as structured content
-                        structuredContent = userMsg.content;
-                    }
-                    else if (typeof userMsg.content === "string") {
-                        // String content - wrap in text object
-                        structuredContent = {
-                            text: userMsg.content,
-                            timestamp: new Date().toISOString(),
-                        };
-                    }
-                    else {
-                        // Other object content - preserve as is
-                        structuredContent = userMsg.content || {};
-                    }
-                    break;
-                }
-                case "system": {
-                    const systemMsg = message;
-                    structuredContent = {
-                        text: systemMsg.content || "",
-                        timestamp: new Date().toISOString(),
-                    };
-                    break;
-                }
-                case "error": {
-                    const errorMsg = message;
-                    messageType = "system";
-                    subtype = "error";
-                    isError = true;
-                    structuredContent = {
-                        text: errorMsg.message || errorMsg.error || "Unknown error",
-                        errorType: errorMsg.error_type || "unknown",
-                        errorDetails: {
-                            stack: errorMsg.stack,
-                            code: errorMsg.code,
-                            context: errorMsg,
-                        },
-                        timestamp: new Date().toISOString(),
-                    };
-                    break;
-                }
-                default: {
-                    // Unknown message type - log and send as assistant
-                    const unknownMsg = message;
-                    console_1.console.warn(`Unknown message type: ${unknownMsg.type}`, message);
-                    messageType = "assistant";
-                    structuredContent = {
-                        text: JSON.stringify(message),
-                        timestamp: new Date().toISOString(),
-                    };
-                }
-            }
-            // Generate a unique message ID
-            const messageId = `${context.agentSessionId}-${Date.now()}-${Math.random()
-                .toString(36)
-                .substr(2, 9)}`;
-            // Send agent message to orchestrator with structured content
-            // Skip if conversation is stopping/stopped to avoid race conditions
-            const currentStatus = context.status;
-            if (currentStatus !== "stopped" && currentStatus !== "stopping") {
-                await this.runner.notify("message.agent", {
-                    conversationId: context.conversationId,
-                    conversationObjectType: context.conversationObjectType,
-                    conversationObjectId: context.conversationObjectId,
-                    agentSessionId: context.agentSessionId,
-                    type: messageType,
-                    subtype,
-                    content: Array.isArray(structuredContent)
-                        ? structuredContent
-                        : [structuredContent],
-                    messageId,
-                    isError,
-                });
-            }
-            // Tool calls are now handled directly by Claude through the MCP server
-            // We just log that we saw them but don't intercept or process them
-            if (structuredContent.toolCalls &&
-                structuredContent.toolCalls.length > 0) {
-                console_1.console.log(`Claude is making ${structuredContent.toolCalls.length} tool call(s) via MCP`, {
-                    conversationObjectId: context.conversationObjectId,
-                    toolNames: structuredContent.toolCalls.map((tc) => tc.name),
-                });
-            }
-        }
-        catch (error) {
-            // Check if this is a transport error due to stopped conversation
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const isTransportError = errorMessage.includes("Cannot read properties of undefined") ||
-                errorMessage.includes("stdout") ||
-                errorMessage.includes("transport");
-            const statusCheck = context.status;
-            if (isTransportError &&
-                (statusCheck === "stopped" || statusCheck === "stopping")) {
-                // This is expected when conversation is stopped - just log it
-                console_1.console.log(`Transport error for stopped/stopping conversation ${context.conversationId} (expected):`, errorMessage);
-                return;
-            }
-            console_1.console.error(`Error handling streamed message for ${context.conversationObjectType} ${context.conversationObjectId}:`, error);
-            await this._handleConversationError(context, error);
-        }
-    }
-}
-exports.ClaudeManager = ClaudeManager;
-//# sourceMappingURL=claude-manager.js.map