@townco/agent 0.1.34 → 0.1.36

package/dist/acp-server/adapter.js

@@ -1,5 +1,5 @@
 import * as acp from "@agentclientprotocol/sdk";
-import { SessionStorage } from "./session-storage.js";
+import { SessionStorage, } from "./session-storage.js";
 /**
  * ACP extension key for subagent mode indicator
  * Following ACP extensibility pattern with namespaced key
@@ -62,20 +62,76 @@ export class AgentAcpAdapter {
             messages: storedSession.messages,
             requestParams: { cwd: process.cwd(), mcpServers: [] },
         });
-        // Replay conversation history to client
+        // Replay conversation history to client with ordered content blocks
         console.log(`[adapter] Replaying ${storedSession.messages.length} messages for session ${params.sessionId}`);
         for (const msg of storedSession.messages) {
-            console.log(`[adapter] Replaying message: ${msg.role} - ${msg.content.substring(0, 50)}...`);
-            this.connection.sessionUpdate({
-                sessionId: params.sessionId,
-                update: {
-                    sessionUpdate: msg.role === "user" ? "user_message_chunk" : "agent_message_chunk",
-                    content: {
-                        type: "text",
-                        text: msg.content,
-                    },
-                },
-            });
+            console.log(`[adapter] Replaying message: ${msg.role} with ${msg.content.length} content blocks`);
+            // Iterate through content blocks in order
+            for (const block of msg.content) {
+                if (block.type === "text") {
+                    // Replay text block
+                    this.connection.sessionUpdate({
+                        sessionId: params.sessionId,
+                        update: {
+                            sessionUpdate: msg.role === "user"
+                                ? "user_message_chunk"
+                                : "agent_message_chunk",
+                            content: {
+                                type: "text",
+                                text: block.text,
+                            },
+                        },
+                    });
+                }
+                else if (block.type === "tool_call") {
+                    // Replay tool call directly in final state (skip pending → completed transitions)
+                    this.connection.sessionUpdate({
+                        sessionId: params.sessionId,
+                        update: {
+                            sessionUpdate: "tool_call",
+                            toolCallId: block.id,
+                            title: block.title,
+                            kind: block.kind,
+                            status: block.status, // Use final status directly
+                            rawInput: block.rawInput,
+                        },
+                    });
+                    // If there's output, emit tool_output event for the UI to display
+                    if (block.rawOutput) {
+                        const outputUpdate = {
+                            sessionUpdate: "tool_output",
+                            toolCallId: block.id,
+                            rawOutput: block.rawOutput,
+                            content: [
+                                {
+                                    type: "content",
+                                    content: {
+                                        type: "text",
+                                        text: typeof block.rawOutput.content === "string"
+                                            ? block.rawOutput.content
+                                            : JSON.stringify(block.rawOutput),
+                                    },
+                                },
+                            ],
+                        };
+                        this.connection.sessionUpdate({
+                            sessionId: params.sessionId,
+                            update: outputUpdate,
+                        });
+                    }
+                    // Also emit tool_call_update with final status for consistency
+                    this.connection.sessionUpdate({
+                        sessionId: params.sessionId,
+                        update: {
+                            sessionUpdate: "tool_call_update",
+                            toolCallId: block.id,
+                            status: block.status,
+                            rawOutput: block.rawOutput,
+                            error: block.error,
+                        },
+                    });
+                }
+            }
         }
         return {};
     }
@@ -104,7 +160,7 @@ export class AgentAcpAdapter {
         // Generate a unique messageId for this assistant response
         const messageId = Math.random().toString(36).substring(2);
         // Extract and store the user message
-        const userMessageContent = params.prompt
+        const userMessageText = params.prompt
             .filter((p) => p.type === "text")
             .map((p) => p.text)
             .join("\n");
@@ -112,13 +168,21 @@ export class AgentAcpAdapter {
         if (!this.noSession) {
             const userMessage = {
                 role: "user",
-                content: userMessageContent,
+                content: [{ type: "text", text: userMessageText }],
                 timestamp: new Date().toISOString(),
             };
             session.messages.push(userMessage);
         }
-        // Accumulate assistant response content
-        let assistantContent = "";
+        // Build ordered content blocks for the assistant response
+        const contentBlocks = [];
+        let pendingText = "";
+        // Helper function to flush pending text as a TextBlock
+        const flushPendingText = () => {
+            if (pendingText.length > 0) {
+                contentBlocks.push({ type: "text", text: pendingText });
+                pendingText = "";
+            }
+        };
         try {
             const invokeParams = {
                 prompt: params.prompt,
@@ -132,7 +196,7 @@ export class AgentAcpAdapter {
                 invokeParams.sessionMeta = session.requestParams._meta;
             }
             for await (const msg of this.agent.invoke(invokeParams)) {
-                // Accumulate assistant content from message chunks
+                // Accumulate text content from message chunks
                 if ("sessionUpdate" in msg &&
                     msg.sessionUpdate === "agent_message_chunk") {
                     if ("content" in msg &&
@@ -140,7 +204,7 @@ export class AgentAcpAdapter {
                         typeof msg.content === "object") {
                         const content = msg.content;
                         if (content.type === "text" && typeof content.text === "string") {
-                            assistantContent += content.text;
+                            pendingText += content.text;
                         }
                     }
                     // Debug: log if this chunk has tokenUsage in _meta
@@ -151,6 +215,62 @@ export class AgentAcpAdapter {
                         console.log("DEBUG adapter: sending agent_message_chunk with tokenUsage in _meta:", JSON.stringify(msg._meta.tokenUsage));
                     }
                 }
+                // Handle tool_call - flush pending text and add ToolCallBlock
+                if ("sessionUpdate" in msg && msg.sessionUpdate === "tool_call") {
+                    flushPendingText();
+                    const toolCallMsg = msg;
+                    const toolCall = {
+                        type: "tool_call",
+                        id: toolCallMsg.toolCallId || `tool_${Date.now()}`,
+                        title: toolCallMsg.title || "Tool",
+                        kind: toolCallMsg.kind || "other",
+                        status: toolCallMsg.status || "pending",
+                        startedAt: Date.now(),
+                    };
+                    // Only add rawInput if it exists
+                    if (toolCallMsg.rawInput) {
+                        toolCall.rawInput = toolCallMsg.rawInput;
+                    }
+                    contentBlocks.push(toolCall);
+                }
+                // Handle tool_call_update - update existing ToolCallBlock
+                if ("sessionUpdate" in msg &&
+                    msg.sessionUpdate === "tool_call_update") {
+                    const updateMsg = msg;
+                    const toolCallBlock = contentBlocks.find((block) => block.type === "tool_call" && block.id === updateMsg.toolCallId);
+                    if (toolCallBlock) {
+                        if (updateMsg.status) {
+                            toolCallBlock.status =
+                                updateMsg.status;
+                        }
+                        if (updateMsg.rawOutput) {
+                            toolCallBlock.rawOutput = updateMsg.rawOutput;
+                        }
+                        if (updateMsg.error) {
+                            toolCallBlock.error = updateMsg.error;
+                        }
+                        if (toolCallBlock.status === "completed" ||
+                            toolCallBlock.status === "failed") {
+                            toolCallBlock.completedAt = Date.now();
+                        }
+                    }
+                }
+                // Handle tool_output - update ToolCallBlock with output content
+                if ("sessionUpdate" in msg && msg.sessionUpdate === "tool_output") {
+                    const outputMsg = msg;
+                    const toolCallBlock = contentBlocks.find((block) => block.type === "tool_call" && block.id === outputMsg.toolCallId);
+                    if (toolCallBlock) {
+                        // Store both rawOutput and output from tool_output
+                        if (outputMsg.rawOutput) {
+                            toolCallBlock.rawOutput = outputMsg.rawOutput;
+                        }
+                        else if (outputMsg.output) {
+                            toolCallBlock.rawOutput = outputMsg.output;
+                        }
+                        // Note: content blocks are handled by the transport for display
+                        // We store the raw output here for session persistence
+                    }
+                }
                 // The agent may emit extended types (like tool_output) that aren't in ACP SDK yet
                 // The http transport will handle routing these appropriately
                 this.connection.sessionUpdate({
@@ -158,6 +278,8 @@ export class AgentAcpAdapter {
                     update: msg,
                 });
             }
+            // Flush any remaining pending text
+            flushPendingText();
         }
         catch (err) {
             if (session.pendingPrompt.signal.aborted) {
@@ -167,10 +289,10 @@ export class AgentAcpAdapter {
         }
         // Store the complete assistant response in session messages
         // Only store if session persistence is enabled
-        if (!this.noSession && assistantContent.length > 0) {
+        if (!this.noSession && contentBlocks.length > 0) {
             const assistantMessage = {
                 role: "assistant",
-                content: assistantContent,
+                content: contentBlocks,
                 timestamp: new Date().toISOString(),
             };
             session.messages.push(assistantMessage);

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

@@ -1,9 +1,29 @@
+/**
+ * Content block types for messages
+ */
+export interface TextBlock {
+    type: "text";
+    text: string;
+}
+export interface ToolCallBlock {
+    type: "tool_call";
+    id: string;
+    title: string;
+    kind: "read" | "edit" | "delete" | "move" | "search" | "execute" | "think" | "fetch" | "switch_mode" | "other";
+    status: "pending" | "in_progress" | "completed" | "failed";
+    rawInput?: Record<string, unknown> | undefined;
+    rawOutput?: Record<string, unknown> | undefined;
+    error?: string | undefined;
+    startedAt?: number | undefined;
+    completedAt?: number | undefined;
+}
+export type ContentBlock = TextBlock | ToolCallBlock;
 /**
  * Session message format stored in files
  */
 export interface SessionMessage {
     role: "user" | "assistant";
-    content: string;
+    content: ContentBlock[];
     timestamp: string;
 }
 /**

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

@@ -4,9 +4,40 @@ import { z } from "zod";
 /**
  * Zod schema for validating session files
  */
+const textBlockSchema = z.object({
+    type: z.literal("text"),
+    text: z.string(),
+});
+const toolCallBlockSchema = z.object({
+    type: z.literal("tool_call"),
+    id: z.string(),
+    title: z.string(),
+    kind: z.enum([
+        "read",
+        "edit",
+        "delete",
+        "move",
+        "search",
+        "execute",
+        "think",
+        "fetch",
+        "switch_mode",
+        "other",
+    ]),
+    status: z.enum(["pending", "in_progress", "completed", "failed"]),
+    rawInput: z.record(z.string(), z.unknown()).optional(),
+    rawOutput: z.record(z.string(), z.unknown()).optional(),
+    error: z.string().optional(),
+    startedAt: z.number().optional(),
+    completedAt: z.number().optional(),
+});
+const contentBlockSchema = z.discriminatedUnion("type", [
+    textBlockSchema,
+    toolCallBlockSchema,
+]);
 const sessionMessageSchema = z.object({
     role: z.enum(["user", "assistant"]),
-    content: z.string(),
+    content: z.array(contentBlockSchema),
     timestamp: z.string(),
 });
 const sessionMetadataSchema = z.object({

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

@@ -1,5 +1,6 @@
 import type { PromptRequest, PromptResponse, SessionNotification } from "@agentclientprotocol/sdk";
 import { z } from "zod";
+import type { ContentBlock } from "../acp-server/session-storage.js";
 export declare const zAgentRunnerParams: z.ZodObject<{
     systemPrompt: z.ZodNullable<z.ZodString>;
     model: z.ZodString;
@@ -31,7 +32,7 @@ export declare const zAgentRunnerParams: z.ZodObject<{
 export type CreateAgentRunnerParams = z.infer<typeof zAgentRunnerParams>;
 export interface SessionMessage {
     role: "user" | "assistant";
-    content: string;
+    content: ContentBlock[];
     timestamp: string;
 }
 export type InvokeRequest = Omit<PromptRequest, "_meta"> & {

package/dist/runner/langchain/index.js

@@ -145,7 +145,11 @@ export class LangchainAgent {
             const historyMessages = req.sessionMessages.slice(0, -1);
             messages = historyMessages.map((msg) => ({
                 type: msg.role === "user" ? "human" : "ai",
-                content: msg.content,
+                // Extract text from content blocks (ignore tool call blocks for LLM context)
+                content: msg.content
+                    .filter((block) => block.type === "text")
+                    .map((block) => block.text)
+                    .join(""),
             }));
             // Add the current prompt as the final human message
             const currentPromptText = req.prompt
@@ -301,7 +305,6 @@ export class LangchainAgent {
                                     text: aiMessage.content,
                                 },
                             };
-                        console.log("DEBUG agent: yielding message (string content):", JSON.stringify(msgToYield));
                         yield msgToYield;
                     }
                     else if (Array.isArray(aiMessage.content)) {
@@ -325,7 +328,6 @@ export class LangchainAgent {
                                             text: part.text,
                                         },
                                     };
-                                console.log("DEBUG agent: yielding message (array content):", JSON.stringify(msgToYield));
                                 yield msgToYield;
                             }
                             else if (part.type === "tool_use") {