@townco/agent 0.1.71 → 0.1.73

package/dist/acp-server/adapter.js

@@ -361,8 +361,27 @@ export class AgentAcpAdapter {
                         ...(block.icon ? { icon: block.icon } : {}),
                         ...(block.subline ? { subline: block.subline } : {}),
                         ...(block.batchId ? { batchId: block.batchId } : {}),
+                        // Include subagent data for replay - full content is sent via direct SSE
+                        // bypassing PostgreSQL NOTIFY size limits
+                        ...(block.subagentPort ? { subagentPort: block.subagentPort } : {}),
+                        ...(block.subagentSessionId
+                            ? { subagentSessionId: block.subagentSessionId }
+                            : {}),
+                        ...(block.subagentMessages
+                            ? { subagentMessages: block.subagentMessages }
+                            : {}),
                         ...block._meta,
                     };
+                    // Debug: log subagent data being replayed
+                    logger.info("Replaying tool_call", {
+                        toolCallId: block.id,
+                        title: block.title,
+                        batchId: block.batchId,
+                        hasSubagentPort: !!block.subagentPort,
+                        hasSubagentSessionId: !!block.subagentSessionId,
+                        hasSubagentMessages: !!block.subagentMessages,
+                        subagentMessagesCount: block.subagentMessages?.length,
+                    });
                     this.connection.sessionUpdate({
                         sessionId: params.sessionId,
                         update: {
@@ -783,6 +802,41 @@ export class AgentAcpAdapter {
                             toolCallBlock.status === "failed") {
                             toolCallBlock.completedAt = Date.now();
                         }
+                        const meta = updateMsg._meta;
+                        // Update batchId from _meta (comes from tool_call_update after preliminary tool_call)
+                        if (meta?.batchId && !toolCallBlock.batchId) {
+                            toolCallBlock.batchId = meta.batchId;
+                        }
+                        if (meta?.subagentPort) {
+                            toolCallBlock.subagentPort = meta.subagentPort;
+                        }
+                        if (meta?.subagentSessionId) {
+                            toolCallBlock.subagentSessionId = meta.subagentSessionId;
+                        }
+                        if (meta?.subagentMessages) {
+                            logger.info("Storing subagent messages for session replay", {
+                                toolCallId: updateMsg.toolCallId,
+                                messageCount: meta.subagentMessages.length,
+                            });
+                            toolCallBlock.subagentMessages = meta.subagentMessages;
+                        }
+                    }
+                    // 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,
+                            },
+                        });
                     }
                     // Forward tool_call_update with _meta to the client (for subagent connection info, etc.)
                     if (updateMsg._meta) {

package/dist/acp-server/http.js

@@ -227,6 +227,48 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                         }
                         continue;
                     }
+                    // Check if this is a tool_call with subagentMessages - send directly via SSE
+                    // to bypass PostgreSQL NOTIFY size limits (7500 bytes)
+                    if (messageType === "session/update" &&
+                        "params" in rawMsg &&
+                        rawMsg.params != null &&
+                        typeof rawMsg.params === "object" &&
+                        "update" in rawMsg.params &&
+                        rawMsg.params.update != null &&
+                        typeof rawMsg.params.update === "object" &&
+                        "sessionUpdate" in rawMsg.params.update &&
+                        rawMsg.params.update.sessionUpdate === "tool_call" &&
+                        "_meta" in rawMsg.params.update &&
+                        rawMsg.params.update._meta != null &&
+                        typeof rawMsg.params.update._meta === "object" &&
+                        "subagentMessages" in rawMsg.params.update._meta) {
+                        // Send subagent tool call directly via SSE, bypassing PostgreSQL NOTIFY
+                        const stream = sseStreams.get(sessionId);
+                        if (stream) {
+                            try {
+                                await stream.writeSSE({
+                                    event: "message",
+                                    data: JSON.stringify(rawMsg),
+                                });
+                                logger.debug("Sent subagent tool call directly via SSE", {
+                                    sessionId,
+                                    payloadSize: JSON.stringify(rawMsg).length,
+                                });
+                            }
+                            catch (error) {
+                                logger.error("Failed to send subagent tool call", {
+                                    error,
+                                    sessionId,
+                                });
+                            }
+                        }
+                        else {
+                            logger.warn("No SSE stream found for subagent tool call", {
+                                sessionId,
+                            });
+                        }
+                        continue;
+                    }
                     // Other messages (notifications, requests from agent) go to
                     // session-specific channel via PostgreSQL NOTIFY
                     const channel = safeChannelName("notifications", sessionId);
@@ -553,7 +595,6 @@ export function makeHttpTransport(agent, agentDir, agentName) {
     logger.info("Starting HTTP server", { port });
     Bun.serve({
         fetch: app.fetch,
-        hostname: Bun.env.BIND_HOST || "localhost",
         port,
     });
     logger.info("HTTP server listening", {

package/dist/acp-server/session-storage.d.ts

@@ -16,6 +16,40 @@ export interface ImageBlock {
     data?: string | undefined;
     mimeType?: string | undefined;
 }
+/**
+ * Sub-agent tool call stored within a parent tool call's subagentMessages
+ */
+export interface SubagentToolCallBlock {
+    id: string;
+    title: string;
+    prettyName?: string | undefined;
+    icon?: string | undefined;
+    status: "pending" | "in_progress" | "completed" | "failed";
+}
+/**
+ * Content block for sub-agent messages - either text or a tool call
+ */
+export interface SubagentTextBlock {
+    type: "text";
+    text: string;
+}
+export interface SubagentToolCallContentBlock {
+    type: "tool_call";
+    toolCall: SubagentToolCallBlock;
+}
+export type SubagentContentBlock = SubagentTextBlock | SubagentToolCallContentBlock;
+/**
+ * Sub-agent message stored for replay
+ */
+export interface SubagentMessage {
+    id: string;
+    /** Accumulated text content (thinking) */
+    content: string;
+    /** Interleaved content blocks in arrival order */
+    contentBlocks?: SubagentContentBlock[] | undefined;
+    /** Tool calls made by the sub-agent */
+    toolCalls?: SubagentToolCallBlock[] | undefined;
+}
 export interface ToolCallBlock {
     type: "tool_call";
     id: string;
@@ -37,6 +71,12 @@ export interface ToolCallBlock {
         originalTokens?: number;
         finalTokens?: number;
     };
+    /** Sub-agent HTTP port (for reference, not used in replay) */
+    subagentPort?: number | undefined;
+    /** Sub-agent session ID (for reference, not used in replay) */
+    subagentSessionId?: string | undefined;
+    /** Stored sub-agent messages for replay */
+    subagentMessages?: SubagentMessage[] | undefined;
 }
 export type ContentBlock = TextBlock | ImageBlock | ToolCallBlock;
 /**

package/dist/acp-server/session-storage.js

@@ -26,6 +26,29 @@ const imageBlockSchema = z.object({
     data: z.string().optional(),
     mimeType: z.string().optional(),
 });
+const subagentToolCallBlockSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    prettyName: z.string().optional(),
+    icon: z.string().optional(),
+    status: z.enum(["pending", "in_progress", "completed", "failed"]),
+});
+const subagentContentBlockSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    }),
+    z.object({
+        type: z.literal("tool_call"),
+        toolCall: subagentToolCallBlockSchema,
+    }),
+]);
+const subagentMessageSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    contentBlocks: z.array(subagentContentBlockSchema).optional(),
+    toolCalls: z.array(subagentToolCallBlockSchema).optional(),
+});
 const toolCallBlockSchema = z.object({
     type: z.literal("tool_call"),
     id: z.string(),
@@ -52,6 +75,9 @@ const toolCallBlockSchema = z.object({
     error: z.string().optional(),
     startedAt: z.number().optional(),
     completedAt: z.number().optional(),
+    subagentPort: z.number().optional(),
+    subagentSessionId: z.string().optional(),
+    subagentMessages: z.array(subagentMessageSchema).optional(),
 });
 const contentBlockSchema = z.discriminatedUnion("type", [
     textBlockSchema,

package/dist/runner/langchain/index.js

@@ -102,6 +102,7 @@ export class LangchainAgent {
         });
         const subagentUpdateQueue = [];
         let subagentUpdateResolver = null;
+        const subagentMessagesQueue = [];
         // Listen for subagent connection events - resolve any waiting promise immediately
         const onSubagentConnection = (event) => {
             _logger.info("Received subagent connection event", {
@@ -121,6 +122,15 @@ export class LangchainAgent {
             }
         };
         subagentEvents.on("connection", onSubagentConnection);
+        // Listen for subagent messages events (for session storage)
+        const onSubagentMessages = (event) => {
+            _logger.info("Received subagent messages event", {
+                toolCallId: event.toolCallId,
+                messageCount: event.messages.length,
+            });
+            subagentMessagesQueue.push(event);
+        };
+        subagentEvents.on("messages", onSubagentMessages);
         // Helper to get next subagent update (returns immediately if queued, otherwise waits)
         const waitForSubagentUpdate = () => {
             if (subagentUpdateQueue.length > 0) {
@@ -149,6 +159,22 @@ export class LangchainAgent {
                     },
                 };
             }
+            // Also yield any pending messages updates
+            while (subagentMessagesQueue.length > 0) {
+                const messagesUpdate = subagentMessagesQueue.shift();
+                _logger.info("Yielding queued subagent messages update", {
+                    toolCallId: messagesUpdate.toolCallId,
+                    messageCount: messagesUpdate.messages.length,
+                });
+                yield {
+                    sessionUpdate: "tool_call_update",
+                    toolCallId: messagesUpdate.toolCallId,
+                    _meta: {
+                        messageId: req.messageId,
+                        subagentMessages: messagesUpdate.messages,
+                    },
+                };
+            }
         }
         // Start telemetry span for entire invocation
         const invocationSpan = telemetry.startSpan("agent.invoke", {
@@ -888,8 +914,9 @@ export class LangchainAgent {
             yield* yieldPendingSubagentUpdates();
             // Now that content streaming is complete, yield all buffered tool call notifications
             yield* flushPendingToolCalls();
-            // Clean up subagent connection listener
+            // Clean up subagent event listeners
             subagentEvents.off("connection", onSubagentConnection);
+            subagentEvents.off("messages", onSubagentMessages);
             // Cancel any pending wait
             if (subagentUpdateResolver) {
                 subagentUpdateResolver = null;
@@ -907,8 +934,9 @@ export class LangchainAgent {
             };
         }
         catch (error) {
-            // Clean up subagent connection listener on error
+            // Clean up subagent event listeners on error
             subagentEvents.off("connection", onSubagentConnection);
+            subagentEvents.off("messages", onSubagentMessages);
             // 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

@@ -7,6 +7,35 @@ export interface SubagentConnectionInfo {
     port: number;
     sessionId: string;
 }
+/**
+ * Sub-agent tool call tracked during streaming
+ */
+export interface SubagentToolCall {
+    id: string;
+    title: string;
+    prettyName?: string | undefined;
+    icon?: string | undefined;
+    status: "pending" | "in_progress" | "completed" | "failed";
+}
+/**
+ * Content block for sub-agent messages
+ */
+export type SubagentContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_call";
+    toolCall: SubagentToolCall;
+};
+/**
+ * Sub-agent message accumulated during streaming
+ */
+export interface SubagentMessage {
+    id: string;
+    content: string;
+    contentBlocks: SubagentContentBlock[];
+    toolCalls: SubagentToolCall[];
+}
 /**
  * Event emitter for subagent connection events.
  * The runner listens to these events and emits tool_call_update.
@@ -26,3 +55,8 @@ export declare function hashQuery(query: string): string;
  * Emits an event that the runner can listen to.
  */
 export declare function emitSubagentConnection(queryHash: string, connectionInfo: SubagentConnectionInfo): void;
+/**
+ * Called by the subagent tool when it completes with accumulated messages.
+ * Emits an event with the messages for session storage.
+ */
+export declare function emitSubagentMessages(queryHash: string, messages: SubagentMessage[]): void;

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

@@ -12,6 +12,11 @@ export const subagentEvents = new EventEmitter();
  * Set by the runner when it sees a subagent tool_call.
  */
 export const queryToToolCallId = new Map();
+/**
+ * Maps query hash to resolved toolCallId (preserved after connection event).
+ * Used to correlate messages when the tool completes.
+ */
+const queryToResolvedToolCallId = new Map();
 /**
  * Generate a hash from the query string for correlation.
  */
@@ -46,7 +51,8 @@ export function emitSubagentConnection(queryHash, connectionInfo) {
             toolCallId,
             ...connectionInfo,
         });
-        // Clean up the mapping
+        // Preserve the toolCallId for message emission, but remove from pending lookup
+        queryToResolvedToolCallId.set(queryHash, toolCallId);
         queryToToolCallId.delete(queryHash);
     }
     else {
@@ -56,3 +62,28 @@ export function emitSubagentConnection(queryHash, connectionInfo) {
         });
     }
 }
+/**
+ * Called by the subagent tool when it completes with accumulated messages.
+ * Emits an event with the messages for session storage.
+ */
+export function emitSubagentMessages(queryHash, messages) {
+    const toolCallId = queryToResolvedToolCallId.get(queryHash);
+    if (toolCallId) {
+        logger.info("Emitting subagent messages for storage", {
+            queryHash,
+            toolCallId,
+            messageCount: messages.length,
+        });
+        subagentEvents.emit("messages", {
+            toolCallId,
+            messages,
+        });
+        // Clean up the resolved mapping
+        queryToResolvedToolCallId.delete(queryHash);
+    }
+    else {
+        logger.warn("No resolved toolCallId for messages emission", {
+            queryHash,
+        });
+    }
+}

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

@@ -7,7 +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";
+import { emitSubagentConnection, emitSubagentMessages, hashQuery, } from "./subagent-connections.js";
 /**
  * Name of the Task tool created by makeSubagentsTool
  */
@@ -317,6 +317,15 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
         // Step 3: Connect to SSE for receiving streaming responses
         sseAbortController = new AbortController();
         let responseText = "";
+        // Track full message structure for session storage
+        const currentMessage = {
+            id: `subagent-${Date.now()}`,
+            content: "",
+            contentBlocks: [],
+            toolCalls: [],
+        };
+        // Map of tool call IDs to their indices in toolCalls array
+        const toolCallMap = new Map();
         const ssePromise = (async () => {
             const sseResponse = await fetch(`${baseUrl}/events`, {
                 headers: { "X-Session-ID": sessionId },
@@ -342,18 +351,63 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
                             continue;
                         try {
                             const message = JSON.parse(data);
-                            // Handle session/update notifications for agent_message_chunk
-                            if (message.method === "session/update" &&
-                                message.params?.update?.sessionUpdate === "agent_message_chunk") {
-                                const content = message.params.update.content;
+                            const update = message.params?.update;
+                            if (message.method !== "session/update" || !update)
+                                continue;
+                            // Handle agent_message_chunk - accumulate text
+                            if (update.sessionUpdate === "agent_message_chunk") {
+                                const content = update.content;
                                 if (content?.type === "text" &&
                                     typeof content.text === "string") {
                                     responseText += content.text;
+                                    currentMessage.content += content.text;
+                                    // Add to contentBlocks - append to last text block or create new one
+                                    const lastBlock = currentMessage.contentBlocks[currentMessage.contentBlocks.length - 1];
+                                    if (lastBlock && lastBlock.type === "text") {
+                                        lastBlock.text += content.text;
+                                    }
+                                    else {
+                                        currentMessage.contentBlocks.push({
+                                            type: "text",
+                                            text: content.text,
+                                        });
+                                    }
                                 }
                             }
-                            // Reset on tool_call (marks new message boundary)
-                            if (message.params?.update?.sessionUpdate === "tool_call") {
-                                responseText = "";
+                            // Handle tool_call - track new tool calls
+                            if (update.sessionUpdate === "tool_call" && update.toolCallId) {
+                                const toolCall = {
+                                    id: update.toolCallId,
+                                    title: update.title || "Tool call",
+                                    prettyName: update._meta?.prettyName,
+                                    icon: update._meta?.icon,
+                                    status: update.status || "pending",
+                                };
+                                currentMessage.toolCalls.push(toolCall);
+                                toolCallMap.set(update.toolCallId, currentMessage.toolCalls.length - 1);
+                                // Add to contentBlocks for interleaved display
+                                currentMessage.contentBlocks.push({
+                                    type: "tool_call",
+                                    toolCall,
+                                });
+                            }
+                            // Handle tool_call_update - update existing tool call status
+                            if (update.sessionUpdate === "tool_call_update" &&
+                                update.toolCallId) {
+                                const idx = toolCallMap.get(update.toolCallId);
+                                if (idx !== undefined && currentMessage.toolCalls[idx]) {
+                                    if (update.status) {
+                                        currentMessage.toolCalls[idx].status =
+                                            update.status;
+                                    }
+                                    // Also update in contentBlocks
+                                    const block = currentMessage.contentBlocks.find((b) => b.type === "tool_call" &&
+                                        b.toolCall.id === update.toolCallId);
+                                    if (block && update.status) {
+                                        block.toolCall.status =
+                                            update.status;
+                                    }
+                                }
                             }
                         }
                         catch {
@@ -404,6 +458,10 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query)
             ssePromise.catch(() => { }), // Ignore abort errors
             new Promise((r) => setTimeout(r, 1000)),
         ]);
+        // Emit accumulated messages for session storage
+        if (currentMessage.content || currentMessage.toolCalls.length > 0) {
+            emitSubagentMessages(queryHash, [currentMessage]);
+        }
         return responseText;
     }
     finally {