@townco/agent 0.1.83 → 0.1.84

package/dist/runner/hooks/predefined/tool-response-compactor.js

@@ -15,6 +15,8 @@ const COMPACTION_MODEL_CONTEXT = 200000; // Haiku context size for calculating t
  * Tool response compaction hook - compacts or truncates large tool responses
  * to prevent context overflow
  */
+// Tools that should never be compacted (internal/small response tools)
+const SKIP_COMPACTION_TOOLS = new Set(["todo_write", "TodoWrite"]);
 export const toolResponseCompactor = async (ctx) => {
     // Only process if we have tool response data
     if (!ctx.toolResponse) {
@@ -22,28 +24,38 @@ export const toolResponseCompactor = async (ctx) => {
         return { newContextEntry: null };
     }
     const { toolCallId, toolName, toolInput, rawOutput, outputTokens } = ctx.toolResponse;
+    // Skip compaction for certain internal tools
+    if (SKIP_COMPACTION_TOOLS.has(toolName)) {
+        logger.debug("Skipping compaction for internal tool", { toolName });
+        return { newContextEntry: null };
+    }
     // Get settings from hook configuration
     const settings = ctx.session.requestParams.hookSettings;
-    const maxContextThreshold = settings?.maxContextThreshold ?? 80;
+    const maxTokensSize = settings?.maxTokensSize ?? 20000; // Default: 20000 tokens
     const responseTruncationThreshold = settings?.responseTruncationThreshold ?? 30;
-    // Calculate actual token limits from percentages
-    const maxAllowedTotal = ctx.maxTokens * (maxContextThreshold / 100);
-    const availableSpace = maxAllowedTotal - ctx.currentTokens;
-    const projectedTotal = ctx.currentTokens + outputTokens;
+    // Use maxTokensSize directly as it's now in tokens
+    const maxAllowedResponseSize = maxTokensSize;
+    // Calculate available space in context
+    const availableSpace = ctx.maxTokens - ctx.currentTokens;
+    // Failsafe: if available space is less than maxTokensSize, use availableSpace - 10%
+    const effectiveMaxResponseSize = availableSpace < maxAllowedResponseSize
+        ? Math.floor(availableSpace * 0.9)
+        : maxAllowedResponseSize;
     const compactionLimit = COMPACTION_MODEL_CONTEXT * (responseTruncationThreshold / 100);
     logger.info("Tool response compaction hook triggered", {
         toolCallId,
         toolName,
         outputTokens,
         currentContext: ctx.currentTokens,
-        maxAllowedTotal,
+        maxTokens: ctx.maxTokens,
+        maxAllowedResponseSize,
         availableSpace,
-        projectedTotal,
+        effectiveMaxResponseSize,
         compactionLimit,
         settings,
     });
     // Case 0: Small response, no action needed
-    if (projectedTotal < maxAllowedTotal) {
+    if (outputTokens <= effectiveMaxResponseSize) {
         logger.info("Tool response fits within threshold, no compaction needed");
         return {
             newContextEntry: null,
@@ -55,19 +67,20 @@ export const toolResponseCompactor = async (ctx) => {
         };
     }
     // Response would exceed threshold, need to compact or truncate
-    // Determine target size: fit within available space, but cap at compactionLimit for truncation
-    // IMPORTANT: If context is already over threshold, availableSpace will be negative
+    // Determine target size: use effectiveMaxResponseSize, but cap at compactionLimit for truncation
+    // IMPORTANT: If context is already very full, availableSpace might be very small
     // In that case, use a minimum reasonable target size (e.g., 10% of the output or 1000 tokens)
     const minTargetSize = Math.max(Math.floor(outputTokens * 0.1), 1000);
-    const targetSize = availableSpace > 0
-        ? Math.min(availableSpace, compactionLimit)
+    const targetSize = effectiveMaxResponseSize > 0
+        ? Math.min(effectiveMaxResponseSize, compactionLimit)
         : minTargetSize;
     logger.info("Calculated target size for compaction", {
         availableSpace,
+        effectiveMaxResponseSize,
         compactionLimit,
         minTargetSize,
         targetSize,
-        contextAlreadyOverThreshold: availableSpace <= 0,
+        contextAlreadyOverThreshold: availableSpace <= maxAllowedResponseSize,
     });
     // Case 2: Huge response, must truncate (too large for LLM compaction)
     if (outputTokens >= compactionLimit) {
@@ -133,7 +146,7 @@ export const toolResponseCompactor = async (ctx) => {
                 originalTokens: outputTokens,
                 finalTokens,
                 modifiedOutput: truncated,
-                truncationWarning: `Tool response was truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens to fit within context limit (available space: ${availableSpace.toLocaleString()} tokens)`,
+                truncationWarning: `Tool response was truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens to fit within max response size limit (max allowed: ${effectiveMaxResponseSize.toLocaleString()} tokens)`,
             },
         };
     }
@@ -141,6 +154,7 @@ export const toolResponseCompactor = async (ctx) => {
     logger.info("Tool response requires intelligent compaction", {
         outputTokens,
         targetSize,
+        effectiveMaxResponseSize,
         availableSpace,
         compactionLimit,
     });

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

@@ -18,11 +18,11 @@ export interface ContextSizeSettings {
  */
 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
+     * Maximum size of a tool response in tokens.
+     * Tool responses larger than this will trigger compaction.
+     * Default: 20000
      */
-    maxContextThreshold?: number | undefined;
+    maxTokensSize?: 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.
@@ -141,7 +141,6 @@ export declare function createContextEntry(messages: Array<{
     toolInputTokens: number;
     toolResultsTokens: number;
     totalEstimated: number;
-    llmReportedInputTokens?: number | undefined;
 }): ContextEntry;
 /**
  * Helper function to create a full message entry for context

package/dist/runner/langchain/index.js

@@ -2,7 +2,7 @@ import { mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
 import { context, propagation, trace } from "@opentelemetry/api";
-import { getShedAuth } from "@townco/core/auth";
+import { ensureAuthenticated } from "@townco/core/auth";
 import { AIMessageChunk, createAgent, ToolMessage, tool, } from "langchain";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY } from "../../acp-server/adapter";
@@ -356,7 +356,8 @@ export class LangchainAgent {
             // MCP tools - calculate overhead separately
             let mcpOverheadTokens = 0;
             if ((this.definition.mcps?.length ?? 0) > 0) {
-                const mcpTools = await makeMcpToolsClient(this.definition.mcps).getTools();
+                const client = await makeMcpToolsClient(this.definition.mcps);
+                const mcpTools = await client.getTools();
                 const mcpToolMetadata = mcpTools.map(extractToolMetadata);
                 mcpOverheadTokens = estimateAllToolsOverhead(mcpToolMetadata);
                 enabledTools.push(...mcpTools);
@@ -447,9 +448,25 @@ export class LangchainAgent {
                                 reduction: `${((1 - compactedTokens / outputTokens) * 100).toFixed(1)}%`,
                                 totalCumulativeTokens: cumulativeToolOutputTokens,
                             });
-                            return typeof result === "string"
-                                ? modifiedOutput.content
-                                : JSON.stringify(modifiedOutput);
+                            // Include compaction metadata in the output for the adapter to extract
+                            // Also include original content so adapter can store it
+                            const originalContentStr = typeof rawOutput === "object" &&
+                                rawOutput !== null &&
+                                "content" in rawOutput
+                                ? String(rawOutput.content)
+                                : JSON.stringify(rawOutput);
+                            const outputWithMeta = {
+                                ...modifiedOutput,
+                                _compactionMeta: {
+                                    action: hookResult.metadata.action,
+                                    originalTokens: hookResult.metadata.originalTokens,
+                                    finalTokens: hookResult.metadata.finalTokens,
+                                    tokensSaved: hookResult.metadata.tokensSaved,
+                                    originalContent: originalContentStr,
+                                },
+                            };
+                            // Always return JSON string to preserve metadata
+                            return JSON.stringify(outputWithMeta);
                         }
                         // No compaction happened, count original size
                         cumulativeToolOutputTokens += outputTokens;
@@ -1037,6 +1054,40 @@ export class LangchainAgent {
                                 _meta: { messageId: req.messageId },
                             });
                             // Buffer tool output separately
+                            // Check if the content contains compaction metadata and extract it
+                            let rawOutput = {
+                                content: aiMessage.content,
+                            };
+                            let compactionMeta;
+                            try {
+                                const parsed = JSON.parse(aiMessage.content);
+                                if (typeof parsed === "object" &&
+                                    parsed !== null &&
+                                    "_compactionMeta" in parsed) {
+                                    // Extract compaction metadata to top level of rawOutput
+                                    const { _compactionMeta, ...contentWithoutMeta } = parsed;
+                                    compactionMeta = _compactionMeta;
+                                    rawOutput = {
+                                        content: JSON.stringify(contentWithoutMeta),
+                                        _compactionMeta,
+                                    };
+                                }
+                            }
+                            catch {
+                                // Not valid JSON, use original content
+                            }
+                            // For content display, use cleaned version if compaction occurred
+                            let displayContent = aiMessage.content;
+                            if (compactionMeta) {
+                                try {
+                                    const parsed = JSON.parse(aiMessage.content);
+                                    const { _compactionMeta: _, ...cleanParsed } = parsed;
+                                    displayContent = JSON.stringify(cleanParsed);
+                                }
+                                catch {
+                                    // Keep original if parsing fails
+                                }
+                            }
                             pendingToolCallNotifications.push({
                                 sessionUpdate: "tool_output",
                                 toolCallId: aiMessage.tool_call_id,
@@ -1045,11 +1096,11 @@ export class LangchainAgent {
                                         type: "content",
                                         content: {
                                             type: "text",
-                                            text: aiMessage.content,
+                                            text: displayContent,
                                         },
                                     },
                                 ],
-                                rawOutput: { content: aiMessage.content },
+                                rawOutput,
                                 _meta: { messageId: req.messageId },
                             });
                             // Flush tool outputs after buffering
@@ -1119,11 +1170,11 @@ const modelRequestSchema = z.object({
         messages: z.array(z.any()),
     }),
 });
-const makeMcpToolsClient = (mcpConfigs) => {
-    const mcpServers = mcpConfigs?.map((config) => {
+const makeMcpToolsClient = async (mcpConfigs) => {
+    const mcpServers = await Promise.all((mcpConfigs ?? []).map(async (config) => {
         if (typeof config === "string") {
             // String configs use the centralized MCP proxy with auth
-            const shedAuth = getShedAuth();
+            const shedAuth = await ensureAuthenticated();
             if (!shedAuth) {
                 throw new Error("Not logged in. Run 'town login' or set SHED_API_KEY to use cloud MCP servers.");
             }
@@ -1155,7 +1206,7 @@ const makeMcpToolsClient = (mcpConfigs) => {
                 args: config.args ?? [],
             },
         ];
-    });
+    }));
     const client = new MultiServerMCPClient({
         // Global tool configuration options
         // Whether to throw on errors if a tool fails to load (optional, default: true)

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

@@ -177,9 +177,6 @@ async function deleteFromSupabase(storageKey) {
         throw new Error(`Failed to delete from Supabase Storage: ${error.message}`);
     }
 }
-/**
- * List files in Supabase Storage with optional prefix and recursion
- */
 async function listFilesInSupabase(sessionId, relativePath, recursive = false) {
     const supabase = getSupabaseClient();
     const bucket = getBucketName();
@@ -426,9 +423,6 @@ const artifactsUrl = tool(async ({ session_id, path, expires_in = 3600, }) => {
             .describe("Expiration time in seconds (1-31536000). Default: 3600 (1 hour)"),
     }),
 });
-// ============================================================================
-// Tool Metadata
-// ============================================================================
 // Add metadata for UI display
 artifactsCp.prettyName = "Copy Artifact";
 artifactsCp.icon = "Upload";
@@ -437,20 +431,23 @@ artifactsCp.verbiage = {
     past: "Copied artifact to {destination}",
     paramKey: "destination",
 };
-artifactsDel.prettyName = "Delete Artifact";
+artifactsDel.prettyName =
+    "Delete Artifact";
 artifactsDel.icon = "Trash";
 artifactsDel.verbiage = {
     active: "Deleting artifact {path}",
     past: "Deleted artifact {path}",
     paramKey: "path",
 };
-artifactsLs.prettyName = "List Artifacts";
+artifactsLs.prettyName =
+    "List Artifacts";
 artifactsLs.icon = "List";
 artifactsLs.verbiage = {
     active: "Listing artifacts",
     past: "Listed artifacts",
 };
-artifactsUrl.prettyName = "Generate Artifact URL";
+artifactsUrl.prettyName =
+    "Generate Artifact URL";
 artifactsUrl.icon = "Link";
 artifactsUrl.verbiage = {
     active: "Generating URL for {path}",

package/dist/templates/index.d.ts

@@ -31,7 +31,7 @@ export interface TemplateVars {
     } | {
         type: "tool_response";
         setting?: {
-            maxContextThreshold?: number | undefined;
+            maxTokensSize?: number | undefined;
             responseTruncationThreshold?: number | undefined;
         } | undefined;
         callback: string;