@townco/agent 0.1.56 → 0.1.58

package/dist/acp-server/adapter.d.ts

@@ -25,6 +25,7 @@ export declare class AgentAcpAdapter implements acp.Agent {
     private agentDescription;
     private agentSuggestedPrompts;
     private agentInitialMessage;
+    private agentUiConfig;
     private currentToolOverheadTokens;
     private currentMcpOverheadTokens;
     constructor(agent: AgentRunner, connection: acp.AgentSideConnection, agentDir?: string, agentName?: string);
@@ -49,6 +50,11 @@ export declare class AgentAcpAdapter implements acp.Agent {
     private saveSessionToDisk;
     initialize(_params: acp.InitializeRequest): Promise<acp.InitializeResponse>;
     newSession(params: acp.NewSessionRequest): Promise<acp.NewSessionResponse>;
+    /**
+     * Store an initial message in the session.
+     * Called by the HTTP transport after sending the initial message via SSE.
+     */
+    storeInitialMessage(sessionId: string, content: string): Promise<void>;
     loadSession(params: acp.LoadSessionRequest): Promise<acp.LoadSessionResponse>;
     authenticate(_params: acp.AuthenticateRequest): Promise<acp.AuthenticateResponse | undefined>;
     setSessionMode(_params: acp.SetSessionModeRequest): Promise<acp.SetSessionModeResponse>;

package/dist/acp-server/adapter.js

@@ -106,6 +106,7 @@ export class AgentAcpAdapter {
     agentDescription;
     agentSuggestedPrompts;
     agentInitialMessage;
+    agentUiConfig;
     currentToolOverheadTokens = 0; // Track tool overhead for current turn
     currentMcpOverheadTokens = 0; // Track MCP overhead for current turn
     constructor(agent, connection, agentDir, agentName) {
@@ -119,6 +120,7 @@ export class AgentAcpAdapter {
         this.agentDescription = agent.definition.description;
         this.agentSuggestedPrompts = agent.definition.suggestedPrompts;
         this.agentInitialMessage = agent.definition.initialMessage;
+        this.agentUiConfig = agent.definition.uiConfig;
         this.noSession = process.env.TOWN_NO_SESSION === "true";
         this.storage =
             agentDir && agentName && !this.noSession
@@ -265,6 +267,7 @@ export class AgentAcpAdapter {
             ...(this.agentInitialMessage
                 ? { initialMessage: this.agentInitialMessage }
                 : {}),
+            ...(this.agentUiConfig ? { uiConfig: this.agentUiConfig } : {}),
             ...(toolsMetadata.length > 0 ? { tools: toolsMetadata } : {}),
             ...(mcpsMetadata.length > 0 ? { mcps: mcpsMetadata } : {}),
             ...(subagentsMetadata.length > 0 ? { subagents: subagentsMetadata } : {}),
@@ -285,6 +288,32 @@ export class AgentAcpAdapter {
             sessionId,
         };
     }
+    /**
+     * Store an initial message in the session.
+     * Called by the HTTP transport after sending the initial message via SSE.
+     */
+    async storeInitialMessage(sessionId, content) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            logger.warn("Cannot store initial message - session not found", {
+                sessionId,
+            });
+            return;
+        }
+        // Add the initial message as an assistant message
+        const initialMessage = {
+            role: "assistant",
+            content: [{ type: "text", text: content }],
+            timestamp: new Date().toISOString(),
+        };
+        session.messages.push(initialMessage);
+        // Save to disk if session persistence is enabled
+        await this.saveSessionToDisk(sessionId, session);
+        logger.debug("Stored initial message in session", {
+            sessionId,
+            contentPreview: content.slice(0, 100),
+        });
+    }
     async loadSession(params) {
         if (!this.storage) {
             throw new Error("Session storage is not configured");
@@ -518,13 +547,11 @@ export class AgentAcpAdapter {
                 ? session.context[session.context.length - 1]
                 : undefined;
             // Calculate context size for this snapshot
-            // Build message pointers for the new context (previous messages + new user message)
+            // Build message pointers for the new context (previous messages only, NOT the new user message)
+            // The new user message will be passed separately via the prompt parameter
             const messageEntries = previousContext
-                ? [
-                    ...previousContext.messages,
-                    { type: "pointer", index: session.messages.length - 1 },
-                ]
-                : [{ type: "pointer", index: 0 }];
+                ? [...previousContext.messages]
+                : [];
             // Resolve message entries to actual messages
             const contextMessages = [];
             for (const entry of messageEntries) {
@@ -749,6 +776,23 @@ export class AgentAcpAdapter {
                             toolCallBlock.completedAt = Date.now();
                         }
                     }
+                    // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
+                    if (updateMsg._meta) {
+                        logger.info("Forwarding tool_call_update with _meta to client", {
+                            toolCallId: updateMsg.toolCallId,
+                            status: updateMsg.status,
+                            _meta: updateMsg._meta,
+                        });
+                        this.connection.sessionUpdate({
+                            sessionId: params.sessionId,
+                            update: {
+                                sessionUpdate: "tool_call_update",
+                                toolCallId: updateMsg.toolCallId,
+                                status: updateMsg.status,
+                                _meta: updateMsg._meta,
+                            },
+                        });
+                    }
                 }
                 // Handle tool_output - update ToolCallBlock with output content
                 if ("sessionUpdate" in msg && msg.sessionUpdate === "tool_output") {
@@ -816,33 +860,53 @@ export class AgentAcpAdapter {
                             // Check if we already have a partial assistant message in messages
                             const lastMessage = session.messages[session.messages.length - 1];
                             let partialMessageIndex;
+                            let userMessageIndex;
+                            let isFirstToolInTurn;
                             if (lastMessage && lastMessage.role === "assistant") {
-                                // Update existing partial message
+                                // Update existing partial message (subsequent tool in same turn)
                                 session.messages[session.messages.length - 1] =
                                     partialAssistantMessage;
                                 partialMessageIndex = session.messages.length - 1;
+                                userMessageIndex = session.messages.length - 2;
+                                isFirstToolInTurn = false;
                             }
                             else {
-                                // Add new partial message
+                                // Add new partial message (first tool in this turn)
                                 session.messages.push(partialAssistantMessage);
                                 partialMessageIndex = session.messages.length - 1;
+                                userMessageIndex = session.messages.length - 2;
+                                isFirstToolInTurn = true;
                             }
                             // Get the latest context
                             const latestContext = session.context.length > 0
                                 ? session.context[session.context.length - 1]
                                 : undefined;
                             // Build message entries for the new context
-                            // Check if we already have a pointer to this message (during mid-turn updates)
                             const existingMessages = latestContext?.messages ?? [];
-                            const lastEntry = existingMessages[existingMessages.length - 1];
-                            const alreadyHasPointer = lastEntry?.type === "pointer" &&
-                                lastEntry.index === partialMessageIndex;
-                            const messageEntries = alreadyHasPointer
-                                ? existingMessages // Don't add duplicate pointer
-                                : [
+                            // Check if we already have pointers to these messages
+                            const hasUserPointer = existingMessages.some((entry) => entry.type === "pointer" && entry.index === userMessageIndex);
+                            const hasAssistantPointer = existingMessages.some((entry) => entry.type === "pointer" &&
+                                entry.index === partialMessageIndex);
+                            let messageEntries;
+                            if (isFirstToolInTurn && !hasUserPointer) {
+                                // First tool: add both user and assistant pointers
+                                messageEntries = [
                                     ...existingMessages,
+                                    { type: "pointer", index: userMessageIndex },
                                     { type: "pointer", index: partialMessageIndex },
                                 ];
+                            }
+                            else if (!hasAssistantPointer) {
+                                // Subsequent tool or user already added: just update/add assistant pointer
+                                messageEntries = [
+                                    ...existingMessages,
+                                    { type: "pointer", index: partialMessageIndex },
+                                ];
+                            }
+                            else {
+                                // Both pointers already exist (updating existing assistant message)
+                                messageEntries = existingMessages;
+                            }
                             // Resolve message entries to actual messages
                             const contextMessages = [];
                             for (const entry of messageEntries) {
@@ -985,13 +1049,19 @@ export class AgentAcpAdapter {
                 ? session.context[session.context.length - 1]
                 : undefined;
             // Calculate final context size
-            // Build message pointers for the new context
+            // Build message pointers for the new context (add both user and assistant messages)
+            const userMessageIndex = session.messages.length - 2;
+            const assistantMessageIndex = session.messages.length - 1;
             const messageEntries = previousContext
                 ? [
                     ...previousContext.messages,
-                    { type: "pointer", index: session.messages.length - 1 },
+                    { type: "pointer", index: userMessageIndex },
+                    { type: "pointer", index: assistantMessageIndex },
                 ]
-                : [{ type: "pointer", index: session.messages.length - 1 }];
+                : [
+                    { type: "pointer", index: userMessageIndex },
+                    { type: "pointer", index: assistantMessageIndex },
+                ];
             // Resolve message entries to actual messages
             const contextMessages = [];
             for (const entry of messageEntries) {

package/dist/acp-server/http.js

@@ -66,7 +66,12 @@ export function makeHttpTransport(agent, agentDir, agentName) {
     const outbound = new TransformStream();
     const bridge = acp.ndJsonStream(outbound.writable, inbound.readable);
     const agentRunner = "definition" in agent ? agent : makeRunnerFromDefinition(agent);
-    new acp.AgentSideConnection((conn) => new AgentAcpAdapter(agentRunner, conn, agentDir, agentName), bridge);
+    // Store adapter reference so we can call methods on it (e.g., storeInitialMessage)
+    let acpAdapter = null;
+    new acp.AgentSideConnection((conn) => {
+        acpAdapter = new AgentAcpAdapter(agentRunner, conn, agentDir, agentName);
+        return acpAdapter;
+    }, bridge);
     const app = new Hono();
     // Track active SSE streams by sessionId for direct output delivery
     const sseStreams = new Map();
@@ -369,6 +374,7 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                             },
                             _meta: {
                                 isInitialMessage: true,
+                                isReplay: true, // Mark as replay so UI adds it to messages
                             },
                         },
                     },
@@ -377,6 +383,10 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                     event: "message",
                     data: JSON.stringify(initialMessage),
                 });
+                // Store the initial message in the session for persistence
+                if (acpAdapter) {
+                    await acpAdapter.storeInitialMessage(sessionId, content);
+                }
                 logger.info("Sent initial message via SSE", {
                     sessionId,
                     contentPreview: content.slice(0, 100),

package/dist/definition/index.d.ts

@@ -31,6 +31,10 @@ export declare const InitialMessageSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
     content: z.ZodString;
 }, z.core.$strip>;
+/** UI configuration schema for controlling the chat interface appearance. */
+export declare const UiConfigSchema: z.ZodObject<{
+    hideTopBar: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
 /** Agent definition schema. */
 export declare const AgentDefinitionSchema: z.ZodObject<{
     displayName: z.ZodOptional<z.ZodString>;
@@ -83,4 +87,7 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
         enabled: z.ZodBoolean;
         content: z.ZodString;
     }, z.core.$strip>>;
+    uiConfig: z.ZodOptional<z.ZodObject<{
+        hideTopBar: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/definition/index.js

@@ -78,6 +78,11 @@ export const InitialMessageSchema = z.object({
     /** The content of the initial message to send. Supports template variables like {{.AgentName}}. */
     content: z.string(),
 });
+/** UI configuration schema for controlling the chat interface appearance. */
+export const UiConfigSchema = z.object({
+    /** Whether to hide the top bar (session switcher, debugger link, settings). Useful for embedded/deployed mode. */
+    hideTopBar: z.boolean().optional(),
+});
 /** Agent definition schema. */
 export const AgentDefinitionSchema = z.object({
     /** Human-readable display name for the agent (shown in UI). */
@@ -93,4 +98,6 @@ export const AgentDefinitionSchema = z.object({
     hooks: z.array(HookConfigSchema).optional(),
     /** Configuration for an initial message the agent sends when a session starts. */
     initialMessage: InitialMessageSchema.optional(),
+    /** UI configuration for controlling the chat interface appearance. */
+    uiConfig: UiConfigSchema.optional(),
 });

package/dist/runner/agent-runner.d.ts

@@ -56,6 +56,9 @@ export declare const zAgentRunnerParams: z.ZodObject<{
         enabled: z.ZodBoolean;
         content: z.ZodString;
     }, z.core.$strip>>;
+    uiConfig: z.ZodOptional<z.ZodObject<{
+        hideTopBar: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type CreateAgentRunnerParams = z.infer<typeof zAgentRunnerParams>;
 export interface SessionMessage {

package/dist/runner/agent-runner.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { HookConfigSchema, InitialMessageSchema, McpConfigSchema, } from "../definition";
+import { HookConfigSchema, InitialMessageSchema, McpConfigSchema, UiConfigSchema, } from "../definition";
 import { zToolType } from "./tools";
 export const zAgentRunnerParams = z.object({
     displayName: z.string().optional(),
@@ -12,4 +12,5 @@ export const zAgentRunnerParams = z.object({
     mcps: z.array(McpConfigSchema).optional(),
     hooks: z.array(HookConfigSchema).optional(),
     initialMessage: InitialMessageSchema.optional(),
+    uiConfig: UiConfigSchema.optional(),
 });

package/dist/runner/langchain/index.js

@@ -13,6 +13,7 @@ import { makeBrowserTools } from "./tools/browser";
 import { makeFilesystemTools } from "./tools/filesystem";
 import { makeGenerateImageTool } from "./tools/generate_image";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
+import { hashQuery, queryToToolCallId, subagentEvents, } from "./tools/subagent-connections";
 import { TODO_WRITE_TOOL_NAME, todoWrite } from "./tools/todo";
 import { makeWebSearchTools } from "./tools/web_search";
 const _logger = createLogger("agent-runner");
@@ -85,6 +86,56 @@ export class LangchainAgent {
         telemetry.setBaseAttributes({
             "agent.session_id": req.sessionId,
         });
+        const subagentUpdateQueue = [];
+        let subagentUpdateResolver = null;
+        // Listen for subagent connection events - resolve any waiting promise immediately
+        const onSubagentConnection = (event) => {
+            _logger.info("Received subagent connection event", {
+                toolCallId: event.toolCallId,
+                port: event.port,
+                sessionId: event.sessionId,
+            });
+            if (subagentUpdateResolver) {
+                // If someone is waiting, resolve immediately
+                const resolver = subagentUpdateResolver;
+                subagentUpdateResolver = null;
+                resolver(event);
+            }
+            else {
+                // Otherwise queue for later
+                subagentUpdateQueue.push(event);
+            }
+        };
+        subagentEvents.on("connection", onSubagentConnection);
+        // Helper to get next subagent update (returns immediately if queued, otherwise waits)
+        const waitForSubagentUpdate = () => {
+            if (subagentUpdateQueue.length > 0) {
+                return Promise.resolve(subagentUpdateQueue.shift());
+            }
+            return new Promise((resolve) => {
+                subagentUpdateResolver = resolve;
+            });
+        };
+        // Helper to check and yield all pending subagent updates
+        async function* yieldPendingSubagentUpdates() {
+            while (subagentUpdateQueue.length > 0) {
+                const update = subagentUpdateQueue.shift();
+                _logger.info("Yielding queued subagent connection update", {
+                    toolCallId: update.toolCallId,
+                    subagentPort: update.port,
+                    subagentSessionId: update.sessionId,
+                });
+                yield {
+                    sessionUpdate: "tool_call_update",
+                    toolCallId: update.toolCallId,
+                    _meta: {
+                        messageId: req.messageId,
+                        subagentPort: update.port,
+                        subagentSessionId: update.sessionId,
+                    },
+                };
+            }
+        }
         // Start telemetry span for entire invocation
         const invocationSpan = telemetry.startSpan("agent.invoke", {
             "agent.model": this.definition.model,
@@ -425,7 +476,53 @@ export class LangchainAgent {
                 recursionLimit: 200,
                 callbacks: [otelCallbacks],
             }));
-            for await (const streamItem of await stream) {
+            // Use manual iteration with Promise.race to interleave stream events with subagent updates
+            const streamIterator = (await stream)[Symbol.asyncIterator]();
+            let streamDone = false;
+            let pendingStreamPromise = null;
+            while (!streamDone) {
+                // Get or create the stream promise (reuse if still pending from last iteration)
+                const nextStreamPromise = pendingStreamPromise ?? streamIterator.next();
+                pendingStreamPromise = nextStreamPromise; // Track it
+                // Create subagent wait promise (only if no queued updates)
+                const subagentPromise = waitForSubagentUpdate();
+                // Use Promise.race, but we need to handle both outcomes
+                const result = await Promise.race([
+                    nextStreamPromise.then((r) => ({
+                        type: "stream",
+                        result: r,
+                    })),
+                    subagentPromise.then((u) => ({ type: "subagent", update: u })),
+                ]);
+                if (result.type === "subagent") {
+                    // Got a subagent update - yield it immediately
+                    const update = result.update;
+                    _logger.info("Yielding subagent connection update (via race)", {
+                        toolCallId: update.toolCallId,
+                        subagentPort: update.port,
+                        subagentSessionId: update.sessionId,
+                    });
+                    yield {
+                        sessionUpdate: "tool_call_update",
+                        toolCallId: update.toolCallId,
+                        _meta: {
+                            messageId: req.messageId,
+                            subagentPort: update.port,
+                            subagentSessionId: update.sessionId,
+                        },
+                    };
+                    // Continue - the stream promise is still pending, will be reused
+                    continue;
+                }
+                // Got a stream item - clear the pending promise
+                pendingStreamPromise = null;
+                const { done, value: streamItem } = result.result;
+                if (done) {
+                    streamDone = true;
+                    break;
+                }
+                // Also yield any queued subagent updates before processing stream item
+                yield* yieldPendingSubagentUpdates();
                 const [streamMode, chunk] = streamItem;
                 if (streamMode === "updates") {
                     const updatesChunk = modelRequestSchema.safeParse(chunk);
@@ -517,6 +614,17 @@ export class LangchainAgent {
                                 const subagentConfigs = taskTool?.subagentConfigs;
                                 const subagentConfig = subagentConfigs?.find((config) => config.agentName === agentName);
                                 prettyName = subagentConfig?.displayName ?? agentName;
+                                // Register query hash -> toolCallId mapping for subagent connection info
+                                if ("query" in toolCall.args &&
+                                    typeof toolCall.args.query === "string") {
+                                    const qHash = hashQuery(toolCall.args.query);
+                                    queryToToolCallId.set(qHash, toolCall.id);
+                                    telemetry.log("info", "Registered subagent query hash mapping", {
+                                        queryHash: qHash,
+                                        toolCallId: toolCall.id,
+                                        queryPreview: toolCall.args.query.slice(0, 50),
+                                    });
+                                }
                             }
                             // Check if we already emitted a preliminary notification from early tool_use block
                             const alreadyEmittedPreliminary = preliminaryToolCallIds.has(toolCall.id);
@@ -750,6 +858,16 @@ export class LangchainAgent {
                 else {
                     throw new Error(`Unhandled stream mode: ${streamMode}`);
                 }
+                // Yield any pending subagent connection updates
+                yield* yieldPendingSubagentUpdates();
+            }
+            // Yield any remaining pending subagent connection updates after stream ends
+            yield* yieldPendingSubagentUpdates();
+            // Clean up subagent connection listener
+            subagentEvents.off("connection", onSubagentConnection);
+            // Cancel any pending wait
+            if (subagentUpdateResolver) {
+                subagentUpdateResolver = null;
             }
             // Log successful completion
             telemetry.log("info", "Agent invocation completed", {
@@ -764,6 +882,8 @@ export class LangchainAgent {
             };
         }
         catch (error) {
+            // Clean up subagent connection listener on error
+            subagentEvents.off("connection", onSubagentConnection);
             // Log error and end span with error status
             telemetry.log("error", "Agent invocation failed", {
                 error: error instanceof Error ? error.message : String(error),

package/dist/runner/langchain/tools/subagent-connections.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter } from "node:events";
+/**
+ * Registry for subagent connection info.
+ * Maps query hash to connection info so the runner can emit tool_call_update.
+ */
+export interface SubagentConnectionInfo {
+    port: number;
+    sessionId: string;
+}
+/**
+ * Event emitter for subagent connection events.
+ * The runner listens to these events and emits tool_call_update.
+ */
+export declare const subagentEvents: EventEmitter<[never]>;
+/**
+ * Maps query hash to toolCallId.
+ * Set by the runner when it sees a subagent tool_call.
+ */
+export declare const queryToToolCallId: Map<string, string>;
+/**
+ * Generate a hash from the query string for correlation.
+ */
+export declare function hashQuery(query: string): string;
+/**
+ * Called by the subagent tool when connection is established.
+ * Emits an event that the runner can listen to.
+ */
+export declare function emitSubagentConnection(queryHash: string, connectionInfo: SubagentConnectionInfo): void;

package/dist/runner/langchain/tools/subagent-connections.js

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { createLogger } from "@townco/core";
+const logger = createLogger("subagent-connections");
+/**
+ * Event emitter for subagent connection events.
+ * The runner listens to these events and emits tool_call_update.
+ */
+export const subagentEvents = new EventEmitter();
+/**
+ * Maps query hash to toolCallId.
+ * Set by the runner when it sees a subagent tool_call.
+ */
+export const queryToToolCallId = new Map();
+/**
+ * Generate a hash from the query string for correlation.
+ */
+export function hashQuery(query) {
+    const hash = createHash("sha256").update(query).digest("hex").slice(0, 16);
+    logger.debug("Generated query hash", {
+        queryPreview: query.slice(0, 50),
+        hash,
+    });
+    return hash;
+}
+/**
+ * Called by the subagent tool when connection is established.
+ * Emits an event that the runner can listen to.
+ */
+export function emitSubagentConnection(queryHash, connectionInfo) {
+    logger.info("emitSubagentConnection called", {
+        queryHash,
+        port: connectionInfo.port,
+        sessionId: connectionInfo.sessionId,
+        registeredHashes: Array.from(queryToToolCallId.keys()),
+    });
+    const toolCallId = queryToToolCallId.get(queryHash);
+    if (toolCallId) {
+        logger.info("Found toolCallId for queryHash, emitting connection event", {
+            queryHash,
+            toolCallId,
+            port: connectionInfo.port,
+            sessionId: connectionInfo.sessionId,
+        });
+        subagentEvents.emit("connection", {
+            toolCallId,
+            ...connectionInfo,
+        });
+        // Clean up the mapping
+        queryToToolCallId.delete(queryHash);
+    }
+    else {
+        logger.warn("No toolCallId found for queryHash", {
+            queryHash,
+            registeredHashes: Array.from(queryToToolCallId.keys()),
+        });
+    }
+}

package/dist/runner/langchain/tools/subagent.js

@@ -7,6 +7,7 @@ import { createLogger as coreCreateLogger } from "@townco/core";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY } from "../../../acp-server/adapter.js";
 import { findAvailablePort } from "./port-utils.js";
+import { emitSubagentConnection, hashQuery } from "./subagent-connections.js";
 /**
  * Name of the Task tool created by makeSubagentsTool
  */
@@ -100,7 +101,7 @@ export function makeSubagentsTool(configs) {
         type: "direct",
         name: SUBAGENT_TOOL_NAME,
         prettyName: "Subagent",
-        icon: "BrainCircuit",
+        icon: "CircleDot",
         description: `Launch a new agent to handle complex, multi-step tasks autonomously.
 
 The Task tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
@@ -310,6 +311,9 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
         if (!sessionId) {
             throw new Error("No sessionId in session/new response");
         }
+        // Emit connection info so the GUI can connect directly to this subagent's SSE
+        const queryHash = hashQuery(query);
+        emitSubagentConnection(queryHash, { port, sessionId });
         // Step 3: Connect to SSE for receiving streaming responses
         sseAbortController = new AbortController();
         let responseText = "";