@townco/agent 0.1.123 → 0.1.125

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

@@ -45,11 +45,36 @@ const subagentContentBlockSchema = z.discriminatedUnion("type", [
         toolCall: subagentToolCallBlockSchema,
     }),
 ]);
+const subagentContextSizeSchema = z.object({
+    systemPromptTokens: z.number(),
+    toolOverheadTokens: z.number().optional(),
+    mcpOverheadTokens: z.number().optional(),
+    userMessagesTokens: z.number(),
+    assistantMessagesTokens: z.number(),
+    toolInputTokens: z.number(),
+    toolResultsTokens: z.number(),
+    totalEstimated: z.number(),
+    llmReportedInputTokens: z.number().optional(),
+    modelContextWindow: z.number().optional(),
+});
 const subagentMessageSchema = z.object({
     id: z.string(),
     content: z.string(),
     contentBlocks: z.array(subagentContentBlockSchema).optional(),
     toolCalls: z.array(subagentToolCallBlockSchema).optional(),
+    // Subagent streaming metadata (for UI)
+    _meta: z
+        .object({
+        semanticName: z.string().optional(),
+        agentDefinitionName: z.string().optional(),
+        currentActivity: z.string().optional(),
+        statusGenerating: z.boolean().optional(),
+        context_size: subagentContextSizeSchema.optional(),
+    })
+        .passthrough()
+        .optional(),
+    // Some older payloads may send context_size top-level
+    context_size: subagentContextSizeSchema.optional(),
 });
 const toolCallBlockSchema = z.object({
     type: z.literal("tool_call"),

package/dist/runner/langchain/tools/subagent-connections.d.ts

@@ -1,3 +1,4 @@
+import type { ContextSize } from "../../../utils/context-size-calculator.js";
 /**
  * Sub-agent tool call tracked during streaming
  */
@@ -33,6 +34,7 @@ export interface SubagentMessage {
         agentDefinitionName?: string;
         currentActivity?: string;
         statusGenerating?: boolean;
+        context_size?: ContextSize;
     };
 }
 /**

package/dist/runner/langchain/tools/subagent.js

@@ -1,6 +1,5 @@
 import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
-import { mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import Anthropic from "@anthropic-ai/sdk";
 import { context, propagation, trace } from "@opentelemetry/api";
@@ -8,7 +7,7 @@ import { createLogger } from "@townco/core";
 import { z } from "zod";
 import { AgentAcpAdapter, SUBAGENT_MODE_KEY, } from "../../../acp-server/adapter.js";
 import { makeRunnerFromDefinition } from "../../index.js";
-import { bindGeneratorToSessionContext, getAbortSignal, getSessionContext, } from "../../session-context.js";
+import { getAbortSignal, getSessionContext } from "../../session-context.js";
 import { emitSubagentMessages, hashQuery, } from "./subagent-connections.js";
 const logger = createLogger("subagent-tool", "debug");
 /**
@@ -404,6 +403,14 @@ function createStreamingConnection(queryHash, currentMessage, toolCallMap, toolN
         sessionUpdate: (notification) => {
             const update = notification.update;
             let shouldEmit = false;
+            // Capture subagent context size (usually sent by adapter via _meta.context_size)
+            const meta = update._meta;
+            const contextSize = meta?.context_size ??
+                update.context_size;
+            if (contextSize != null && currentMessage._meta) {
+                currentMessage._meta.context_size = contextSize;
+                shouldEmit = true;
+            }
             // Handle agent_message_chunk
             if (update.sessionUpdate === "agent_message_chunk") {
                 const content = update.content;
@@ -424,13 +431,13 @@ function createStreamingConnection(queryHash, currentMessage, toolCallMap, toolN
             }
             // Handle tool_call
             if (update.sessionUpdate === "tool_call" && update.toolCallId) {
-                const meta = update._meta;
+                const toolMeta = update._meta;
                 const rawInput = update.rawInput;
                 const toolCall = {
                     id: update.toolCallId,
                     title: update.title || "Tool call",
-                    prettyName: meta?.prettyName,
-                    icon: meta?.icon,
+                    prettyName: toolMeta?.prettyName,
+                    icon: toolMeta?.icon,
                     status: update.status || "pending",
                     rawInput,
                 };
@@ -608,7 +615,7 @@ async function querySubagent(agentName, agentPath, agentWorkingDirectory, query,
     try {
         // Invoke through adapter (gets full session tracking + hook execution)
         // The adapter will call connection.sessionUpdate() for streaming updates
-        const response = await adapter.prompt(promptRequest);
+        await adapter.prompt(promptRequest);
         logger.info("[DEBUG] Subagent adapter.prompt() completed", {
             agentName,
             queryHash,

package/dist/templates/index.d.ts

@@ -1,6 +1,13 @@
 import type { z } from "zod";
 import type { AgentDefinition, McpConfigSchema } from "../definition";
 type McpConfig = z.infer<typeof McpConfigSchema>;
+/** Config for a subagent to wire up via makeSubagentsTool */
+export interface SubagentConfig {
+    agentName: string;
+    toolDescription: string;
+    displayName?: string;
+    path: string;
+}
 export interface TemplateVars {
     name: string;
     model: string;
@@ -21,6 +28,7 @@ export interface TemplateVars {
         schema: unknown;
     }>;
     mcps?: McpConfig[];
+    subagents?: SubagentConfig[];
     systemPrompt: string | null;
     hasWebSearch: boolean;
     hasGenerateImage: boolean;

package/dist/templates/index.js

@@ -23,6 +23,11 @@ export function getTemplateVars(name, definition) {
     if (definition.mcps && definition.mcps.length > 0) {
         result.mcps = definition.mcps;
     }
+    // Handle subagents if defined (using type assertion since AgentDefinition may not have subagents yet)
+    const defWithSubagents = definition;
+    if (defWithSubagents.subagents && defWithSubagents.subagents.length > 0) {
+        result.subagents = defWithSubagents.subagents;
+    }
     return result;
 }
 export function generatePackageJson(vars) {
@@ -59,33 +64,57 @@ export function generatePackageJson(vars) {
     return JSON.stringify(pkg, null, 2);
 }
 export async function generateIndexTs(vars) {
-    // Build agent definition with fields in a logical order
-    const agentDef = {
-        model: vars.model,
-    };
+    const hasSubagents = vars.subagents && vars.subagents.length > 0;
+    let imports = 'import type { AgentDefinition } from "@townco/agent/definition";';
+    if (hasSubagents) {
+        imports += '\nimport { makeSubagentsTool } from "@townco/agent/utils";';
+    }
+    // Build tools code - either plain JSON or with makeSubagentsTool call
+    const toolsCode = (() => {
+        if (!hasSubagents) {
+            return JSON.stringify(vars.tools);
+        }
+        // makeSubagentsTool expects 'description' not 'toolDescription'
+        const subagentConfigs = vars.subagents.map((s) => ({
+            agentName: s.agentName,
+            description: s.toolDescription,
+            ...(s.displayName && { displayName: s.displayName }),
+            path: s.path,
+        }));
+        const subagentToolCall = `makeSubagentsTool(${JSON.stringify(subagentConfigs, null, 2)})`;
+        const toolItems = vars.tools.map((t) => JSON.stringify(t));
+        toolItems.push(subagentToolCall);
+        return `[${toolItems.join(", ")}]`;
+    })();
+    // Build optional fields
+    const optionalFields = [];
     if (vars.displayName) {
-        agentDef.displayName = vars.displayName;
+        optionalFields.push(`displayName: ${JSON.stringify(vars.displayName)},`);
     }
     if (vars.description) {
-        agentDef.description = vars.description;
+        optionalFields.push(`description: ${JSON.stringify(vars.description)},`);
     }
     if (vars.suggestedPrompts) {
-        agentDef.suggestedPrompts = vars.suggestedPrompts;
+        optionalFields.push(`suggestedPrompts: ${JSON.stringify(vars.suggestedPrompts)},`);
     }
-    agentDef.systemPrompt = vars.systemPrompt;
-    agentDef.tools = vars.tools;
     if (vars.mcps && vars.mcps.length > 0) {
-        agentDef.mcps = vars.mcps;
+        optionalFields.push(`mcps: ${JSON.stringify(vars.mcps)},`);
     }
     if (vars.hooks) {
-        agentDef.hooks = vars.hooks;
+        optionalFields.push(`hooks: ${JSON.stringify(vars.hooks)},`);
     }
-    return prettier.format(`import type { AgentDefinition } from "@townco/agent/definition";
+    const optionalFieldsStr = optionalFields.length > 0 ? `\n  ${optionalFields.join("\n  ")}` : "";
+    const code = `${imports}
 
-const agent: AgentDefinition = ${JSON.stringify(agentDef)};
+const agent: AgentDefinition = {
+  model: ${JSON.stringify(vars.model)},${optionalFieldsStr}
+  systemPrompt: ${JSON.stringify(vars.systemPrompt)},
+  tools: ${toolsCode},
+};
 
 export default agent;
-`, { parser: "typescript" });
+`;
+    return prettier.format(code, { parser: "typescript" });
 }
 export function generateBinTs() {
     return `#!/usr/bin/env bun