@townco/agent 0.1.55 → 0.1.56

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

@@ -24,6 +24,7 @@ export declare class AgentAcpAdapter implements acp.Agent {
     private agentVersion;
     private agentDescription;
     private agentSuggestedPrompts;
+    private agentInitialMessage;
     private currentToolOverheadTokens;
     private currentMcpOverheadTokens;
     constructor(agent: AgentRunner, connection: acp.AgentSideConnection, agentDir?: string, agentName?: string);

package/dist/acp-server/adapter.js

@@ -105,6 +105,7 @@ export class AgentAcpAdapter {
     agentVersion;
     agentDescription;
     agentSuggestedPrompts;
+    agentInitialMessage;
     currentToolOverheadTokens = 0; // Track tool overhead for current turn
     currentMcpOverheadTokens = 0; // Track MCP overhead for current turn
     constructor(agent, connection, agentDir, agentName) {
@@ -117,6 +118,7 @@ export class AgentAcpAdapter {
         this.agentVersion = agent.definition.version;
         this.agentDescription = agent.definition.description;
         this.agentSuggestedPrompts = agent.definition.suggestedPrompts;
+        this.agentInitialMessage = agent.definition.initialMessage;
         this.noSession = process.env.TOWN_NO_SESSION === "true";
         this.storage =
             agentDir && agentName && !this.noSession
@@ -129,6 +131,7 @@ export class AgentAcpAdapter {
             agentVersion: this.agentVersion,
             agentDescription: this.agentDescription,
             suggestedPrompts: this.agentSuggestedPrompts,
+            initialMessage: this.agentInitialMessage,
             noSession: this.noSession,
             hasStorage: this.storage !== null,
             sessionStoragePath: this.storage ? `${agentDir}/.sessions` : null,
@@ -259,6 +262,9 @@ export class AgentAcpAdapter {
             ...(this.agentSuggestedPrompts
                 ? { suggestedPrompts: this.agentSuggestedPrompts }
                 : {}),
+            ...(this.agentInitialMessage
+                ? { initialMessage: this.agentInitialMessage }
+                : {}),
             ...(toolsMetadata.length > 0 ? { tools: toolsMetadata } : {}),
             ...(mcpsMetadata.length > 0 ? { mcps: mcpsMetadata } : {}),
             ...(subagentsMetadata.length > 0 ? { subagents: subagentsMetadata } : {}),
@@ -273,6 +279,8 @@ export class AgentAcpAdapter {
             context: [],
             requestParams: params,
         });
+        // Note: Initial message is sent by the HTTP transport when SSE connection is established
+        // This ensures the message is delivered after the client is ready to receive it
         return {
             sessionId,
         };

package/dist/acp-server/http.js

@@ -10,6 +10,7 @@ import { streamSSE } from "hono/streaming";
 import { createLogger, isSubagent } from "../logger.js";
 import { makeRunnerFromDefinition } from "../runner";
 import { AgentAcpAdapter } from "./adapter";
+import { SessionStorage } from "./session-storage";
 const logger = createLogger("http");
 /**
  * Compress a payload using gzip if it's too large for PostgreSQL NOTIFY
@@ -69,6 +70,10 @@ export function makeHttpTransport(agent, agentDir, agentName) {
     const app = new Hono();
     // Track active SSE streams by sessionId for direct output delivery
     const sseStreams = new Map();
+    // Track sessions that have already received initial message
+    const initialMessageSentSessions = new Set();
+    // Get initial message config from agent definition
+    const initialMessageConfig = agentRunner.definition.initialMessage;
     const decoder = new TextDecoder();
     const encoder = new TextEncoder();
     (async () => {
@@ -270,6 +275,28 @@ export function makeHttpTransport(agent, agentDir, agentName) {
         allowMethods: ["GET", "POST", "OPTIONS"],
     }));
     app.get("/health", (c) => c.json({ ok: true }));
+    // List available sessions
+    app.get("/sessions", async (c) => {
+        if (!agentDir || !agentName) {
+            return c.json({ sessions: [], error: "Session storage not configured" });
+        }
+        const noSession = process.env.TOWN_NO_SESSION === "true";
+        if (noSession) {
+            return c.json({ sessions: [], error: "Sessions disabled" });
+        }
+        try {
+            const storage = new SessionStorage(agentDir, agentName);
+            const sessions = await storage.listSessionsWithMetadata();
+            return c.json({ sessions });
+        }
+        catch (error) {
+            logger.error("Failed to list sessions", { error });
+            return c.json({
+                sessions: [],
+                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) => {
@@ -319,6 +346,42 @@ export function makeHttpTransport(agent, agentDir, agentName) {
             // Register this stream for direct tool output delivery
             sseStreams.set(sessionId, stream);
             await stream.writeSSE({ event: "ping", data: "{}" });
+            // Send initial message if configured and not already sent for this session
+            if (initialMessageConfig?.enabled &&
+                initialMessageConfig.content &&
+                !initialMessageSentSessions.has(sessionId)) {
+                initialMessageSentSessions.add(sessionId);
+                // Process template variables in the content
+                let content = initialMessageConfig.content;
+                content = content.replace(/\{\{\.AgentName\}\}/g, agentName ?? "Agent");
+                const displayName = agentRunner.definition.displayName;
+                content = content.replace(/\{\{\.DisplayName\}\}/g, displayName ?? agentName ?? "Agent");
+                const initialMessage = {
+                    jsonrpc: "2.0",
+                    method: "session/update",
+                    params: {
+                        sessionId,
+                        update: {
+                            sessionUpdate: "agent_message_chunk",
+                            content: {
+                                type: "text",
+                                text: content,
+                            },
+                            _meta: {
+                                isInitialMessage: true,
+                            },
+                        },
+                    },
+                };
+                await stream.writeSSE({
+                    event: "message",
+                    data: JSON.stringify(initialMessage),
+                });
+                logger.info("Sent initial message via SSE", {
+                    sessionId,
+                    contentPreview: content.slice(0, 100),
+                });
+            }
             const hb = setInterval(() => {
                 // Heartbeat to keep proxies from terminating idle connections
                 void stream.writeSSE({ event: "ping", data: "{}" });

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

@@ -150,4 +150,18 @@ export declare class SessionStorage {
      * List all session IDs
      */
     listSessions(): Promise<string[]>;
+    /**
+     * Session summary for listing
+     */
+    /**
+     * List all sessions with metadata
+     * Returns sessions sorted by updatedAt (most recent first)
+     */
+    listSessionsWithMetadata(): Promise<Array<{
+        sessionId: string;
+        createdAt: string;
+        updatedAt: string;
+        messageCount: number;
+        firstUserMessage?: string;
+    }>>;
 }

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

@@ -236,4 +236,51 @@ export class SessionStorage {
             throw new Error(`Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Session summary for listing
+     */
+    /**
+     * List all sessions with metadata
+     * 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);
+                    }
+                }
+                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;
+        }
+        catch (error) {
+            throw new Error(`Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
 }

package/dist/definition/index.d.ts

@@ -26,6 +26,11 @@ export declare const HookConfigSchema: z.ZodObject<{
     }, z.core.$strip>]>>;
     callback: z.ZodString;
 }, z.core.$strip>;
+/** Initial message configuration schema. */
+export declare const InitialMessageSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    content: z.ZodString;
+}, z.core.$strip>;
 /** Agent definition schema. */
 export declare const AgentDefinitionSchema: z.ZodObject<{
     displayName: z.ZodOptional<z.ZodString>;
@@ -74,4 +79,8 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
         }, z.core.$strip>]>>;
         callback: z.ZodString;
     }, z.core.$strip>>>;
+    initialMessage: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        content: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/definition/index.js

@@ -71,6 +71,13 @@ export const HookConfigSchema = z.object({
         .optional(),
     callback: z.string(),
 });
+/** Initial message configuration schema. */
+export const InitialMessageSchema = z.object({
+    /** Whether the agent should send an initial message when a session starts. */
+    enabled: z.boolean(),
+    /** The content of the initial message to send. Supports template variables like {{.AgentName}}. */
+    content: z.string(),
+});
 /** Agent definition schema. */
 export const AgentDefinitionSchema = z.object({
     /** Human-readable display name for the agent (shown in UI). */
@@ -84,4 +91,6 @@ export const AgentDefinitionSchema = z.object({
     mcps: z.array(McpConfigSchema).optional(),
     harnessImplementation: z.literal("langchain").optional(),
     hooks: z.array(HookConfigSchema).optional(),
+    /** Configuration for an initial message the agent sends when a session starts. */
+    initialMessage: InitialMessageSchema.optional(),
 });

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

@@ -8,7 +8,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<"filesystem">, z.ZodLiteral<"generate_image">]>, z.ZodObject<{
+    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<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"browser">]>, z.ZodObject<{
         type: z.ZodLiteral<"custom">;
         modulePath: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
@@ -52,6 +52,10 @@ export declare const zAgentRunnerParams: z.ZodObject<{
         }, z.core.$strip>]>>;
         callback: z.ZodString;
     }, z.core.$strip>>>;
+    initialMessage: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        content: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type CreateAgentRunnerParams = z.infer<typeof zAgentRunnerParams>;
 export interface SessionMessage {

package/dist/runner/agent-runner.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { HookConfigSchema, McpConfigSchema } from "../definition";
+import { HookConfigSchema, InitialMessageSchema, McpConfigSchema, } from "../definition";
 import { zToolType } from "./tools";
 export const zAgentRunnerParams = z.object({
     displayName: z.string().optional(),
@@ -11,4 +11,5 @@ export const zAgentRunnerParams = z.object({
     tools: z.array(zToolType).optional(),
     mcps: z.array(McpConfigSchema).optional(),
     hooks: z.array(HookConfigSchema).optional(),
+    initialMessage: InitialMessageSchema.optional(),
 });

package/dist/runner/langchain/index.js

@@ -1,5 +1,6 @@
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { context, propagation, trace } from "@opentelemetry/api";
+import { loadAuthCredentials } from "@townco/core/auth";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY } from "../../acp-server/adapter";
@@ -8,6 +9,7 @@ import { telemetry } from "../../telemetry/index.js";
 import { loadCustomToolModule, } from "../tool-loader.js";
 import { createModelFromString, detectProvider } from "./model-factory.js";
 import { makeOtelCallbacks } from "./otel-callbacks.js";
+import { makeBrowserTools } from "./tools/browser";
 import { makeFilesystemTools } from "./tools/filesystem";
 import { makeGenerateImageTool } from "./tools/generate_image";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
@@ -29,6 +31,7 @@ export const TOOL_REGISTRY = {
     web_search: () => makeWebSearchTools(),
     filesystem: () => makeFilesystemTools(process.cwd()),
     generate_image: () => makeGenerateImageTool(),
+    browser: () => makeBrowserTools(),
 };
 // ============================================================================
 // Custom tool loading
@@ -78,11 +81,14 @@ export class LangchainAgent {
         const countedMessageIds = new Set();
         // Track tool calls for which we've emitted preliminary notifications (from early tool_use blocks)
         const preliminaryToolCallIds = new Set();
+        // Set session_id as a base attribute so all spans in this invocation include it
+        telemetry.setBaseAttributes({
+            "agent.session_id": req.sessionId,
+        });
         // Start telemetry span for entire invocation
         const invocationSpan = telemetry.startSpan("agent.invoke", {
             "agent.model": this.definition.model,
             "agent.subagent": meta?.[SUBAGENT_MODE_KEY] === true,
-            "agent.session_id": req.sessionId,
             "agent.message_id": req.messageId,
         }, parentContext);
         // Create a context with the invocation span as active
@@ -294,7 +300,7 @@ export class LangchainAgent {
                 : wrappedTools;
             // Wrap tools with tracing so each tool executes within its own span context.
             // This ensures subagent spans are children of the Task tool span.
-            const finalTools = filteredTools.map((t) => wrapToolWithTracing(t, req.sessionId));
+            const finalTools = filteredTools.map((t) => wrapToolWithTracing(t));
             // Create the model instance using the factory
             // This detects the provider from the model string:
             // - "gemini-2.0-flash" → Google Generative AI
@@ -776,12 +782,19 @@ const modelRequestSchema = z.object({
 const makeMcpToolsClient = (mcpConfigs) => {
     const mcpServers = mcpConfigs?.map((config) => {
         if (typeof config === "string") {
-            // Default to localhost:3000/mcp_proxy if not specified
-            const proxyUrl = process.env.MCP_PROXY_URL || "http://localhost:3000/mcp_proxy";
+            // String configs use the centralized MCP proxy with auth
+            const credentials = loadAuthCredentials();
+            if (!credentials) {
+                throw new Error("Not logged in. Run 'town login' first to use cloud MCP servers.");
+            }
+            const proxyUrl = process.env.MCP_PROXY_URL ?? `${credentials.shed_url}/mcp_proxy`;
             return [
                 config,
                 {
                     url: `${proxyUrl}?server=${config}`,
+                    headers: {
+                        Authorization: `Bearer ${credentials.access_token}`,
+                    },
                 },
             ];
         }
@@ -874,13 +887,12 @@ export { makeSubagentsTool } from "./tools/subagent.js";
  * so any child operations (like subagent spawning) become children
  * of the tool span rather than the parent invocation span.
  */
-function wrapToolWithTracing(originalTool, sessionId) {
+function wrapToolWithTracing(originalTool) {
     const wrappedFunc = async (input) => {
         const toolInputJson = JSON.stringify(input);
         const toolSpan = telemetry.startSpan("agent.tool_call", {
             "tool.name": originalTool.name,
             "tool.input": toolInputJson,
-            "agent.session_id": sessionId,
         });
         // Create a context with the tool span as active
         const spanContext = toolSpan

package/dist/runner/langchain/model-factory.d.ts

@@ -4,6 +4,7 @@ import type { BaseChatModel } from "@langchain/core/language_models/chat_models"
  * LangChain chat model instance.
  *
  * Detection logic:
+ * - If model starts with "town-" → Proxied via shed (strips prefix, uses TOWN_SHED_URL)
  * - If model starts with "vertex-" → Google Vertex AI (strips prefix)
  * - If model contains "gemini" (unprefixed) → Google Generative AI
  * - If model contains "gpt" → OpenAI (future support)
@@ -12,6 +13,7 @@ import type { BaseChatModel } from "@langchain/core/language_models/chat_models"
  * Supported formats:
  * - Direct model name: "gemini-2.0-flash", "vertex-gemini-2.0-flash", "claude-sonnet-4-5-20250929"
  * - Provider prefix: "google_vertexai:gemini-2.0-flash", "google_genai:gemini-2.0-flash", "anthropic:claude-3-5-sonnet"
+ * - Proxied: "town-claude-sonnet-4-5-20250929" (uses TOWN_SHED_URL or defaults to localhost:3000)
  */
 export declare function createModelFromString(modelString: string): BaseChatModel;
 /**

package/dist/runner/langchain/model-factory.js

@@ -1,6 +1,7 @@
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ChatVertexAI } from "@langchain/google-vertexai";
+import { loadAuthCredentials } from "@townco/core/auth";
 import { createLogger } from "../../logger.js";
 const logger = createLogger("model-factory");
 /**
@@ -8,6 +9,7 @@ const logger = createLogger("model-factory");
  * LangChain chat model instance.
  *
  * Detection logic:
+ * - If model starts with "town-" → Proxied via shed (strips prefix, uses TOWN_SHED_URL)
  * - If model starts with "vertex-" → Google Vertex AI (strips prefix)
  * - If model contains "gemini" (unprefixed) → Google Generative AI
  * - If model contains "gpt" → OpenAI (future support)
@@ -16,8 +18,25 @@ const logger = createLogger("model-factory");
  * Supported formats:
  * - Direct model name: "gemini-2.0-flash", "vertex-gemini-2.0-flash", "claude-sonnet-4-5-20250929"
  * - Provider prefix: "google_vertexai:gemini-2.0-flash", "google_genai:gemini-2.0-flash", "anthropic:claude-3-5-sonnet"
+ * - Proxied: "town-claude-sonnet-4-5-20250929" (uses TOWN_SHED_URL or defaults to localhost:3000)
  */
 export function createModelFromString(modelString) {
+    // Check for town- prefix for proxied models via shed
+    if (modelString.startsWith("town-")) {
+        const actualModel = modelString.slice(5); // strip "town-"
+        const credentials = loadAuthCredentials();
+        if (!credentials) {
+            throw new Error("Not logged in. Run 'town login' first.");
+        }
+        const shedUrl = credentials.shed_url ??
+            process.env.TOWN_SHED_URL ??
+            "http://localhost:3000";
+        return new ChatAnthropic({
+            model: actualModel,
+            anthropicApiUrl: `${shedUrl}/api/anthropic`,
+            apiKey: credentials.access_token,
+        });
+    }
     // Check if the model string uses provider prefix format
     const parts = modelString.split(":", 2);
     const maybeProvider = parts[0];

package/dist/runner/langchain/tools/browser.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+interface BrowserNavigateResult {
+    success: boolean;
+    url?: string;
+    title?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserScreenshotResult {
+    success: boolean;
+    screenshotPath?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserExtractResult {
+    success: boolean;
+    content?: string;
+    url?: string;
+    title?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserClickResult {
+    success: boolean;
+    message?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserTypeResult {
+    success: boolean;
+    message?: string;
+    liveViewUrl?: string;
+    error?: string;
+}
+interface BrowserCloseResult {
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export declare function makeBrowserTools(): readonly [import("langchain").DynamicStructuredTool<z.ZodObject<{
+    url: z.ZodString;
+    waitUntil: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        load: "load";
+        domcontentloaded: "domcontentloaded";
+        networkidle: "networkidle";
+    }>>>;
+}, z.core.$strip>, {
+    url: string;
+    waitUntil: "load" | "domcontentloaded" | "networkidle";
+}, {
+    url: string;
+    waitUntil?: "load" | "domcontentloaded" | "networkidle" | undefined;
+}, BrowserNavigateResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    fullPage: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    selector: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, {
+    fullPage: boolean;
+    selector?: string | undefined;
+}, {
+    fullPage?: boolean | undefined;
+    selector?: string | undefined;
+}, BrowserScreenshotResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    selector: z.ZodOptional<z.ZodString>;
+    extractType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        text: "text";
+        html: "html";
+    }>>>;
+}, z.core.$strip>, {
+    extractType: "text" | "html";
+    selector?: string | undefined;
+}, {
+    selector?: string | undefined;
+    extractType?: "text" | "html" | undefined;
+}, BrowserExtractResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    selector: z.ZodString;
+    button: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+        middle: "middle";
+    }>>>;
+}, z.core.$strip>, {
+    selector: string;
+    button: "left" | "right" | "middle";
+}, {
+    selector: string;
+    button?: "left" | "right" | "middle" | undefined;
+}, BrowserClickResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
+    selector: z.ZodString;
+    text: z.ZodString;
+    pressEnter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>, {
+    selector: string;
+    text: string;
+    pressEnter: boolean;
+}, {
+    selector: string;
+    text: string;
+    pressEnter?: boolean | undefined;
+}, BrowserTypeResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{}, z.core.$strip>, Record<string, never>, Record<string, never>, BrowserCloseResult>];
+export {};