@townco/agent 0.1.42 → 0.1.43

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

@@ -1,5 +1,3 @@
 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/test-acp-summarize.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Test the agent/summarize ACP method via the /rpc endpoint
+ *
+ * This test does NOT require an Anthropic API key because
+ * summarization just analyzes existing messages without calling the API
+ */
+export {};

package/dist/acp-server/test-acp-summarize.js

@@ -0,0 +1,127 @@
+/**
+ * Test the agent/summarize ACP method via the /rpc endpoint
+ *
+ * This test does NOT require an Anthropic API key because
+ * summarization just analyzes existing messages without calling the API
+ */
+// Make this a module
+export {};
+// Sample Anthropic API request with tool calls
+const request = {
+    jsonrpc: "2.0",
+    id: "test-123",
+    method: "agent/summarize",
+    params: {
+        messages: [
+            {
+                role: "assistant",
+                content: [
+                    {
+                        type: "tool_use",
+                        id: "toolu_01ABC",
+                        name: "read_file",
+                        input: {
+                            target_file: "package.json",
+                        },
+                    },
+                ],
+            },
+            {
+                role: "user",
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: "toolu_01ABC",
+                        content: '{"name":"my-project"}',
+                    },
+                ],
+            },
+            {
+                role: "assistant",
+                content: [
+                    {
+                        type: "tool_use",
+                        id: "toolu_02DEF",
+                        name: "codebase_search",
+                        input: {
+                            query: "React components",
+                            target_directories: [],
+                        },
+                    },
+                ],
+            },
+            {
+                role: "user",
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: "toolu_02DEF",
+                        content: "Found 5 components",
+                    },
+                ],
+            },
+        ],
+    },
+};
+const serverUrl = process.env.ACP_SERVER_URL || "http://localhost:3100";
+console.log("=".repeat(60));
+console.log("Testing agent/summarize via ACP Protocol");
+console.log("=".repeat(60));
+console.log();
+console.log(`Server URL: ${serverUrl}`);
+console.log(`Method: agent/summarize`);
+console.log(`Tool Calls: 2 (read_file, codebase_search)`);
+console.log();
+try {
+    const response = await fetch(`${serverUrl}/rpc`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(request),
+    });
+    if (!response.ok) {
+        console.error(`HTTP Error: ${response.status} ${response.statusText}`);
+        const errorText = await response.text();
+        console.error("Response:", errorText);
+        process.exit(1);
+    }
+    const data = await response.json();
+    // Check for JSON-RPC error
+    if (data.error) {
+        console.error("JSON-RPC Error:", JSON.stringify(data.error, null, 2));
+        process.exit(1);
+    }
+    console.log("✅ Success! JSON-RPC Response:");
+    console.log(JSON.stringify(data, null, 2));
+    console.log();
+    // Display the summary in a nice format
+    if (data.result && data.result.summary) {
+        console.log("Summary:");
+        console.log(`  Total: ${data.result.summary.total}`);
+        console.log(`  Completed: ${data.result.summary.byStatus.completed || 0}`);
+        console.log(`  Errors: ${data.result.summary.byStatus.error || 0}`);
+        console.log();
+        console.log("Tool Calls:");
+        for (const toolCall of data.result.toolCalls || []) {
+            const statusEmoji = toolCall.status === "completed"
+                ? "✓"
+                : toolCall.status === "error"
+                    ? "✗"
+                    : "⋯";
+            console.log(`  ${statusEmoji} ${toolCall.description}`);
+        }
+    }
+    console.log();
+    console.log("=".repeat(60));
+    console.log("Test Complete - No API Key Required! ✅");
+    console.log("=".repeat(60));
+}
+catch (error) {
+    console.error("Connection Error:");
+    console.error(error instanceof Error ? error.message : String(error));
+    console.log();
+    console.log("Make sure the ACP server is running:");
+    console.log("  bun run dev:agent-http --no-session");
+    process.exit(1);
+}

package/dist/acp-server/test-summarizer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Test script for the /summarize endpoint
+ *
+ * Usage:
+ *   bun packages/agent/acp-server/test-summarizer.ts
+ */
+export {};

package/dist/acp-server/test-summarizer.js

@@ -0,0 +1,170 @@
+/**
+ * Test script for the /summarize endpoint
+ *
+ * Usage:
+ *   bun packages/agent/acp-server/test-summarizer.ts
+ */
+import { extractToolCalls, generateTextSummary, summarizeToolCalls, } from "./tool-summarizer";
+// Test data: Sample Anthropic API request with tool calls
+const sampleRequest = {
+    model: "claude-sonnet-4-5-20250929",
+    messages: [
+        {
+            role: "user",
+            content: "Please read the package.json file",
+        },
+        {
+            role: "assistant",
+            content: [
+                {
+                    type: "text",
+                    text: "I'll read the package.json file for you.",
+                },
+                {
+                    type: "tool_use",
+                    id: "toolu_01ABC123",
+                    name: "read_file",
+                    input: {
+                        target_file: "package.json",
+                    },
+                },
+            ],
+        },
+        {
+            role: "user",
+            content: [
+                {
+                    type: "tool_result",
+                    tool_use_id: "toolu_01ABC123",
+                    content: JSON.stringify({
+                        name: "my-project",
+                        version: "1.0.0",
+                        dependencies: {
+                            react: "^18.0.0",
+                        },
+                    }),
+                },
+            ],
+        },
+        {
+            role: "assistant",
+            content: [
+                {
+                    type: "text",
+                    text: "Now let me search for React components.",
+                },
+                {
+                    type: "tool_use",
+                    id: "toolu_02DEF456",
+                    name: "codebase_search",
+                    input: {
+                        query: "React components using hooks",
+                        target_directories: [],
+                    },
+                },
+            ],
+        },
+        {
+            role: "user",
+            content: [
+                {
+                    type: "tool_result",
+                    tool_use_id: "toolu_02DEF456",
+                    content: "Found 5 components...",
+                },
+            ],
+        },
+        {
+            role: "assistant",
+            content: [
+                {
+                    type: "text",
+                    text: "Let me try to run a command that will fail.",
+                },
+                {
+                    type: "tool_use",
+                    id: "toolu_03GHI789",
+                    name: "run_terminal_cmd",
+                    input: {
+                        command: "invalid-command",
+                    },
+                },
+            ],
+        },
+        {
+            role: "user",
+            content: [
+                {
+                    type: "tool_result",
+                    tool_use_id: "toolu_03GHI789",
+                    content: "Command not found: invalid-command",
+                    is_error: true,
+                },
+            ],
+        },
+    ],
+};
+console.log("=".repeat(60));
+console.log("Testing Tool Call Summarizer");
+console.log("=".repeat(60));
+console.log();
+// Test 1: Extract tool calls
+console.log("Test 1: Extract Tool Calls");
+console.log("-".repeat(60));
+const toolCalls = extractToolCalls(sampleRequest.messages);
+console.log(`Found ${toolCalls.length} tool calls`);
+console.log();
+for (const toolCall of toolCalls) {
+    console.log(`- ${toolCall.description} [${toolCall.status}]`);
+    console.log(`  ID: ${toolCall.id}`);
+    console.log(`  Name: ${toolCall.name}`);
+}
+console.log();
+// Test 2: Generate summary
+console.log("Test 2: Generate Summary");
+console.log("-".repeat(60));
+const summary = summarizeToolCalls(sampleRequest);
+console.log(`Total: ${summary.total}`);
+console.log(`By Status:`, summary.byStatus);
+console.log(`By Tool:`, summary.byTool);
+console.log();
+// Test 3: Generate text summary
+console.log("Test 3: Generate Text Summary");
+console.log("-".repeat(60));
+const textSummary = generateTextSummary(summary.summaries, {
+    includeDetails: true,
+});
+console.log(textSummary);
+console.log();
+// Test 4: Test with HTTP endpoint (if server is running)
+console.log("Test 4: Test HTTP Endpoint");
+console.log("-".repeat(60));
+const serverUrl = process.env.ACP_SERVER_URL || "http://localhost:3100";
+console.log(`Testing endpoint: ${serverUrl}/summarize`);
+try {
+    const response = await fetch(`${serverUrl}/summarize`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(sampleRequest),
+    });
+    if (!response.ok) {
+        const errorData = await response.json();
+        console.error("Error:", errorData);
+    }
+    else {
+        const data = await response.json();
+        console.log("Success! Response:");
+        console.log(JSON.stringify(data, null, 2));
+    }
+}
+catch (error) {
+    console.error("Could not connect to server. Make sure the ACP server is running.");
+    console.error("Start it with: bun packages/agent/acp-server/cli.ts");
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+}
+console.log();
+console.log("=".repeat(60));
+console.log("Tests Complete");
+console.log("=".repeat(60));

package/dist/acp-server/tool-summarizer.d.ts

@@ -0,0 +1,125 @@
+import { z } from "zod";
+/**
+ * Anthropic API tool call format
+ */
+export declare const AnthropicToolCallSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"tool_use">;
+    name: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type AnthropicToolCall = z.infer<typeof AnthropicToolCallSchema>;
+/**
+ * Anthropic API content block format
+ */
+export declare const AnthropicContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"tool_use">;
+    name: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    tool_use_id: z.ZodString;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>>]>;
+    is_error: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>], "type">;
+export type AnthropicContentBlock = z.infer<typeof AnthropicContentBlockSchema>;
+/**
+ * Anthropic API message format
+ */
+export declare const AnthropicMessageSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        assistant: "assistant";
+        user: "user";
+    }>;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"tool_use">;
+        name: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        tool_use_id: z.ZodString;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>>]>;
+        is_error: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "type">>]>;
+}, z.core.$strip>;
+export type AnthropicMessage = z.infer<typeof AnthropicMessageSchema>;
+/**
+ * Anthropic API request format
+ */
+export declare const AnthropicRequestSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            user: "user";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"tool_use">;
+            name: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_result">;
+            tool_use_id: z.ZodString;
+            content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>>]>;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>], "type">>]>;
+    }, z.core.$strip>>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    system: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodAny>]>>;
+}, z.core.$strip>;
+export type AnthropicRequest = z.infer<typeof AnthropicRequestSchema>;
+/**
+ * Tool call summary for display
+ */
+export interface ToolCallSummary {
+    id: string;
+    name: string;
+    description: string;
+    input: Record<string, unknown>;
+    output?: string | undefined;
+    status: "pending" | "completed" | "error";
+    error?: string | undefined;
+}
+/**
+ * Extract tool calls from Anthropic API messages
+ */
+export declare function extractToolCalls(messages: AnthropicMessage[]): ToolCallSummary[];
+/**
+ * Generate a summary of tool calls for the entire conversation
+ */
+export declare function summarizeToolCalls(request: AnthropicRequest): {
+    total: number;
+    byStatus: Record<string, number>;
+    byTool: Record<string, number>;
+    summaries: ToolCallSummary[];
+};
+/**
+ * Generate a text summary of tool calls
+ */
+export declare function generateTextSummary(summaries: ToolCallSummary[], options?: {
+    includeDetails?: boolean;
+    maxLength?: number;
+}): string;

package/dist/acp-server/tool-summarizer.js

@@ -0,0 +1,182 @@
+import { z } from "zod";
+/**
+ * Anthropic API tool call format
+ */
+export const AnthropicToolCallSchema = z.object({
+    id: z.string(),
+    type: z.literal("tool_use"),
+    name: z.string(),
+    input: z.record(z.string(), z.unknown()),
+});
+/**
+ * Anthropic API content block format
+ */
+export const AnthropicContentBlockSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    }),
+    AnthropicToolCallSchema,
+    z.object({
+        type: z.literal("tool_result"),
+        tool_use_id: z.string(),
+        content: z.union([
+            z.string(),
+            z.array(z.object({
+                type: z.literal("text"),
+                text: z.string(),
+            })),
+        ]),
+        is_error: z.boolean().optional(),
+    }),
+]);
+/**
+ * Anthropic API message format
+ */
+export const AnthropicMessageSchema = z.object({
+    role: z.enum(["user", "assistant"]),
+    content: z.union([z.string(), z.array(AnthropicContentBlockSchema)]),
+});
+/**
+ * Anthropic API request format
+ */
+export const AnthropicRequestSchema = z.object({
+    model: z.string().optional(),
+    messages: z.array(AnthropicMessageSchema),
+    max_tokens: z.number().optional(),
+    temperature: z.number().optional(),
+    tools: z.array(z.any()).optional(),
+    system: z.union([z.string(), z.array(z.any())]).optional(),
+});
+/**
+ * Extract tool calls from Anthropic API messages
+ */
+export function extractToolCalls(messages) {
+    const summaries = [];
+    const toolResultsMap = new Map();
+    // First pass: collect all tool results
+    for (const message of messages) {
+        if (typeof message.content === "string")
+            continue;
+        for (const block of message.content) {
+            if (block.type === "tool_result") {
+                const content = typeof block.content === "string"
+                    ? block.content
+                    : block.content.map((c) => c.text).join("\n");
+                toolResultsMap.set(block.tool_use_id, {
+                    content,
+                    isError: block.is_error ?? false,
+                });
+            }
+        }
+    }
+    // Second pass: collect all tool calls and match with results
+    for (const message of messages) {
+        if (typeof message.content === "string")
+            continue;
+        for (const block of message.content) {
+            if (block.type === "tool_use") {
+                const result = toolResultsMap.get(block.id);
+                const summary = {
+                    id: block.id,
+                    name: block.name,
+                    description: generateToolDescription(block.name, block.input),
+                    input: block.input,
+                    output: result?.content ?? undefined,
+                    status: result
+                        ? result.isError
+                            ? "error"
+                            : "completed"
+                        : "pending",
+                    error: result?.isError ? result.content : undefined,
+                };
+                summaries.push(summary);
+            }
+        }
+    }
+    return summaries;
+}
+/**
+ * Generate a human-readable description for a tool call
+ */
+function generateToolDescription(toolName, input) {
+    switch (toolName) {
+        case "read_file":
+            return `Reading file: ${input.target_file || "unknown"}`;
+        case "write":
+            return `Writing file: ${input.file_path || "unknown"}`;
+        case "search_replace":
+            return `Editing file: ${input.file_path || "unknown"}`;
+        case "grep":
+            return `Searching for: "${input.pattern || "unknown"}"`;
+        case "codebase_search":
+            return `Semantic search: "${input.query || "unknown"}"`;
+        case "run_terminal_cmd":
+            return `Running command: ${input.command || "unknown"}`;
+        case "list_dir":
+            return `Listing directory: ${input.target_directory || "unknown"}`;
+        case "glob_file_search":
+            return `Finding files: ${input.glob_pattern || "unknown"}`;
+        case "delete_file":
+            return `Deleting file: ${input.target_file || "unknown"}`;
+        case "todo_write":
+            return `Updating TODO list (${input.todos?.length || 0} items)`;
+        default:
+            return `${toolName}(${Object.keys(input).join(", ")})`;
+    }
+}
+/**
+ * Generate a summary of tool calls for the entire conversation
+ */
+export function summarizeToolCalls(request) {
+    const summaries = extractToolCalls(request.messages);
+    const byStatus = {
+        pending: 0,
+        completed: 0,
+        error: 0,
+    };
+    const byTool = {};
+    for (const summary of summaries) {
+        byStatus[summary.status] = (byStatus[summary.status] || 0) + 1;
+        byTool[summary.name] = (byTool[summary.name] || 0) + 1;
+    }
+    return {
+        total: summaries.length,
+        byStatus,
+        byTool,
+        summaries,
+    };
+}
+/**
+ * Generate a text summary of tool calls
+ */
+export function generateTextSummary(summaries, options) {
+    if (summaries.length === 0) {
+        return "No tool calls in this conversation.";
+    }
+    const { includeDetails = false, maxLength = 1000 } = options || {};
+    let text = `Found ${summaries.length} tool call(s):\n\n`;
+    for (const summary of summaries) {
+        const statusEmoji = summary.status === "completed"
+            ? "✓"
+            : summary.status === "error"
+                ? "✗"
+                : "⋯";
+        text += `${statusEmoji} ${summary.description}\n`;
+        if (includeDetails) {
+            if (summary.output) {
+                const outputPreview = summary.output.length > 100
+                    ? `${summary.output.slice(0, 100)}...`
+                    : summary.output;
+                text += `  Output: ${outputPreview}\n`;
+            }
+            if (summary.error) {
+                text += `  Error: ${summary.error}\n`;
+            }
+        }
+    }
+    if (text.length > maxLength) {
+        text = `${text.slice(0, maxLength)}...\n\n(truncated)`;
+    }
+    return text;
+}

package/dist/definition/index.d.ts

@@ -28,6 +28,8 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
         description: z.ZodString;
         fn: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
         schema: z.ZodAny;
+        prettyName: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;

package/dist/definition/index.js

@@ -42,6 +42,8 @@ const DirectToolSchema = z.object({
     description: z.string(),
     fn: z.function(),
     schema: z.any(), // Accept any Zod schema
+    prettyName: z.string().optional(),
+    icon: z.string().optional(),
 });
 /** Tool schema - can be a string (built-in tool) or custom tool object. */
 const ToolSchema = z.union([

package/dist/definition/mcp.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -16,6 +16,8 @@ export declare const zAgentRunnerParams: z.ZodObject<{
         description: z.ZodString;
         fn: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
         schema: z.ZodAny;
+        prettyName: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>]>>>;
     mcps: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;
@@ -56,7 +58,10 @@ export interface AgentMessageChunkWithTokens {
         [key: string]: unknown;
     };
 }
-export type ExtendedSessionUpdate = SessionNotification["update"] | {
+export type ExtendedSessionUpdate = (SessionNotification["update"] & {
+    prettyName?: string;
+    icon?: string;
+}) | {
     sessionUpdate: "tool_output";
     toolCallId: string;
     content?: Array<{

package/dist/runner/index.d.ts

@@ -1,6 +1,4 @@
 import type { AgentDefinition } from "../definition";
 import { type AgentRunner } from "./agent-runner";
 export type { AgentRunner };
-export declare const makeRunnerFromDefinition: (
-	definition: AgentDefinition,
-) => AgentRunner;
+export declare const makeRunnerFromDefinition: (definition: AgentDefinition) => AgentRunner;