@townco/agent 0.1.31 → 0.1.33

package/dist/acp-server/adapter.d.ts

@@ -16,9 +16,12 @@ export declare class AgentAcpAdapter implements acp.Agent {
     private connection;
     private sessions;
     private agent;
-    constructor(agent: AgentRunner, connection: acp.AgentSideConnection);
+    private storage;
+    private noSession;
+    constructor(agent: AgentRunner, connection: acp.AgentSideConnection, agentDir?: string, agentName?: string);
     initialize(_params: acp.InitializeRequest): Promise<acp.InitializeResponse>;
     newSession(params: acp.NewSessionRequest): Promise<acp.NewSessionResponse>;
+    loadSession(params: acp.LoadSessionRequest): Promise<acp.LoadSessionResponse>;
     authenticate(_params: acp.AuthenticateRequest): Promise<acp.AuthenticateResponse | undefined>;
     setSessionMode(_params: acp.SetSessionModeRequest): Promise<acp.SetSessionModeResponse>;
     prompt(params: acp.PromptRequest): Promise<acp.PromptResponse>;

package/dist/acp-server/adapter.js

@@ -1,4 +1,5 @@
 import * as acp from "@agentclientprotocol/sdk";
+import { SessionStorage } from "./session-storage.js";
 /**
  * ACP extension key for subagent mode indicator
  * Following ACP extensibility pattern with namespaced key
@@ -9,16 +10,30 @@ export class AgentAcpAdapter {
     connection;
     sessions;
     agent;
-    constructor(agent, connection) {
+    storage;
+    noSession;
+    constructor(agent, connection, agentDir, agentName) {
         this.connection = connection;
         this.sessions = new Map();
         this.agent = agent;
+        this.noSession = process.env.TOWN_NO_SESSION === "true";
+        this.storage =
+            agentDir && agentName && !this.noSession
+                ? new SessionStorage(agentDir, agentName)
+                : null;
+        console.log("[adapter] Initialized with:", {
+            agentDir,
+            agentName,
+            noSession: this.noSession,
+            hasStorage: this.storage !== null,
+            sessionStoragePath: this.storage ? `${agentDir}/.sessions` : null,
+        });
     }
     async initialize(_params) {
         return {
             protocolVersion: acp.PROTOCOL_VERSION,
             agentCapabilities: {
-                loadSession: false,
+                loadSession: !this.noSession && this.storage !== null,
             },
         };
     }
@@ -33,6 +48,37 @@ export class AgentAcpAdapter {
             sessionId,
         };
     }
+    async loadSession(params) {
+        if (!this.storage) {
+            throw new Error("Session storage is not configured");
+        }
+        const storedSession = await this.storage.loadSession(params.sessionId);
+        if (!storedSession) {
+            throw new Error(`Session ${params.sessionId} not found`);
+        }
+        // Restore session in active sessions map
+        this.sessions.set(params.sessionId, {
+            pendingPrompt: null,
+            messages: storedSession.messages,
+            requestParams: { cwd: process.cwd(), mcpServers: [] },
+        });
+        // Replay conversation history to client
+        console.log(`[adapter] Replaying ${storedSession.messages.length} messages for session ${params.sessionId}`);
+        for (const msg of storedSession.messages) {
+            console.log(`[adapter] Replaying message: ${msg.role} - ${msg.content.substring(0, 50)}...`);
+            this.connection.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: msg.role === "user" ? "user_message_chunk" : "agent_message_chunk",
+                    content: {
+                        type: "text",
+                        text: msg.content,
+                    },
+                },
+            });
+        }
+        return {};
+    }
     async authenticate(_params) {
         // No auth needed - return empty response
         return {};
@@ -57,25 +103,52 @@ export class AgentAcpAdapter {
         session.pendingPrompt = new AbortController();
         // Generate a unique messageId for this assistant response
         const messageId = Math.random().toString(36).substring(2);
+        // Extract and store the user message
+        const userMessageContent = params.prompt
+            .filter((p) => p.type === "text")
+            .map((p) => p.text)
+            .join("\n");
+        // Only store messages if session persistence is enabled
+        if (!this.noSession) {
+            const userMessage = {
+                role: "user",
+                content: userMessageContent,
+                timestamp: new Date().toISOString(),
+            };
+            session.messages.push(userMessage);
+        }
+        // Accumulate assistant response content
+        let assistantContent = "";
         try {
             const invokeParams = {
                 prompt: params.prompt,
                 sessionId: params.sessionId,
                 messageId,
+                // Only pass session history if session persistence is enabled
+                sessionMessages: this.noSession ? [] : session.messages,
             };
             // Only add sessionMeta if it's defined
             if (session.requestParams._meta) {
                 invokeParams.sessionMeta = session.requestParams._meta;
             }
             for await (const msg of this.agent.invoke(invokeParams)) {
-                // Debug: log if this is an agent_message_chunk with tokenUsage in _meta
+                // Accumulate assistant content from message chunks
                 if ("sessionUpdate" in msg &&
                     msg.sessionUpdate === "agent_message_chunk") {
+                    if ("content" in msg &&
+                        msg.content &&
+                        typeof msg.content === "object") {
+                        const content = msg.content;
+                        if (content.type === "text" && typeof content.text === "string") {
+                            assistantContent += content.text;
+                        }
+                    }
+                    // Debug: log if this chunk has tokenUsage in _meta
                     if ("_meta" in msg &&
                         msg._meta &&
                         typeof msg._meta === "object" &&
                         "tokenUsage" in msg._meta) {
-                        console.error("DEBUG adapter: sending agent_message_chunk with tokenUsage in _meta:", JSON.stringify(msg._meta.tokenUsage));
+                        console.log("DEBUG adapter: sending agent_message_chunk with tokenUsage in _meta:", JSON.stringify(msg._meta.tokenUsage));
                     }
                 }
                 // The agent may emit extended types (like tool_output) that aren't in ACP SDK yet
@@ -92,6 +165,25 @@ export class AgentAcpAdapter {
             }
             throw err;
         }
+        // Store the complete assistant response in session messages
+        // Only store if session persistence is enabled
+        if (!this.noSession && assistantContent.length > 0) {
+            const assistantMessage = {
+                role: "assistant",
+                content: assistantContent,
+                timestamp: new Date().toISOString(),
+            };
+            session.messages.push(assistantMessage);
+        }
+        // Save session to disk if storage is configured and session persistence is enabled
+        if (!this.noSession && this.storage) {
+            try {
+                await this.storage.saveSession(params.sessionId, session.messages);
+            }
+            catch (error) {
+                console.error(`Failed to save session ${params.sessionId}:`, error instanceof Error ? error.message : String(error));
+            }
+        }
         session.pendingPrompt = null;
         return {
             stopReason: "end_turn",

package/dist/acp-server/cli.d.ts

@@ -1,3 +1,5 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "../runner";
-export declare function makeStdioTransport(agent: AgentRunner | AgentDefinition): void;
+export declare function makeStdioTransport(
+	agent: AgentRunner | AgentDefinition,
+): void;

package/dist/acp-server/cli.js

@@ -3,9 +3,13 @@ import * as acp from "@agentclientprotocol/sdk";
 import { makeRunnerFromDefinition } from "../runner";
 import { AgentAcpAdapter } from "./adapter";
 export function makeStdioTransport(agent) {
-    const agentRunner = "definition" in agent ? agent : makeRunnerFromDefinition(agent);
-    const input = Writable.toWeb(process.stdout);
-    const output = Readable.toWeb(process.stdin);
-    const stream = acp.ndJsonStream(input, output);
-    new acp.AgentSideConnection((conn) => new AgentAcpAdapter(agentRunner, conn), stream);
+	const agentRunner =
+		"definition" in agent ? agent : makeRunnerFromDefinition(agent);
+	const input = Writable.toWeb(process.stdout);
+	const output = Readable.toWeb(process.stdin);
+	const stream = acp.ndJsonStream(input, output);
+	new acp.AgentSideConnection(
+		(conn) => new AgentAcpAdapter(agentRunner, conn),
+		stream,
+	);
 }

package/dist/acp-server/http.d.ts

@@ -1,3 +1,3 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "../runner";
-export declare function makeHttpTransport(agent: AgentRunner | AgentDefinition): void;
+export declare function makeHttpTransport(agent: AgentRunner | AgentDefinition, agentDir?: string, agentName?: string): void;

package/dist/acp-server/http.js

@@ -47,12 +47,12 @@ function safeChannelName(prefix, id) {
     const hash = createHash("sha256").update(id).digest("hex").slice(0, 16);
     return `${prefix}_${hash}`;
 }
-export function makeHttpTransport(agent) {
+export function makeHttpTransport(agent, agentDir, agentName) {
     const inbound = new TransformStream();
     const outbound = new TransformStream();
     const bridge = acp.ndJsonStream(outbound.writable, inbound.readable);
     const agentRunner = "definition" in agent ? agent : makeRunnerFromDefinition(agent);
-    new acp.AgentSideConnection((conn) => new AgentAcpAdapter(agentRunner, conn), bridge);
+    new acp.AgentSideConnection((conn) => new AgentAcpAdapter(agentRunner, conn, agentDir, agentName), bridge);
     const app = new Hono();
     // Track active SSE streams by sessionId for direct output delivery
     const sseStreams = new Map();
@@ -330,12 +330,23 @@ export function makeHttpTransport(agent) {
                 details: parseResult.error.issues,
             }, 400);
         }
-        const body = parseResult.data;
+        // Use rawBody instead of parseResult.data to preserve all fields
+        // The Zod validation above ensures the structure is valid, but we don't
+        // want it to strip fields due to union matching issues
+        const body = rawBody;
         // Ensure the request has an id
         const id = "id" in body ? body.id : null;
         const isRequest = id != null;
         const method = "method" in body ? body.method : "notification";
         logger.debug("POST /rpc - Received request", { method, id, isRequest });
+        // Debug log for session/load requests
+        if (method === "session/load") {
+            logger.debug("POST /rpc - session/load request details", {
+                rawBody: JSON.stringify(rawBody),
+                parsedBody: JSON.stringify(body),
+                params: "params" in body ? body.params : "NO PARAMS",
+            });
+        }
         if (isRequest) {
             // For requests, set up a listener before sending the request
             const responseChannel = safeChannelName("response", String(id));

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

@@ -0,0 +1,71 @@
+/**
+ * Session message format stored in files
+ */
+export interface SessionMessage {
+    role: "user" | "assistant";
+    content: string;
+    timestamp: string;
+}
+/**
+ * Session metadata
+ */
+export interface SessionMetadata {
+    createdAt: string;
+    updatedAt: string;
+    agentName: string;
+}
+/**
+ * Complete session data stored in JSON files
+ */
+export interface StoredSession {
+    sessionId: string;
+    messages: SessionMessage[];
+    metadata: SessionMetadata;
+}
+/**
+ * File-based session storage
+ * Stores sessions in agents/<agent-name>/.sessions/<session_id>.json
+ */
+export declare class SessionStorage {
+    private sessionsDir;
+    private agentName;
+    /**
+     * Create a new SessionStorage instance
+     * @param agentDir - Path to the agent directory (e.g., agents/my-agent)
+     * @param agentName - Name of the agent (used in metadata)
+     */
+    constructor(agentDir: string, agentName: string);
+    /**
+     * Ensure the .sessions directory exists
+     */
+    private ensureSessionsDir;
+    /**
+     * Get the file path for a session
+     */
+    private getSessionPath;
+    /**
+     * Save a session to disk
+     * Uses atomic write (write to temp file, then rename)
+     */
+    saveSession(sessionId: string, messages: SessionMessage[]): Promise<void>;
+    /**
+     * Load a session from disk
+     */
+    loadSession(sessionId: string): Promise<StoredSession | null>;
+    /**
+     * Synchronous session loading (for internal use)
+     */
+    private loadSessionSync;
+    /**
+     * Check if a session exists
+     */
+    sessionExists(sessionId: string): boolean;
+    /**
+     * Delete a session
+     */
+    deleteSession(sessionId: string): Promise<boolean>;
+    /**
+     * List all session IDs
+     */
+    listSessions(): Promise<string[]>;
+}

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

@@ -0,0 +1,155 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+/**
+ * Zod schema for validating session files
+ */
+const sessionMessageSchema = z.object({
+    role: z.enum(["user", "assistant"]),
+    content: z.string(),
+    timestamp: z.string(),
+});
+const sessionMetadataSchema = z.object({
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    agentName: z.string(),
+});
+const storedSessionSchema = z.object({
+    sessionId: z.string(),
+    messages: z.array(sessionMessageSchema),
+    metadata: sessionMetadataSchema,
+});
+/**
+ * File-based session storage
+ * Stores sessions in agents/<agent-name>/.sessions/<session_id>.json
+ */
+export class SessionStorage {
+    sessionsDir;
+    agentName;
+    /**
+     * Create a new SessionStorage instance
+     * @param agentDir - Path to the agent directory (e.g., agents/my-agent)
+     * @param agentName - Name of the agent (used in metadata)
+     */
+    constructor(agentDir, agentName) {
+        this.sessionsDir = join(agentDir, ".sessions");
+        this.agentName = agentName;
+    }
+    /**
+     * Ensure the .sessions directory exists
+     */
+    ensureSessionsDir() {
+        if (!existsSync(this.sessionsDir)) {
+            mkdirSync(this.sessionsDir, { recursive: true });
+        }
+    }
+    /**
+     * Get the file path for a session
+     */
+    getSessionPath(sessionId) {
+        return join(this.sessionsDir, `${sessionId}.json`);
+    }
+    /**
+     * Save a session to disk
+     * Uses atomic write (write to temp file, then rename)
+     */
+    async saveSession(sessionId, messages) {
+        this.ensureSessionsDir();
+        const sessionPath = this.getSessionPath(sessionId);
+        const tempPath = `${sessionPath}.tmp`;
+        const now = new Date().toISOString();
+        const existingSession = this.sessionExists(sessionId)
+            ? this.loadSessionSync(sessionId)
+            : null;
+        const session = {
+            sessionId,
+            messages,
+            metadata: {
+                createdAt: existingSession?.metadata.createdAt || now,
+                updatedAt: now,
+                agentName: this.agentName,
+            },
+        };
+        try {
+            // Write to temp file
+            writeFileSync(tempPath, JSON.stringify(session, null, 2), "utf-8");
+            // Atomic rename
+            if (existsSync(sessionPath)) {
+                unlinkSync(sessionPath);
+            }
+            writeFileSync(sessionPath, readFileSync(tempPath, "utf-8"), "utf-8");
+            unlinkSync(tempPath);
+        }
+        catch (error) {
+            // Clean up temp file on error
+            if (existsSync(tempPath)) {
+                unlinkSync(tempPath);
+            }
+            throw new Error(`Failed to save session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Load a session from disk
+     */
+    async loadSession(sessionId) {
+        return this.loadSessionSync(sessionId);
+    }
+    /**
+     * Synchronous session loading (for internal use)
+     */
+    loadSessionSync(sessionId) {
+        const sessionPath = this.getSessionPath(sessionId);
+        if (!existsSync(sessionPath)) {
+            return null;
+        }
+        try {
+            const content = readFileSync(sessionPath, "utf-8");
+            const parsed = JSON.parse(content);
+            // Validate with zod
+            const validated = storedSessionSchema.parse(parsed);
+            return validated;
+        }
+        catch (error) {
+            throw new Error(`Failed to load session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Check if a session exists
+     */
+    sessionExists(sessionId) {
+        return existsSync(this.getSessionPath(sessionId));
+    }
+    /**
+     * Delete a session
+     */
+    async deleteSession(sessionId) {
+        const sessionPath = this.getSessionPath(sessionId);
+        if (!existsSync(sessionPath)) {
+            return false;
+        }
+        try {
+            unlinkSync(sessionPath);
+            return true;
+        }
+        catch (error) {
+            throw new Error(`Failed to delete session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * List all session IDs
+     */
+    async listSessions() {
+        if (!existsSync(this.sessionsDir)) {
+            return [];
+        }
+        try {
+            const files = readdirSync(this.sessionsDir);
+            return files
+                .filter((file) => file.endsWith(".json") && !file.endsWith(".tmp"))
+                .map((file) => file.replace(".json", ""));
+        }
+        catch (error) {
+            throw new Error(`Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/definition/tools/todo.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export declare const todoItemSchema: z.ZodObject<
+	{
+		content: z.ZodString;
+		status: z.ZodEnum<{
+			pending: "pending";
+			in_progress: "in_progress";
+			completed: "completed";
+		}>;
+		activeForm: z.ZodString;
+	},
+	z.core.$strip
+>;
+export declare const todoWrite: import("langchain").DynamicStructuredTool<
+	z.ZodObject<
+		{
+			todos: z.ZodArray<
+				z.ZodObject<
+					{
+						content: z.ZodString;
+						status: z.ZodEnum<{
+							pending: "pending";
+							in_progress: "in_progress";
+							completed: "completed";
+						}>;
+						activeForm: z.ZodString;
+					},
+					z.core.$strip
+				>
+			>;
+		},
+		z.core.$strip
+	>,
+	{
+		todos: {
+			content: string;
+			status: "pending" | "in_progress" | "completed";
+			activeForm: string;
+		}[];
+	},
+	{
+		todos: {
+			content: string;
+			status: "pending" | "in_progress" | "completed";
+			activeForm: string;
+		}[];
+	},
+	string
+>;

package/dist/definition/tools/todo.js

@@ -0,0 +1,80 @@
+import { tool } from "langchain";
+import { z } from "zod";
+export const todoItemSchema = z.object({
+	content: z.string().min(1),
+	status: z.enum(["pending", "in_progress", "completed"]),
+	activeForm: z.string().min(1),
+});
+export const todoWrite = tool(
+	({ todos }) => {
+		// Simple implementation that confirms the todos were written
+		return `Successfully updated todo list with ${todos.length} items`;
+	},
+	{
+		name: "todo_write",
+		description: `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+It also helps the user understand the progress of the task and overall progress of their requests.
+
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+3. User explicitly requests todo list - When the user directly asks you to use the todo list
+4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+5. After receiving new instructions - Immediately capture user requirements as todos
+6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no organizational benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+
+## Task States and Management
+
+1. **Task States**: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (limit to ONE task at a time)
+   - completed: Task finished successfully
+
+   **IMPORTANT**: Task descriptions must have two forms:
+   - content: The imperative form describing what needs to be done (e.g., "Run tests", "Build the project")
+   - activeForm: The present continuous form shown during execution (e.g., "Running tests", "Building the project")
+
+2. **Task Management**:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Exactly ONE task must be in_progress at any time (not less, not more)
+   - Complete current tasks before starting new ones
+   - Remove tasks that are no longer relevant from the list entirely
+
+3. **Task Completion Requirements**:
+   - ONLY mark a task as completed when you have FULLY accomplished it
+   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+   - When blocked, create a new task describing what needs to be resolved
+   - Never mark a task as completed if:
+     - Tests are failing
+     - Implementation is partial
+     - You encountered unresolved errors
+     - You couldn't find necessary files or dependencies
+
+4. **Task Breakdown**:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+   - Always provide both forms:
+     - content: "Fix authentication bug"
+     - activeForm: "Fixing authentication bug"
+
+When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.`,
+		schema: z.object({
+			todos: z.array(todoItemSchema),
+		}),
+	},
+);

package/dist/definition/tools/web_search.d.ts

@@ -0,0 +1,4 @@
+import { ExaSearchResults } from "@langchain/exa";
+export declare function makeWebSearchTool(): ExaSearchResults<{
+	text: true;
+}>;

package/dist/definition/tools/web_search.js

@@ -0,0 +1,26 @@
+import { ExaSearchResults } from "@langchain/exa";
+import Exa from "exa-js";
+
+let _webSearchInstance = null;
+export function makeWebSearchTool() {
+	if (_webSearchInstance) {
+		return _webSearchInstance;
+	}
+	const apiKey = process.env.EXA_API_KEY;
+	if (!apiKey) {
+		throw new Error(
+			"EXA_API_KEY environment variable is required to use the web_search tool. " +
+				"Please set it to your Exa API key from https://exa.ai",
+		);
+	}
+	const client = new Exa(apiKey);
+	_webSearchInstance = new ExaSearchResults({
+		client,
+		searchArgs: {
+			numResults: 5,
+			type: "auto",
+			text: true,
+		},
+	});
+	return _webSearchInstance;
+}

package/dist/dev-agent/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/dev-agent/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { makeHttpTransport, makeStdioTransport } from "../acp-server/index";
+// Load agent definition from JSON file
+const configPath = join(import.meta.dir, "agent.json");
+const agent = JSON.parse(readFileSync(configPath, "utf-8"));
+const transport = process.argv[2] || "stdio";
+if (transport === "http") {
+    makeHttpTransport(agent);
+}
+else if (transport === "stdio") {
+    makeStdioTransport(agent);
+}
+else {
+    console.error(`Invalid transport: ${transport}`);
+    process.exit(1);
+}

package/dist/example.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};