@townco/agent 0.1.78 → 0.1.79

package/dist/acp-server/http.js

@@ -65,16 +65,235 @@ export function makeHttpTransport(agent, agentDir, agentName) {
             isSubagent: isSubagent(),
         });
     }
-    const inbound = new TransformStream();
-    const outbound = new TransformStream();
-    const bridge = acp.ndJsonStream(outbound.writable, inbound.readable);
     const agentRunner = "definition" in agent ? agent : makeRunnerFromDefinition(agent);
-    // Store adapter reference so we can call methods on it (e.g., storeInitialMessage)
+    const sessionAcpMap = new Map();
+    // Create or get session-specific ACP infrastructure
+    function getOrCreateSessionAcp(sessionId) {
+        let sessionAcp = sessionAcpMap.get(sessionId);
+        if (!sessionAcp) {
+            const inbound = new TransformStream();
+            const outbound = new TransformStream();
+            const bridge = acp.ndJsonStream(outbound.writable, inbound.readable);
+            const encoder = new TextEncoder();
+            let adapter = null;
+            new acp.AgentSideConnection((conn) => {
+                adapter = new AgentAcpAdapter(agentRunner, conn, agentDir, agentName);
+                return adapter;
+            }, bridge);
+            // Start processing outbound messages for this session
+            const decoder = new TextDecoder();
+            (async () => {
+                const reader = outbound.readable.getReader();
+                let buf = "";
+                for (;;) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    buf += decoder.decode(value, { stream: true });
+                    for (let nl = buf.indexOf("\n"); nl !== -1; nl = buf.indexOf("\n")) {
+                        const line = buf.slice(0, nl).trim();
+                        buf = buf.slice(nl + 1);
+                        if (!line)
+                            continue;
+                        let rawMsg;
+                        try {
+                            rawMsg = JSON.parse(line);
+                        }
+                        catch {
+                            continue;
+                        }
+                        const parseResult = acp.agentOutgoingMessageSchema.safeParse(rawMsg);
+                        if (!parseResult.success) {
+                            logger.error("Invalid agent message", {
+                                issues: parseResult.error.issues,
+                            });
+                            continue;
+                        }
+                        if (rawMsg == null || typeof rawMsg !== "object") {
+                            logger.warn("Malformed message, cannot route", {
+                                message: rawMsg,
+                            });
+                            continue;
+                        }
+                        // Route response to correct channel
+                        if ("id" in rawMsg &&
+                            typeof rawMsg.id === "string" &&
+                            rawMsg.id != null) {
+                            const channel = safeChannelName("response", rawMsg.id);
+                            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)}%`,
+                                });
+                            }
+                            const escapedPayload = payload.replace(/'/g, "''");
+                            if (compressedSize > 7500) {
+                                logger.error("Response payload too large even after compression", {
+                                    requestId: rawMsg.id,
+                                    originalSize,
+                                    compressedSize,
+                                });
+                                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,
+                                });
+                                const errorResponse = {
+                                    jsonrpc: "2.0",
+                                    id: rawMsg.id,
+                                    error: {
+                                        code: -32603,
+                                        message: "Failed to send response",
+                                        data: {
+                                            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") {
+                            const msgSessionId = rawMsg.params.sessionId;
+                            const messageType = "method" in rawMsg && typeof rawMsg.method === "string"
+                                ? rawMsg.method
+                                : undefined;
+                            // Handle tool_output - 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") {
+                                const stream = sseStreams.get(msgSessionId);
+                                if (stream) {
+                                    try {
+                                        await stream.writeSSE({
+                                            event: "message",
+                                            data: JSON.stringify(rawMsg),
+                                        });
+                                    }
+                                    catch (error) {
+                                        logger.error("Failed to send tool output", {
+                                            error,
+                                            sessionId: msgSessionId,
+                                        });
+                                    }
+                                }
+                                continue;
+                            }
+                            // Handle subagent tool calls - 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_call" &&
+                                "_meta" in rawMsg.params.update &&
+                                rawMsg.params.update._meta != null &&
+                                typeof rawMsg.params.update._meta === "object" &&
+                                "subagentMessages" in rawMsg.params.update._meta) {
+                                const stream = sseStreams.get(msgSessionId);
+                                if (stream) {
+                                    try {
+                                        await stream.writeSSE({
+                                            event: "message",
+                                            data: JSON.stringify(rawMsg),
+                                        });
+                                    }
+                                    catch (error) {
+                                        logger.error("Failed to send subagent tool call", {
+                                            error,
+                                            sessionId: msgSessionId,
+                                        });
+                                    }
+                                }
+                                continue;
+                            }
+                            // Regular session update - send via PubSub
+                            const channel = safeChannelName("notifications", msgSessionId);
+                            const { payload, isCompressed, originalSize, compressedSize } = compressIfNeeded(rawMsg);
+                            if (compressedSize <= 7500) {
+                                const escapedPayload = payload.replace(/'/g, "''");
+                                try {
+                                    await pg.query(`NOTIFY ${channel}, '${escapedPayload}'`);
+                                }
+                                catch (error) {
+                                    logger.error("Failed to notify session channel", {
+                                        error,
+                                        sessionId: msgSessionId,
+                                    });
+                                }
+                            }
+                            else {
+                                const stream = sseStreams.get(msgSessionId);
+                                if (stream) {
+                                    try {
+                                        await stream.writeSSE({
+                                            event: "message",
+                                            data: JSON.stringify(rawMsg),
+                                        });
+                                    }
+                                    catch (error) {
+                                        logger.error("Failed to send large message via SSE", {
+                                            error,
+                                            sessionId: msgSessionId,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            })();
+            if (!adapter) {
+                throw new Error("Failed to create ACP adapter for session");
+            }
+            sessionAcp = { inbound, outbound, adapter, encoder };
+            sessionAcpMap.set(sessionId, sessionAcp);
+            logger.debug("Created new session ACP infrastructure", { sessionId });
+        }
+        return sessionAcp;
+    }
+    // Legacy global adapter for backwards compatibility with initialize/etc
+    // These don't need session isolation
+    const globalInbound = new TransformStream();
+    const globalOutbound = new TransformStream();
+    const globalBridge = acp.ndJsonStream(globalOutbound.writable, globalInbound.readable);
     let acpAdapter = null;
     new acp.AgentSideConnection((conn) => {
         acpAdapter = new AgentAcpAdapter(agentRunner, conn, agentDir, agentName);
         return acpAdapter;
-    }, bridge);
+    }, globalBridge);
     const app = new Hono();
     // Track active SSE streams by sessionId for direct output delivery
     const sseStreams = new Map();
@@ -82,16 +301,19 @@ export function makeHttpTransport(agent, agentDir, agentName) {
     const initialMessageSentSessions = new Set();
     // Get initial message config from agent definition
     const initialMessageConfig = agentRunner.definition.initialMessage;
-    const decoder = new TextDecoder();
+    // Global encoder for non-session-specific operations
     const encoder = new TextEncoder();
+    // Start processing outbound messages from the global adapter
+    // This handles non-session-specific operations like initialize
+    const globalDecoder = new TextDecoder();
     (async () => {
-        const reader = outbound.readable.getReader();
+        const reader = globalOutbound.readable.getReader();
         let buf = "";
         for (;;) {
             const { value, done } = await reader.read();
             if (done)
                 break;
-            buf += decoder.decode(value, { stream: true });
+            buf += globalDecoder.decode(value, { stream: true });
             for (let nl = buf.indexOf("\n"); nl !== -1; nl = buf.indexOf("\n")) {
                 const line = buf.slice(0, nl).trim();
                 buf = buf.slice(nl + 1);
@@ -102,39 +324,36 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                     rawMsg = JSON.parse(line);
                 }
                 catch {
-                    // ignore malformed lines
                     continue;
                 }
-                // Validate the agent message with Zod schema
                 const parseResult = acp.agentOutgoingMessageSchema.safeParse(rawMsg);
                 if (!parseResult.success) {
-                    logger.error("Invalid agent message", {
+                    logger.error("Invalid agent message from global adapter", {
                         issues: parseResult.error.issues,
                     });
                     continue;
                 }
-                //const msg = parseResult.data;
                 if (rawMsg == null || typeof rawMsg !== "object") {
-                    logger.warn("Malformed message, cannot route", { message: rawMsg });
+                    logger.warn("Malformed global message, cannot route", {
+                        message: rawMsg,
+                    });
                     continue;
                 }
+                // Route response to correct channel
                 if ("id" in rawMsg &&
                     typeof rawMsg.id === "string" &&
                     rawMsg.id != null) {
-                    // This is a response to a request - send to response-specific channel
                     const channel = safeChannelName("response", rawMsg.id);
                     const { payload, isCompressed, originalSize, compressedSize } = compressIfNeeded(rawMsg);
                     if (isCompressed) {
-                        logger.info("Compressed response payload", {
+                        logger.info("Compressed global 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.info("Response payload too large for NOTIFY, using direct storage", {
                             requestId: rawMsg.id,
@@ -157,13 +376,10 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                         await pg.query(`NOTIFY ${channel}, '${escapedPayload}'`);
                     }
                     catch (error) {
-                        logger.error("Failed to send response", {
+                        logger.error("Failed to send global 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,
@@ -171,8 +387,6 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                                 code: -32603,
                                 message: "Failed to send response",
                                 data: {
-                                    originalSize,
-                                    compressedSize,
                                     error: error instanceof Error ? error.message : String(error),
                                 },
                             },
@@ -181,135 +395,6 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                         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") {
-                    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;
-                    }
-                    // 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);
-                    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", {
-                        message: rawMsg,
-                    });
-                }
             }
         }
     })();
@@ -342,6 +427,34 @@ export function makeHttpTransport(agent, agentDir, agentName) {
             }, 500);
         }
     });
+    // Get full session data by ID
+    app.get("/sessions/:sessionId", async (c) => {
+        if (!agentDir || !agentName) {
+            return c.json({ error: "Session storage not configured" }, 500);
+        }
+        const noSession = process.env.TOWN_NO_SESSION === "true";
+        if (noSession) {
+            return c.json({ error: "Sessions disabled" }, 500);
+        }
+        const sessionId = c.req.param("sessionId");
+        if (!sessionId) {
+            return c.json({ error: "Session ID required" }, 400);
+        }
+        try {
+            const storage = new SessionStorage(agentDir, agentName);
+            const session = await storage.loadSession(sessionId);
+            if (!session) {
+                return c.json({ error: "Session not found" }, 404);
+            }
+            return c.json(session);
+        }
+        catch (error) {
+            logger.error("Failed to load session", { error, sessionId });
+            return c.json({
+                error: error instanceof Error ? error.message : String(error),
+            }, 500);
+        }
+    });
     // Serve static files from agent directory (for generated images, etc.)
     if (agentDir) {
         app.get("/static/*", async (c) => {
@@ -511,6 +624,56 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                 params: "params" in body ? body.params : "NO PARAMS",
             });
         }
+        // Determine which stream to use based on method
+        // Session-specific methods go to per-session streams to avoid interference
+        const sessionMethods = [
+            "session/new",
+            "session/prompt",
+            "session/load",
+            "session/stop",
+        ];
+        const isSessionMethod = sessionMethods.includes(method);
+        // Extract sessionId from params for existing session operations
+        let sessionId = null;
+        if (isSessionMethod &&
+            method !== "session/new" &&
+            "params" in body &&
+            body.params != null &&
+            typeof body.params === "object" &&
+            "sessionId" in body.params &&
+            typeof body.params.sessionId === "string") {
+            sessionId = body.params.sessionId;
+        }
+        // For session/new, generate sessionId upfront so we can create the session ACP
+        if (method === "session/new") {
+            sessionId = crypto.randomUUID();
+            // Inject the sessionId into the request if not already present
+            if ("params" in body &&
+                body.params != null &&
+                typeof body.params === "object") {
+                body.params.sessionId = sessionId;
+            }
+            else {
+                body.params = { sessionId };
+            }
+            logger.debug("POST /rpc - session/new with generated sessionId", {
+                sessionId,
+            });
+        }
+        // Choose the appropriate inbound stream
+        let inboundStream;
+        if (isSessionMethod && sessionId) {
+            const sessionAcp = getOrCreateSessionAcp(sessionId);
+            inboundStream = sessionAcp.inbound;
+            logger.debug("POST /rpc - Using session-specific stream", {
+                sessionId,
+                method,
+            });
+        }
+        else {
+            inboundStream = globalInbound;
+            logger.debug("POST /rpc - Using global stream", { method });
+        }
         if (isRequest) {
             // For requests, set up a listener before sending the request
             const responseChannel = safeChannelName("response", String(id));
@@ -573,8 +736,8 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                 }
                 responseResolver(rawResponse);
             });
-            // Write NDJSON line into the ACP inbound stream
-            const writer = inbound.writable.getWriter();
+            // Write NDJSON line into the appropriate ACP inbound stream
+            const writer = inboundStream.writable.getWriter();
             await writer.write(encoder.encode(`${JSON.stringify(body)}\n`));
             writer.releaseLock();
             // Wait for response with ten minute timeout
@@ -582,6 +745,29 @@ export function makeHttpTransport(agent, agentDir, agentName) {
             try {
                 const response = await Promise.race([responsePromise, timeoutPromise]);
                 logger.debug("POST /rpc - Response received", { id });
+                // For session/new responses, map the returned sessionId to the same adapter
+                // The adapter may generate its own sessionId, so we need to ensure subsequent
+                // requests using that sessionId route to the correct adapter
+                if (method === "session/new" &&
+                    sessionId &&
+                    response &&
+                    typeof response === "object" &&
+                    "result" in response &&
+                    response.result &&
+                    typeof response.result === "object" &&
+                    "sessionId" in response.result &&
+                    typeof response.result.sessionId === "string" &&
+                    response.result.sessionId !== sessionId) {
+                    const returnedSessionId = response.result.sessionId;
+                    const existingAcp = sessionAcpMap.get(sessionId);
+                    if (existingAcp) {
+                        sessionAcpMap.set(returnedSessionId, existingAcp);
+                        logger.debug("POST /rpc - Added sessionId alias for session/new response", {
+                            generatedSessionId: sessionId,
+                            returnedSessionId,
+                        });
+                    }
+                }
                 return c.json(response);
             }
             catch (error) {
@@ -598,7 +784,7 @@ export function makeHttpTransport(agent, agentDir, agentName) {
         }
         else {
             // For notifications, just send and return success
-            const writer = inbound.writable.getWriter();
+            const writer = inboundStream.writable.getWriter();
             await writer.write(encoder.encode(`${JSON.stringify(body)}\n`));
             writer.releaseLock();
             return c.json({

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

@@ -125,6 +125,7 @@ export interface ContextEntry {
         toolResultsTokens: number;
         totalEstimated: number;
         llmReportedInputTokens?: number | undefined;
+        modelContextWindow?: number | undefined;
     };
 }
 /**

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

@@ -115,6 +115,7 @@ const contextEntrySchema = z.object({
         toolResultsTokens: z.number(),
         totalEstimated: z.number(),
         llmReportedInputTokens: z.number().optional(),
+        modelContextWindow: z.number().optional(),
     }),
 });
 const sessionMetadataSchema = z.object({

package/dist/runner/hooks/constants.d.ts

@@ -7,3 +7,7 @@ export declare const MODEL_CONTEXT_WINDOWS: Record<string, number>;
  * Default context size for unknown models
  */
 export declare const DEFAULT_CONTEXT_SIZE = 200000;
+/**
+ * Get max context size for a model
+ */
+export declare function getModelContextWindow(model: string): number;

package/dist/runner/hooks/constants.js

@@ -17,3 +17,9 @@ export const MODEL_CONTEXT_WINDOWS = {
  * Default context size for unknown models
  */
 export const DEFAULT_CONTEXT_SIZE = 200000;
+/**
+ * Get max context size for a model
+ */
+export function getModelContextWindow(model) {
+    return MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_SIZE;
+}