@townco/agent 0.1.80 → 0.1.82

package/dist/acp-server/adapter.js

@@ -602,8 +602,7 @@ export class AgentAcpAdapter {
             const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined, // No LLM-reported tokens yet
             this.currentToolOverheadTokens, // Include tool overhead
             this.currentMcpOverheadTokens, // Include MCP overhead
-            getModelContextWindow(this.agent.definition.model), // Model context window for UI
-            true);
+            getModelContextWindow(this.agent.definition.model));
             const contextSnapshot = createContextSnapshot(session.messages.length - 1, // Exclude the newly added user message (it will be passed separately via prompt)
             new Date().toISOString(), previousContext, context_size);
             session.context.push(contextSnapshot);
@@ -1215,13 +1214,10 @@ export class AgentAcpAdapter {
                 }
             }
             // Calculate context size with LLM-reported tokens from this turn
-            // Exclude tool results - they're only sent during the turn they were received,
-            // not in subsequent turns (only messages are sent)
             const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, turnTokenUsage.inputTokens, // Final LLM-reported tokens from this turn
             this.currentToolOverheadTokens, // Include tool overhead
             this.currentMcpOverheadTokens, // Include MCP overhead
-            getModelContextWindow(this.agent.definition.model), // Model context window for UI
-            true);
+            getModelContextWindow(this.agent.definition.model));
             const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
             session.context.push(contextSnapshot);
             await this.saveSessionToDisk(params.sessionId, session);

package/dist/runner/hooks/executor.js

@@ -163,6 +163,7 @@ export class HookExecutor {
             currentPercentage: percentage,
             callback: hook.callback,
             triggeredAt,
+            toolCallId: toolResponse.toolCallId,
         }, notifications);
         try {
             // Load and execute callback
@@ -200,6 +201,7 @@ export class HookExecutor {
                     callback: hook.callback,
                     metadata: result.metadata,
                     completedAt: Date.now(),
+                    toolCallId: toolResponse.toolCallId,
                 }, notifications);
                 return response;
             }
@@ -210,6 +212,7 @@ export class HookExecutor {
                 callback: hook.callback,
                 metadata: { action: "no_action_needed" },
                 completedAt: Date.now(),
+                toolCallId: toolResponse.toolCallId,
             }, notifications);
             return { notifications };
         }
@@ -221,6 +224,7 @@ export class HookExecutor {
                 callback: hook.callback,
                 error: error instanceof Error ? error.message : String(error),
                 completedAt: Date.now(),
+                toolCallId: toolResponse.toolCallId,
             }, notifications);
             logger.error("Tool response hook execution failed", {
                 callback: hook.callback,

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

@@ -24,14 +24,36 @@ export const compactionTool = async (ctx) => {
         });
         // Build the conversation history to compact
         const messagesToCompact = ctx.session.messages;
-        // Convert session messages to text for context
+        // Convert session messages to text for context, including tool calls and results
         const conversationText = messagesToCompact
             .map((msg) => {
-            const textContent = msg.content
-                .filter((block) => block.type === "text")
-                .map((block) => block.text)
-                .join("\n");
-            return `${msg.role.toUpperCase()}:\n${textContent}`;
+            const parts = [];
+            for (const block of msg.content) {
+                if (block.type === "text") {
+                    parts.push(block.text);
+                }
+                else if (block.type === "tool_call") {
+                    // Include tool call info
+                    parts.push(`[Tool: ${block.title}]`);
+                    if (block.rawInput) {
+                        parts.push(`Input: ${JSON.stringify(block.rawInput, null, 2)}`);
+                    }
+                    if (block.rawOutput) {
+                        // Summarize large outputs to avoid overwhelming the compaction LLM
+                        const outputStr = JSON.stringify(block.rawOutput);
+                        if (outputStr.length > 2000) {
+                            parts.push(`Output: [Large output - ${outputStr.length} chars]`);
+                        }
+                        else {
+                            parts.push(`Output: ${outputStr}`);
+                        }
+                    }
+                    if (block.error) {
+                        parts.push(`Error: ${block.error}`);
+                    }
+                }
+            }
+            return `${msg.role.toUpperCase()}:\n${parts.join("\n")}`;
         })
             .join("\n\n---\n\n");
         // Create system prompt for compaction

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

@@ -56,7 +56,19 @@ 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
-    const targetSize = Math.min(availableSpace, compactionLimit);
+    // IMPORTANT: If context is already over threshold, availableSpace will be negative
+    // 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)
+        : minTargetSize;
+    logger.info("Calculated target size for compaction", {
+        availableSpace,
+        compactionLimit,
+        minTargetSize,
+        targetSize,
+        contextAlreadyOverThreshold: availableSpace <= 0,
+    });
     // Case 2: Huge response, must truncate (too large for LLM compaction)
     if (outputTokens >= compactionLimit) {
         logger.warn("Tool response exceeds compaction capacity, truncating", {

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

@@ -168,16 +168,19 @@ export type HookNotification = {
     currentPercentage: number;
     callback: string;
     triggeredAt: number;
+    toolCallId?: string;
 } | {
     type: "hook_completed";
     hookType: HookType;
     callback: string;
     metadata?: HookResult["metadata"];
     completedAt: number;
+    toolCallId?: string;
 } | {
     type: "hook_error";
     hookType: HookType;
     callback: string;
     error: string;
     completedAt: number;
+    toolCallId?: string;
 };

package/dist/runner/langchain/index.js

@@ -472,6 +472,7 @@ export class LangchainAgent {
             }
             const agent = createAgent(agentConfig);
             // Build messages from context history if available, otherwise use just the prompt
+            // Type includes tool messages for sending tool results
             let messages;
             // Helper to convert content blocks to LangChain format
             // LangChain expects image_url type with data URL, not Claude's native image+source format
@@ -539,11 +540,62 @@ export class LangchainAgent {
             };
             if (req.contextMessages && req.contextMessages.length > 0) {
                 // Use context messages (already resolved from context entries)
-                // Convert to LangChain format
-                messages = req.contextMessages.map((msg) => ({
-                    type: msg.role === "user" ? "human" : "ai",
-                    content: convertContentBlocks(msg.content),
-                }));
+                // Convert to LangChain format, including tool calls and their results
+                messages = [];
+                for (const msg of req.contextMessages) {
+                    if (msg.role === "user") {
+                        messages.push({
+                            type: "human",
+                            content: convertContentBlocks(msg.content),
+                        });
+                    }
+                    else if (msg.role === "assistant") {
+                        // Check if message has tool calls
+                        const toolCalls = msg.content.filter((block) => block.type === "tool_call");
+                        const textBlocks = msg.content.filter((block) => block.type === "text" || block.type === "image");
+                        if (toolCalls.length > 0) {
+                            // Build AI message with tool_use blocks
+                            const aiContent = [];
+                            // Add any text content first
+                            for (const block of textBlocks) {
+                                if (block.type === "text") {
+                                    aiContent.push({ type: "text", text: block.text });
+                                }
+                            }
+                            // Add tool_use blocks
+                            for (const tc of toolCalls) {
+                                if (tc.type === "tool_call") {
+                                    aiContent.push({
+                                        type: "tool_use",
+                                        id: tc.id,
+                                        name: tc.title,
+                                        input: tc.rawInput || {},
+                                    });
+                                }
+                            }
+                            messages.push({ type: "ai", content: aiContent });
+                            // Add tool result messages for each tool call that has output
+                            for (const tc of toolCalls) {
+                                if (tc.type === "tool_call" && tc.rawOutput) {
+                                    messages.push({
+                                        type: "tool",
+                                        tool_call_id: tc.id,
+                                        content: typeof tc.rawOutput === "string"
+                                            ? tc.rawOutput
+                                            : JSON.stringify(tc.rawOutput),
+                                    });
+                                }
+                            }
+                        }
+                        else {
+                            // No tool calls - simple AI message
+                            messages.push({
+                                type: "ai",
+                                content: convertContentBlocks(msg.content),
+                            });
+                        }
+                    }
+                }
                 // Add the current prompt as the final human message
                 const promptContent = convertContentBlocks(req.prompt);
                 messages.push({
@@ -1059,7 +1111,7 @@ const makeMcpToolsClient = (mcpConfigs) => {
         // Whether to throw on errors if a tool fails to load (optional, default: true)
         throwOnLoadError: true,
         // Whether to prefix tool names with the server name (optional, default: false)
-        prefixToolNameWithServerName: false,
+        prefixToolNameWithServerName: true,
         // Optional additional prefix for tool names (optional, default: "")
         additionalToolNamePrefix: "",
         // Use standardized content block format in tool outputs

package/dist/runner/langchain/tools/filesystem.d.ts

@@ -5,8 +5,8 @@ export declare function makeFilesystemTools(workingDirectory: string): readonly
     glob: z.ZodOptional<z.ZodString>;
     output_mode: z.ZodOptional<z.ZodEnum<{
         content: "content";
-        files_with_matches: "files_with_matches";
         count: "count";
+        files_with_matches: "files_with_matches";
     }>>;
     "-B": z.ZodOptional<z.ZodNumber>;
     "-A": z.ZodOptional<z.ZodNumber>;
@@ -20,7 +20,7 @@ export declare function makeFilesystemTools(workingDirectory: string): readonly
     pattern: string;
     path?: string | undefined;
     glob?: string | undefined;
-    output_mode?: "content" | "files_with_matches" | "count" | undefined;
+    output_mode?: "content" | "count" | "files_with_matches" | undefined;
     "-B"?: number | undefined;
     "-A"?: number | undefined;
     "-C"?: number | undefined;
@@ -33,7 +33,7 @@ export declare function makeFilesystemTools(workingDirectory: string): readonly
     pattern: string;
     path?: string | undefined;
     glob?: string | undefined;
-    output_mode?: "content" | "files_with_matches" | "count" | undefined;
+    output_mode?: "content" | "count" | "files_with_matches" | undefined;
     "-B"?: number | undefined;
     "-A"?: number | undefined;
     "-C"?: number | undefined;