@townco/agent 0.1.81 → 0.1.83

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 = {
@@ -602,8 +604,7 @@ export class AgentAcpAdapter {
             const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined, // No LLM-reported tokens yet
             this.currentToolOverheadTokens, // Include tool overhead
             this.currentMcpOverheadTokens, // Include MCP overhead
-            getModelContextWindow(this.agent.definition.model), // Model context window for UI
-            true);
+            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)
             new Date().toISOString(), previousContext, context_size);
             session.context.push(contextSnapshot);
@@ -620,7 +621,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,
@@ -654,8 +655,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,
             });
@@ -663,6 +664,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,
             };
@@ -1155,7 +1158,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();
         }
@@ -1215,13 +1218,10 @@ export class AgentAcpAdapter {
                 }
             }
             // Calculate context size with LLM-reported tokens from this turn
-            // Exclude tool results - they're only sent during the turn they were received,
-            // not in subsequent turns (only messages are sent)
             const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, turnTokenUsage.inputTokens, // Final LLM-reported tokens from this turn
             this.currentToolOverheadTokens, // Include tool overhead
             this.currentMcpOverheadTokens, // Include MCP overhead
-            getModelContextWindow(this.agent.definition.model), // Model context window for UI
-            true);
+            getModelContextWindow(this.agent.definition.model));
             const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
             session.context.push(contextSnapshot);
             await this.saveSessionToDisk(params.sessionId, session);

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 {

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

@@ -147,7 +147,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 +160,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 +183,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[]>;
     /**

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

@@ -131,7 +131,8 @@ const storedSessionSchema = z.object({
 });
 /**
  * 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 class SessionStorage {
     sessionsDir;
@@ -146,17 +147,25 @@ export class SessionStorage {
         this.agentName = agentName;
     }
     /**
-     * Ensure the .sessions directory exists
+     * Ensure the session directory exists
      */
-    ensureSessionsDir() {
-        if (!existsSync(this.sessionsDir)) {
-            mkdirSync(this.sessionsDir, { recursive: true });
+    ensureSessionDir(sessionId) {
+        const sessionDir = join(this.sessionsDir, sessionId);
+        if (!existsSync(sessionDir)) {
+            mkdirSync(sessionDir, { recursive: true });
         }
     }
     /**
      * Get the file path for a session
      */
     getSessionPath(sessionId) {
+        return join(this.sessionsDir, sessionId, "session.json");
+    }
+    /**
+     * Get the legacy file path for a session (for backwards compatibility)
+     * Legacy format: .sessions/<session_id>.json (flat file, not directory)
+     */
+    getLegacySessionPath(sessionId) {
         return join(this.sessionsDir, `${sessionId}.json`);
     }
     /**
@@ -164,7 +173,7 @@ export class SessionStorage {
      * Uses atomic write (write to temp file, then rename)
      */
     async saveSession(sessionId, messages, context) {
-        this.ensureSessionsDir();
+        this.ensureSessionDir(sessionId);
         const sessionPath = this.getSessionPath(sessionId);
         const tempPath = `${sessionPath}.tmp`;
         const now = new Date().toISOString();
@@ -207,14 +216,24 @@ export class SessionStorage {
     }
     /**
      * Synchronous session loading (for internal use)
+     * Checks new location first, falls back to legacy location
      */
     loadSessionSync(sessionId) {
         const sessionPath = this.getSessionPath(sessionId);
+        const legacyPath = this.getLegacySessionPath(sessionId);
+        // Check new location first
+        let actualPath = sessionPath;
         if (!existsSync(sessionPath)) {
-            return null;
+            // Fall back to legacy location
+            if (existsSync(legacyPath)) {
+                actualPath = legacyPath;
+            }
+            else {
+                return null;
+            }
         }
         try {
-            const content = readFileSync(sessionPath, "utf-8");
+            const content = readFileSync(actualPath, "utf-8");
             const parsed = JSON.parse(content);
             // Validate with zod
             const validated = storedSessionSchema.parse(parsed);
@@ -225,39 +244,64 @@ export class SessionStorage {
         }
     }
     /**
-     * Check if a session exists
+     * Check if a session exists (checks both new and legacy locations)
      */
     sessionExists(sessionId) {
-        return existsSync(this.getSessionPath(sessionId));
+        return (existsSync(this.getSessionPath(sessionId)) ||
+            existsSync(this.getLegacySessionPath(sessionId)));
     }
     /**
-     * Delete a session
+     * Delete a session (deletes entire session directory or legacy file)
      */
     async deleteSession(sessionId) {
-        const sessionPath = this.getSessionPath(sessionId);
-        if (!existsSync(sessionPath)) {
-            return false;
-        }
+        const sessionDir = join(this.sessionsDir, sessionId);
+        const legacyPath = this.getLegacySessionPath(sessionId);
+        let deleted = false;
         try {
-            unlinkSync(sessionPath);
-            return true;
+            // Delete session directory (.sessions/<sessionId>/)
+            if (existsSync(sessionDir)) {
+                // Recursively delete the session directory
+                const { rmSync } = await import("node:fs");
+                rmSync(sessionDir, { recursive: true, force: true });
+                deleted = true;
+            }
+            // Also delete legacy location if it exists (.sessions/<sessionId>.json)
+            if (existsSync(legacyPath)) {
+                unlinkSync(legacyPath);
+                deleted = true;
+            }
+            return deleted;
         }
         catch (error) {
             throw new Error(`Failed to delete session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
-     * List all session IDs
+     * List all session IDs (checks both new and legacy locations)
      */
     async listSessions() {
-        if (!existsSync(this.sessionsDir)) {
-            return [];
-        }
+        const sessionIds = new Set();
         try {
-            const files = readdirSync(this.sessionsDir);
-            return files
-                .filter((file) => file.endsWith(".json") && !file.endsWith(".tmp"))
-                .map((file) => file.replace(".json", ""));
+            // Check .sessions/ directory
+            if (existsSync(this.sessionsDir)) {
+                const entries = readdirSync(this.sessionsDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        // New format: .sessions/<sessionId>/session.json
+                        const sessionJsonPath = join(this.sessionsDir, entry.name, "session.json");
+                        if (existsSync(sessionJsonPath)) {
+                            sessionIds.add(entry.name);
+                        }
+                    }
+                    else if (entry.isFile() &&
+                        entry.name.endsWith(".json") &&
+                        !entry.name.endsWith(".tmp")) {
+                        // Legacy format: .sessions/<sessionId>.json
+                        sessionIds.add(entry.name.replace(".json", ""));
+                    }
+                }
+            }
+            return Array.from(sessionIds);
         }
         catch (error) {
             throw new Error(`Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`);
@@ -271,43 +315,34 @@ export class SessionStorage {
      * Returns sessions sorted by updatedAt (most recent first)
      */
     async listSessionsWithMetadata() {
-        if (!existsSync(this.sessionsDir)) {
-            return [];
-        }
-        try {
-            const files = readdirSync(this.sessionsDir);
-            const sessionFiles = files.filter((file) => file.endsWith(".json") && !file.endsWith(".tmp"));
-            const sessions = [];
-            for (const file of sessionFiles) {
-                const sessionId = file.replace(".json", "");
-                try {
-                    const session = this.loadSessionSync(sessionId);
-                    if (session) {
-                        // Find the first user message for preview
-                        const firstUserMsg = session.messages.find((m) => m.role === "user");
-                        const firstUserText = firstUserMsg?.content.find((c) => c.type === "text");
-                        const entry = {
-                            sessionId: session.sessionId,
-                            createdAt: session.metadata.createdAt,
-                            updatedAt: session.metadata.updatedAt,
-                            messageCount: session.messages.length,
-                        };
-                        if (firstUserText && "text" in firstUserText) {
-                            entry.firstUserMessage = firstUserText.text.slice(0, 100);
-                        }
-                        sessions.push(entry);
+        // Get all session IDs from both locations
+        const sessionIds = await this.listSessions();
+        const sessions = [];
+        for (const sessionId of sessionIds) {
+            try {
+                const session = this.loadSessionSync(sessionId);
+                if (session) {
+                    // Find the first user message for preview
+                    const firstUserMsg = session.messages.find((m) => m.role === "user");
+                    const firstUserText = firstUserMsg?.content.find((c) => c.type === "text");
+                    const entry = {
+                        sessionId: session.sessionId,
+                        createdAt: session.metadata.createdAt,
+                        updatedAt: session.metadata.updatedAt,
+                        messageCount: session.messages.length,
+                    };
+                    if (firstUserText && "text" in firstUserText) {
+                        entry.firstUserMessage = firstUserText.text.slice(0, 100);
                     }
-                }
-                catch {
-                    // Skip invalid sessions
+                    sessions.push(entry);
                 }
             }
-            // Sort by updatedAt, most recent first
-            sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
-            return sessions;
-        }
-        catch (error) {
-            throw new Error(`Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`);
+            catch {
+                // Skip invalid sessions
+            }
         }
+        // Sort by updatedAt, most recent first
+        sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        return sessions;
     }
 }

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

@@ -9,7 +9,7 @@ export declare const zAgentRunnerParams: z.ZodObject<{
     suggestedPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     systemPrompt: z.ZodNullable<z.ZodString>;
     model: z.ZodString;
-    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"town_web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"browser">]>, z.ZodObject<{
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"artifacts">, z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"town_web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"town_generate_image">, z.ZodLiteral<"browser">]>, z.ZodObject<{
         type: z.ZodLiteral<"custom">;
         modulePath: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
@@ -74,6 +74,8 @@ export interface ConfigOverrides {
 }
 export type InvokeRequest = Omit<PromptRequest, "_meta"> & {
     messageId: string;
+    /** Agent directory path for session-scoped file storage */
+    agentDir?: string;
     sessionMeta?: Record<string, unknown>;
     contextMessages?: SessionMessage[];
     configOverrides?: ConfigOverrides;

package/dist/runner/hooks/executor.js

@@ -186,7 +186,7 @@ export class HookExecutor {
             };
             const result = await callback(hookContext);
             // Extract modified output and warnings from metadata
-            if (result.metadata && result.metadata.modifiedOutput) {
+            if (result.metadata?.modifiedOutput) {
                 // Hook took action - emit completed notification
                 const response = { notifications };
                 response.modifiedOutput = result.metadata.modifiedOutput;

package/dist/runner/hooks/predefined/compaction-tool.js

@@ -11,7 +11,7 @@ export const compactionTool = async (ctx) => {
     logger.info("Compaction tool triggered", {
         currentTokens: ctx.currentTokens,
         maxTokens: ctx.maxTokens,
-        percentage: ctx.percentage.toFixed(2) + "%",
+        percentage: `${ctx.percentage.toFixed(2)}%`,
         contextEntries: ctx.session.context.length,
         totalMessages: ctx.session.messages.length,
         model: ctx.model,
@@ -24,14 +24,36 @@ export const compactionTool = async (ctx) => {
         });
         // Build the conversation history to compact
         const messagesToCompact = ctx.session.messages;
-        // Convert session messages to text for context
+        // Convert session messages to text for context, including tool calls and results
         const conversationText = messagesToCompact
             .map((msg) => {
-            const textContent = msg.content
-                .filter((block) => block.type === "text")
-                .map((block) => block.text)
-                .join("\n");
-            return `${msg.role.toUpperCase()}:\n${textContent}`;
+            const parts = [];
+            for (const block of msg.content) {
+                if (block.type === "text") {
+                    parts.push(block.text);
+                }
+                else if (block.type === "tool_call") {
+                    // Include tool call info
+                    parts.push(`[Tool: ${block.title}]`);
+                    if (block.rawInput) {
+                        parts.push(`Input: ${JSON.stringify(block.rawInput, null, 2)}`);
+                    }
+                    if (block.rawOutput) {
+                        // Summarize large outputs to avoid overwhelming the compaction LLM
+                        const outputStr = JSON.stringify(block.rawOutput);
+                        if (outputStr.length > 2000) {
+                            parts.push(`Output: [Large output - ${outputStr.length} chars]`);
+                        }
+                        else {
+                            parts.push(`Output: ${outputStr}`);
+                        }
+                    }
+                    if (block.error) {
+                        parts.push(`Error: ${block.error}`);
+                    }
+                }
+            }
+            return `${msg.role.toUpperCase()}:\n${parts.join("\n")}`;
         })
             .join("\n\n---\n\n");
         // Create system prompt for compaction
@@ -85,7 +107,8 @@ Please provide your summary based on the conversation above, following this stru
                     .join("\n")
                 : "Failed to extract summary";
         // Extract token usage from LLM response
-        const responseUsage = response.usage_metadata;
+        const responseUsage = response
+            .usage_metadata;
         const summaryTokens = responseUsage?.output_tokens ?? 0;
         const inputTokensUsed = responseUsage?.input_tokens ?? ctx.currentTokens;
         logger.info("Generated compaction summary", {

package/dist/runner/hooks/predefined/tool-response-compactor.js

@@ -89,7 +89,7 @@ export const toolResponseCompactor = async (ctx) => {
             // Try more aggressive truncation (70% of target as emergency measure)
             const emergencySize = Math.floor(targetSize * 0.7);
             const emergencyTruncated = truncateToolResponse(rawOutput, emergencySize);
-            let emergencyTokens = countToolResultTokens(emergencyTruncated);
+            const emergencyTokens = countToolResultTokens(emergencyTruncated);
             // Final safety check - if emergency truncation STILL exceeded target, use ultra-conservative fallback
             if (emergencyTokens > targetSize) {
                 logger.error("Emergency truncation STILL exceeded target - using ultra-conservative fallback", {
@@ -151,7 +151,7 @@ export const toolResponseCompactor = async (ctx) => {
             .map((msg) => {
             const text = msg.content
                 .filter((b) => b.type === "text")
-                .map((b) => b.text)
+                .map((b) => (b.type === "text" ? b.text : ""))
                 .join("\n");
             return `${msg.role}: ${text}`;
         })

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

@@ -13,5 +13,6 @@ export declare class LangchainAgent implements AgentRunner {
     constructor(params: CreateAgentRunnerParams);
     invoke(req: InvokeRequest): AsyncGenerator<ExtendedSessionUpdate, PromptResponse, undefined>;
     private invokeInternal;
+    private invokeWithContext;
 }
 export { makeSubagentsTool } from "./tools/subagent.js";