@townco/agent 0.1.20 → 0.1.21

package/dist/acp-server/adapter.js

@@ -1,77 +1,81 @@
 import * as acp from "@agentclientprotocol/sdk";
 /** Adapts an Agent to speak the ACP protocol */
 export class AgentAcpAdapter {
-	connection;
-	sessions;
-	agent;
-	constructor(agent, connection) {
-		this.connection = connection;
-		this.sessions = new Map();
-		this.agent = agent;
-	}
-	async initialize(_params) {
-		return {
-			protocolVersion: acp.PROTOCOL_VERSION,
-			agentCapabilities: {
-				loadSession: false,
-			},
-		};
-	}
-	async newSession(_params) {
-		const sessionId = Math.random().toString(36).substring(2);
-		this.sessions.set(sessionId, {
-			pendingPrompt: null,
-			messages: [],
-		});
-		return {
-			sessionId,
-		};
-	}
-	async authenticate(_params) {
-		// No auth needed - return empty response
-		return {};
-	}
-	async setSessionMode(_params) {
-		// Session mode changes are no-op for us (not related to coding)
-		return {};
-	}
-	async prompt(params) {
-		let session = this.sessions.get(params.sessionId);
-		// If session not found (e.g., after server restart), create a new one
-		if (!session) {
-			console.log(
-				`Session ${params.sessionId} not found, creating new session`,
-			);
-			session = {
-				pendingPrompt: null,
-				messages: [],
-			};
-			this.sessions.set(params.sessionId, session);
-		}
-		session.pendingPrompt?.abort();
-		session.pendingPrompt = new AbortController();
-		try {
-			for await (const msg of this.agent.invoke({
-				prompt: params.prompt,
-				sessionId: params.sessionId,
-			})) {
-				this.connection.sessionUpdate({
-					sessionId: params.sessionId,
-					update: msg,
-				});
-			}
-		} catch (err) {
-			if (session.pendingPrompt.signal.aborted) {
-				return { stopReason: "cancelled" };
-			}
-			throw err;
-		}
-		session.pendingPrompt = null;
-		return {
-			stopReason: "end_turn",
-		};
-	}
-	async cancel(params) {
-		this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
-	}
+    connection;
+    sessions;
+    agent;
+    constructor(agent, connection) {
+        this.connection = connection;
+        this.sessions = new Map();
+        this.agent = agent;
+    }
+    async initialize(_params) {
+        return {
+            protocolVersion: acp.PROTOCOL_VERSION,
+            agentCapabilities: {
+                loadSession: false,
+            },
+        };
+    }
+    async newSession(_params) {
+        const sessionId = Math.random().toString(36).substring(2);
+        this.sessions.set(sessionId, {
+            pendingPrompt: null,
+            messages: [],
+        });
+        return {
+            sessionId,
+        };
+    }
+    async authenticate(_params) {
+        // No auth needed - return empty response
+        return {};
+    }
+    async setSessionMode(_params) {
+        // Session mode changes are no-op for us (not related to coding)
+        return {};
+    }
+    async prompt(params) {
+        let session = this.sessions.get(params.sessionId);
+        // If session not found (e.g., after server restart), create a new one
+        if (!session) {
+            console.log(`Session ${params.sessionId} not found, creating new session`);
+            session = {
+                pendingPrompt: null,
+                messages: [],
+            };
+            this.sessions.set(params.sessionId, session);
+        }
+        session.pendingPrompt?.abort();
+        session.pendingPrompt = new AbortController();
+        // Generate a unique messageId for this assistant response
+        const messageId = Math.random().toString(36).substring(2);
+        try {
+            for await (const msg of this.agent.invoke({
+                prompt: params.prompt,
+                sessionId: params.sessionId,
+                messageId,
+            })) {
+                // 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({
+                    sessionId: params.sessionId,
+                    update: msg,
+                });
+            }
+        }
+        catch (err) {
+            if (session.pendingPrompt.signal.aborted) {
+                return { stopReason: "cancelled" };
+            }
+            throw err;
+        }
+        session.pendingPrompt = null;
+        return {
+            stopReason: "end_turn",
+        };
+    }
+    async cancel(params) {
+        this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
+    }
 }

package/dist/acp-server/http.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { gzipSync } from "node:zlib";
 import * as acp from "@agentclientprotocol/sdk";
 import { PGlite } from "@electric-sql/pglite";
 import { Hono } from "hono";
@@ -8,6 +9,37 @@ import { makeRunnerFromDefinition } from "../runner";
 import { createLogger } from "../utils/logger.js";
 import { AgentAcpAdapter } from "./adapter";
 const logger = createLogger("agent");
+/**
+ * Compress a payload using gzip if it's too large for PostgreSQL NOTIFY
+ * Returns an object with the payload and metadata about compression
+ */
+function compressIfNeeded(rawMsg) {
+    const jsonStr = JSON.stringify(rawMsg);
+    const originalSize = jsonStr.length;
+    // If it fits without compression, send as-is
+    if (originalSize <= 7500) {
+        return {
+            payload: jsonStr,
+            isCompressed: false,
+            originalSize,
+            compressedSize: originalSize,
+        };
+    }
+    // Compress and encode as base64
+    const compressed = gzipSync(jsonStr);
+    const base64 = compressed.toString("base64");
+    // Wrap in a compression envelope
+    const envelope = JSON.stringify({
+        _compressed: true,
+        data: base64,
+    });
+    return {
+        payload: envelope,
+        isCompressed: true,
+        originalSize,
+        compressedSize: envelope.length,
+    };
+}
 // Use PGlite in-memory database for LISTEN/NOTIFY
 const pg = new PGlite();
 // Helper to create safe channel names from untrusted IDs
@@ -22,6 +54,8 @@ export function makeHttpTransport(agent) {
     const agentRunner = "definition" in agent ? agent : makeRunnerFromDefinition(agent);
     new acp.AgentSideConnection((conn) => new AgentAcpAdapter(agentRunner, conn), bridge);
     const app = new Hono();
+    // Track active SSE streams by sessionId for direct output delivery
+    const sseStreams = new Map();
     const decoder = new TextDecoder();
     const encoder = new TextEncoder();
     (async () => {
@@ -63,20 +97,150 @@ export function makeHttpTransport(agent) {
                     rawMsg.id != null) {
                     // This is a response to a request - send to response-specific channel
                     const channel = safeChannelName("response", rawMsg.id);
-                    const payload = JSON.stringify(rawMsg).replace(/'/g, "''");
-                    await pg.query(`NOTIFY ${channel}, '${payload}'`);
+                    const { payload, isCompressed, originalSize, compressedSize } = compressIfNeeded(rawMsg);
+                    if (isCompressed) {
+                        logger.info("Compressed response payload", {
+                            requestId: rawMsg.id,
+                            originalSize,
+                            compressedSize,
+                            compressionRatio: ((1 - compressedSize / originalSize) * 100).toFixed(1) + "%",
+                        });
+                    }
+                    // Escape single quotes for PostgreSQL
+                    const escapedPayload = payload.replace(/'/g, "''");
+                    // Check if even compressed payload is too large
+                    if (compressedSize > 7500) {
+                        logger.error("Response payload too large even after compression", {
+                            requestId: rawMsg.id,
+                            originalSize,
+                            compressedSize,
+                        });
+                        // Send error response
+                        const errorResponse = {
+                            jsonrpc: "2.0",
+                            id: rawMsg.id,
+                            error: {
+                                code: -32603,
+                                message: "Response payload too large even after compression",
+                                data: {
+                                    originalSize,
+                                    compressedSize,
+                                },
+                            },
+                        };
+                        const errorPayload = JSON.stringify(errorResponse).replace(/'/g, "''");
+                        await pg.query(`NOTIFY ${channel}, '${errorPayload}'`);
+                        continue;
+                    }
+                    try {
+                        await pg.query(`NOTIFY ${channel}, '${escapedPayload}'`);
+                    }
+                    catch (error) {
+                        logger.error("Failed to send response", {
+                            error,
+                            requestId: rawMsg.id,
+                            originalSize,
+                            compressedSize,
+                        });
+                        // For responses, we still need to send something to unblock the client
+                        const errorResponse = {
+                            jsonrpc: "2.0",
+                            id: rawMsg.id,
+                            error: {
+                                code: -32603,
+                                message: "Failed to send response",
+                                data: {
+                                    originalSize,
+                                    compressedSize,
+                                    error: error instanceof Error ? error.message : String(error),
+                                },
+                            },
+                        };
+                        const errorPayload = JSON.stringify(errorResponse).replace(/'/g, "''");
+                        await pg.query(`NOTIFY ${channel}, '${errorPayload}'`);
+                    }
                 }
                 else if ("params" in rawMsg &&
                     rawMsg.params != null &&
                     typeof rawMsg.params === "object" &&
                     "sessionId" in rawMsg.params &&
                     typeof rawMsg.params.sessionId === "string") {
-                    // Other messages (notifications, requests from agent) go to
-                    // session-specific channel
                     const sessionId = rawMsg.params.sessionId;
+                    const messageType = "method" in rawMsg && typeof rawMsg.method === "string"
+                        ? rawMsg.method
+                        : undefined;
+                    // Check if this is a tool_output update - send directly via SSE
+                    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_output") {
+                        // Send tool output 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 tool output", {
+                                    sessionId,
+                                    payloadSize: JSON.stringify(rawMsg).length,
+                                });
+                            }
+                            catch (error) {
+                                logger.error("Failed to send tool output", {
+                                    error,
+                                    sessionId,
+                                });
+                            }
+                        }
+                        else {
+                            logger.warn("No SSE stream found for tool output", { sessionId });
+                        }
+                        continue;
+                    }
+                    // Other messages (notifications, requests from agent) go to
+                    // session-specific channel via PostgreSQL NOTIFY
                     const channel = safeChannelName("notifications", sessionId);
-                    const payload = JSON.stringify(rawMsg).replace(/'/g, "''");
-                    await pg.query(`NOTIFY ${channel}, '${payload}'`);
+                    const { payload, isCompressed, originalSize, compressedSize } = compressIfNeeded(rawMsg);
+                    if (isCompressed) {
+                        logger.info("Compressed notification payload", {
+                            sessionId,
+                            messageType,
+                            originalSize,
+                            compressedSize,
+                            compressionRatio: ((1 - compressedSize / originalSize) * 100).toFixed(1) + "%",
+                        });
+                    }
+                    // Escape single quotes for PostgreSQL
+                    const escapedPayload = payload.replace(/'/g, "''");
+                    // Check if even compressed payload is too large
+                    if (compressedSize > 7500) {
+                        logger.error("Notification payload too large even after compression, skipping", {
+                            sessionId,
+                            messageType,
+                            originalSize,
+                            compressedSize,
+                        });
+                        continue;
+                    }
+                    try {
+                        await pg.query(`NOTIFY ${channel}, '${escapedPayload}'`);
+                    }
+                    catch (error) {
+                        logger.error("Failed to send notification", {
+                            error,
+                            sessionId,
+                            messageType,
+                            originalSize,
+                            compressedSize,
+                        });
+                    }
                 }
                 else {
                     logger.warn("Message without sessionId, cannot route", {
@@ -101,6 +265,8 @@ export function makeHttpTransport(agent) {
         }
         logger.debug("GET /events - SSE connection opened", { sessionId });
         return streamSSE(c, async (stream) => {
+            // Register this stream for direct tool output delivery
+            sseStreams.set(sessionId, stream);
             await stream.writeSSE({ event: "ping", data: "{}" });
             const hb = setInterval(() => {
                 // Heartbeat to keep proxies from terminating idle connections
@@ -108,7 +274,31 @@ export function makeHttpTransport(agent) {
             }, 1000);
             const channel = safeChannelName("notifications", sessionId);
             const unsub = await pg.listen(channel, async (payload) => {
-                const json = JSON.parse(payload);
+                let json = JSON.parse(payload);
+                // Check if the message is compressed
+                if (json &&
+                    typeof json === "object" &&
+                    "_compressed" in json &&
+                    json._compressed === true &&
+                    "data" in json &&
+                    typeof json.data === "string") {
+                    // This is a compressed message - decompress it
+                    try {
+                        const { gunzipSync } = await import("node:zlib");
+                        const compressed = Buffer.from(json.data, "base64");
+                        const decompressed = gunzipSync(compressed);
+                        json = JSON.parse(decompressed.toString());
+                        logger.trace("Decompressed SSE message", { sessionId, channel });
+                    }
+                    catch (error) {
+                        logger.error("Failed to decompress message", {
+                            error,
+                            sessionId,
+                            channel,
+                        });
+                        return;
+                    }
+                }
                 logger.trace("Sending SSE message", { sessionId, channel });
                 await stream.writeSSE({
                     event: "message",
@@ -120,6 +310,7 @@ export function makeHttpTransport(agent) {
                 logger.debug("GET /events - SSE connection closed", { sessionId });
                 clearInterval(hb);
                 unsub();
+                sseStreams.delete(sessionId);
             });
             // Keep the connection open indefinitely
             await stream.sleep(1000 * 60 * 60 * 24);
@@ -152,8 +343,41 @@ export function makeHttpTransport(agent) {
             const responsePromise = new Promise((resolve) => {
                 responseResolver = resolve;
             });
-            const unsub = await pg.listen(responseChannel, (payload) => {
-                const rawResponse = JSON.parse(payload);
+            const unsub = await pg.listen(responseChannel, async (payload) => {
+                let rawResponse = JSON.parse(payload);
+                // Check if the response is compressed
+                if (rawResponse &&
+                    typeof rawResponse === "object" &&
+                    "_compressed" in rawResponse &&
+                    rawResponse._compressed === true &&
+                    "data" in rawResponse &&
+                    typeof rawResponse.data === "string") {
+                    // This is a compressed response - decompress it
+                    try {
+                        const { gunzipSync } = await import("node:zlib");
+                        const compressed = Buffer.from(rawResponse.data, "base64");
+                        const decompressed = gunzipSync(compressed);
+                        rawResponse = JSON.parse(decompressed.toString());
+                        logger.trace("Decompressed RPC response", { id });
+                    }
+                    catch (error) {
+                        logger.error("Failed to decompress response", {
+                            error,
+                            requestId: id,
+                        });
+                        rawResponse = {
+                            jsonrpc: "2.0",
+                            id,
+                            error: {
+                                code: -32603,
+                                message: "Failed to decompress response",
+                                data: {
+                                    error: error instanceof Error ? error.message : String(error),
+                                },
+                            },
+                        };
+                    }
+                }
                 responseResolver(rawResponse);
             });
             // Write NDJSON line into the ACP inbound stream
@@ -184,7 +408,6 @@ export function makeHttpTransport(agent) {
             const writer = inbound.writable.getWriter();
             await writer.write(encoder.encode(`${JSON.stringify(body)}\n`));
             writer.releaseLock();
-            logger.debug("POST /rpc - Notification sent", { method });
             return c.json({
                 success: true,
                 message: "Notification sent to agent",

package/dist/index.js

@@ -1,15 +1,9 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { makeHttpTransport, makeStdioTransport } from "./acp-server";
-const exampleAgent = {
-    model: "claude-sonnet-4-5-20250929",
-    systemPrompt: "You are a helpful assistant.",
-    tools: [
-        "todo_write",
-        "get_weather",
-        "web_search",
-        { type: "filesystem", working_directory: "/Users/michael/code/town" },
-    ],
-    mcps: [],
-};
+// Load agent definition from shared JSON file at repo root
+const configPath = join(import.meta.dir, "../../agent.json");
+const exampleAgent = JSON.parse(readFileSync(configPath, "utf-8"));
 // Parse transport type from command line argument
 const transport = process.argv[2] || "stdio";
 if (transport === "http") {

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

@@ -23,9 +23,23 @@ export declare const zAgentRunnerParams: z.ZodObject<{
     }, z.core.$strip>]>>>;
 }, z.core.$strip>;
 export type CreateAgentRunnerParams = z.infer<typeof zAgentRunnerParams>;
-export type InvokeRequest = Omit<PromptRequest, "_meta">;
+export type InvokeRequest = Omit<PromptRequest, "_meta"> & {
+    messageId: string;
+};
+export type ExtendedSessionUpdate = SessionNotification["update"] | {
+    sessionUpdate: "tool_output";
+    toolCallId: string;
+    content?: Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
+    rawOutput?: Record<string, unknown>;
+    _meta?: {
+        messageId?: string;
+    };
+};
 /** Describes an object that can run an agent definition */
 export interface AgentRunner {
     definition: CreateAgentRunnerParams;
-    invoke(req: InvokeRequest): AsyncGenerator<SessionNotification["update"], PromptResponse, undefined>;
+    invoke(req: InvokeRequest): AsyncGenerator<ExtendedSessionUpdate, PromptResponse, undefined>;
 }

package/dist/runner/agent-runner.js

@@ -2,8 +2,8 @@ import { z } from "zod";
 import { McpConfigSchema } from "../definition";
 import { zToolType } from "./tools";
 export const zAgentRunnerParams = z.object({
-	systemPrompt: z.string().nullable(),
-	model: z.string(),
-	tools: z.array(zToolType).optional(),
-	mcps: z.array(McpConfigSchema).optional(),
+    systemPrompt: z.string().nullable(),
+    model: z.string(),
+    tools: z.array(zToolType).optional(),
+    mcps: z.array(McpConfigSchema).optional(),
 });

package/dist/runner/langchain/index.d.ts

@@ -1,7 +1,7 @@
-import type { PromptResponse, SessionNotification } from "@agentclientprotocol/sdk";
+import type { PromptResponse } from "@agentclientprotocol/sdk";
 import { type DynamicStructuredTool, type Tool } from "langchain";
-import type { AgentRunner, CreateAgentRunnerParams, InvokeRequest } from "../agent-runner";
-import type { BuiltInToolType } from "../tools";
+import type { AgentRunner, CreateAgentRunnerParams, ExtendedSessionUpdate, InvokeRequest } from "../agent-runner";
+import type { BuiltInToolType } from "../tools.js";
 type LangchainTool = DynamicStructuredTool | Tool;
 /** Lazily-loaded langchain tools */
 type LazyLangchainTool = MakeLazy<LangchainTool>;
@@ -11,6 +11,6 @@ export declare const TOOL_REGISTRY: Record<BuiltInToolType, LangchainTool | Lazy
 export declare class LangchainAgent implements AgentRunner {
     definition: CreateAgentRunnerParams;
     constructor(params: CreateAgentRunnerParams);
-    invoke(req: InvokeRequest): AsyncGenerator<SessionNotification["update"], PromptResponse, undefined>;
+    invoke(req: InvokeRequest): AsyncGenerator<ExtendedSessionUpdate, PromptResponse, undefined>;
 }
 export {};

package/dist/runner/langchain/index.js

@@ -1,10 +1,12 @@
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
-import { loadCustomToolModule } from "../tool-loader";
-import { makeFilesystemTools } from "./tools/filesystem";
+import { createLogger } from "../../utils/logger.js";
+import { loadCustomToolModule, } from "../tool-loader.js";
+import { makeFilesystemTools } from "./tools/filesystem.js";
 import { todoItemSchema, todoWrite } from "./tools/todo";
 import { makeWebSearchTool } from "./tools/web_search";
+const logger = createLogger("agent-runner");
 const getWeather = tool(({ city }) => `It's always sunny in ${city}!`, {
     name: "get_weather",
     description: "Get the weather for a given city",
@@ -109,14 +111,13 @@ export class LangchainAgent {
             agentConfig.systemPrompt = this.definition.systemPrompt;
         }
         const agent = createAgent(agentConfig);
-        const stream = agent.stream({
-            messages: req.prompt
-                .filter((promptMsg) => promptMsg.type === "text")
-                .map((promptMsg) => ({
-                type: "human",
-                content: promptMsg.text,
-            })),
-        }, {
+        const messages = req.prompt
+            .filter((promptMsg) => promptMsg.type === "text")
+            .map((promptMsg) => ({
+            type: "human",
+            content: promptMsg.text,
+        }));
+        const stream = agent.stream({ messages }, {
             streamMode: ["updates", "messages"],
         });
         for await (const [streamMode, chunk] of await stream) {
@@ -133,6 +134,15 @@ export class LangchainAgent {
                     throw new Error(`Unhandled updates message chunk types: ${JSON.stringify(updatesMessages)}`);
                 }
                 for (const msg of updatesMessages) {
+                    // Extract token usage metadata if available
+                    const tokenUsage = msg.usage_metadata
+                        ? {
+                            inputTokens: msg.usage_metadata.input_tokens,
+                            outputTokens: msg.usage_metadata.output_tokens,
+                            totalTokens: msg.usage_metadata.total_tokens,
+                        }
+                        : undefined;
+                    logger.debug("Token usage:", tokenUsage);
                     for (const toolCall of msg.tool_calls ?? []) {
                         if (toolCall.id == null) {
                             throw new Error(`Tool call is missing id: ${JSON.stringify(toolCall)}`);
@@ -168,11 +178,15 @@ export class LangchainAgent {
                             kind: "other",
                             status: "pending",
                             rawInput: toolCall.args,
+                            ...(tokenUsage ? { tokenUsage } : {}),
+                            _meta: { messageId: req.messageId },
                         };
                         yield {
                             sessionUpdate: "tool_call_update",
                             toolCallId: toolCall.id,
                             status: "in_progress",
+                            ...(tokenUsage ? { tokenUsage } : {}),
+                            _meta: { messageId: req.messageId },
                         };
                     }
                 }
@@ -221,10 +235,17 @@ export class LangchainAgent {
                             // Skip tool_call_update for todo_write tools
                             continue;
                         }
+                        // Send status update (metadata only, no content)
                         yield {
                             sessionUpdate: "tool_call_update",
                             toolCallId: aiMessage.tool_call_id,
                             status: "completed",
+                            _meta: { messageId: req.messageId },
+                        };
+                        // Send tool output separately (via direct SSE, bypassing PostgreSQL NOTIFY)
+                        yield {
+                            sessionUpdate: "tool_output",
+                            toolCallId: aiMessage.tool_call_id,
                             content: [
                                 {
                                     type: "content",
@@ -235,6 +256,7 @@ export class LangchainAgent {
                                 },
                             ],
                             rawOutput: { content: aiMessage.content },
+                            _meta: { messageId: req.messageId },
                         };
                     }
                     else {