@northflare/runner 0.0.19 → 0.0.21

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

@@ -9,11 +9,20 @@
 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 { 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";
+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;
@@ -22,7 +31,7 @@ export class NorthflareAgentManager {
         this.runner = runner;
         this.repositoryManager = repositoryManager;
         // Log debug mode status
-        if (isRunnerDebugEnabled()) {
+        if (isDebugEnabledFor("sdk")) {
             console.log("[NorthflareAgentManager] DEBUG MODE ENABLED - Northflare Agent SDK will log verbose output");
         }
         // Note: MCP host configuration is passed from orchestrator
@@ -33,6 +42,48 @@ export class NorthflareAgentManager {
         // 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
@@ -155,7 +206,9 @@ export class NorthflareAgentManager {
                 console.warn("[NorthflareAgentManager] Unable to generate TOOL_TOKEN - missing required data");
             }
         }
-        const debugEnabled = isRunnerDebugEnabled();
+        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 = {
@@ -165,13 +218,8 @@ export class NorthflareAgentManager {
             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);
+        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;
         }
@@ -188,40 +236,67 @@ export class NorthflareAgentManager {
         if (toolToken) {
             envVars["TOOL_TOKEN"] = toolToken;
         }
-        if (debugEnabled) {
+        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 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),
+        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,
         });
-        // Simplified tool restrictions for read-only mode
+        // Tool restrictions based on permissions mode
+        // "read" = read-only mode (no file writes, no shell)
+        // "project" = read + no subagents (for ProjectStep orchestrators)
+        const readOnlyTools = [
+            "write_file",
+            "edit_file",
+            "multi_edit_file",
+            "delete_file",
+            "move_file",
+            "copy_file",
+            "run_command",
+            "todo_write",
+        ];
         const disallowedTools = context.permissionsMode === "read"
-            ? [
-                "write_file",
-                "edit_file",
-                "multi_edit_file",
-                "delete_file",
-                "move_file",
-                "copy_file",
-                "run_command",
-                "todo_write",
-            ]
-            : [];
+            ? readOnlyTools
+            : context.permissionsMode === "project"
+                ? [...readOnlyTools, "task"]
+                : [];
+        if (!subAgentConfig.enabled) {
+            disallowedTools.push("task");
+        }
         if (disallowedTools.length) {
-            console.log("[NorthflareAgentManager] Applied read-only mode tool restrictions");
+            console.log("[NorthflareAgentManager] Tool restrictions applied", {
+                disallowedTools,
+            });
         }
         // Simplified MCP server configuration
         let mcpServers;
@@ -237,7 +312,11 @@ export class NorthflareAgentManager {
                 cwd: workspacePath,
                 hasMcpServers: !!mcpServers && Object.keys(mcpServers).length > 0,
                 disallowedTools,
-                hasAppendSystemPrompt: Boolean(appendSystemPrompt),
+                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"]),
@@ -283,29 +362,95 @@ export class NorthflareAgentManager {
             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,
+                ...(agentsOption ? { agents: agentsOption } : {}),
                 ...(maxTurns !== undefined ? { maxTurns } : {}),
-                ...(appendSystemPrompt
-                    ? {
-                        systemPrompt: {
-                            type: "preset",
-                            preset: "claude_code",
-                            append: appendSystemPrompt,
-                        },
-                    }
-                    : {}),
+                ...(systemPromptOption ? { systemPrompt: systemPromptOption } : {}),
                 ...(disallowedTools.length ? { disallowedTools } : {}),
                 ...(mcpServers ? { mcpServers } : {}),
-                ...(debugEnabled
+                conversationId: context.conversationId,
+                conversationObjectId: context.conversationObjectId,
+                taskId: context.taskId,
+                onTaskProgress: handleTaskProgress,
+                ...(sdkDebug
                     ? {
                         debug: true,
                         stderr: (data) => {
@@ -316,12 +461,8 @@ export class NorthflareAgentManager {
                         },
                         onStepFinish: (step) => {
                             try {
-                                console.log("[NorthflareAgentManager] Agent step finished", {
-                                    conversationId: context.conversationId,
-                                    type: step?.type,
-                                    tool: step?.tool,
-                                    finishReason: step?.finishReason,
-                                });
+                                console.log("[NorthflareAgentManager] Agent step finished (full step object): " +
+                                    JSON.stringify(step, null, 2));
                             }
                             catch { }
                         },
@@ -334,30 +475,56 @@ export class NorthflareAgentManager {
             model: context.model,
             cwd: workspacePath,
             maxTurns: maxTurns ?? "default (SDK)",
-            hasSystemPrompt: Boolean(appendSystemPrompt),
+            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,
-                errorMessage: error?.message,
+                sdkErrorDetected: sdkError?.isError,
+                effectiveHadError,
+                errorMessage: effectiveError?.message,
                 streamedMessageCount,
             });
-            if (silenceTimer) {
-                clearInterval(silenceTimer);
-                silenceTimer = null;
+            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._finalizeConversation(context, hadError, error);
+            await this._finalizeConversation(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)
@@ -387,10 +554,7 @@ export class NorthflareAgentManager {
                     if (typeof message === "string")
                         return message.slice(0, 300);
                     const m = message;
-                    const content = m?.message?.content ||
-                        m?.content ||
-                        m?.message?.text ||
-                        m?.text;
+                    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)) {
@@ -435,25 +599,12 @@ export class NorthflareAgentManager {
                         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) {
+        if (managerDebug) {
             silenceTimer = setInterval(() => {
                 const now = Date.now();
                 const idleMs = now - lastSdkActivity;
@@ -467,10 +618,9 @@ export class NorthflareAgentManager {
                 }
             }, 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
+        // 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) {
                 const initialText = this.normalizeToText(message.content);
@@ -485,6 +635,13 @@ export class NorthflareAgentManager {
                     text: initialText,
                 });
             }
+            // 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;
@@ -550,6 +707,13 @@ export class NorthflareAgentManager {
         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);
@@ -613,7 +777,9 @@ export class NorthflareAgentManager {
                 // 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,
+                    systemPrompt: config?.systemPrompt || conversationDetails?.systemPrompt,
+                    systemPromptMode: config?.systemPromptMode ||
+                        conversationDetails?.systemPromptMode,
                     workspaceId: conversationDetails.workspaceId,
                     ...config, // Use the full config provided in the RunnerMessage
                     ...(conversationDetails.agentSessionId
@@ -637,8 +803,7 @@ export class NorthflareAgentManager {
         }
         try {
             // Send immediately when a conversation instance exists; no need to wait for "active"
-            if (!context.conversation ||
-                !isAgentConversation(context.conversation)) {
+            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
@@ -654,7 +819,7 @@ export class NorthflareAgentManager {
             }
             // Native message injection - SDK handles queueing and delivery
             const normalizedText = this.normalizeToText(content);
-            if (isRunnerDebugEnabled()) {
+            if (isDebugEnabledFor("manager")) {
                 console.log("[NorthflareAgentManager] Normalized follow-up content", {
                     originalType: typeof content,
                     isArray: Array.isArray(content) || undefined,
@@ -716,21 +881,40 @@ export class NorthflareAgentManager {
         console.error(`Conversation error for ${context.conversationObjectType} ${context.conversationObjectId}:`, error);
     }
     classifyError(error) {
-        if (error.message.includes("process exited")) {
+        const msg = error.message.toLowerCase();
+        if (msg.includes("process exited")) {
             return "process_exit";
         }
-        else if (error.message.includes("model")) {
+        else if (msg.includes("model")) {
             return "model_error";
         }
-        else if (error.message.includes("tool")) {
+        else if (msg.includes("tool")) {
             return "tool_error";
         }
-        else if (error.message.includes("permission")) {
+        else if (msg.includes("permission") ||
+            msg.includes("forbidden") ||
+            msg.includes("403")) {
             return "permission_error";
         }
-        else if (error.message.includes("timeout")) {
+        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) {
@@ -1000,7 +1184,8 @@ export class NorthflareAgentManager {
                         toolResultMsg.id ||
                         toolResultMsg?.message?.id;
                     const resolvedContent = (() => {
-                        if ("content" in toolResultMsg && toolResultMsg.content !== undefined) {
+                        if ("content" in toolResultMsg &&
+                            toolResultMsg.content !== undefined) {
                             return toolResultMsg.content;
                         }
                         if (toolResultMsg.result !== undefined) {
@@ -1119,8 +1304,8 @@ export class NorthflareAgentManager {
                         userMsg?.content ||
                         [];
                     // Check if this is a tool result message (needs processing)
-                    const blocks = typeof rawContent === 'string'
-                        ? [{ type: 'text', text: rawContent }]
+                    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");
@@ -1244,6 +1429,50 @@ export class NorthflareAgentManager {
                     };
                     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;
@@ -1303,6 +1532,24 @@ export class NorthflareAgentManager {
                         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 { }
             }
@@ -1342,6 +1589,11 @@ function createUserMessageStream() {
         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;
             }