@townco/agent 0.1.50 → 0.1.51

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

@@ -3,7 +3,7 @@ import type { SessionMessage } from "../agent-runner";
 /**
  * Hook types supported by the agent system
  */
-export type HookType = "context_size";
+export type HookType = "context_size" | "tool_response";
 /**
  * Settings for context_size hook
  */
@@ -13,6 +13,24 @@ export interface ContextSizeSettings {
      */
     threshold: number;
 }
+/**
+ * Settings for tool_response hook
+ */
+export interface ToolResponseSettings {
+    /**
+     * Maximum % of main model context that tool response + current context can reach
+     * If adding the tool response would exceed this, compaction is triggered
+     * Default: 80
+     */
+    maxContextThreshold?: number | undefined;
+    /**
+     * Maximum % of compaction model context (Haiku: 200k) that a tool response can be
+     * to attempt LLM-based compaction. Larger responses are truncated instead.
+     * The truncation limit is also this percentage.
+     * Default: 30
+     */
+    responseTruncationThreshold?: number | undefined;
+}
 /**
  * Hook configuration in agent definition
  */
@@ -24,7 +42,7 @@ export interface HookConfig {
     /**
      * Optional hook-specific settings
      */
-    setting?: ContextSizeSettings | undefined;
+    setting?: ContextSizeSettings | ToolResponseSettings | undefined;
     /**
      * Callback reference - either a predefined hook name or a file path
      * Examples: "compaction_tool" or "./hooks/my_compaction_tool.ts"
@@ -72,6 +90,16 @@ export interface HookContext {
      * The model being used
      */
     model: string;
+    /**
+     * Tool response data (only for tool_response hooks)
+     */
+    toolResponse?: {
+        toolCallId: string;
+        toolName: string;
+        toolInput: Record<string, unknown>;
+        rawOutput: Record<string, unknown>;
+        outputTokens: number;
+    };
 }
 /**
  * Result returned by hook callbacks
@@ -106,7 +134,15 @@ export declare function createContextEntry(messages: Array<{
 } | {
     type: "full";
     message: SessionMessage;
-}>, timestamp?: string, compactedUpTo?: number, inputTokens?: number): ContextEntry;
+}>, timestamp?: string, compactedUpTo?: number, context_size?: {
+    systemPromptTokens: number;
+    userMessagesTokens: number;
+    assistantMessagesTokens: number;
+    toolInputTokens: number;
+    toolResultsTokens: number;
+    totalEstimated: number;
+    llmReportedInputTokens?: number | undefined;
+}): ContextEntry;
 /**
  * Helper function to create a full message entry for context
  * Use this when hooks need to inject new messages into context

package/dist/runner/hooks/types.js

@@ -2,17 +2,22 @@
  * Helper function to create a new context entry
  * Use this when hooks want to create a new context snapshot
  */
-export function createContextEntry(messages, timestamp, compactedUpTo, inputTokens) {
+export function createContextEntry(messages, timestamp, compactedUpTo, context_size) {
     const entry = {
         timestamp: timestamp || new Date().toISOString(),
         messages,
+        context_size: context_size || {
+            systemPromptTokens: 0,
+            userMessagesTokens: 0,
+            assistantMessagesTokens: 0,
+            toolInputTokens: 0,
+            toolResultsTokens: 0,
+            totalEstimated: 0,
+        },
     };
     if (compactedUpTo !== undefined) {
         entry.compactedUpTo = compactedUpTo;
     }
-    if (inputTokens !== undefined) {
-        entry.inputTokens = inputTokens;
-    }
     return entry;
 }
 /**

package/dist/runner/langchain/index.js

@@ -161,11 +161,103 @@ export class LangchainAgent {
             if ((this.definition.mcps?.length ?? 0) > 0) {
                 enabledTools.push(...(await makeMcpToolsClient(this.definition.mcps).getTools()));
             }
+            // Wrap tools with response compaction if hook is configured
+            const hooks = this.definition.hooks ?? [];
+            const hasToolResponseHook = hooks.some((h) => h.type === "tool_response");
+            const noSession = req.sessionMeta?.[SUBAGENT_MODE_KEY] === true; // Subagents don't have session storage
+            // Track cumulative tool output tokens in this turn for proper context calculation
+            let cumulativeToolOutputTokens = 0;
+            let wrappedTools = enabledTools;
+            if (hasToolResponseHook && !noSession) {
+                const { countToolResultTokens } = await import("../../utils/token-counter.js");
+                const { toolResponseCompactor } = await import("../hooks/predefined/tool-response-compactor.js");
+                wrappedTools = enabledTools.map((originalTool) => {
+                    const wrappedFunc = async (input) => {
+                        // Execute the original tool
+                        const result = await originalTool.invoke(input);
+                        // Check if result should be compacted
+                        const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+                        const rawOutput = { content: resultStr };
+                        const outputTokens = countToolResultTokens(rawOutput);
+                        // Skip compaction for small results (under 10k tokens)
+                        if (outputTokens < 10000) {
+                            // Still track this in cumulative total
+                            cumulativeToolOutputTokens += outputTokens;
+                            return result;
+                        }
+                        _logger.info("Tool wrapper: compacting large tool result", {
+                            toolName: originalTool.name,
+                            originalTokens: outputTokens,
+                            cumulativeToolOutputTokens,
+                        });
+                        // Calculate current context including all tool outputs so far in this turn
+                        // This ensures we account for multiple large tool calls in the same turn
+                        const baseContextTokens = turnTokenUsage.inputTokens || 10000;
+                        const currentTokens = baseContextTokens + cumulativeToolOutputTokens;
+                        const maxTokens = 200000; // Claude's limit
+                        // Build proper hook context with all required fields
+                        const hookContext = {
+                            session: {
+                                messages: req.contextMessages || [],
+                                context: [],
+                                requestParams: {
+                                    hookSettings: hooks.find((h) => h.type === "tool_response")
+                                        ?.setting,
+                                },
+                            },
+                            currentTokens,
+                            maxTokens,
+                            percentage: (currentTokens / maxTokens) * 100,
+                            model: this.definition.model,
+                            toolResponse: {
+                                toolCallId: "pending",
+                                toolName: originalTool.name,
+                                toolInput: input,
+                                rawOutput,
+                                outputTokens,
+                            },
+                        };
+                        // Call the tool response compactor directly
+                        const hookResult = await toolResponseCompactor(hookContext);
+                        // Extract modified output from metadata
+                        if (hookResult?.metadata?.modifiedOutput) {
+                            const modifiedOutput = hookResult.metadata
+                                .modifiedOutput;
+                            const compactedTokens = countToolResultTokens(modifiedOutput);
+                            // Update cumulative total with the compacted size (not original!)
+                            cumulativeToolOutputTokens += compactedTokens;
+                            _logger.info("Tool wrapper: compaction complete", {
+                                toolName: originalTool.name,
+                                originalTokens: outputTokens,
+                                compactedTokens,
+                                reduction: `${((1 - compactedTokens / outputTokens) * 100).toFixed(1)}%`,
+                                totalCumulativeTokens: cumulativeToolOutputTokens,
+                            });
+                            return typeof result === "string"
+                                ? modifiedOutput.content
+                                : JSON.stringify(modifiedOutput);
+                        }
+                        // No compaction happened, count original size
+                        cumulativeToolOutputTokens += outputTokens;
+                        return result;
+                    };
+                    // Create new tool with wrapped function
+                    const wrappedTool = tool(wrappedFunc, {
+                        name: originalTool.name,
+                        description: originalTool.description,
+                        schema: originalTool.schema,
+                    });
+                    // Preserve metadata
+                    wrappedTool.prettyName = originalTool.prettyName;
+                    wrappedTool.icon = originalTool.icon;
+                    return wrappedTool;
+                });
+            }
             // Filter tools if running in subagent mode
             const isSubagent = req.sessionMeta?.[SUBAGENT_MODE_KEY] === true;
             const finalTools = isSubagent
-                ? enabledTools.filter((t) => t.name !== TODO_WRITE_TOOL_NAME && t.name !== TASK_TOOL_NAME)
-                : enabledTools;
+                ? wrappedTools.filter((t) => t.name !== TODO_WRITE_TOOL_NAME && t.name !== TASK_TOOL_NAME)
+                : wrappedTools;
             // Create the model instance using the factory
             // This detects the provider from the model string:
             // - "gemini-2.0-flash" → Google Generative AI
@@ -187,79 +279,6 @@ export class LangchainAgent {
             const agent = createAgent(agentConfig);
             // Add logging callbacks for model requests
             const provider = detectProvider(this.definition.model);
-            const loggingCallback = {
-                handleChatModelStart: async (_llm, messages, runId, parentRunId, extraParams) => {
-                    _logger.info("Model request started", {
-                        provider,
-                        model: this.definition.model,
-                        runId,
-                        parentRunId,
-                        messageCount: messages.length,
-                        extraParams,
-                    });
-                },
-                handleLLMEnd: async (output, runId, parentRunId, tags, extraParams) => {
-                    // Extract token usage from output
-                    const llmResult = output;
-                    _logger.info("Model request completed", {
-                        provider,
-                        model: this.definition.model,
-                        runId,
-                        parentRunId,
-                        tags,
-                        tokenUsage: llmResult.llmOutput?.tokenUsage,
-                        generationCount: llmResult.generations?.length,
-                        extraParams,
-                    });
-                },
-                handleLLMError: async (error, runId, parentRunId, tags) => {
-                    _logger.error("Model request failed", {
-                        provider,
-                        model: this.definition.model,
-                        runId,
-                        parentRunId,
-                        tags,
-                        error: error.message,
-                        stack: error.stack,
-                    });
-                },
-                handleToolStart: async (_tool, input, runId, parentRunId, tags, metadata, runName) => {
-                    if (process.env.DEBUG_TELEMETRY === "true") {
-                        console.log(`[handleToolStart] runId=${runId}, runName=${runName}, parentRunId=${parentRunId}`);
-                        console.log(`[handleToolStart] Active context span:`, trace.getSpan(context.active())?.spanContext());
-                    }
-                    _logger.info("Tool started", {
-                        runId,
-                        parentRunId,
-                        runName,
-                        tags,
-                        metadata,
-                        input: input.substring(0, 200), // Truncate for logging
-                    });
-                },
-                handleToolEnd: async (_output, runId, parentRunId, tags) => {
-                    if (process.env.DEBUG_TELEMETRY === "true") {
-                        console.log(`[handleToolEnd] runId=${runId}, parentRunId=${parentRunId}`);
-                    }
-                    _logger.info("Tool completed", {
-                        runId,
-                        parentRunId,
-                        tags,
-                    });
-                },
-                handleToolError: async (error, runId, parentRunId, tags) => {
-                    if (process.env.DEBUG_TELEMETRY === "true") {
-                        console.log(`[handleToolError] runId=${runId}, error=${error.message}`);
-                    }
-                    _logger.error("Tool failed", {
-                        runId,
-                        parentRunId,
-                        tags,
-                        error: error.message,
-                        stack: error.stack,
-                    });
-                },
-            };
             // Build messages from context history if available, otherwise use just the prompt
             let messages;
             if (req.contextMessages && req.contextMessages.length > 0) {
@@ -303,7 +322,7 @@ export class LangchainAgent {
             const stream = context.with(invocationContext, () => agent.stream({ messages }, {
                 streamMode: ["updates", "messages"],
                 recursionLimit: 200,
-                callbacks: [loggingCallback, otelCallbacks],
+                callbacks: [otelCallbacks],
             }));
             for await (const streamItem of await stream) {
                 const [streamMode, chunk] = streamItem;

package/dist/scaffold/link-local.d.ts

@@ -0,0 +1 @@
+export declare function linkLocalPackages(projectPath: string): Promise<void>;

package/dist/scaffold/link-local.js

@@ -0,0 +1,54 @@
+import { exists } from "node:fs/promises";
+import { join } from "node:path";
+import { $ } from "bun";
+const PACKAGE_PATHS = {
+    "@townco/ui": "packages/ui",
+    "@townco/core": "packages/core",
+    "@townco/tsconfig": "packages/tsconfig",
+    "@townco/tui-template": "apps/tui",
+    "@townco/gui-template": "apps/gui",
+    "@townco/secret": "packages/secret",
+    "@townco/agent": "packages/agent",
+    "@townco/cli": "apps/cli",
+};
+async function getMonorepoRoot() {
+    try {
+        // 1. Get git repo root
+        const result = await $ `git rev-parse --show-toplevel`.quiet();
+        const repoRoot = result.text().trim();
+        // 2. Check package.json name === "town"
+        const pkgJsonPath = join(repoRoot, "package.json");
+        const pkgJson = await Bun.file(pkgJsonPath).json();
+        if (pkgJson.name !== "town")
+            return null;
+        // 3. Check packages/agent and packages/ui exist
+        const agentExists = await exists(join(repoRoot, "packages/agent"));
+        const uiExists = await exists(join(repoRoot, "packages/ui"));
+        if (!agentExists || !uiExists)
+            return null;
+        return repoRoot;
+    }
+    catch {
+        return null;
+    }
+}
+export async function linkLocalPackages(projectPath) {
+    const repoRoot = await getMonorepoRoot();
+    if (!repoRoot)
+        return; // Not in monorepo, no-op
+    console.log("Detected town monorepo, linking local packages...");
+    // 1. Register each local package globally
+    for (const [, localPath] of Object.entries(PACKAGE_PATHS)) {
+        const pkgPath = join(repoRoot, localPath);
+        await $ `bun link`.cwd(pkgPath).quiet();
+    }
+    // 2. Parse project's package.json for @townco/* deps
+    const pkgJson = await Bun.file(join(projectPath, "package.json")).json();
+    const deps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+    const towncoPackages = Object.keys(deps).filter((name) => name.startsWith("@townco/"));
+    // 3. Link each package in the project
+    for (const pkgName of towncoPackages) {
+        await $ `bun link ${pkgName}`.cwd(projectPath);
+        console.log(`Linked ${pkgName}`);
+    }
+}

package/dist/scaffold/project-scaffold.js

@@ -21,6 +21,7 @@ function generateProjectPackageJson() {
             "@radix-ui/react-select": "^2.2.6",
             "@radix-ui/react-slot": "^1.2.4",
             "@radix-ui/react-tabs": "^1.1.13",
+            "@townco/core": "~0.0.23",
             "@townco/ui": "^0.1.0",
             "@townco/agent": "^0.1.20",
             "class-variance-authority": "^0.7.1",

package/dist/templates/index.d.ts

@@ -23,6 +23,13 @@ export interface TemplateVars {
             threshold: number;
         } | undefined;
         callback: string;
+    } | {
+        type: "tool_response";
+        setting?: {
+            maxContextThreshold?: number | undefined;
+            responseTruncationThreshold?: number | undefined;
+        } | undefined;
+        callback: string;
     }> | undefined;
 }
 export declare function getTemplateVars(name: string, definition: AgentDefinition): TemplateVars;