@townco/agent 0.1.82 → 0.1.84

package/dist/acp-server/adapter.js

@@ -278,8 +278,10 @@ export class AgentAcpAdapter {
         return response;
     }
     async newSession(params) {
-        // Generate a unique session ID for this session
-        const sessionId = Math.random().toString(36).substring(2);
+        // Use sessionId from params if provided (HTTP transport injects it),
+        // otherwise generate a unique session ID for this session
+        const sessionId = params.sessionId ??
+            Math.random().toString(36).substring(2);
         // Extract configOverrides from _meta if provided (Town Hall comparison feature)
         const configOverrides = params._meta?.configOverrides;
         const sessionData = {
@@ -380,7 +382,7 @@ export class AgentAcpAdapter {
                             : {}),
                         ...block._meta,
                     };
-                    // Debug: log subagent data being replayed
+                    // Debug: log subagent data and compaction metadata being replayed
                     logger.info("Replaying tool_call", {
                         toolCallId: block.id,
                         title: block.title,
@@ -389,6 +391,8 @@ export class AgentAcpAdapter {
                         hasSubagentSessionId: !!block.subagentSessionId,
                         hasSubagentMessages: !!block.subagentMessages,
                         subagentMessagesCount: block.subagentMessages?.length,
+                        blockMeta: block._meta,
+                        replayMeta,
                     });
                     this.connection.sessionUpdate({
                         sessionId: params.sessionId,
@@ -434,6 +438,7 @@ export class AgentAcpAdapter {
                             status: block.status,
                             rawOutput: block.rawOutput,
                             error: block.error,
+                            _meta: replayMeta,
                         },
                     });
                 }
@@ -598,9 +603,8 @@ export class AgentAcpAdapter {
                     contextMessages.push(entry.message);
                 }
             }
-            // Calculate context size - no LLM call yet, so only estimated values
-            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined, // No LLM-reported tokens yet
-            this.currentToolOverheadTokens, // Include tool overhead
+            // Calculate context size - only estimated values
+            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, this.currentToolOverheadTokens, // Include tool overhead
             this.currentMcpOverheadTokens, // Include MCP overhead
             getModelContextWindow(this.agent.definition.model));
             const contextSnapshot = createContextSnapshot(session.messages.length - 1, // Exclude the newly added user message (it will be passed separately via prompt)
@@ -619,7 +623,7 @@ export class AgentAcpAdapter {
             }
         };
         // Declare agentResponse and turnTokenUsage outside try block so they're accessible after catch
-        let agentResponse;
+        let _agentResponse;
         // Track accumulated token usage during the turn
         const turnTokenUsage = {
             inputTokens: 0,
@@ -653,8 +657,8 @@ export class AgentAcpAdapter {
                 latestContextEntry: session.context.length > 0 &&
                     session.context[session.context.length - 1]
                     ? {
-                        messageCount: session.context[session.context.length - 1].messages.length,
-                        contextSize: session.context[session.context.length - 1].context_size,
+                        messageCount: session.context[session.context.length - 1]?.messages.length,
+                        contextSize: session.context[session.context.length - 1]?.context_size,
                     }
                     : null,
             });
@@ -662,6 +666,8 @@ export class AgentAcpAdapter {
                 prompt: params.prompt,
                 sessionId: params.sessionId,
                 messageId,
+                // Pass agent directory for session-scoped file storage (only if defined)
+                ...(this.agentDir ? { agentDir: this.agentDir } : {}),
                 // Pass resolved context messages to agent
                 contextMessages,
             };
@@ -717,19 +723,8 @@ export class AgentAcpAdapter {
                         if (tokenUsage.inputTokens !== undefined &&
                             tokenUsage.inputTokens > 0) {
                             turnTokenUsage.inputTokens = tokenUsage.inputTokens;
-                            // Update the LAST context entry with LLM-reported tokens
-                            if (!this.noSession && session.context.length > 0) {
-                                const lastContext = session.context[session.context.length - 1];
-                                if (lastContext) {
-                                    lastContext.context_size.llmReportedInputTokens =
-                                        tokenUsage.inputTokens;
-                                    logger.debug("Updated context entry with LLM-reported tokens", {
-                                        contextIndex: session.context.length - 1,
-                                        llmReportedTokens: tokenUsage.inputTokens,
-                                        estimatedTokens: lastContext.context_size.totalEstimated,
-                                    });
-                                }
-                            }
+                            // Note: We no longer update context entries with LLM-reported tokens
+                            // as they can cause mismatches when updated on mid-turn snapshots
                         }
                         turnTokenUsage.outputTokens += tokenUsage.outputTokens ?? 0;
                         turnTokenUsage.totalTokens += tokenUsage.totalTokens ?? 0;
@@ -906,19 +901,71 @@ export class AgentAcpAdapter {
                         // Get the raw output
                         let rawOutput = outputMsg.rawOutput || outputMsg.output;
                         let truncationWarning;
+                        // Check for compaction metadata embedded by LangChain tool wrapper
+                        // This happens when compaction runs in the wrapper (before reaching adapter)
+                        if (rawOutput &&
+                            typeof rawOutput === "object" &&
+                            "_compactionMeta" in rawOutput) {
+                            const compactionMeta = rawOutput._compactionMeta;
+                            // Store in _meta for UI persistence
+                            if (!toolCallBlock._meta) {
+                                toolCallBlock._meta = {};
+                            }
+                            if (compactionMeta.action) {
+                                toolCallBlock._meta.compactionAction = compactionMeta.action;
+                            }
+                            if (compactionMeta.originalTokens !== undefined) {
+                                toolCallBlock._meta.originalTokens =
+                                    compactionMeta.originalTokens;
+                            }
+                            if (compactionMeta.finalTokens !== undefined) {
+                                toolCallBlock._meta.finalTokens = compactionMeta.finalTokens;
+                            }
+                            // Store original content only if compaction or truncation actually occurred
+                            const wasCompacted = compactionMeta.action === "compacted" ||
+                                compactionMeta.action === "truncated" ||
+                                compactionMeta.action === "compacted_then_truncated";
+                            if (compactionMeta.originalContent &&
+                                wasCompacted &&
+                                this.storage) {
+                                try {
+                                    const toolName = toolCallBlock.title || "unknown";
+                                    const originalContentPath = this.storage.saveToolOriginal(params.sessionId, toolName, outputMsg.toolCallId, compactionMeta.originalContent);
+                                    toolCallBlock._meta.originalContentPath = originalContentPath;
+                                    logger.info("Saved original content to artifacts", {
+                                        toolCallId: outputMsg.toolCallId,
+                                        toolName,
+                                        path: originalContentPath,
+                                    });
+                                }
+                                catch (error) {
+                                    logger.warn("Failed to save original tool content", {
+                                        toolCallId: outputMsg.toolCallId,
+                                        error: error instanceof Error ? error.message : String(error),
+                                    });
+                                }
+                            }
+                            logger.info("Extracted compaction metadata from tool response wrapper", {
+                                toolCallId: outputMsg.toolCallId,
+                                action: compactionMeta.action,
+                                originalTokens: compactionMeta.originalTokens,
+                                finalTokens: compactionMeta.finalTokens,
+                                hasOriginalContent: !!compactionMeta.originalContent,
+                            });
+                            // Remove the metadata from rawOutput to keep it clean
+                            const { _compactionMeta: _, ...cleanOutput } = rawOutput;
+                            rawOutput = cleanOutput;
+                        }
                         if (rawOutput && !this.noSession) {
                             // Execute tool_response hooks if configured
                             const hooks = this.agent.definition.hooks ?? [];
                             if (hooks.some((h) => h.type === "tool_response")) {
                                 const latestContext = session.context[session.context.length - 1];
-                                // Use max of estimated and LLM-reported tokens (same logic as UI)
-                                const currentContextTokens = Math.max(latestContext?.context_size.totalEstimated ?? 0, latestContext?.context_size.llmReportedInputTokens ?? 0);
-                                // Send the context size to the UI so it shows the same value we're using for hook evaluation
+                                // Use estimated tokens for hook evaluation
+                                const currentContextTokens = latestContext?.context_size.totalEstimated ?? 0;
+                                // Send the context size to the UI
                                 if (latestContext?.context_size) {
-                                    const contextSizeForUI = {
-                                        ...latestContext.context_size,
-                                        totalEstimated: currentContextTokens,
-                                    };
+                                    const contextSizeForUI = latestContext.context_size;
                                     this.connection.sessionUpdate({
                                         sessionId: params.sessionId,
                                         update: {
@@ -960,6 +1007,12 @@ export class AgentAcpAdapter {
                                 });
                                 // Note: Notifications are now sent in real-time via the callback
                                 // The hookResult.notifications array is kept for backwards compatibility
+                                // Capture original content BEFORE any modification (needed for storage)
+                                const originalContentStr = typeof rawOutput === "object" &&
+                                    rawOutput !== null &&
+                                    "content" in rawOutput
+                                    ? String(rawOutput.content)
+                                    : JSON.stringify(rawOutput);
                                 // Apply modifications if hook returned them
                                 if (hookResult.modifiedOutput) {
                                     rawOutput = hookResult.modifiedOutput;
@@ -970,6 +1023,49 @@ export class AgentAcpAdapter {
                                     });
                                 }
                                 truncationWarning = hookResult.truncationWarning;
+                                // Store hook result metadata in toolCallBlock._meta for persistence
+                                if (hookResult.metadata) {
+                                    if (!toolCallBlock._meta) {
+                                        toolCallBlock._meta = {};
+                                    }
+                                    // Store compaction action and stats
+                                    if (hookResult.metadata.action) {
+                                        toolCallBlock._meta.compactionAction = hookResult.metadata
+                                            .action;
+                                    }
+                                    if (hookResult.metadata.originalTokens !== undefined) {
+                                        toolCallBlock._meta.originalTokens = hookResult.metadata
+                                            .originalTokens;
+                                    }
+                                    if (hookResult.metadata.finalTokens !== undefined) {
+                                        toolCallBlock._meta.finalTokens = hookResult.metadata
+                                            .finalTokens;
+                                    }
+                                    // Store original content if compaction occurred (action !== "none")
+                                    if (hookResult.metadata.action &&
+                                        hookResult.metadata.action !== "none" &&
+                                        this.storage) {
+                                        try {
+                                            const toolName = toolCallBlock.title || "unknown";
+                                            const originalContentPath = this.storage.saveToolOriginal(params.sessionId, toolName, outputMsg.toolCallId, originalContentStr);
+                                            toolCallBlock._meta.originalContentPath =
+                                                originalContentPath;
+                                            logger.info("Saved original content to artifacts", {
+                                                toolCallId: outputMsg.toolCallId,
+                                                toolName,
+                                                path: originalContentPath,
+                                            });
+                                        }
+                                        catch (error) {
+                                            logger.warn("Failed to save original tool content", {
+                                                toolCallId: outputMsg.toolCallId,
+                                                error: error instanceof Error
+                                                    ? error.message
+                                                    : String(error),
+                                            });
+                                        }
+                                    }
+                                }
                             }
                         }
                         // Store the (potentially modified) output
@@ -983,6 +1079,22 @@ export class AgentAcpAdapter {
                             }
                             toolCallBlock._meta.truncationWarning = truncationWarning;
                         }
+                        // Send compaction metadata to the client if present
+                        // This is needed for live streaming (not just replay)
+                        if (toolCallBlock._meta?.compactionAction) {
+                            logger.info("Sending compaction metadata to client during live streaming", {
+                                toolCallId: outputMsg.toolCallId,
+                                _meta: toolCallBlock._meta,
+                            });
+                            this.connection.sessionUpdate({
+                                sessionId: params.sessionId,
+                                update: {
+                                    sessionUpdate: "tool_call_update",
+                                    toolCallId: outputMsg.toolCallId,
+                                    _meta: toolCallBlock._meta,
+                                },
+                            });
+                        }
                         // Note: content blocks are handled by the transport for display
                         // We store the raw output here for session persistence
                         // Create mid-turn context snapshot after tool completes
@@ -1058,8 +1170,7 @@ export class AgentAcpAdapter {
                                 }
                             }
                             // Calculate context size - tool result is now in the message, but hasn't been sent to LLM yet
-                            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined, // Tool result hasn't been sent to LLM yet, so no new LLM-reported tokens
-                            this.currentToolOverheadTokens, // Include tool overhead
+                            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, this.currentToolOverheadTokens, // Include tool overhead
                             this.currentMcpOverheadTokens, // Include MCP overhead
                             getModelContextWindow(this.agent.definition.model));
                             // Create snapshot with a pointer to the partial message (not a full copy!)
@@ -1154,7 +1265,7 @@ export class AgentAcpAdapter {
                 iterResult = await generator.next();
             }
             // Capture the return value (PromptResponse with tokenUsage)
-            agentResponse = iterResult.value;
+            _agentResponse = iterResult.value;
             // Flush any remaining pending text
             flushPendingText();
         }
@@ -1213,9 +1324,8 @@ export class AgentAcpAdapter {
                     contextMessages.push(entry.message);
                 }
             }
-            // Calculate context size with LLM-reported tokens from this turn
-            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, turnTokenUsage.inputTokens, // Final LLM-reported tokens from this turn
-            this.currentToolOverheadTokens, // Include tool overhead
+            // Calculate context size - only estimated values
+            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, this.currentToolOverheadTokens, // Include tool overhead
             this.currentMcpOverheadTokens, // Include MCP overhead
             getModelContextWindow(this.agent.definition.model));
             const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
@@ -1293,28 +1403,19 @@ export class AgentAcpAdapter {
             context: session.context,
             requestParams: session.requestParams,
         };
-        // Get actual input token count from latest context entry
+        // Get input token count from latest context entry
         const latestContext = session.context.length > 0
             ? session.context[session.context.length - 1]
             : undefined;
-        // Use max of estimated and LLM-reported tokens (same logic as UI)
-        // This is conservative - we want to trigger compaction earlier rather than later
-        const actualInputTokens = Math.max(latestContext?.context_size.totalEstimated ?? 0, latestContext?.context_size.llmReportedInputTokens ?? 0);
+        // Use estimated tokens for hook evaluation
+        const actualInputTokens = latestContext?.context_size.totalEstimated ?? 0;
         logger.debug("Using tokens for hook execution", {
-            llmReported: latestContext?.context_size.llmReportedInputTokens,
             estimated: latestContext?.context_size.totalEstimated,
             used: actualInputTokens,
         });
-        // Send the context size to the UI so it shows the same value we're using for hook evaluation
-        // This ensures the UI percentage matches what the hook sees
+        // Send the context size to the UI
         if (latestContext?.context_size) {
-            // Create an updated context_size with the actualInputTokens we computed
-            // so UI can calculate the same percentage
-            const contextSizeForUI = {
-                ...latestContext.context_size,
-                // Override with the max value we computed (what hooks actually use)
-                totalEstimated: actualInputTokens,
-            };
+            const contextSizeForUI = latestContext.context_size;
             this.connection.sessionUpdate({
                 sessionId,
                 update: {

package/dist/acp-server/http.js

@@ -241,7 +241,7 @@ export function makeHttpTransport(agent, agentDir, agentName) {
                             }
                             // Regular session update - send via PubSub
                             const channel = safeChannelName("notifications", msgSessionId);
-                            const { payload, isCompressed, originalSize, compressedSize } = compressIfNeeded(rawMsg);
+                            const { payload, compressedSize } = compressIfNeeded(rawMsg);
                             if (compressedSize <= 7500) {
                                 const escapedPayload = payload.replace(/'/g, "''");
                                 try {
@@ -455,6 +455,61 @@ export function makeHttpTransport(agent, agentDir, agentName) {
             }, 500);
         }
     });
+    // Serve files from session artifacts folder
+    app.get("/sessions/:sessionId/artifacts/*", 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");
+        // Extract the filename from the wildcard path
+        const filename = c.req.path.replace(`/sessions/${sessionId}/artifacts/`, "");
+        if (!sessionId || !filename) {
+            return c.json({ error: "Session ID and filename required" }, 400);
+        }
+        // Build path to artifacts folder
+        const storage = new SessionStorage(agentDir, agentName);
+        const artifactsDir = storage.getArtifactsDir(sessionId);
+        const filePath = join(artifactsDir, filename);
+        // Security check: ensure the file is within the artifacts directory
+        const normalizedPath = resolve(filePath);
+        const normalizedArtifactsDir = resolve(artifactsDir);
+        if (!normalizedPath.startsWith(normalizedArtifactsDir)) {
+            logger.warn("Attempted to access file outside artifacts directory", {
+                filename,
+                filePath,
+                artifactsDir,
+            });
+            return c.json({ error: "Invalid path" }, 403);
+        }
+        try {
+            const file = Bun.file(filePath);
+            const exists = await file.exists();
+            if (!exists) {
+                logger.warn("Artifact file not found", {
+                    sessionId,
+                    filename,
+                    filePath,
+                });
+                return c.json({ error: "File not found" }, 404);
+            }
+            const content = await file.text();
+            return c.json({ content });
+        }
+        catch (error) {
+            logger.error("Failed to load artifact", {
+                error,
+                sessionId,
+                filename,
+            });
+            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) => {

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

@@ -66,11 +66,13 @@ export interface ToolCallBlock {
     startedAt?: number | undefined;
     completedAt?: number | undefined;
     _meta?: {
-        truncationWarning?: string;
-        compactionAction?: "compacted" | "truncated";
-        originalTokens?: number;
-        finalTokens?: number;
-    };
+        truncationWarning?: string | undefined;
+        compactionAction?: "compacted" | "truncated" | undefined;
+        originalTokens?: number | undefined;
+        finalTokens?: number | undefined;
+        originalContentPreview?: string | undefined;
+        originalContentPath?: string | undefined;
+    } | undefined;
     /** Sub-agent HTTP port (for reference, not used in replay) */
     subagentPort?: number | undefined;
     /** Sub-agent session ID (for reference, not used in replay) */
@@ -124,7 +126,6 @@ export interface ContextEntry {
         toolInputTokens: number;
         toolResultsTokens: number;
         totalEstimated: number;
-        llmReportedInputTokens?: number | undefined;
         modelContextWindow?: number | undefined;
     };
 }
@@ -147,7 +148,8 @@ export interface StoredSession {
 }
 /**
  * File-based session storage
- * Stores sessions in agents/<agent-name>/.sessions/<session_id>.json
+ * Stores sessions in agents/<agent-name>/.sessions/<session_id>/session.json
+ * (Legacy: agents/<agent-name>/.sessions/<session_id>.json)
  */
 export declare class SessionStorage {
     private sessionsDir;
@@ -159,13 +161,18 @@ export declare class SessionStorage {
      */
     constructor(agentDir: string, agentName: string);
     /**
-     * Ensure the .sessions directory exists
+     * Ensure the session directory exists
      */
-    private ensureSessionsDir;
+    private ensureSessionDir;
     /**
      * Get the file path for a session
      */
     private getSessionPath;
+    /**
+     * Get the legacy file path for a session (for backwards compatibility)
+     * Legacy format: .sessions/<session_id>.json (flat file, not directory)
+     */
+    private getLegacySessionPath;
     /**
      * Save a session to disk
      * Uses atomic write (write to temp file, then rename)
@@ -177,18 +184,19 @@ export declare class SessionStorage {
     loadSession(sessionId: string): Promise<StoredSession | null>;
     /**
      * Synchronous session loading (for internal use)
+     * Checks new location first, falls back to legacy location
      */
     private loadSessionSync;
     /**
-     * Check if a session exists
+     * Check if a session exists (checks both new and legacy locations)
      */
     sessionExists(sessionId: string): boolean;
     /**
-     * Delete a session
+     * Delete a session (deletes entire session directory or legacy file)
      */
     deleteSession(sessionId: string): Promise<boolean>;
     /**
-     * List all session IDs
+     * List all session IDs (checks both new and legacy locations)
      */
     listSessions(): Promise<string[]>;
     /**
@@ -205,4 +213,28 @@ export declare class SessionStorage {
         messageCount: number;
         firstUserMessage?: string;
     }>>;
+    /**
+     * Get the directory for storing large content files for a session (artifacts folder)
+     */
+    getArtifactsDir(sessionId: string): string;
+    /**
+     * Get the file path for a tool's original content
+     * Follows the pattern: artifacts/tool-<ToolName>/<toolCallId>.original.txt
+     */
+    private getToolOriginalPath;
+    /**
+     * Save original tool response to a separate file
+     * Follows the pattern: artifacts/tool-<ToolName>/<toolCallId>.original.txt
+     * @param toolName - The name of the tool (e.g., "Read", "Grep")
+     * @returns Relative file path (for storage in _meta.originalContentPath)
+     */
+    saveToolOriginal(sessionId: string, toolName: string, toolCallId: string, content: string): string;
+    /**
+     * Load original tool response from separate file
+     */
+    loadToolOriginal(sessionId: string, toolName: string, toolCallId: string): string | null;
+    /**
+     * Check if original content exists for a tool call
+     */
+    hasToolOriginal(sessionId: string, toolName: string, toolCallId: string): boolean;
 }