@townco/agent 0.1.50 → 0.1.52

package/dist/check-jaeger.js

@@ -0,0 +1,82 @@
+/**
+ * Quick script to verify Jaeger connectivity
+ * Run with: bun check-jaeger.ts
+ */
+export {}; // Make this a module for top-level await
+console.log("🔍 Checking Jaeger connectivity...\n");
+// Check if Jaeger collector is accepting OTLP on gRPC port
+const checkPort = async (port, protocol) => {
+    try {
+        const net = await import("node:net");
+        const socket = new net.Socket();
+        return new Promise((resolve) => {
+            socket.setTimeout(2000);
+            socket.on("connect", () => {
+                console.log(`✅ ${protocol} port ${port} is accepting connections`);
+                socket.destroy();
+                resolve(true);
+            });
+            socket.on("timeout", () => {
+                console.log(`❌ ${protocol} port ${port} timed out`);
+                socket.destroy();
+                resolve(false);
+            });
+            socket.on("error", (error) => {
+                console.log(`❌ ${protocol} port ${port} not reachable: ${error.message}`);
+                resolve(false);
+            });
+            socket.connect(port, "localhost");
+        });
+    }
+    catch (error) {
+        console.log(`❌ Error checking ${protocol} port ${port}:`, error);
+        return false;
+    }
+};
+// Check Jaeger ports
+console.log("Checking Jaeger ports:");
+console.log("─────────────────────────────");
+await checkPort(4317, "OTLP gRPC"); // Collector OTLP gRPC
+await checkPort(4318, "OTLP HTTP"); // Collector OTLP HTTP
+await checkPort(16686, "UI       "); // Query UI
+console.log("\n🔍 Checking Docker container...\n");
+// Check if Jaeger container is running
+try {
+    const { execSync } = await import("node:child_process");
+    const output = execSync("docker ps --filter name=jaeger --format '{{.Status}}'", {
+        encoding: "utf-8",
+    }).trim();
+    if (output) {
+        console.log(`✅ Jaeger container is running: ${output}`);
+        // Check container logs for OTLP
+        try {
+            const logs = execSync("docker logs jaeger 2>&1 | tail -20", {
+                encoding: "utf-8",
+            });
+            console.log("\n📋 Recent container logs:");
+            console.log("─────────────────────────────");
+            console.log(logs);
+        }
+        catch (e) {
+            console.log("⚠️  Could not fetch container logs");
+        }
+    }
+    else {
+        console.log("❌ No Jaeger container running with name 'jaeger'");
+        console.log("\n💡 Start Jaeger with:");
+        console.log("docker run -d --name jaeger \\");
+        console.log("  -e COLLECTOR_OTLP_ENABLED=true \\");
+        console.log("  -p 16686:16686 \\");
+        console.log("  -p 4317:4317 \\");
+        console.log("  -p 4318:4318 \\");
+        console.log("  jaegertracing/all-in-one:latest");
+    }
+}
+catch (error) {
+    console.log("⚠️  Could not check Docker container:", error);
+}
+console.log("\n🎯 Next steps:");
+console.log("─────────────────────────────");
+console.log("1. Make sure ports above show ✅");
+console.log("2. Run the test: ENABLE_TELEMETRY=true bun test-telemetry.ts");
+console.log("3. Check UI: http://localhost:16686");

package/dist/definition/index.d.ts

@@ -16,14 +16,22 @@ export declare const McpConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
 export declare const HookConfigSchema: z.ZodObject<{
     type: z.ZodEnum<{
         context_size: "context_size";
+        tool_response: "tool_response";
     }>;
-    setting: z.ZodOptional<z.ZodObject<{
+    setting: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         threshold: z.ZodNumber;
-    }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        maxContextThreshold: z.ZodOptional<z.ZodNumber>;
+        responseTruncationThreshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
     callback: z.ZodString;
 }, z.core.$strip>;
 /** Agent definition schema. */
 export declare const AgentDefinitionSchema: z.ZodObject<{
+    displayName: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    suggestedPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     systemPrompt: z.ZodNullable<z.ZodString>;
     model: z.ZodString;
     tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -56,10 +64,14 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
     hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             context_size: "context_size";
+            tool_response: "tool_response";
         }>;
-        setting: z.ZodOptional<z.ZodObject<{
+        setting: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
             threshold: z.ZodNumber;
-        }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            maxContextThreshold: z.ZodOptional<z.ZodNumber>;
+            responseTruncationThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>]>>;
         callback: z.ZodString;
     }, z.core.$strip>>>;
 }, z.core.$strip>;

package/dist/definition/index.js

@@ -54,16 +54,29 @@ const ToolSchema = z.union([
 ]);
 /** Hook configuration schema. */
 export const HookConfigSchema = z.object({
-    type: z.enum(["context_size"]),
+    type: z.enum(["context_size", "tool_response"]),
     setting: z
-        .object({
-        threshold: z.number().min(0).max(100),
-    })
+        .union([
+        // For context_size hooks
+        z.object({
+            threshold: z.number().min(0).max(100),
+        }),
+        // For tool_response hooks
+        z.object({
+            maxContextThreshold: z.number().min(0).max(100).optional(),
+            responseTruncationThreshold: z.number().min(0).max(100).optional(),
+        }),
+    ])
         .optional(),
     callback: z.string(),
 });
 /** Agent definition schema. */
 export const AgentDefinitionSchema = z.object({
+    /** Human-readable display name for the agent (shown in UI). */
+    displayName: z.string().optional(),
+    version: z.string().optional(),
+    description: z.string().optional(),
+    suggestedPrompts: z.array(z.string()).optional(),
     systemPrompt: z.string().nullable(),
     model: z.string(),
     tools: z.array(ToolSchema).optional(),

package/dist/index.js

@@ -36,7 +36,7 @@ const exampleAgent = {
         {
             type: "context_size",
             setting: {
-                threshold: 95,
+                threshold: 80,
             },
             callback: "compaction_tool",
         },

package/dist/run-subagents.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+/**
+ * Helper script to test makeSubagentsTool
+ *
+ * Usage:
+ *   bun packages/agent/run-subagents.ts
+ *   bun packages/agent/run-subagents.ts "your custom query here"
+ */
+export {};

package/dist/run-subagents.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env bun
+/**
+ * Helper script to test makeSubagentsTool
+ *
+ * Usage:
+ *   bun packages/agent/run-subagents.ts
+ *   bun packages/agent/run-subagents.ts "your custom query here"
+ */
+import { makeSubagentsTool } from "./utils";
+import { makeRunnerFromDefinition } from "./runner";
+// Default query if none provided
+const defaultQuery = "Can you search for news about artificial intelligence?";
+const userQuery = process.argv[2] || defaultQuery;
+console.log("🧪 Testing makeSubagentsTool\n");
+console.log("Query:", userQuery);
+console.log("─".repeat(60));
+// Create a simple subagent definition
+const simpleSubagent = {
+    model: "claude-sonnet-4-5-20250929",
+    systemPrompt: "You are a helpful research assistant. Provide concise, informative responses.",
+    tools: [
+        "web_search",
+        "todo_write",
+    ],
+    mcps: [],
+};
+// Create the coordinator agent with subagent tool
+const coordinatorAgent = {
+    model: "claude-sonnet-4-5-20250929",
+    systemPrompt: `You are a coordinator agent that delegates tasks to specialized subagents.
+When you receive a query, evaluate if it needs to be delegated to a subagent.
+If so, use the Task tool with the appropriate subagent.`,
+    tools: [
+        makeSubagentsTool([
+            {
+                agentName: "researcher",
+                description: "Use this agent to research topics, search the web, and gather information",
+                path: import.meta.filename, // Points to itself as a simple test
+            },
+            {
+                agentName: "simple",
+                description: "Use this for general tasks that don't require specialized tools",
+                path: import.meta.filename,
+            },
+        ]),
+    ],
+    mcps: [],
+};
+// Run the test
+async function runTest() {
+    console.log("\n📝 Creating runner...");
+    const runner = makeRunnerFromDefinition(coordinatorAgent);
+    console.log("🚀 Running query...\n");
+    try {
+        const stream = runner.invoke({
+            prompt: [
+                {
+                    type: "text",
+                    text: userQuery,
+                },
+            ],
+            sessionId: "test-session",
+            messageId: "msg-1",
+        });
+        console.log("📊 Stream output:");
+        console.log("─".repeat(60));
+        let messageCount = 0;
+        let toolCallCount = 0;
+        let lastTextContent = "";
+        for await (const chunk of stream) {
+            messageCount++;
+            // Pretty print different types of chunks
+            if (chunk.type === "agent_message_chunk") {
+                const content = chunk.content;
+                if (content.type === "text" && content.text) {
+                    process.stdout.write(content.text);
+                    lastTextContent += content.text;
+                }
+                else if (content.type === "tool_use") {
+                    toolCallCount++;
+                    console.log(`\n\n🔧 Tool Call #${toolCallCount}: ${content.name}`);
+                    console.log("   Input:", JSON.stringify(content.input, null, 2).split('\n').join('\n   '));
+                }
+            }
+            else if (chunk.type === "tool_result") {
+                console.log("\n\n✅ Tool Result:");
+                console.log("   ", JSON.stringify(chunk, null, 2).split('\n').join('\n   '));
+            }
+            else {
+                // Print other chunk types for debugging
+                console.log("\n\n📦 Chunk:", JSON.stringify(chunk, null, 2));
+            }
+        }
+        console.log("\n\n" + "─".repeat(60));
+        console.log("✨ Test completed!");
+        console.log(`   Total chunks: ${messageCount}`);
+        console.log(`   Tool calls: ${toolCallCount}`);
+        console.log("─".repeat(60));
+    }
+    catch (error) {
+        console.error("\n❌ Error during test:");
+        console.error(error);
+        process.exit(1);
+    }
+}
+// Run the test
+runTest().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

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

@@ -2,6 +2,10 @@ import type { PromptRequest, PromptResponse, SessionNotification } from "@agentc
 import { z } from "zod";
 import type { ContentBlock } from "../acp-server/session-storage.js";
 export declare const zAgentRunnerParams: z.ZodObject<{
+    displayName: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    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.ZodObject<{
@@ -33,10 +37,14 @@ export declare const zAgentRunnerParams: z.ZodObject<{
     hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             context_size: "context_size";
+            tool_response: "tool_response";
         }>;
-        setting: z.ZodOptional<z.ZodObject<{
+        setting: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
             threshold: z.ZodNumber;
-        }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            maxContextThreshold: z.ZodOptional<z.ZodNumber>;
+            responseTruncationThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>]>>;
         callback: z.ZodString;
     }, z.core.$strip>>>;
 }, z.core.$strip>;

package/dist/runner/agent-runner.js

@@ -2,6 +2,10 @@ import { z } from "zod";
 import { HookConfigSchema, McpConfigSchema } from "../definition";
 import { zToolType } from "./tools";
 export const zAgentRunnerParams = z.object({
+    displayName: z.string().optional(),
+    version: z.string().optional(),
+    description: z.string().optional(),
+    suggestedPrompts: z.array(z.string()).optional(),
     systemPrompt: z.string().nullable(),
     model: z.string(),
     tools: z.array(zToolType).optional(),

package/dist/runner/hooks/executor.d.ts

@@ -20,4 +20,21 @@ export declare class HookExecutor {
      * Execute a context_size hook
      */
     private executeContextSizeHook;
+    /**
+     * Execute tool_response hooks when a tool returns output
+     */
+    executeToolResponseHooks(session: ReadonlySession, currentContextTokens: number, toolResponse: {
+        toolCallId: string;
+        toolName: string;
+        toolInput: Record<string, unknown>;
+        rawOutput: Record<string, unknown>;
+        outputTokens: number;
+    }): Promise<{
+        modifiedOutput?: Record<string, unknown>;
+        truncationWarning?: string;
+    }>;
+    /**
+     * Execute a single tool_response hook
+     */
+    private executeToolResponseHook;
 }

package/dist/runner/hooks/executor.js

@@ -106,4 +106,70 @@ export class HookExecutor {
             };
         }
     }
+    /**
+     * Execute tool_response hooks when a tool returns output
+     */
+    async executeToolResponseHooks(session, currentContextTokens, toolResponse) {
+        logger.info(`Executing tool_response hooks - found ${this.hooks.length} hook(s)`, {
+            toolCallId: toolResponse.toolCallId,
+            toolName: toolResponse.toolName,
+            outputTokens: toolResponse.outputTokens,
+        });
+        for (const hook of this.hooks) {
+            if (hook.type === "tool_response") {
+                const result = await this.executeToolResponseHook(hook, session, currentContextTokens, toolResponse);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return {}; // No modifications
+    }
+    /**
+     * Execute a single tool_response hook
+     */
+    async executeToolResponseHook(hook, session, currentContextTokens, toolResponse) {
+        const maxTokens = getModelMaxTokens(this.model);
+        try {
+            // Load and execute callback
+            const callback = await this.loadCallback(hook.callback);
+            // Pass hook settings through requestParams
+            const sessionWithSettings = {
+                ...session,
+                requestParams: {
+                    ...session.requestParams,
+                    hookSettings: hook.setting,
+                },
+            };
+            const hookContext = {
+                session: sessionWithSettings,
+                currentTokens: currentContextTokens,
+                maxTokens,
+                percentage: (currentContextTokens / maxTokens) * 100,
+                model: this.model,
+                toolResponse,
+            };
+            const result = await callback(hookContext);
+            // Extract modified output and warnings from metadata
+            if (result.metadata) {
+                const response = {};
+                if (result.metadata.modifiedOutput) {
+                    response.modifiedOutput = result.metadata.modifiedOutput;
+                }
+                if (result.metadata.truncationWarning) {
+                    response.truncationWarning = result.metadata
+                        .truncationWarning;
+                }
+                return response;
+            }
+            return null;
+        }
+        catch (error) {
+            logger.error("Tool response hook execution failed", {
+                callback: hook.callback,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null; // Return original output on error
+        }
+    }
 }

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

@@ -99,7 +99,15 @@ Please provide your summary based on the conversation above, following this stru
         const summaryEntry = createFullMessageEntry("user", `This session is being continued from a previous conversation that ran out of context. The conversation is summarized below:\n${summaryText}`);
         // Set compactedUpTo to indicate all messages have been compacted into the summary
         const lastMessageIndex = messagesToCompact.length - 1;
-        const newContextEntry = createContextEntry([summaryEntry], undefined, lastMessageIndex, summaryTokens);
+        const newContextEntry = createContextEntry([summaryEntry], undefined, lastMessageIndex, {
+            // Store summary tokens in userMessagesTokens since the summary is a user message
+            systemPromptTokens: 0,
+            userMessagesTokens: summaryTokens,
+            assistantMessagesTokens: 0,
+            toolInputTokens: 0,
+            toolResultsTokens: 0,
+            totalEstimated: summaryTokens,
+        });
         return {
             newContextEntry,
             metadata: {

package/dist/runner/hooks/predefined/tool-response-compactor.d.ts

@@ -0,0 +1,6 @@
+import type { HookCallback } from "../types.js";
+/**
+ * Tool response compaction hook - compacts or truncates large tool responses
+ * to prevent context overflow
+ */
+export declare const toolResponseCompactor: HookCallback;