@northflare/runner 0.0.13 → 0.0.16

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

@@ -0,0 +1,1456 @@
+/**
+ * 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 { console } from '../utils/console.js';
+import { expandEnv } from '../utils/expand-env.js';
+import { isRunnerDebugEnabled } from '../utils/debug.js';
+import jwt from "jsonwebtoken";
+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 (isRunnerDebugEnabled()) {
+            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
+    }
+    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 ||
+            "anthropic/claude-3-5-sonnet-20241022";
+        const model = this.normalizeModel(rawModel);
+        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,
+            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 in local workspaces, create a local task handle
+            if (conversationObjectType === "Task") {
+                const taskHandle = await this.repositoryManager.createLocalTaskHandle(conversationObjectId, workspacePath);
+                // Store task handle information in context for later use
+                context.taskHandle = taskHandle;
+            }
+        }
+        else if (conversationObjectType === "Task" &&
+            config.repository &&
+            workspaceId) {
+            // Use task-specific worktree for task conversations
+            console.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 debugEnabled = isRunnerDebugEnabled();
+        // 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 ||
+            config.apiKey ||
+            process.env["OPENROUTER_API_KEY"];
+        const groqApiKey = config.groqApiKey ||
+            process.env["GROQ_API_KEY"] ||
+            // Backwards compat if older configs set apiKey for Groq
+            (provider === "groq" ? config.apiKey : undefined);
+        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 (debugEnabled) {
+            envVars["DEBUG"] = "1";
+        }
+        // Simplified system prompt handling
+        const appendSystemPrompt = [
+            context.globalInstructions,
+            context.workspaceInstructions,
+        ]
+            .filter(Boolean)
+            .join("\n\n");
+        // Debug log the appendSystemPrompt being sent to Northflare Agent SDK
+        console.log(`[NorthflareAgentManager] Building appendSystemPrompt for conversation ${context.conversationId}:`, {
+            hasGlobalInstructions: !!context.globalInstructions,
+            globalInstructionsLength: context.globalInstructions?.length ?? 0,
+            hasWorkspaceInstructions: !!context.workspaceInstructions,
+            workspaceInstructionsLength: context.workspaceInstructions?.length ?? 0,
+            appendSystemPromptLength: appendSystemPrompt.length,
+            appendSystemPromptPreview: appendSystemPrompt.slice(0, 150),
+        });
+        // Simplified tool restrictions for read-only mode
+        const disallowedTools = context.permissionsMode === "read"
+            ? [
+                "write_file",
+                "edit_file",
+                "multi_edit_file",
+                "delete_file",
+                "move_file",
+                "copy_file",
+                "run_command",
+                "todo_write",
+            ]
+            : [];
+        if (disallowedTools.length) {
+            console.log("[NorthflareAgentManager] Applied read-only mode tool restrictions");
+        }
+        // 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,
+                hasAppendSystemPrompt: Boolean(appendSystemPrompt),
+                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,
+        });
+        // Launch SDK with simplified configuration
+        let silenceTimer = null;
+        let lastSdkActivity = Date.now();
+        const sdk = sdkQuery({
+            prompt: input.iterable,
+            options: {
+                cwd: workspacePath,
+                env: envVars,
+                model: sdkModel,
+                resume: config.sessionId || conversationData?.agentSessionId || undefined,
+                ...(maxTurns !== undefined ? { maxTurns } : {}),
+                ...(appendSystemPrompt
+                    ? {
+                        systemPrompt: {
+                            type: "preset",
+                            preset: "claude_code",
+                            append: appendSystemPrompt,
+                        },
+                    }
+                    : {}),
+                ...(disallowedTools.length ? { disallowedTools } : {}),
+                ...(mcpServers ? { mcpServers } : {}),
+                ...(debugEnabled
+                    ? {
+                        debug: true,
+                        stderr: (data) => {
+                            try {
+                                console.log(`[Northflare Agent SDK] ${data}`);
+                            }
+                            catch { }
+                        },
+                        onStepFinish: (step) => {
+                            try {
+                                console.log("[NorthflareAgentManager] Agent step finished", {
+                                    conversationId: context.conversationId,
+                                    type: step?.type,
+                                    tool: step?.tool,
+                                    finishReason: step?.finishReason,
+                                });
+                            }
+                            catch { }
+                        },
+                    }
+                    : {}),
+            },
+        });
+        console.log("[NorthflareAgentManager] sdkQuery options summary", {
+            provider,
+            model: context.model,
+            cwd: workspacePath,
+            maxTurns: maxTurns ?? "default (SDK)",
+            hasSystemPrompt: Boolean(appendSystemPrompt),
+            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;
+        // Simplified conversation wrapper - reduced complexity while maintaining interface
+        const conversation = createConversationWrapper(sdk, input, async (hadError, error) => {
+            console.log("[NorthflareAgentManager] SDK stream completed", {
+                conversationId: context.conversationId,
+                agentSessionId: context.agentSessionId,
+                hadError,
+                errorMessage: error?.message,
+                streamedMessageCount,
+            });
+            if (silenceTimer) {
+                clearInterval(silenceTimer);
+                silenceTimer = null;
+            }
+            await this._finalizeConversation(context, hadError, error);
+        });
+        // Store conversation instance in context for reuse
+        context.conversation = conversation;
+        // Observe session id from first messages that include it
+        conversation.onSessionId(async (agentSessionId) => {
+            if (!agentSessionId)
+                return;
+            const oldSessionId = context.agentSessionId;
+            if (oldSessionId !== agentSessionId) {
+                context.agentSessionId = agentSessionId;
+                context.status = "active";
+                await this.runner.notify("agentSessionId.changed", {
+                    conversationId: context.conversationId,
+                    conversationObjectType,
+                    conversationObjectId,
+                    oldAgentSessionId: oldSessionId,
+                    newAgentSessionId: agentSessionId,
+                });
+            }
+        });
+        // Set up streaming message handler
+        const messageHandler = async (message, sessionId) => {
+            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._finalizeConversation(context, false);
+                    }
+                }
+                else if (message?.type === "result") {
+                    // Treat 'result' as an end-of-conversation signal for the SDK
+                    try {
+                        await this._finalizeConversation(context, false);
+                        console.log("[NorthflareAgentManager] Finalized conversation due to SDK 'result' message", {
+                            conversationId: context.conversationId,
+                            agentSessionId: context.agentSessionId,
+                        });
+                    }
+                    catch (e) {
+                        console.warn("[NorthflareAgentManager] Error finalizing on 'result' message:", e);
+                    }
+                }
+            }
+            catch (e) {
+                console.warn("[NorthflareAgentManager] finalize-on-system heuristic error:", e);
+            }
+        };
+        if (debugEnabled) {
+            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);
+        }
+        conversation.stream(messageHandler);
+        // Note: Error handling is done via process completion handler
+        // The Northflare Agent SDK doesn't have an onError method on conversations
+        // Send initial messages
+        try {
+            for (const message of initialMessages) {
+                const initialText = this.normalizeToText(message.content);
+                console.log("[NorthflareAgentManager] Sending initial message to SDK", {
+                    conversationId: context.conversationId,
+                    agentSessionId: context.agentSessionId,
+                    textPreview: initialText.slice(0, 200),
+                    length: initialText.length,
+                });
+                conversation.send({
+                    type: "text",
+                    text: initialText,
+                });
+            }
+            console.log(`Started conversation for ${conversationObjectType} ${conversationObjectId} in workspace ${workspacePath}`);
+            // Return the conversation context directly
+            return context;
+        }
+        catch (error) {
+            // Handle startup errors
+            await this._handleConversationError(context, error);
+            throw error;
+        }
+    }
+    async stopConversation(agentSessionId, context, isRunnerShutdown = false, reason) {
+        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);
+                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 _finalizeConversation(context, hadError, error, reason) {
+        // Synchronous idempotency check - must happen before any async operations
+        if (context._finalized)
+            return;
+        context._finalized = true;
+        // Mark as completed immediately to prevent restart on catch-up
+        // This is synchronous and happens before any async operations
+        this.runner.markConversationCompleted(context.conversationId);
+        // Clean up conversation from active conversations (synchronous)
+        try {
+            console.log(`[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);
+        }
+    }
+    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,
+                    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
+            const normalizedText = this.normalizeToText(content);
+            if (isRunnerDebugEnabled()) {
+                console.log("[NorthflareAgentManager] Normalized follow-up content", {
+                    originalType: typeof content,
+                    isArray: Array.isArray(content) || undefined,
+                    normalizedPreview: typeof normalizedText === "string"
+                        ? normalizedText.slice(0, 160)
+                        : String(normalizedText).slice(0, 160),
+                });
+            }
+            context.conversation.send({
+                type: "text",
+                text: normalizedText,
+            });
+            // Update last activity timestamp
+            context.lastActivityAt = new Date();
+            console.log(`Sent user message to conversation ${context.conversationId} (agentSessionId: ${context.agentSessionId}, status: ${context.status})`);
+        }
+        catch (error) {
+            // Handle errors properly
+            await this._handleConversationError(context, error);
+            throw error; // Re-throw to maintain the same behavior
+        }
+    }
+    async fetchGithubTokens(workspaceId) {
+        try {
+            const response = await fetch(`${this.runner.config_.orchestratorUrl}/api/runner/tokens?workspaceId=${workspaceId}`, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${process.env["NORTHFLARE_RUNNER_TOKEN"]}`,
+                },
+            });
+            if (!response.ok) {
+                console.error(`Failed to fetch GitHub tokens: ${response.status}`);
+                return undefined;
+            }
+            const data = (await response.json());
+            return data.githubToken;
+        }
+        catch (error) {
+            console.error("Error fetching GitHub tokens:", error);
+            return undefined;
+        }
+    }
+    async _handleConversationError(context, error) {
+        const errorType = this.classifyError(error);
+        // Notify orchestrator
+        await this.runner.notify("error.report", {
+            conversationId: context.conversationId,
+            conversationObjectType: context.conversationObjectType,
+            conversationObjectId: context.conversationObjectId,
+            agentSessionId: context.agentSessionId,
+            errorType,
+            message: error.message,
+            details: {
+                stack: error.stack,
+                timestamp: new Date(),
+            },
+        });
+        // Conversation continues on error - no automatic cleanup
+        console.error(`Conversation error for ${context.conversationObjectType} ${context.conversationObjectId}:`, error);
+    }
+    classifyError(error) {
+        if (error.message.includes("process exited")) {
+            return "process_exit";
+        }
+        else if (error.message.includes("model")) {
+            return "model_error";
+        }
+        else if (error.message.includes("tool")) {
+            return "tool_error";
+        }
+        else if (error.message.includes("permission")) {
+            return "permission_error";
+        }
+        else if (error.message.includes("timeout")) {
+            return "timeout_error";
+        }
+        return "unknown_error";
+    }
+    normalizeModel(rawModel) {
+        if (!rawModel) {
+            return "anthropic/claude-3-5-sonnet-20241022";
+        }
+        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);
+        }
+        return trimmed;
+    }
+    /**
+     * 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;
+                }
+                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,
+                    });
+                }
+                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();
+                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;
+    function toSdkUserMessage(text) {
+        return {
+            type: "user",
+            session_id: observedSessionId || "",
+            parent_tool_use_id: null,
+            message: {
+                role: "user",
+                content: text,
+            },
+        };
+    }
+    return {
+        send(payload) {
+            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