@northflare/runner 0.0.30 → 0.0.32

package/dist/components/northflare-agent-sdk-manager.js

@@ -1,2032 +0,0 @@
-/**
- * NorthflareAgentManager - Manages conversations using the @northflare/agent SDK
- *
- * Mirrors the existing Claude integration but targets OpenRouter-style models
- * via the Northflare Agent SDK. Lifecycle, repository handling, and message
- * normalization stay aligned with the existing managers so downstream
- * interfaces remain compatible.
- */
-import { query as sdkQuery } from "@northflare/agent";
-import { createGroq, groq as groqProvider } from "@ai-sdk/groq";
-import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-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 jwt from "jsonwebtoken";
-import fs from "fs/promises";
-import path from "path";
-import { simpleGit } from "simple-git";
-const console = createScopedConsole(isDebugEnabledFor("manager") ? "manager" : "sdk");
-function buildSystemPromptWithNorthflare(basePrompt, northflarePrompt) {
-    const parts = [northflarePrompt, basePrompt]
-        .filter((p) => typeof p === "string" && p.trim().length > 0)
-        .map((p) => p.trim());
-    if (parts.length === 0)
-        return undefined;
-    return parts.join("\n\n");
-}
-export class NorthflareAgentManager {
-    runner;
-    repositoryManager;
-    submitToolUseIds = new Map(); // conversationId -> Set of submit tool_use_ids
-    constructor(runner, repositoryManager) {
-        this.runner = runner;
-        this.repositoryManager = repositoryManager;
-        // Log debug mode status
-        if (isDebugEnabledFor("sdk")) {
-            console.log("[NorthflareAgentManager] DEBUG MODE ENABLED - Northflare Agent 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
-    }
-    buildSubAgentConfig(subAgentTypes) {
-        const enabled = subAgentTypes?.["enabled"] !== false;
-        const allowInherit = subAgentTypes?.["inherit"] !== false;
-        if (!enabled) {
-            return { enabled: false, agents: {} };
-        }
-        const agents = {};
-        if (allowInherit) {
-            agents["inherit"] = {
-                description: "Use the main task model and toolset.",
-                prompt: "",
-                model: "inherit",
-            };
-        }
-        const RESERVED = new Set(["inherit", "enabled"]);
-        Object.entries(subAgentTypes || {}).forEach(([name, value]) => {
-            if (RESERVED.has(name))
-                return;
-            if (!value || typeof value !== "object")
-                return;
-            const description = typeof value.description === "string" &&
-                value.description.trim().length
-                ? value.description.trim()
-                : `Use agentType \"${name}\" when its specialization fits the task.`;
-            const prompt = typeof value.instructions === "string"
-                ? value.instructions.trim()
-                : "";
-            const model = typeof value.model === "string" &&
-                value.model.trim().length
-                ? value.model.trim()
-                : "inherit";
-            agents[name] = {
-                description,
-                prompt,
-                model,
-            };
-        });
-        if (Object.keys(agents).length === 0) {
-            return { enabled: false, agents: {} };
-        }
-        return { enabled: true, agents };
-    }
-    async startConversation(conversationObjectType, conversationObjectId, config, initialMessages, conversationData, provider = "openrouter") {
-        // 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 rawModel = conversationData?.model ||
-            config?.model ||
-            config?.defaultModel;
-        if (!rawModel) {
-            throw new Error("Model is required for Northflare conversations (provide conversationData.model, config.model, or config.defaultModel).");
-        }
-        const model = this.normalizeModel(rawModel);
-        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,
-            summary: normalizedSummary,
-            globalInstructions: conversationData?.globalInstructions || "",
-            workspaceInstructions: conversationData?.workspaceInstructions || "",
-            permissionsMode: conversationData?.permissionsMode || "all",
-            provider,
-        };
-        // Store with conversation.id as the key
-        this.runner.activeConversations_.set(conversationId, context);
-        console.log(`[NorthflareAgentManager] 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(`[NorthflareAgentManager] 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("[NorthflareAgentManager] Generated TOOL_TOKEN for MCP authentication");
-            }
-            else {
-                console.warn("[NorthflareAgentManager] Unable to generate TOOL_TOKEN - missing required data");
-            }
-        }
-        const managerDebug = isDebugEnabledFor("manager");
-        const sdkDebug = isDebugEnabledFor("sdk");
-        const debugEnabled = managerDebug || sdkDebug;
-        // Simplified SDK configuration - using native query API with streamlined options
-        // 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;
-        }
-        // OpenRouter / Groq API key support (prefer provider-specific fields)
-        const openRouterApiKey = config.openRouterApiKey || process.env["OPENROUTER_API_KEY"];
-        const groqApiKey = config.groqApiKey || process.env["GROQ_API_KEY"];
-        if (openRouterApiKey) {
-            envVars["OPENROUTER_API_KEY"] = openRouterApiKey;
-        }
-        if (groqApiKey) {
-            envVars["GROQ_API_KEY"] = groqApiKey;
-        }
-        // Pass through OpenAI API key if supplied for provider-prefixed models
-        if (config.openaiApiKey) {
-            envVars["OPENAI_API_KEY"] = config.openaiApiKey;
-        }
-        if (githubToken) {
-            envVars["GITHUB_TOKEN"] = githubToken;
-        }
-        if (toolToken) {
-            envVars["TOOL_TOKEN"] = toolToken;
-        }
-        if (sdkDebug) {
-            envVars["DEBUG"] = "1";
-        }
-        const subAgentConfig = this.buildSubAgentConfig(config.subAgentTypes);
-        const agentsOption = subAgentConfig.enabled && Object.keys(subAgentConfig.agents).length > 0
-            ? subAgentConfig.agents
-            : undefined;
-        // Simplified system prompt handling
-        const providedSystemPrompt = buildSystemPromptWithNorthflare(config.systemPrompt || conversationData?.systemPrompt, config?.northflareSystemPrompt ||
-            conversationData?.northflareSystemPrompt);
-        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,
-                };
-            }
-        }
-        // Debug log the systemPrompt being sent to Northflare Agent SDK
-        console.log(`[NorthflareAgentManager] System prompt configuration for conversation ${context.conversationId}:`, {
-            mode: systemPromptMode,
-            hasProvidedSystemPrompt: Boolean(providedSystemPrompt),
-            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_file",
-            "edit_file",
-            "multi_edit_file",
-            "delete_file",
-            "move_file",
-            "copy_file",
-            "run_command",
-            "todo_write",
-        ];
-        const projectModeTools = [
-            "write_file",
-            "edit_file",
-            "multi_edit_file",
-            "delete_file",
-            "move_file",
-            "copy_file",
-            "todo_write",
-            "task",
-        ];
-        const disallowedTools = context.permissionsMode === "read"
-            ? readOnlyTools
-            : context.permissionsMode === "project"
-                ? projectModeTools
-                : [];
-        if (!subAgentConfig.enabled) {
-            disallowedTools.push("task");
-        }
-        if (disallowedTools.length) {
-            console.log("[NorthflareAgentManager] Tool restrictions applied", {
-                disallowedTools,
-            });
-        }
-        // Simplified MCP server configuration
-        let mcpServers;
-        if (config.mcpServers) {
-            mcpServers = expandEnv(config.mcpServers, { TOOL_TOKEN: toolToken });
-            console.log("[NorthflareAgentManager] MCP servers configuration:", JSON.stringify(mcpServers, null, 2));
-        }
-        if (debugEnabled) {
-            console.log("[NorthflareAgentManager] SDK launch summary", {
-                conversationId: context.conversationId,
-                model,
-                provider,
-                cwd: workspacePath,
-                hasMcpServers: !!mcpServers && Object.keys(mcpServers).length > 0,
-                disallowedTools,
-                systemPromptMode,
-                hasSystemPrompt: Boolean(systemPromptOption),
-                systemPromptType: typeof systemPromptOption,
-                subAgentsEnabled: subAgentConfig.enabled,
-                agentTypes: agentsOption ? Object.keys(agentsOption) : [],
-                env: {
-                    OPENROUTER_API_KEY: Boolean(envVars["OPENROUTER_API_KEY"]),
-                    GROQ_API_KEY: Boolean(envVars["GROQ_API_KEY"]),
-                    ANTHROPIC_API_KEY: Boolean(envVars["ANTHROPIC_API_KEY"]),
-                    OPENAI_API_KEY: Boolean(envVars["OPENAI_API_KEY"]),
-                    GITHUB_TOKEN: Boolean(envVars["GITHUB_TOKEN"]),
-                    TOOL_TOKEN: Boolean(envVars["TOOL_TOKEN"]),
-                },
-            });
-        }
-        // Create input stream for user messages (simplified message queueing)
-        const input = createUserMessageStream();
-        // NOTE: different @ai-sdk/provider versions (v2 via @northflare/agent and
-        // v3 via @ai-sdk/groq/ai) can lead to nominally incompatible LanguageModel
-        // types. We only need runtime compatibility here, so coerce to `any` to
-        // avoid TS conflicts between the duplicated provider packages.
-        // Build provider-specific model instance. OpenRouter requires an explicit
-        // client factory instead of the generic model string.
-        const sdkModel = (() => {
-            if (provider === "groq") {
-                const groqClient = groqApiKey && groqApiKey.length > 0
-                    ? createGroq({ apiKey: groqApiKey })
-                    : groqProvider;
-                return groqClient(context.model);
-            }
-            if (provider === "openrouter") {
-                const client = createOpenRouter({
-                    apiKey: openRouterApiKey || process.env["OPENROUTER_API_KEY"] || "",
-                });
-                return client(context.model);
-            }
-            return context.model;
-        })();
-        // Respect a maxTurns override if provided (falls back to SDK default when unset)
-        const maxTurns = Number.isFinite(config.maxTurns)
-            ? config.maxTurns
-            : undefined;
-        // Log how the model was resolved to help compare with the standalone script
-        console.log("[NorthflareAgentManager] Model resolution", {
-            provider,
-            rawModel: rawModel,
-            normalizedModel: context.model,
-            openRouterApiKeyPresent: Boolean(openRouterApiKey || process.env["OPENROUTER_API_KEY"]),
-            sdkModelType: sdkModel?.constructor?.name,
-        });
-        // Build a modelResolver for sub-agents that can resolve model strings to LanguageModel instances
-        const modelResolver = (modelId) => {
-            // Normalize the model ID (strip provider prefixes)
-            const normalizedModelId = this.normalizeModel(modelId);
-            // Determine the provider from the model ID prefix or fall back to the parent provider
-            let modelProvider = provider;
-            if (modelId.startsWith("groq:") || modelId.startsWith("groq/")) {
-                modelProvider = "groq";
-            }
-            else if (modelId.startsWith("openrouter:") ||
-                modelId.startsWith("openrouter/")) {
-                modelProvider = "openrouter";
-            }
-            // Create the appropriate model instance
-            if (modelProvider === "groq") {
-                const groqClient = groqApiKey && groqApiKey.length > 0
-                    ? createGroq({ apiKey: groqApiKey })
-                    : groqProvider;
-                return groqClient(normalizedModelId);
-            }
-            if (modelProvider === "openrouter") {
-                const client = createOpenRouter({
-                    apiKey: openRouterApiKey || process.env["OPENROUTER_API_KEY"] || "",
-                });
-                return client(normalizedModelId);
-            }
-            // Unknown provider - return undefined to let SDK throw a helpful error
-            return undefined;
-        };
-        // Launch SDK with simplified configuration
-        let silenceTimer = null;
-        let lastSdkActivity = Date.now();
-        const handleTaskProgress = async (update) => {
-            const pct = Number(update?.progressPercent);
-            if (!Number.isFinite(pct))
-                return;
-            const clamped = Math.max(0, Math.min(100, pct));
-            const messageId = `${context.agentSessionId}-progress-${Date.now()}-${Math.random()
-                .toString(36)
-                .slice(2, 8)}`;
-            const progressPayload = {
-                conversationId: context.conversationId,
-                conversationObjectType: context.conversationObjectType,
-                conversationObjectId: context.conversationObjectId,
-                agentSessionId: context.agentSessionId,
-                type: "assistant",
-                subtype: "task_progress",
-                messageMetaType: "task_progress",
-                metadata: {
-                    progressPercent: clamped,
-                    toolCallId: update?.toolCallId,
-                    raw: update?.raw,
-                },
-                content: [
-                    {
-                        type: "text",
-                        text: `Task progress ${Math.round(clamped)}%`,
-                    },
-                ],
-                messageId,
-            };
-            try {
-                await this.runner.notify("message.agent", progressPayload);
-            }
-            catch (err) {
-                console.warn("[NorthflareAgentManager] Failed to send task progress", {
-                    conversationId: context.conversationId,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        };
-        const sdk = sdkQuery({
-            prompt: input.iterable,
-            options: {
-                cwd: workspacePath,
-                env: envVars,
-                model: sdkModel,
-                modelResolver,
-                resume: config.sessionId || conversationData?.agentSessionId || undefined,
-                // Enable vision support - allows passing images directly to the model
-                visionModel: true,
-                ...(agentsOption ? { agents: agentsOption } : {}),
-                ...(maxTurns !== undefined ? { maxTurns } : {}),
-                ...(systemPromptOption ? { systemPrompt: systemPromptOption } : {}),
-                ...(disallowedTools.length ? { disallowedTools } : {}),
-                ...(mcpServers ? { mcpServers } : {}),
-                conversationId: context.conversationId,
-                conversationObjectId: context.conversationObjectId,
-                taskId: context.taskId,
-                onTaskProgress: handleTaskProgress,
-                ...(sdkDebug
-                    ? {
-                        debug: true,
-                        stderr: (data) => {
-                            try {
-                                console.log(`[Northflare Agent SDK] ${data}`);
-                            }
-                            catch { }
-                        },
-                        onStepFinish: (step) => {
-                            try {
-                                console.log("[NorthflareAgentManager] Agent step finished (full step object): " +
-                                    JSON.stringify(step, null, 2));
-                            }
-                            catch { }
-                        },
-                    }
-                    : {}),
-            },
-        });
-        console.log("[NorthflareAgentManager] sdkQuery options summary", {
-            provider,
-            model: context.model,
-            cwd: workspacePath,
-            maxTurns: maxTurns ?? "default (SDK)",
-            hasSystemPrompt: Boolean(systemPromptOption),
-            hasMcpServers: Boolean(mcpServers && Object.keys(mcpServers).length),
-            disallowedToolsCount: disallowedTools.length,
-            envKeys: Object.keys(envVars),
-        });
-        // Track number of streamed messages to aid debugging when sessions appear silent
-        let streamedMessageCount = 0;
-        const clearSilenceTimer = () => {
-            if (silenceTimer) {
-                clearInterval(silenceTimer);
-                silenceTimer = null;
-            }
-        };
-        // Simplified conversation wrapper - reduced complexity while maintaining interface
-        const conversation = createConversationWrapper(sdk, input, async (hadError, error) => {
-            // Check if SDK reported an error via result message (stored in metadata)
-            const sdkError = context.metadata?.["_sdkError"];
-            const effectiveHadError = hadError || sdkError?.isError === true;
-            const effectiveError = error ||
-                (sdkError?.isError
-                    ? new Error(sdkError.errorMessage || "SDK execution error")
-                    : undefined);
-            console.log("[NorthflareAgentManager] SDK stream completed", {
-                conversationId: context.conversationId,
-                agentSessionId: context.agentSessionId,
-                hadError,
-                sdkErrorDetected: sdkError?.isError,
-                effectiveHadError,
-                errorMessage: effectiveError?.message,
-                streamedMessageCount,
-            });
-            clearSilenceTimer();
-            // Surface SDK-level failures to the orchestrator so the task
-            // transitions to needs_attention and an error bubble appears in chat.
-            if (effectiveHadError && effectiveError) {
-                try {
-                    const normalizedError = effectiveError instanceof Error
-                        ? effectiveError
-                        : new Error(String(effectiveError));
-                    await this._handleConversationError(context, normalizedError);
-                }
-                catch (err) {
-                    console.error("[NorthflareAgentManager] Failed to report SDK error:", err);
-                }
-            }
-            await this._handleRunCompletion(context, effectiveHadError, effectiveError);
-        });
-        // Store conversation instance in context for reuse
-        context.conversation = conversation;
-        context._clearSilenceTimer = clearSilenceTimer;
-        // 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) => {
-            streamedMessageCount += 1;
-            lastSdkActivity = Date.now();
-            // Lightweight visibility into every SDK message before normalization
-            try {
-                const preview = (() => {
-                    if (!message)
-                        return null;
-                    if (typeof message === "string")
-                        return message.slice(0, 300);
-                    const m = message;
-                    const content = m?.message?.content || m?.content || m?.message?.text || m?.text;
-                    if (typeof content === "string")
-                        return content.slice(0, 300);
-                    if (Array.isArray(content)) {
-                        const textBlock = content.find((b) => b && b.type === "text" && typeof b.text === "string");
-                        if (textBlock)
-                            return textBlock.text.slice(0, 300);
-                    }
-                    try {
-                        return JSON.stringify(message).slice(0, 300);
-                    }
-                    catch {
-                        return "[unstringifiable message]";
-                    }
-                })();
-                console.log("[NorthflareAgentManager] Agent stream message", {
-                    conversationId: context.conversationId,
-                    agentSessionId: sessionId || context.agentSessionId,
-                    count: streamedMessageCount,
-                    type: message?.type,
-                    preview,
-                });
-            }
-            catch (e) {
-                console.warn("[NorthflareAgentManager] Failed to log early agent stream message:", e);
-            }
-            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);
-                    }
-                }
-            }
-            catch (e) {
-                console.warn("[NorthflareAgentManager] finalize-on-system heuristic error:", e);
-            }
-        };
-        if (managerDebug) {
-            silenceTimer = setInterval(() => {
-                const now = Date.now();
-                const idleMs = now - lastSdkActivity;
-                if (idleMs >= 5000) {
-                    console.log("[NorthflareAgentManager] Waiting for agent output", {
-                        conversationId: context.conversationId,
-                        agentSessionId: context.agentSessionId || null,
-                        streamedMessageCount,
-                        idleMs,
-                    });
-                }
-            }, 5000);
-        }
-        // Send initial messages BEFORE starting the stream.
-        // This ensures all initial messages are queued and available when the SDK
-        // starts iterating, so it can collect them all without timing issues.
-        try {
-            for (const message of initialMessages) {
-                // Use normalizeContentForSDK to preserve multimodal content (images)
-                const normalizedContent = this.normalizeContentForSDK(message.content);
-                const isMultimodal = Array.isArray(normalizedContent);
-                console.log("[NorthflareAgentManager] Sending initial message to SDK", {
-                    conversationId: context.conversationId,
-                    agentSessionId: context.agentSessionId,
-                    isMultimodal,
-                    contentPreview: isMultimodal
-                        ? `[${normalizedContent.length} blocks: ${normalizedContent.map((b) => b.type).join(", ")}]`
-                        : normalizedContent.slice(0, 200),
-                    length: isMultimodal ? normalizedContent.length : normalizedContent.length,
-                });
-                if (isMultimodal) {
-                    // Send multimodal content blocks directly to the SDK
-                    conversation.send({
-                        type: "multimodal",
-                        content: normalizedContent,
-                    });
-                }
-                else {
-                    conversation.send({
-                        type: "text",
-                        text: normalizedContent,
-                    });
-                }
-            }
-            // Kick off streaming; completion/error is handled by the wrapper's
-            // onComplete callback above. (The stream method returns void, so awaiting
-            // it would resolve immediately and incorrectly mark the conversation
-            // finished.)
-            conversation.stream(messageHandler);
-            // Note: Error handling is done via process completion handler
-            // The Northflare Agent SDK doesn't have an onError method on conversations
-            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, 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 (isAgentConversation(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, provider = "openrouter") {
-        console.log(`[NorthflareAgentManager] 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, provider);
-        // After starting the conversation with the sessionId, we need to send a message
-        // to actually trigger the agent process to continue
-        if (context.conversation && isAgentConversation(context.conversation)) {
-            try {
-                // Use the provided resume message or default to system instruction
-                const messageToSend = resumeMessage ||
-                    "<system-instructions>Please continue</system-instructions>";
-                console.log(`[NorthflareAgentManager] Sending resume message to conversation ${agentSessionId}`);
-                context.conversation.send({
-                    type: "text",
-                    text: messageToSend,
-                });
-            }
-            catch (error) {
-                console.error(`[NorthflareAgentManager] Error sending resume message:`, error);
-            }
-        }
-        else {
-            console.warn("[NorthflareAgentManager] Resume requested but conversation instance missing or incompatible");
-        }
-        return context.agentSessionId;
-    }
-    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("[NorthflareAgentManager] 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, context.provider === "groq" ? "groq" : "openrouter");
-    }
-    async _finalizeConversation(context, hadError, error, reason) {
-        // Synchronous idempotency check - must happen before any async operations
-        if (context._finalized)
-            return;
-        context._finalized = true;
-        try {
-            const clearSilenceTimer = context._clearSilenceTimer;
-            if (typeof clearSilenceTimer === "function") {
-                clearSilenceTimer();
-            }
-        }
-        catch { }
-        // 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(`[NorthflareAgentManager] Removing conversation from active map:`, {
-                conversationId: context.conversationId,
-                agentSessionId: context.agentSessionId,
-                mapSizeBefore: this.runner.activeConversations_.size,
-            });
-            this.runner.activeConversations_.delete(context.conversationId);
-            // Clean up submit tool tracking
-            this.submitToolUseIds.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("[NorthflareAgentManager] 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("[NorthflareAgentManager] Failed to notify onConversationEnd:", e);
-        }
-    }
-    async sendUserMessage(conversationId, content, config, conversationObjectType, conversationObjectId, conversation, _agentSessionIdOverride) {
-        console.log(`[NorthflareAgentManager] 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(`[NorthflareAgentManager] Lookup by conversationId result:`, {
-            found: !!context,
-            conversationId: context?.conversationId,
-            agentSessionId: context?.agentSessionId,
-        });
-        if (!context && conversation) {
-            // Use provided conversation details
-            try {
-                const conversationDetails = conversation;
-                console.log(`[NorthflareAgentManager] Using provided config from RunnerMessage:`, {
-                    hasConfig: !!config,
-                    hasRepository: !!config?.repository,
-                    repositoryType: config?.repository?.type,
-                    repositoryPath: config?.repository?.localPath,
-                    hasTokens: !!(config?.accessToken || config?.githubToken),
-                    hasMcpServers: !!config?.mcpServers,
-                });
-                // Use the config that was already prepared by TaskOrchestrator and sent in the RunnerMessage
-                const startConfig = {
-                    anthropicApiKey: config?.anthropicApiKey || process.env["ANTHROPIC_API_KEY"] || "",
-                    systemPrompt: config?.systemPrompt || conversationDetails?.systemPrompt,
-                    systemPromptMode: config?.systemPromptMode ||
-                        conversationDetails?.systemPromptMode,
-                    workspaceId: conversationDetails.workspaceId,
-                    ...config, // Use the full config provided in the RunnerMessage
-                    ...(conversationDetails.agentSessionId
-                        ? { sessionId: conversationDetails.agentSessionId }
-                        : {}),
-                };
-                // Start the SDK conversation (no initial messages); this attaches to existing session when provided
-                const derivedProvider = conversationDetails?.provider ||
-                    startConfig?.providerType ||
-                    "openrouter";
-                await this.startConversation(conversationDetails.objectType, conversationDetails.objectId, startConfig, [], conversationDetails, derivedProvider);
-                // Refresh context after start/resume
-                context = this.runner.getConversationContext(conversationId);
-            }
-            catch (error) {
-                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 || !isAgentConversation(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
-            // Use normalizeContentForSDK to preserve multimodal content (images)
-            const normalizedContent = this.normalizeContentForSDK(content);
-            const isMultimodal = Array.isArray(normalizedContent);
-            if (isDebugEnabledFor("manager")) {
-                console.log("[NorthflareAgentManager] Normalized follow-up content", {
-                    originalType: typeof content,
-                    isArray: Array.isArray(content) || undefined,
-                    isMultimodal,
-                    normalizedPreview: isMultimodal
-                        ? `[${normalizedContent.length} blocks: ${normalizedContent.map((b) => b.type).join(", ")}]`
-                        : normalizedContent.slice(0, 160),
-                });
-            }
-            if (isMultimodal) {
-                // Send multimodal content blocks directly to the SDK
-                // Use any cast to bypass type restrictions - our wrapper supports this
-                context.conversation.send({
-                    type: "multimodal",
-                    content: normalizedContent,
-                });
-            }
-            else {
-                context.conversation.send({
-                    type: "text",
-                    text: normalizedContent,
-                });
-            }
-            // 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) {
-        const msg = error.message.toLowerCase();
-        if (msg.includes("process exited")) {
-            return "process_exit";
-        }
-        else if (msg.includes("model")) {
-            return "model_error";
-        }
-        else if (msg.includes("tool")) {
-            return "tool_error";
-        }
-        else if (msg.includes("permission") ||
-            msg.includes("forbidden") ||
-            msg.includes("403")) {
-            return "permission_error";
-        }
-        else if (msg.includes("timeout")) {
-            return "timeout_error";
-        }
-        else if (msg.includes("unauthorized") ||
-            msg.includes("401") ||
-            msg.includes("authentication")) {
-            return "auth_error";
-        }
-        else if (msg.includes("rate limit") ||
-            msg.includes("429") ||
-            msg.includes("too many requests")) {
-            return "rate_limit_error";
-        }
-        else if (msg.includes("api") ||
-            msg.includes("network") ||
-            msg.includes("fetch") ||
-            msg.includes("connection")) {
-            return "api_error";
-        }
-        return "unknown_error";
-    }
-    normalizeModel(rawModel) {
-        if (!rawModel) {
-            throw new Error("normalizeModel called without a model; caller must supply one.");
-        }
-        const trimmed = rawModel.trim();
-        if (trimmed.startsWith("openrouter:")) {
-            return trimmed.slice("openrouter:".length);
-        }
-        if (trimmed.startsWith("openrouter/")) {
-            return trimmed.slice("openrouter/".length);
-        }
-        if (trimmed.startsWith("groq:")) {
-            return trimmed.slice("groq:".length);
-        }
-        if (trimmed.startsWith("groq/")) {
-            return trimmed.slice("groq/".length);
-        }
-        if (!trimmed) {
-            throw new Error("Model string cannot be empty.");
-        }
-        return trimmed;
-    }
-    /**
-     * Check if content contains multimodal blocks (images or documents)
-     */
-    hasMultimodalContent(value) {
-        if (!Array.isArray(value))
-            return false;
-        return value.some((item) => item &&
-            typeof item === "object" &&
-            (item.type === "image" || item.type === "document"));
-    }
-    /**
-     * Normalize content for the SDK, preserving multimodal blocks when present.
-     * Returns either a string (text-only) or an array of content blocks (multimodal).
-     */
-    normalizeContentForSDK(value) {
-        // If it's an array with multimodal content, convert to SDK format
-        if (Array.isArray(value) && this.hasMultimodalContent(value)) {
-            const blocks = [];
-            for (const item of value) {
-                if (!item || typeof item !== "object")
-                    continue;
-                if (item.type === "text" && typeof item.text === "string") {
-                    blocks.push({ type: "text", text: item.text });
-                }
-                else if (item.type === "image" && item.source) {
-                    // Convert image blocks: { type: "image", source: { type: "url", url: "..." } }
-                    // to SDK format: { type: "image", image: "..." }
-                    const imageUrl = item.source.type === "url" ? item.source.url : item.source.data;
-                    if (imageUrl) {
-                        blocks.push({ type: "image", image: imageUrl });
-                    }
-                }
-                else if (item.type === "document" && item.source) {
-                    // Documents (PDFs) - the SDK doesn't have native document support,
-                    // so we include them as text with the URL for now
-                    // TODO: When SDK adds document support, update this
-                    const docUrl = item.source.type === "url" ? item.source.url : item.source.data;
-                    if (docUrl) {
-                        // For now, add PDF URL as text since SDK doesn't support documents directly
-                        // The model can still access PDFs via URL if supported
-                        blocks.push({
-                            type: "text",
-                            text: `[PDF Document: ${docUrl}]`,
-                        });
-                    }
-                }
-            }
-            // If we have any image blocks, return the multimodal array
-            if (blocks.some((b) => b.type === "image")) {
-                return blocks;
-            }
-            // Otherwise, fall back to text extraction
-        }
-        // Fall back to text-only normalization
-        return this.normalizeToText(value);
-    }
-    /**
-     * 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) {
-        /*
-         * 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("[NorthflareAgentManager] 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("[NorthflareAgentManager] RAW SDK message summary:", summary);
-                if (message?.content !== undefined) {
-                    console.log("[NorthflareAgentManager] RAW SDK content:", message.content);
-                }
-                if (message?.message?.content !== undefined) {
-                    console.log("[NorthflareAgentManager] RAW SDK nested content:", message.message.content);
-                }
-                // Highlight tool calls as soon as they appear so downstream observers
-                // can correlate real-time activity without waiting for the final result.
-                if (message?.type === "assistant") {
-                    const assistantMsg = message;
-                    const toolBlocks = Array.isArray(assistantMsg?.message?.content)
-                        ? assistantMsg.message.content.filter((part) => part?.type === "tool_use")
-                        : [];
-                    if (toolBlocks.length > 0) {
-                        console.log("[NorthflareAgentManager] Agent announced tool calls", toolBlocks.map((part) => ({
-                            id: part?.id,
-                            name: part?.name,
-                        })));
-                    }
-                }
-            }
-            catch (e) {
-                console.warn("[NorthflareAgentManager] 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;
-            const mergeMetadata = (extra) => {
-                if (!extra)
-                    return;
-                metadata = metadata ? { ...metadata, ...extra } : extra;
-            };
-            // Extract parent_tool_use_id if present (for all message types)
-            const msgAsAny = message;
-            if (msgAsAny.parent_tool_use_id) {
-                mergeMetadata({
-                    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;
-                    // Track submit tool calls for special handling of their results
-                    if (toolCalls && toolCalls.length > 0) {
-                        const submitTools = toolCalls.filter((tc) => tc.name === "submit");
-                        if (submitTools.length > 0) {
-                            if (!this.submitToolUseIds.has(context.conversationId)) {
-                                this.submitToolUseIds.set(context.conversationId, new Set());
-                            }
-                            const submitIds = this.submitToolUseIds.get(context.conversationId);
-                            submitTools.forEach((st) => submitIds.add(st.id));
-                            console.log(`[NorthflareAgentManager] Tracking submit tool calls:`, {
-                                conversationId: context.conversationId,
-                                submitToolIds: submitTools.map((st) => st.id),
-                            });
-                        }
-                    }
-                    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": {
-                    const toolResultMsg = message;
-                    const toolName = toolResultMsg.tool_name ||
-                        toolResultMsg.name ||
-                        toolResultMsg?.toolCall?.name ||
-                        null;
-                    const toolUseId = toolResultMsg.tool_use_id ||
-                        toolResultMsg.tool_call_id ||
-                        toolResultMsg.id ||
-                        toolResultMsg?.message?.id;
-                    const resolvedContent = (() => {
-                        if ("content" in toolResultMsg &&
-                            toolResultMsg.content !== undefined) {
-                            return toolResultMsg.content;
-                        }
-                        if (toolResultMsg.result !== undefined) {
-                            return toolResultMsg.result;
-                        }
-                        if (toolResultMsg.output !== undefined) {
-                            return toolResultMsg.output;
-                        }
-                        if (toolResultMsg?.message?.content !== undefined) {
-                            return toolResultMsg.message.content;
-                        }
-                        return null;
-                    })();
-                    // Check if this is a submit tool result
-                    const submitIds = this.submitToolUseIds.get(context.conversationId);
-                    const isSubmitTool = submitIds && submitIds.has(toolUseId);
-                    if (isSubmitTool) {
-                        // Convert submit tool result to assistant message
-                        const previewSource = resolvedContent ?? toolResultMsg.content ?? null;
-                        let previewText = "[no content]";
-                        if (typeof previewSource === "string") {
-                            previewText = previewSource.slice(0, 100);
-                        }
-                        else if (previewSource !== null) {
-                            try {
-                                previewText = JSON.stringify(previewSource).slice(0, 100);
-                            }
-                            catch {
-                                previewText = String(previewSource);
-                            }
-                        }
-                        console.log(`[NorthflareAgentManager] Converting submit tool result to assistant message:`, {
-                            conversationId: context.conversationId,
-                            toolUseId,
-                            contentPreview: previewText,
-                        });
-                        messageType = "assistant";
-                        subtype = "submit_result";
-                        // Extract the text content from the tool result
-                        let textContent = "";
-                        if (typeof resolvedContent === "string") {
-                            textContent = resolvedContent;
-                        }
-                        else if (Array.isArray(resolvedContent)) {
-                            // Handle array of content blocks
-                            textContent = resolvedContent
-                                .filter((b) => b && b.type === "text" && typeof b.text === "string")
-                                .map((b) => b.text)
-                                .join("");
-                        }
-                        else if (resolvedContent && typeof resolvedContent === "object") {
-                            // Handle object with text property
-                            if (typeof resolvedContent.text === "string") {
-                                textContent = resolvedContent.text;
-                            }
-                            else if (typeof resolvedContent.result === "string") {
-                                textContent = resolvedContent.result;
-                            }
-                        }
-                        structuredContent = {
-                            text: textContent,
-                            timestamp: new Date().toISOString(),
-                            metadata: {
-                                source: "submit_tool",
-                                tool_use_id: toolUseId,
-                            },
-                        };
-                        // Remove this tool_use_id from tracking
-                        submitIds.delete(toolUseId);
-                        if (submitIds.size === 0) {
-                            this.submitToolUseIds.delete(context.conversationId);
-                        }
-                    }
-                    else {
-                        // Regular tool result - normalize to v1-style tool_result blocks
-                        messageType = "tool_result";
-                        subtype = "tool_result";
-                        structuredContent = [
-                            {
-                                type: "tool_result",
-                                subtype: "tool_result",
-                                tool_use_id: toolUseId,
-                                content: resolvedContent, // Keep content as native (array or string)
-                                timestamp: new Date().toISOString(),
-                            },
-                        ];
-                        const toolCallMetadata = {};
-                        if (toolUseId) {
-                            toolCallMetadata["id"] = toolUseId;
-                        }
-                        if (toolName) {
-                            toolCallMetadata["name"] = toolName;
-                        }
-                        mergeMetadata({
-                            ...(toolName ? { tool_name: toolName } : {}),
-                            ...(Object.keys(toolCallMetadata).length > 0
-                                ? { toolCall: toolCallMetadata }
-                                : {}),
-                        });
-                    }
-                    break;
-                }
-                case "result": {
-                    const resultMsg = message;
-                    structuredContent = {
-                        text: resultMsg.content || resultMsg.result || "",
-                        timestamp: new Date().toISOString(),
-                    };
-                    break;
-                }
-                case "user": {
-                    const userMsg = message;
-                    // Skip user messages that were sent by the runner itself (already in database via orchestrator)
-                    // Only process user messages that contain tool results (which need special handling)
-                    const rawContent = (userMsg && userMsg.message && userMsg.message.content) ||
-                        userMsg?.content ||
-                        [];
-                    // Check if this is a tool result message (needs processing)
-                    const blocks = typeof rawContent === "string"
-                        ? [{ type: "text", text: rawContent }]
-                        : rawContent;
-                    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 {
-                            // Regular user messages (non-tool-result) are already created by the orchestrator
-                            // Skip them to avoid duplicates
-                            console.log("[NorthflareAgentManager] Skipping regular user message (already in database via orchestrator)");
-                            skipSend = true;
-                            // Special case: Check if this is a subagent prompt (has parent_tool_use_id)
-                            if (userMsg.parent_tool_use_id) {
-                                // These should still be processed as assistant messages
-                                console.log("[NorthflareAgentManager] Detected subagent prompt message (parent_tool_use_id present, no tool_result)", {
-                                    parent_tool_use_id: userMsg.parent_tool_use_id,
-                                });
-                                skipSend = false; // Don't skip subagent prompts
-                                messageType = "assistant"; // Change from "user" to "assistant"
-                                subtype = "subagent_prompt";
-                                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(),
-                                };
-                                // 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("[NorthflareAgentManager] 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 {
-                                    // Regular user message in JSON array format - skip
-                                    console.log("[NorthflareAgentManager] Skipping regular user message from JSON array (already in database)");
-                                    skipSend = true;
-                                }
-                            }
-                            else {
-                                // Regular user message as parsed JSON - skip
-                                console.log("[NorthflareAgentManager] Skipping regular user message from parsed JSON (already in database)");
-                                skipSend = true;
-                            }
-                        }
-                        catch {
-                            // Not JSON - regular text user message - skip
-                            console.log("[NorthflareAgentManager] Skipping regular text user message (already in database)");
-                            skipSend = true;
-                        }
-                    }
-                    else {
-                        // Other object content - skip regular user messages
-                        console.log("[NorthflareAgentManager] Skipping regular user message with object content (already in database)");
-                        skipSend = true;
-                    }
-                    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;
-                }
-                case "result": {
-                    // SDK result message - check if it's an error result
-                    const resultMsg = message;
-                    const resultIsError = resultMsg.is_error === true;
-                    const resultSubtype = resultMsg.subtype || "success";
-                    const errorMessage = resultMsg.error_message || resultMsg.result || "";
-                    if (resultIsError) {
-                        // Store the SDK error in context metadata so onComplete knows about it
-                        context.metadata = context.metadata || {};
-                        context.metadata["_sdkError"] = {
-                            isError: true,
-                            errorMessage: errorMessage,
-                            subtype: resultSubtype,
-                        };
-                        console.log("[NorthflareAgentManager] SDK result message indicates error", {
-                            conversationId: context.conversationId,
-                            subtype: resultSubtype,
-                            errorMessage: errorMessage?.slice?.(0, 200),
-                        });
-                        messageType = "system";
-                        subtype = "error";
-                        isError = true;
-                        structuredContent = {
-                            text: errorMessage || "SDK execution error",
-                            errorType: resultSubtype,
-                            errorDetails: {
-                                sdk_subtype: resultSubtype,
-                                duration_ms: resultMsg.duration_ms,
-                                num_turns: resultMsg.num_turns,
-                            },
-                            timestamp: new Date().toISOString(),
-                        };
-                    }
-                    else {
-                        // Success result - just log it, don't send as a separate message
-                        console.log("[NorthflareAgentManager] SDK result message (success)", {
-                            conversationId: context.conversationId,
-                            subtype: resultSubtype,
-                            resultPreview: (resultMsg.result || "").slice?.(0, 100),
-                        });
-                        skipSend = true;
-                    }
-                    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("[NorthflareAgentManager] 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("[NorthflareAgentManager] 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);
-                try {
-                    console.log("[NorthflareAgentManager] message.agent dispatched", {
-                        conversationId: context.conversationId,
-                        agentSessionId: context.agentSessionId,
-                        messageId,
-                        type: payload.type,
-                        subtype: payload.subtype,
-                    });
-                    // If the main agent sent a submit tool result, treat it as terminal and finalize
-                    if (payload.subtype === "submit_result") {
-                        console.log("[NorthflareAgentManager] Submit tool detected - finalizing conversation", {
-                            conversationId: context.conversationId,
-                            agentSessionId: context.agentSessionId,
-                        });
-                        // End SDK conversation to stop further streaming
-                        try {
-                            if (context.conversation &&
-                                isAgentConversation(context.conversation)) {
-                                await context.conversation.end();
-                            }
-                        }
-                        catch (e) {
-                            console.warn("[NorthflareAgentManager] Error ending conversation on submit:", e);
-                        }
-                        await this._finalizeConversation(context, false, undefined, "submit_tool");
-                    }
-                }
-                catch { }
-            }
-            // Tool calls are handled directly by the agent 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(`Northflare Agent 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();
-                // Attach metadata about remaining queue length so consumers can check
-                // if more messages are immediately available without Promise.race tricks
-                if (value && typeof value === "object") {
-                    value.__queueHasMore = queue.length > 0;
-                }
-                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 SDK user message from text or multimodal content
-    function toSdkUserMessage(content) {
-        // If content is an array with image blocks, convert to SDK multimodal format
-        if (Array.isArray(content)) {
-            const sdkContent = content.map((block) => {
-                if (block.type === "text" && block.text) {
-                    return { type: "text", text: block.text };
-                }
-                else if (block.type === "image" && block.image) {
-                    return { type: "image", image: block.image };
-                }
-                return null;
-            }).filter(Boolean);
-            return {
-                type: "user",
-                session_id: observedSessionId || "",
-                parent_tool_use_id: null,
-                message: {
-                    role: "user",
-                    content: sdkContent,
-                },
-            };
-        }
-        // Plain text message
-        return {
-            type: "user",
-            session_id: observedSessionId || "",
-            parent_tool_use_id: null,
-            message: {
-                role: "user",
-                content: content,
-            },
-        };
-    }
-    return {
-        // Send a message - accepts either text-only or multimodal content
-        send(payload) {
-            // Check if multimodal content is provided
-            if (payload.content && Array.isArray(payload.content)) {
-                const hasImages = payload.content.some((b) => b.type === "image");
-                try {
-                    console.log("[NorthflareAgentManager] -> SDK send (multimodal)", {
-                        sessionId: observedSessionId,
-                        type: payload?.type,
-                        blockCount: payload.content.length,
-                        hasImages,
-                        blockTypes: payload.content.map((b) => b.type).join(", "),
-                    });
-                }
-                catch { }
-                input.enqueue(toSdkUserMessage(payload.content));
-                return;
-            }
-            // Text-only message
-            const text = payload?.text ?? "";
-            try {
-                console.log("[NorthflareAgentManager] -> SDK send", {
-                    sessionId: observedSessionId,
-                    type: payload?.type,
-                    textPreview: text.slice(0, 200),
-                    length: text.length,
-                });
-            }
-            catch { }
-            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 isAgentConversation(conversation) {
-    return (!!conversation &&
-        typeof conversation.send === "function" &&
-        typeof conversation.end === "function");
-}
-//# sourceMappingURL=northflare-agent-sdk-manager.js.map