@northflare/runner 0.0.31 → 0.0.32

package/dist/components/claude-sdk-manager.js

@@ -1,1378 +0,0 @@
-/**
- * ClaudeManager - Manages Claude conversations using SDK-native patterns
- *
- * This component handles stateful conversation lifecycle management, maintaining
- * persistent conversation instances indexed by taskId. Uses the SDK's native
- * capabilities including the builder pattern, native session management, and
- * built-in streaming instead of custom wrappers.
- *
- * Key improvements:
- * - Uses claude() builder pattern for simplified configuration
- * - Native session management with withSessionId()
- * - Direct AsyncGenerator streaming without custom wrappers
- * - SDK's onProcessComplete() for proper cleanup
- * - Simplified error handling while maintaining compatibility
- */
-import { query as sdkQuery } from "@anthropic-ai/claude-agent-sdk";
-import { statusLineManager } from '../utils/status-line.js';
-import { createScopedConsole } from '../utils/console.js';
-import { expandEnv } from '../utils/expand-env.js';
-import { isDebugEnabledFor } from '../utils/debug.js';
-import fs from "fs/promises";
-import path from "path";
-import { simpleGit } from "simple-git";
-const console = createScopedConsole(isDebugEnabledFor("manager") ? "manager" : "sdk");
-import jwt from "jsonwebtoken";
-export class ClaudeManager {
-    runner;
-    repositoryManager;
-    constructor(runner, repositoryManager) {
-        this.runner = runner;
-        this.repositoryManager = repositoryManager;
-        // Log debug mode status
-        if (isDebugEnabledFor("sdk")) {
-            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 useWorktrees = config.useWorktrees !== false;
-        const pendingSummary = this.runner.consumePendingConversationSummary(conversationId);
-        const rawSummary = typeof conversationData.summary === "string"
-            ? conversationData.summary
-            : pendingSummary;
-        const normalizedSummary = typeof rawSummary === "string"
-            ? rawSummary.replace(/\s+/g, " ").trim()
-            : null;
-        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 || "opus",
-            summary: normalizedSummary,
-            globalInstructions: conversationData?.globalInstructions || "",
-            workspaceInstructions: conversationData?.workspaceInstructions || "",
-            permissionsMode: conversationData?.permissionsMode || "all",
-            provider: "claude",
-            metadata: {
-                instructionsInjected: false,
-            },
-        };
-        // Store with conversation.id as the key
-        this.runner.activeConversations_.set(conversationId, context);
-        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.log(`Using local workspace path: ${workspacePath}`);
-            // For task conversations, isolate the worktree/branch when the repo has a .git directory
-            if (conversationObjectType === "Task" && workspaceId) {
-                const hasGitDir = await fs
-                    .access(path.join(workspacePath, ".git"))
-                    .then(() => true)
-                    .catch(() => false);
-                if (hasGitDir && useWorktrees) {
-                    const repoUrl = config.repository?.url || `file://${workspacePath}`;
-                    const baseBranch = config.repository?.branch || "main";
-                    const taskHandle = await this.repositoryManager.createTaskWorktree(conversationObjectId, workspaceId, repoUrl, baseBranch, config.githubToken);
-                    workspacePath = taskHandle.worktreePath;
-                    context.taskHandle = taskHandle;
-                }
-            }
-        }
-        else if (conversationObjectType === "Task" &&
-            config.repository &&
-            workspaceId &&
-            useWorktrees) {
-            // Use task-specific worktree for all task conversations (keeps shared workspace checkout clean)
-            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.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["NORTHFLARE_RUNNER_TOKEN"];
-            const runnerUid = this.runner.getRunnerUid();
-            if (runnerToken && runnerUid && context.conversationId) {
-                // Sign JWT with runner's token
-                toolToken = jwt.sign({
-                    conversationId: context.conversationId,
-                    runnerUid: runnerUid,
-                }, runnerToken, {
-                    expiresIn: "60m", // 60 minutes expiry
-                });
-                console.log("[ClaudeManager] Generated TOOL_TOKEN for MCP authentication");
-            }
-            else {
-                console.warn("[ClaudeManager] Unable to generate TOOL_TOKEN - missing required data");
-            }
-        }
-        // Simplified SDK configuration - using native query API with streamlined options
-        // const cliPath = require.resolve("@anthropic-ai/claude-code/cli.js");
-        // Debug logging for executable paths
-        //console.log("[ClaudeManager] SDK executable paths:", {
-        //  cliPath,
-        //  cwd: workspacePath,
-        //});
-        // Simplified environment configuration
-        const envVars = {
-            ...Object.fromEntries(Object.entries(process.env).filter(([_, value]) => value !== undefined)), // Preserve parent environment, filter out undefined values
-        };
-        if (config.anthropicApiKey) {
-            envVars["ANTHROPIC_API_KEY"] = config.anthropicApiKey;
-        }
-        if (config.accessToken) {
-            envVars["CLAUDE_CODE_OAUTH_TOKEN"] = config.accessToken;
-        }
-        if (githubToken) {
-            envVars["GITHUB_TOKEN"] = githubToken;
-        }
-        if (isDebugEnabledFor("sdk")) {
-            envVars["DEBUG"] = "1";
-        }
-        const instructionPrefix = this.getInstructionPrefix(context);
-        // System prompt handling (append uses preset+append; replace uses raw string)
-        // Include global/workspace instructions in the system prompt so Claude sees them.
-        const baseSystemPrompt = config.systemPrompt || conversationData?.systemPrompt;
-        const northflareSystemPrompt = config?.northflareSystemPrompt ||
-            conversationData?.northflareSystemPrompt;
-        const providedSystemPrompt = [northflareSystemPrompt, instructionPrefix, baseSystemPrompt]
-            .filter((p) => typeof p === "string" && p.trim().length > 0)
-            .map((p) => p.trim())
-            .join("\n\n");
-        const systemPromptMode = config.systemPromptMode ||
-            conversationData?.systemPromptMode ||
-            // Default ProjectStep conversations to append so preset stays intact
-            "append";
-        let systemPromptOption;
-        if (providedSystemPrompt) {
-            if (systemPromptMode === "replace") {
-                systemPromptOption = providedSystemPrompt;
-            }
-            else {
-                systemPromptOption = {
-                    type: "preset",
-                    preset: "claude_code",
-                    append: providedSystemPrompt,
-                };
-            }
-        }
-        console.log(`[ClaudeManager] System prompt configuration for conversation ${context.conversationId}:`, {
-            mode: systemPromptMode,
-            hasProvidedSystemPrompt: Boolean(providedSystemPrompt),
-            hasInstructionPrefix: Boolean(instructionPrefix),
-            finalPromptType: typeof systemPromptOption,
-            finalPromptLength: typeof systemPromptOption === "string"
-                ? systemPromptOption.length
-                : systemPromptOption?.append?.length ?? 0,
-        });
-        // Tool restrictions based on permissions mode
-        // "read" = read-only mode (no file writes, no shell)
-        // "project" = no file writes but allows bash, no subagents (for Project conversation)
-        const readOnlyTools = [
-            "Write",
-            "Edit",
-            "MultiEdit",
-            "Bash",
-            "KillBash",
-            "NotebookEdit",
-            "ExitPlanMode",
-        ];
-        const projectModeTools = [
-            "Write",
-            "Edit",
-            "MultiEdit",
-            "NotebookEdit",
-            "ExitPlanMode",
-            "Task",
-        ];
-        const disallowedTools = context.permissionsMode === "read"
-            ? readOnlyTools
-            : context.permissionsMode === "project"
-                ? projectModeTools
-                : [];
-        if (disallowedTools.length) {
-            console.log("[ClaudeManager] Applied read-only mode tool restrictions");
-        }
-        // Simplified MCP server configuration
-        let mcpServers;
-        if (config.mcpServers) {
-            mcpServers = expandEnv(config.mcpServers, { TOOL_TOKEN: toolToken });
-            console.log("[ClaudeManager] MCP servers configuration:", JSON.stringify(mcpServers, null, 2));
-        }
-        // Create input stream for user messages (simplified message queueing)
-        const input = createUserMessageStream();
-        // Launch SDK with simplified configuration
-        const sdk = sdkQuery({
-            prompt: input.iterable,
-            options: {
-                //pathToClaudeCodeExecutable: cliPath,
-                cwd: workspacePath,
-                env: envVars,
-                model: context.model,
-                permissionMode: "bypassPermissions", // Runner handles permissions
-                resume: config.sessionId || conversationData?.agentSessionId || undefined,
-                ...(systemPromptOption ? { systemPrompt: systemPromptOption } : {}),
-                ...(disallowedTools.length ? { disallowedTools } : {}),
-                ...(mcpServers ? { mcpServers } : {}),
-                ...(isDebugEnabledFor("sdk")
-                    ? {
-                        stderr: (data) => {
-                            try {
-                                console.log(`[Claude SDK] ${data}`);
-                            }
-                            catch { }
-                        },
-                    }
-                    : {}),
-            },
-        });
-        // Simplified conversation wrapper - reduced complexity while maintaining interface
-        const conversation = createConversationWrapper(sdk, input, async (hadError, error) => {
-            await this._handleRunCompletion(context, hadError, error);
-        });
-        // Store conversation instance in context for reuse
-        context.conversation = conversation;
-        // Observe session id from first messages that include it
-        conversation.onSessionId(async (agentSessionId) => {
-            if (!agentSessionId)
-                return;
-            const oldSessionId = context.agentSessionId;
-            if (oldSessionId !== agentSessionId) {
-                context.agentSessionId = agentSessionId;
-                context.status = "active";
-                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);
-            // Heuristic: detect terminal system events and finalize
-            try {
-                if (message?.type === "system") {
-                    const m = message;
-                    const subtype = m.subtype || m?.message?.subtype || m?.event;
-                    const exitSignals = [
-                        "exit",
-                        "exiting",
-                        "session_end",
-                        "conversation_end",
-                        "process_exit",
-                        "done",
-                        "completed",
-                    ];
-                    if (subtype && exitSignals.includes(String(subtype))) {
-                        await this._handleRunCompletion(context, false);
-                    }
-                }
-                else if (message?.type === "result") {
-                    // Treat 'result' as an end-of-conversation signal for the SDK
-                    try {
-                        await this._handleRunCompletion(context, false);
-                        console.log("[ClaudeManager] Finalized conversation due to SDK 'result' message", {
-                            conversationId: context.conversationId,
-                            agentSessionId: context.agentSessionId,
-                        });
-                    }
-                    catch (e) {
-                        console.warn("[ClaudeManager] Error finalizing on 'result' message:", e);
-                    }
-                }
-            }
-            catch (e) {
-                console.warn("[ClaudeManager] finalize-on-system heuristic error:", e);
-            }
-        };
-        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) {
-                // Check if the message content contains multimodal content blocks (e.g., images, documents)
-                const contentBlocks = this.normalizeToContentBlocks(message.content);
-                if (contentBlocks && Array.isArray(contentBlocks) && contentBlocks.some(b => b.type === 'image' || b.type === 'document')) {
-                    // Send multimodal message with content blocks array
-                    // SDK supports URL images directly: { type: "image", source: { type: "url", url: "..." } }
-                    // SDK supports URL documents directly: { type: "document", source: { type: "url", url: "..." } }
-                    console.log('[ClaudeManager] Sending multimodal message with', contentBlocks.length, 'content blocks');
-                    if (isDebugEnabledFor("manager")) {
-                        console.log('[ClaudeManager] Content blocks:', JSON.stringify(contentBlocks, null, 2));
-                    }
-                    conversation.send(contentBlocks);
-                }
-                else {
-                    // Fallback to text-only message
-                    const initialText = this.normalizeToText(message.content);
-                    conversation.send({
-                        type: "text",
-                        text: initialText,
-                    });
-                }
-            }
-            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;
-        }
-    }
-    getInstructionPrefix(context) {
-        const parts = [];
-        if (context.globalInstructions) {
-            parts.push(`<global-instructions>\n${context.globalInstructions}\n</global-instructions>`);
-        }
-        if (context.workspaceInstructions) {
-            parts.push(`<workspace-instructions>\n${context.workspaceInstructions}\n</workspace-instructions>`);
-        }
-        return parts.join("\n\n");
-    }
-    async _handleRunCompletion(context, hadError, error) {
-        if (context._finalized)
-            return;
-        const inFlight = context._runCompletionInFlight;
-        if (inFlight)
-            return inFlight;
-        const promise = (async () => {
-            const isTaskConversation = context.conversationObjectType === "Task";
-            const stopRequested = context._stopRequested === true;
-            const taskHandle = context.taskHandle;
-            const shouldRunGitFlow = context.config.useWorktrees !== false &&
-                isTaskConversation &&
-                !!taskHandle &&
-                taskHandle.branch !== "local";
-            if (!shouldRunGitFlow || hadError || stopRequested) {
-                await this._finalizeConversation(context, hadError, error);
-                return;
-            }
-            const taskId = context.conversationObjectId;
-            const baseBranch = context.config.repository?.branch || "main";
-            try {
-                const taskState = await this.repositoryManager.getTaskState(taskId);
-                const taskRepoInfo = await this.repositoryManager.getTaskRepoInfo(taskId);
-                if (!taskState ||
-                    !taskRepoInfo ||
-                    !taskRepoInfo.worktreePath ||
-                    taskState.branch === "local") {
-                    await this._finalizeConversation(context, false);
-                    return;
-                }
-                const isLocalRepo = taskRepoInfo.repoKey.startsWith("local__");
-                const mergeWorkdir = isLocalRepo
-                    ? taskRepoInfo.controlPath
-                    : taskRepoInfo.worktreePath;
-                // If we already have unresolved conflicts, immediately ask the agent to resolve them.
-                const taskGit = simpleGit(taskRepoInfo.worktreePath);
-                const initialTaskStatus = await taskGit.status();
-                if (initialTaskStatus.conflicted.length > 0) {
-                    await this._resumeForGitConflictResolution(context, {
-                        kind: "conflicts",
-                        baseBranch,
-                        conflicts: initialTaskStatus.conflicted,
-                        workdir: taskRepoInfo.worktreePath,
-                    });
-                    return;
-                }
-                if (isLocalRepo && mergeWorkdir !== taskRepoInfo.worktreePath) {
-                    const mergeGit = simpleGit(mergeWorkdir);
-                    const mergeStatus = await mergeGit.status();
-                    if (mergeStatus.conflicted.length > 0) {
-                        await this._resumeForGitConflictResolution(context, {
-                            kind: "conflicts",
-                            baseBranch,
-                            conflicts: mergeStatus.conflicted,
-                            workdir: mergeWorkdir,
-                        });
-                        return;
-                    }
-                }
-                // Ensure we're on the task branch for commit/rebase operations.
-                const currentBranch = (await taskGit.revparse(["--abbrev-ref", "HEAD"])).trim();
-                if (currentBranch !== taskState.branch) {
-                    await taskGit.checkout(taskState.branch);
-                }
-                const status = await taskGit.status();
-                if (!status.isClean()) {
-                    await this.repositoryManager.stageAll(taskId);
-                    try {
-                        const previousCommitCount = taskState?.commitCount ?? 0;
-                        const baseSubject = (context.summary ?? "").replace(/\s+/g, " ").trim() ||
-                            `Task ${taskId}`;
-                        const message = previousCommitCount > 0
-                            ? `${baseSubject} (followup #${previousCommitCount})`
-                            : baseSubject;
-                        await this.repositoryManager.commit(taskId, message);
-                    }
-                    catch (commitError) {
-                        const msg = commitError instanceof Error ? commitError.message : String(commitError);
-                        if (!msg.toLowerCase().includes("nothing to commit")) {
-                            throw commitError;
-                        }
-                    }
-                }
-                const integrateResult = await this.repositoryManager.integrateTask(taskId, baseBranch, "no-ff");
-                if (!integrateResult.success) {
-                    await this._resumeForGitConflictResolution(context, {
-                        kind: integrateResult.phase,
-                        baseBranch,
-                        conflicts: integrateResult.conflicts ?? [],
-                        workdir: integrateResult.conflictWorkdir,
-                        error: integrateResult.error,
-                    });
-                    return;
-                }
-                // Worktree is no longer needed after a successful merge; preserve the branch
-                await this.repositoryManager.removeTaskWorktree(taskId, { preserveBranch: true });
-                const wsId = context.config.workspaceId || context.workspaceId;
-                const repoUrl = context.config.repository?.url;
-                if (wsId && repoUrl) {
-                    await this.repositoryManager.syncWorkspaceWorktree(wsId, repoUrl, baseBranch);
-                }
-                await this._finalizeConversation(context, false);
-            }
-            catch (mergeError) {
-                console.error("[ClaudeManager] Post-task git flow failed", mergeError);
-                await this._finalizeConversation(context, true, mergeError);
-            }
-        })();
-        context._runCompletionInFlight = promise.finally(() => {
-            delete context._runCompletionInFlight;
-        });
-        return context._runCompletionInFlight;
-    }
-    async _resumeForGitConflictResolution(context, payload) {
-        const { kind, baseBranch, conflicts, workdir, error } = payload;
-        const conflictsList = conflicts?.length
-            ? `\n\nConflicted files:\n${conflicts.map((f) => `- ${f}`).join("\n")}`
-            : "";
-        const workdirHint = workdir ? `\n\nWork directory:\n- ${workdir}` : "";
-        const errorHint = error ? `\n\nError:\n${error}` : "";
-        const hasConflicts = !!conflicts?.length;
-        let instruction;
-        if (kind === "rebase") {
-            instruction = hasConflicts
-                ? `<system-instructions>\nA git rebase onto \`${baseBranch}\` produced merge conflicts.${conflictsList}${workdirHint}${errorHint}\n\nPlease resolve the conflicts in that directory, then run:\n- git add -A\n- git rebase --continue\n\nWhen the rebase finishes cleanly, reply briefly so I can retry the integration.\n</system-instructions>`
-                : `<system-instructions>\nA git rebase onto \`${baseBranch}\` failed.${workdirHint}${errorHint}\n\nNo conflicted files were reported. Please run:\n- git status\n\nFix the error (or complete/abort any in-progress git operation) and reply briefly so I can retry the integration.\n</system-instructions>`;
-        }
-        else if (kind === "merge") {
-            instruction = hasConflicts
-                ? `<system-instructions>\nA git merge into \`${baseBranch}\` produced merge conflicts.${conflictsList}${workdirHint}${errorHint}\n\nPlease resolve the conflicts in that directory, then run:\n- git add -A\n- git commit -m \"Resolve merge conflicts for ${context.conversationObjectId}\"\n\nWhen the working tree is clean, reply briefly so I can retry the integration.\n</system-instructions>`
-                : `<system-instructions>\nA git merge into \`${baseBranch}\` failed.${workdirHint}${errorHint}\n\nNo conflicted files were reported. Please run:\n- git status\n\nFix the error (or complete/abort any in-progress git operation) and reply briefly so I can retry the integration.\n</system-instructions>`;
-        }
-        else {
-            instruction = `<system-instructions>\nGit has unresolved conflicts.${conflictsList}${workdirHint}${errorHint}\n\nPlease resolve the conflicts in that directory and complete the in-progress git operation (rebase or merge). When the working tree is clean, reply briefly so I can retry the integration.\n</system-instructions>`;
-        }
-        const conversationData = {
-            id: context.conversationId,
-            objectType: context.conversationObjectType,
-            objectId: context.conversationObjectId,
-            model: context.model,
-            summary: context.summary ?? null,
-            globalInstructions: context.globalInstructions,
-            workspaceInstructions: context.workspaceInstructions,
-            permissionsMode: context.permissionsMode,
-            agentSessionId: context.agentSessionId,
-        };
-        await this.resumeConversation(context.conversationObjectType, context.conversationObjectId, context.agentSessionId, context.config, conversationData, instruction);
-    }
-    async stopConversation(agentSessionId, context, isRunnerShutdown = false, reason) {
-        context._stopRequested = true;
-        if (context && context.conversation) {
-            context.status = "stopping";
-            try {
-                // Proactively send end notification to avoid missing it on abnormal exits
-                // Use provided reason, or fall back to 'runner_shutdown' if isRunnerShutdown is true
-                const finalReason = reason || (isRunnerShutdown ? "runner_shutdown" : undefined);
-                context._stopReason = finalReason;
-                await this._finalizeConversation(context, false, undefined, finalReason).catch(() => { });
-                // Mark conversation as stopped BEFORE ending to prevent race conditions
-                context.status = "stopped";
-                // Properly end the conversation using the SDK
-                if (isClaudeConversation(context.conversation)) {
-                    await context.conversation.end();
-                }
-            }
-            catch (error) {
-                console.error(`Error ending conversation ${agentSessionId}:`, error);
-            }
-            // Clean up conversation reference
-            delete context.conversation;
-        }
-        console.log(`Stopped conversation ${agentSessionId} for ${context.conversationObjectType} ${context.conversationObjectId}`);
-    }
-    async resumeConversation(conversationObjectType, conversationObjectId, agentSessionId, config, conversationData, resumeMessage) {
-        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 && isClaudeConversation(context.conversation)) {
-            try {
-                // Use the provided resume message or default to system instruction
-                const messageToSend = resumeMessage ||
-                    "<system-instructions>Please continue</system-instructions>";
-                console.log(`[ClaudeManager] Sending resume message to conversation ${agentSessionId}`);
-                context.conversation.send({
-                    type: "text",
-                    text: messageToSend,
-                });
-            }
-            catch (error) {
-                console.error(`[ClaudeManager] Error sending resume message:`, error);
-            }
-        }
-        else {
-            console.warn("[ClaudeManager] Resume requested but conversation instance missing or incompatible");
-        }
-        return context.agentSessionId;
-    }
-    async _finalizeConversation(context, hadError, error, reason) {
-        // Synchronous idempotency check - must happen before any async operations
-        if (context._finalized)
-            return;
-        context._finalized = true;
-        // Mark as completed immediately to prevent restart on catch-up
-        // This is synchronous and happens before any async operations
-        this.runner.markConversationCompleted(context.conversationId);
-        // Clean up conversation from active conversations (synchronous)
-        try {
-            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);
-            statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-        }
-        catch { }
-        // Now do async notification (after all sync cleanup)
-        try {
-            await this.runner.notify("conversation.end", {
-                conversationId: context.conversationId,
-                conversationObjectType: context.conversationObjectType,
-                conversationObjectId: context.conversationObjectId,
-                agentSessionId: context.agentSessionId,
-                isError: hadError,
-                errorMessage: error?.message,
-                reason: reason,
-            });
-        }
-        catch (e) {
-            console.error("[ClaudeManager] Failed to notify conversation.end:", e);
-        }
-        // Notify update coordinator that a conversation has ended
-        // This may trigger an auto-update if one is pending and runner is now idle
-        try {
-            await this.runner.onConversationEnd();
-        }
-        catch (e) {
-            console.error("[ClaudeManager] Failed to notify onConversationEnd:", e);
-        }
-    }
-    async sendUserMessage(conversationId, content, config, conversationObjectType, conversationObjectId, conversation, _agentSessionIdOverride) {
-        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.log(`[ClaudeManager] Lookup by conversationId result:`, {
-            found: !!context,
-            conversationId: context?.conversationId,
-            agentSessionId: context?.agentSessionId,
-        });
-        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 ||
-                !isClaudeConversation(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.warn(`Attempted to send message to stopped/stopping conversation ${context.conversationId}`, {
-                    status: context.status,
-                    conversationObjectType: context.conversationObjectType,
-                    conversationObjectId: context.conversationObjectId,
-                });
-                return;
-            }
-            // Native message injection - SDK handles queueing and delivery
-            // Check if the message content contains multimodal content blocks (e.g., images, documents)
-            const contentBlocks = this.normalizeToContentBlocks(content);
-            if (contentBlocks && Array.isArray(contentBlocks) && contentBlocks.some(b => b.type === 'image' || b.type === 'document')) {
-                // Send multimodal message with content blocks array
-                // SDK supports URL images directly: { type: "image", source: { type: "url", url: "..." } }
-                // SDK supports URL documents directly: { type: "document", source: { type: "url", url: "..." } }
-                console.log('[ClaudeManager] Sending multimodal follow-up message with', contentBlocks.length, 'content blocks');
-                if (isDebugEnabledFor("manager")) {
-                    console.log('[ClaudeManager] Content blocks:', JSON.stringify(contentBlocks, null, 2));
-                }
-                context.conversation.send(contentBlocks);
-            }
-            else {
-                // Fallback to text-only message
-                const normalizedText = this.normalizeToText(content);
-                if (isDebugEnabledFor("manager")) {
-                    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),
-                    });
-                }
-                context.conversation.send({
-                    type: "text",
-                    text: normalizedText,
-                });
-            }
-            // Update last activity timestamp
-            context.lastActivityAt = new Date();
-            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["NORTHFLARE_RUNNER_TOKEN"]}`,
-                },
-            });
-            if (!response.ok) {
-                console.error(`Failed to fetch GitHub tokens: ${response.status}`);
-                return undefined;
-            }
-            const data = (await response.json());
-            return data.githubToken;
-        }
-        catch (error) {
-            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.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);
-        }
-    }
-    /**
-     * Normalize arbitrary content shapes into content blocks array for multimodal support.
-     * Returns the array of content blocks if the content contains image or document blocks,
-     * otherwise returns null to indicate text-only content.
-     */
-    normalizeToContentBlocks(value) {
-        // If already an array, check if it contains image or document blocks
-        if (Array.isArray(value)) {
-            const hasMultimodal = value.some(b => b && (b.type === 'image' || b.type === 'document'));
-            if (hasMultimodal) {
-                // Return the content blocks (will be converted to SDK format later)
-                return value;
-            }
-            return null;
-        }
-        // Check if it's a wrapped content object
-        if (typeof value === 'object' && value !== null) {
-            // Check for nested content array
-            if (Array.isArray(value.content)) {
-                const hasMultimodal = value.content.some((b) => b && (b.type === 'image' || b.type === 'document'));
-                if (hasMultimodal) {
-                    return value.content;
-                }
-            }
-        }
-        return null;
-    }
-    async handleStreamedMessage(context, message, sessionId) {
-        /*
-         * SDK tool call payload reference (observed shapes)
-         *
-         * 1) Assistant tool call (tool_use)
-         * {
-         *   "type": "assistant",
-         *   "message": {
-         *     "role": "assistant",
-         *     "content": [
-         *       { "type": "text", "text": "…optional text…" },
-         *       { "type": "tool_use", "id": "toolu_01Nbv…", "name": "TodoWrite", "input": { ... } }
-         *     ]
-         *   },
-         *   "session_id": "…"
-         * }
-         *
-         * 2) Tool result (often emitted as type 'user')
-         * {
-         *   "type": "user",
-         *   "message": {
-         *     "role": "user",
-         *     "content": [
-         *       {
-         *         "tool_use_id": "toolu_01E9R475…",
-         *         "type": "tool_result",
-         *         "content": "Todos have been modified successfully. …"
-         *       }
-         *     ]
-         *   },
-         *   "parent_tool_use_id": null,
-         *   "session_id": "…",
-         *   "uuid": "…"
-         * }
-         *
-         * Normalization (runner → server message.agent):
-         * - assistant tool_use → type: 'assistant', content: [{ toolCalls: [{ id, name, arguments }] }, …]
-         * - tool_result (any shape) → type: 'tool_result', subtype: 'tool_result', content:
-         *   [ { type: 'tool_result', subtype: 'tool_result', tool_use_id, content } ]
-         */
-        // Guard: Don't process messages if conversation is stopped or stopping
-        const status = context.status;
-        if (status === "stopped" || status === "stopping") {
-            console.log(`Ignoring message for stopped/stopping conversation ${context.conversationId}`, {
-                status: context.status,
-                messageType: message.type,
-            });
-            return;
-        }
-        try {
-            // High-level receipt log
-            console.log(`Received streamed message for ${context.conversationObjectType} ${context.conversationObjectId}`, {
-                type: message?.type,
-            });
-            // Raw SDK message diagnostics
-            try {
-                // Log the full raw SDK message safely (handles circular refs)
-                const safeStringify = (obj) => {
-                    const seen = new WeakSet();
-                    return JSON.stringify(obj, (key, value) => {
-                        if (typeof value === "function")
-                            return undefined;
-                        if (typeof value === "bigint")
-                            return String(value);
-                        if (typeof value === "object" && value !== null) {
-                            if (seen.has(value))
-                                return "[Circular]";
-                            seen.add(value);
-                        }
-                        return value;
-                    }, 2);
-                };
-                console.log("[ClaudeManager] RAW SDK message FULL:", safeStringify(message));
-                const summary = {
-                    keys: Object.keys(message || {}),
-                    hasMessage: !!message?.message,
-                    contentType: typeof message?.content,
-                    messageContentType: typeof message?.message?.content,
-                    sessionId: message?.session_id || message?.sessionId || null,
-                };
-                console.log("[ClaudeManager] RAW SDK message summary:", summary);
-                if (message?.content !== undefined) {
-                    console.log("[ClaudeManager] RAW SDK content:", message.content);
-                }
-                if (message?.message?.content !== undefined) {
-                    console.log("[ClaudeManager] RAW SDK nested content:", message.message.content);
-                }
-            }
-            catch (e) {
-                console.warn("[ClaudeManager] Failed to log raw SDK message:", e);
-            }
-            // Build structured content based on message type
-            let messageType = message.type;
-            let subtype;
-            let structuredContent = {};
-            let isError = false;
-            let skipSend = false;
-            let metadata = null;
-            // Extract parent_tool_use_id if present (for all message types)
-            const msgAsAny = message;
-            if (msgAsAny.parent_tool_use_id) {
-                metadata = {
-                    parent_tool_use_id: msgAsAny.parent_tool_use_id,
-                };
-            }
-            // Extract content based on message type
-            switch (message.type) {
-                case "assistant": {
-                    const assistantMsg = message;
-                    const blocks = assistantMsg?.message?.content || assistantMsg?.content || [];
-                    const textContent = Array.isArray(blocks)
-                        ? blocks
-                            .filter((b) => b && b.type === "text" && typeof b.text === "string")
-                            .map((b) => b.text)
-                            .join("")
-                        : "";
-                    const toolCalls = Array.isArray(blocks)
-                        ? blocks
-                            .filter((b) => b && b.type === "tool_use")
-                            .map((b) => ({
-                            id: b.id,
-                            name: b.name,
-                            arguments: b.input,
-                        }))
-                        : undefined;
-                    structuredContent = {
-                        ...(textContent ? { text: textContent } : {}),
-                        ...(toolCalls && toolCalls.length ? { toolCalls } : {}),
-                        timestamp: new Date().toISOString(),
-                    };
-                    break;
-                }
-                case "thinking": {
-                    messageType = "thinking";
-                    subtype = undefined;
-                    const thinkingMsg = message;
-                    structuredContent = [
-                        {
-                            type: "thinking",
-                            thinking: thinkingMsg.content || "",
-                            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 - normalize to v1-style tool_result blocks
-                    // so the server persists as messageType: tool_call_result with correct content
-                    messageType = "tool_result";
-                    subtype = "tool_result";
-                    const toolResultMsg = message;
-                    structuredContent = [
-                        {
-                            type: "tool_result",
-                            subtype: "tool_result",
-                            tool_use_id: toolResultMsg.tool_use_id,
-                            content: toolResultMsg.content, // Keep content as native (array or string)
-                            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;
-                    // Prefer nested message.content if present (SDK shape), fallback to top-level content
-                    const blocks = (userMsg && userMsg.message && userMsg.message.content) ||
-                        userMsg?.content ||
-                        [];
-                    if (Array.isArray(blocks)) {
-                        const hasToolResult = blocks.some((b) => b && typeof b === "object" && b.type === "tool_result");
-                        if (hasToolResult) {
-                            // Normalize tool_result blocks to v1-style
-                            messageType = "tool_result";
-                            subtype = "tool_result";
-                            structuredContent = blocks
-                                .filter((b) => b && b.type === "tool_result")
-                                .map((b) => ({
-                                type: "tool_result",
-                                subtype: "tool_result",
-                                tool_use_id: b.tool_use_id || b.toolUseId || b.id,
-                                content: b.content, // Keep content as native (array or string)
-                            }));
-                        }
-                        else {
-                            // Treat as plain text content by joining text blocks
-                            const textContent = blocks
-                                .filter((b) => b && b.type === "text" && typeof b.text === "string")
-                                .map((b) => b.text)
-                                .join("");
-                            structuredContent = {
-                                text: textContent,
-                                timestamp: new Date().toISOString(),
-                            };
-                            // Check if this is a subagent prompt (Task tool input being sent to subagent)
-                            // These have parent_tool_use_id but are NOT tool_result messages
-                            if (userMsg.parent_tool_use_id) {
-                                console.log("[ClaudeManager] Detected subagent prompt message (parent_tool_use_id present, no tool_result)", {
-                                    parent_tool_use_id: userMsg.parent_tool_use_id,
-                                });
-                                messageType = "assistant"; // Change from "user" to "assistant"
-                                subtype = "subagent_prompt";
-                                // metadata already set above with parent_tool_use_id
-                            }
-                        }
-                        // If content array only contains empty objects, skip sending
-                        if (Array.isArray(structuredContent) &&
-                            structuredContent.length > 0 &&
-                            structuredContent.every((it) => !it || typeof it !== "object" || Object.keys(it).length === 0)) {
-                            console.log("[ClaudeManager] Skipping empty 'user' message with only empty objects from SDK");
-                            skipSend = true;
-                        }
-                    }
-                    else if (typeof userMsg?.content === "string") {
-                        // Attempt to parse JSON arrays (common for tool_result payloads)
-                        const text = userMsg.content;
-                        try {
-                            const parsed = JSON.parse(text);
-                            if (Array.isArray(parsed)) {
-                                const hasToolResult = parsed.some((item) => item &&
-                                    typeof item === "object" &&
-                                    item.type === "tool_result");
-                                if (hasToolResult) {
-                                    messageType = "tool_result";
-                                    subtype = "tool_result";
-                                    structuredContent = parsed;
-                                }
-                                else {
-                                    structuredContent = {
-                                        text,
-                                        timestamp: new Date().toISOString(),
-                                    };
-                                }
-                            }
-                            else {
-                                structuredContent = {
-                                    text,
-                                    timestamp: new Date().toISOString(),
-                                };
-                            }
-                        }
-                        catch {
-                            // Not JSON - treat as plain text
-                            structuredContent = { text, timestamp: new Date().toISOString() };
-                        }
-                    }
-                    else {
-                        // Other object content - preserve as is
-                        structuredContent = userMsg?.content || {};
-                    }
-                    break;
-                }
-                case "system": {
-                    const systemMsg = message;
-                    const subtype = systemMsg.subtype || "system";
-                    const model = systemMsg.model || systemMsg?.message?.model;
-                    const permissionMode = systemMsg.permissionMode || systemMsg?.message?.permissionMode;
-                    const summary = [
-                        subtype && `[${subtype}]`,
-                        model && `model=${model}`,
-                        permissionMode && `perm=${permissionMode}`,
-                    ]
-                        .filter(Boolean)
-                        .join(" ");
-                    structuredContent = {
-                        text: summary || "",
-                        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.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") {
-                if (skipSend) {
-                    console.log("[ClaudeManager] Not sending message.agent due to skipSend=true");
-                    return;
-                }
-                const payload = {
-                    conversationId: context.conversationId,
-                    conversationObjectType: context.conversationObjectType,
-                    conversationObjectId: context.conversationObjectId,
-                    agentSessionId: context.agentSessionId,
-                    type: messageType,
-                    subtype,
-                    content: Array.isArray(structuredContent)
-                        ? structuredContent
-                        : [structuredContent],
-                    messageId,
-                    isError,
-                };
-                // Add metadata if present
-                if (metadata) {
-                    payload.metadata = metadata;
-                }
-                try {
-                    console.log("[ClaudeManager] Sending message.agent payload:", {
-                        type: payload.type,
-                        subtype: payload.subtype,
-                        contentPreview: Array.isArray(payload.content)
-                            ? payload.content.slice(0, 1)
-                            : payload.content,
-                    });
-                }
-                catch { }
-                await this.runner.notify("message.agent", payload);
-            }
-            // 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.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.log(`Transport error for stopped/stopping conversation ${context.conversationId} (expected):`, errorMessage);
-                return;
-            }
-            console.error(`Error handling streamed message for ${context.conversationObjectType} ${context.conversationObjectId}:`, error);
-            await this._handleConversationError(context, error);
-        }
-    }
-}
-function createUserMessageStream() {
-    const queue = [];
-    let resolver = null;
-    let done = false;
-    async function* iterator() {
-        while (true) {
-            if (queue.length > 0) {
-                const value = queue.shift();
-                yield value;
-                continue;
-            }
-            if (done)
-                return;
-            await new Promise((resolve) => (resolver = resolve));
-            resolver = null;
-        }
-    }
-    return {
-        iterable: iterator(),
-        enqueue: (msg) => {
-            if (done)
-                return;
-            queue.push(msg);
-            if (resolver) {
-                const r = resolver;
-                resolver = null;
-                r();
-            }
-        },
-        close: () => {
-            done = true;
-            if (resolver) {
-                const r = resolver;
-                resolver = null;
-                r();
-            }
-        },
-    };
-}
-function createConversationWrapper(sdk, input, onComplete) {
-    let onSessionIdCb = null;
-    let observedSessionId = null;
-    let startedReader = false;
-    /**
-     * Create an SDK user message from content.
-     * Content can be a string (for text-only messages) or an array of content blocks
-     * (for multimodal messages with images).
-     */
-    function toSdkUserMessage(content) {
-        const message = {
-            type: "user",
-            session_id: observedSessionId || "",
-            parent_tool_use_id: null,
-            message: {
-                role: "user",
-                // Content should be an array of content blocks for multimodal
-                // For text-only, SDK accepts string directly
-                content: typeof content === 'string'
-                    ? content
-                    : content,
-            },
-        };
-        console.log('[ClaudeManager] toSdkUserMessage creating message:', JSON.stringify(message, null, 2));
-        return message;
-    }
-    return {
-        /**
-         * Send a message to the conversation.
-         * Accepts either:
-         * - { type: "text", text: string } for text-only messages
-         * - Array of content blocks for multimodal messages (e.g., [{ type: "text", text: "..." }, { type: "image", source: {...} }])
-         */
-        send(payload) {
-            // Handle multimodal content (array of content blocks)
-            if (Array.isArray(payload)) {
-                input.enqueue(toSdkUserMessage(payload));
-                return;
-            }
-            // Handle text-only messages
-            const text = payload?.text ?? "";
-            input.enqueue(toSdkUserMessage(text));
-        },
-        async end() {
-            try {
-                input.close();
-            }
-            finally {
-                // Simplified process cleanup
-                try {
-                    if (sdk?.abortController) {
-                        sdk.abortController.abort();
-                    }
-                }
-                catch { }
-            }
-        },
-        onSessionId(cb) {
-            onSessionIdCb = cb;
-        },
-        stream(handler) {
-            if (startedReader)
-                return;
-            startedReader = true;
-            (async () => {
-                try {
-                    for await (const msg of sdk) {
-                        // Simplified session ID extraction
-                        const sid = (msg && (msg.session_id || msg.sessionId)) || null;
-                        if (sid && sid !== observedSessionId) {
-                            observedSessionId = sid;
-                            if (onSessionIdCb)
-                                onSessionIdCb(sid);
-                        }
-                        await handler(msg, sid);
-                    }
-                    // Normal completion
-                    if (onComplete)
-                        await onComplete(false);
-                }
-                catch (e) {
-                    // Error completion
-                    if (onComplete)
-                        await onComplete(true, e);
-                }
-            })();
-        },
-    };
-}
-function isClaudeConversation(conversation) {
-    return (!!conversation &&
-        typeof conversation.send === "function" &&
-        typeof conversation.end === "function");
-}
-//# sourceMappingURL=claude-sdk-manager.js.map