@townco/agent 0.1.83 → 0.1.85

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

@@ -2,6 +2,7 @@ import Anthropic from "@anthropic-ai/sdk";
 import { createLogger } from "../../../logger.js";
 import { telemetry } from "../../../telemetry/index.js";
 import { countToolResultTokens } from "../../../utils/token-counter.js";
+import { extractDocumentContext } from "./document-context-extractor/index.js";
 const logger = createLogger("tool-response-compactor");
 // Create Anthropic client directly (not using LangChain)
 // This ensures compaction LLM calls don't get captured by LangGraph's streaming
@@ -15,6 +16,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 +25,39 @@ 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 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;
-    const compactionLimit = COMPACTION_MODEL_CONTEXT * (responseTruncationThreshold / 100);
+    const maxTokensSize = settings?.maxTokensSize ?? 20000; // Default: 20000 tokens
+    // 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;
+    // Calculate compaction limit: max response size that can fit in a single LLM compaction call
+    const COMPACTION_OVERHEAD = 10000;
+    const compactionLimit = Math.floor((COMPACTION_MODEL_CONTEXT - COMPACTION_OVERHEAD) * 0.9); // ~175K tokens
     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,
@@ -54,93 +68,99 @@ 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
+    // Response would exceed threshold, need to compact or extract
+    // Target size is the effectiveMaxResponseSize (what we want the final output to be)
+    // 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)
-        : minTargetSize;
+    const targetSize = effectiveMaxResponseSize > 0 ? effectiveMaxResponseSize : 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)
+    // Case 2: Huge response - use document context extractor (with truncation fallback)
     if (outputTokens >= compactionLimit) {
-        logger.warn("Tool response exceeds compaction capacity, truncating", {
+        logger.info("Tool response exceeds compaction capacity, using document context extractor", {
             outputTokens,
             compactionLimit,
             targetSize,
             availableSpace,
         });
-        const truncated = truncateToolResponse(rawOutput, targetSize);
-        const finalTokens = countToolResultTokens(truncated);
-        // Verify truncation stayed within boundaries
-        if (finalTokens > targetSize) {
-            logger.error("Truncation exceeded target size - this should not happen!", {
-                finalTokens,
-                targetSize,
-                excess: finalTokens - targetSize,
-            });
-            // Try more aggressive truncation (70% of target as emergency measure)
-            const emergencySize = Math.floor(targetSize * 0.7);
-            const emergencyTruncated = truncateToolResponse(rawOutput, emergencySize);
-            const emergencyTokens = countToolResultTokens(emergencyTruncated);
-            // Final safety check - if emergency truncation STILL exceeded target, use ultra-conservative fallback
-            if (emergencyTokens > targetSize) {
-                logger.error("Emergency truncation STILL exceeded target - using ultra-conservative fallback", {
-                    emergencyTokens,
-                    targetSize,
-                    emergencySize,
+        // Build conversation context for extraction
+        const recentMessages = ctx.session.messages.slice(-5);
+        const conversationContext = recentMessages
+            .map((msg) => {
+            const text = msg.content
+                .filter((b) => b.type === "text")
+                .map((b) => (b.type === "text" ? b.text : ""))
+                .join("\n");
+            return `${msg.role}: ${text}`;
+        })
+            .join("\n\n");
+        // Try document context extraction
+        try {
+            const extractionResult = await extractDocumentContext(rawOutput, toolName, toolCallId, toolInput, conversationContext, targetSize, ctx.sessionId ?? "unknown", ctx.storage);
+            if (extractionResult.success && extractionResult.extractedData) {
+                logger.info("Document context extraction succeeded", {
+                    originalTokens: outputTokens,
+                    finalTokens: extractionResult.extractedTokens,
+                    chunksProcessed: extractionResult.metadata.chunksProcessed,
+                    chunksExtractedFrom: extractionResult.metadata.chunksExtractedFrom,
                 });
-                // Ultra-conservative: just return a simple error structure with the raw data sliced to 50% of target
-                const ultraConservativeSize = Math.floor(targetSize * 0.5);
                 return {
                     newContextEntry: null,
                     metadata: {
-                        action: "truncated",
+                        action: "compacted",
                         originalTokens: outputTokens,
-                        finalTokens: ultraConservativeSize, // Conservative estimate
-                        modifiedOutput: {
-                            _truncation_error: "Tool response was too large and could not be reliably truncated",
-                            _original_token_count: outputTokens,
-                            _target_token_count: targetSize,
-                            _partial_data: JSON.stringify(rawOutput).slice(0, ultraConservativeSize * 3),
-                        },
-                        truncationWarning: `Tool response was severely truncated from ${outputTokens.toLocaleString()} to ~${ultraConservativeSize.toLocaleString()} tokens (emergency truncation failed - data may be incomplete)`,
+                        finalTokens: extractionResult.extractedTokens,
+                        tokensSaved: outputTokens - (extractionResult.extractedTokens ?? 0),
+                        modifiedOutput: extractionResult.extractedData,
+                        compactionMethod: "document_context_extraction",
+                        extractionMetadata: extractionResult.metadata,
                     },
                 };
             }
-            return {
-                newContextEntry: null,
-                metadata: {
-                    action: "truncated",
-                    originalTokens: outputTokens,
-                    finalTokens: emergencyTokens,
-                    modifiedOutput: emergencyTruncated,
-                    truncationWarning: `Tool response was aggressively truncated from ${outputTokens.toLocaleString()} to ${emergencyTokens.toLocaleString()} tokens to fit within context limit (emergency truncation)`,
-                },
-            };
+            // Extraction failed - throw error to terminate agent loop
+            logger.error("Document context extraction failed", {
+                error: extractionResult.error,
+                phase: extractionResult.metadata.phase,
+                toolName,
+                toolCallId,
+                outputTokens,
+            });
+            throw new Error(`Document context extraction failed for tool "${toolName}": ${extractionResult.error}. ` +
+                `Original response was ${outputTokens.toLocaleString()} tokens. ` +
+                `Full response saved to artifacts.`);
+        }
+        catch (extractionError) {
+            // Re-throw if it's already our error
+            if (extractionError instanceof Error &&
+                extractionError.message.includes("Document context extraction failed")) {
+                throw extractionError;
+            }
+            // Extraction threw an unexpected error - terminate agent loop
+            logger.error("Document context extraction threw an error", {
+                error: extractionError instanceof Error
+                    ? extractionError.message
+                    : String(extractionError),
+                toolName,
+                toolCallId,
+                outputTokens,
+            });
+            throw new Error(`Document context extraction failed for tool "${toolName}": ${extractionError instanceof Error
+                ? extractionError.message
+                : String(extractionError)}. Original response was ${outputTokens.toLocaleString()} tokens.`);
         }
-        return {
-            newContextEntry: null,
-            metadata: {
-                action: "truncated",
-                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)`,
-            },
-        };
     }
     // Case 1: Medium response, intelligent compaction
     logger.info("Tool response requires intelligent compaction", {
         outputTokens,
         targetSize,
+        effectiveMaxResponseSize,
         availableSpace,
         compactionLimit,
     });
@@ -157,28 +177,19 @@ export const toolResponseCompactor = async (ctx) => {
         })
             .join("\n\n");
         const compacted = await compactWithLLM(rawOutput, toolName, toolInput, conversationContext, targetSize);
-        let finalTokens = countToolResultTokens(compacted);
+        const finalTokens = countToolResultTokens(compacted);
         // Verify compaction stayed within boundaries
         if (finalTokens > targetSize) {
-            logger.warn("LLM compaction exceeded target, falling back to truncation", {
+            logger.error("LLM compaction exceeded target", {
                 finalTokens,
                 targetSize,
                 excess: finalTokens - targetSize,
+                toolName,
+                toolCallId,
             });
-            // Fallback to truncation
-            const truncated = truncateToolResponse(compacted, targetSize);
-            finalTokens = countToolResultTokens(truncated);
-            return {
-                newContextEntry: null,
-                metadata: {
-                    action: "compacted_then_truncated",
-                    originalTokens: outputTokens,
-                    finalTokens,
-                    tokensSaved: outputTokens - finalTokens,
-                    modifiedOutput: truncated,
-                    truncationWarning: `Tool response was compacted then truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens to fit within context limit`,
-                },
-            };
+            throw new Error(`LLM compaction for tool "${toolName}" exceeded target size. ` +
+                `Compacted to ${finalTokens.toLocaleString()} tokens but target was ${targetSize.toLocaleString()}. ` +
+                `Original response was ${outputTokens.toLocaleString()} tokens.`);
         }
         logger.info("Successfully compacted tool response", {
             originalTokens: outputTokens,
@@ -198,62 +209,13 @@ export const toolResponseCompactor = async (ctx) => {
         };
     }
     catch (error) {
-        logger.error("Compaction failed, falling back to truncation", {
+        logger.error("Compaction failed", {
             error: error instanceof Error ? error.message : String(error),
+            toolName,
+            toolCallId,
+            outputTokens,
         });
-        // Fallback to truncation with the same target size
-        const truncated = truncateToolResponse(rawOutput, targetSize);
-        let finalTokens = countToolResultTokens(truncated);
-        // Verify truncation stayed within boundaries
-        if (finalTokens > targetSize) {
-            logger.error("Fallback truncation exceeded target, using emergency truncation", {
-                finalTokens,
-                targetSize,
-            });
-            const emergencySize = Math.floor(targetSize * 0.7);
-            const emergencyTruncated = truncateToolResponse(rawOutput, emergencySize);
-            finalTokens = countToolResultTokens(emergencyTruncated);
-            // Final safety check
-            if (finalTokens > targetSize) {
-                logger.error("Emergency truncation STILL exceeded target - using ultra-conservative fallback");
-                const ultraConservativeSize = Math.floor(targetSize * 0.5);
-                return {
-                    newContextEntry: null,
-                    metadata: {
-                        action: "truncated",
-                        originalTokens: outputTokens,
-                        finalTokens: ultraConservativeSize,
-                        modifiedOutput: {
-                            _truncation_error: "Tool response was too large and could not be reliably truncated (compaction failed)",
-                            _original_token_count: outputTokens,
-                            _target_token_count: targetSize,
-                            _partial_data: JSON.stringify(rawOutput).slice(0, ultraConservativeSize * 3),
-                        },
-                        truncationWarning: `Tool response was severely truncated from ${outputTokens.toLocaleString()} to ~${ultraConservativeSize.toLocaleString()} tokens (compaction+emergency truncation failed)`,
-                    },
-                };
-            }
-            return {
-                newContextEntry: null,
-                metadata: {
-                    action: "truncated",
-                    originalTokens: outputTokens,
-                    finalTokens,
-                    modifiedOutput: emergencyTruncated,
-                    truncationWarning: `Tool response was truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens (compaction failed, emergency truncation applied)`,
-                },
-            };
-        }
-        return {
-            newContextEntry: null,
-            metadata: {
-                action: "truncated",
-                originalTokens: outputTokens,
-                finalTokens,
-                modifiedOutput: truncated,
-                truncationWarning: `Tool response was truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens (compaction failed)`,
-            },
-        };
+        throw new Error(`LLM compaction failed for tool "${toolName}": ${error instanceof Error ? error.message : String(error)}. Original response was ${outputTokens.toLocaleString()} tokens.`);
     }
 };
 /**
@@ -442,86 +404,3 @@ Return ONLY valid JSON (no explanation text).`;
     });
     return currentData;
 }
-/**
- * Truncate tool response to target token count
- * Uses iterative approach to ensure we stay under the target
- */
-function truncateToolResponse(rawOutput, targetTokens) {
-    const currentTokens = countToolResultTokens(rawOutput);
-    if (currentTokens <= targetTokens) {
-        return rawOutput; // Already within limit
-    }
-    const outputString = JSON.stringify(rawOutput);
-    // Start with 70% of target to leave significant room for closing braces and metadata
-    let ratio = 0.7;
-    let lastResult = null;
-    // Iteratively truncate until we meet the target
-    for (let attempt = 0; attempt < 15; attempt++) {
-        // Calculate character limit based on ratio
-        const targetChars = Math.floor((targetTokens * ratio * outputString.length) / currentTokens);
-        // Truncate the JSON string
-        let truncated = outputString.slice(0, targetChars);
-        // Try to close any open JSON structures
-        const openBraces = (truncated.match(/{/g) || []).length;
-        const closeBraces = (truncated.match(/}/g) || []).length;
-        const openBrackets = (truncated.match(/\[/g) || []).length;
-        const closeBrackets = (truncated.match(/\]/g) || []).length;
-        truncated += "}".repeat(Math.max(0, openBraces - closeBraces));
-        truncated += "]".repeat(Math.max(0, openBrackets - closeBrackets));
-        try {
-            // Try to parse as valid JSON
-            const parsed = JSON.parse(truncated);
-            const parsedTokens = countToolResultTokens(parsed);
-            // Store the result
-            lastResult = { parsed, tokens: parsedTokens };
-            if (parsedTokens <= targetTokens) {
-                // Success! Add truncation notice
-                return {
-                    ...parsed,
-                    _truncation_notice: "... [TRUNCATED - response exceeded size limit]",
-                    _original_token_count: currentTokens,
-                    _truncated_token_count: parsedTokens,
-                };
-            }
-            // Still too large - calculate how much we need to reduce
-            // If we overshot, reduce ratio proportionally to how much we exceeded
-            const overshootRatio = parsedTokens / targetTokens; // e.g., 1.03 if we're 3% over
-            ratio = (ratio / overshootRatio) * 0.95; // Reduce by overshoot amount plus 5% safety margin
-            logger.debug("Truncation attempt resulted in overshoot, retrying", {
-                attempt,
-                targetTokens,
-                parsedTokens,
-                overshootRatio,
-                newRatio: ratio,
-            });
-        }
-        catch {
-            // JSON parse failed, try more aggressive truncation
-            ratio *= 0.85;
-        }
-    }
-    // If we exhausted all attempts, return the last successful parse (if any)
-    // or a very conservative fallback
-    if (lastResult && lastResult.tokens <= targetTokens * 1.1) {
-        // Within 10% of target - good enough
-        logger.warn("Truncation reached attempt limit but result is close enough", {
-            targetTokens,
-            actualTokens: lastResult.tokens,
-        });
-        return {
-            ...lastResult.parsed,
-            _truncation_notice: "... [TRUNCATED - response exceeded size limit]",
-            _original_token_count: currentTokens,
-            _truncated_token_count: lastResult.tokens,
-        };
-    }
-    // If all attempts failed, return a simple truncated structure
-    const safeChars = Math.floor(targetTokens * 3); // Very conservative
-    return {
-        truncated: true,
-        originalSize: currentTokens,
-        targetSize: targetTokens,
-        content: outputString.slice(0, safeChars),
-        warning: "Response was truncated due to size constraints (JSON parsing failed)",
-    };
-}

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

@@ -1,5 +1,11 @@
 import type { ContextEntry } from "../../acp-server/session-storage";
 import type { SessionMessage } from "../agent-runner";
+/**
+ * Storage interface for hooks that need to persist data
+ */
+export interface HookStorageInterface {
+    getArtifactsDir(sessionId: string): string;
+}
 /**
  * Hook types supported by the agent system
  */
@@ -18,18 +24,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
-     */
-    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
+     * Maximum size of a tool response in tokens.
+     * Tool responses larger than this will trigger compaction/extraction.
+     * Default: 20000
      */
-    responseTruncationThreshold?: number | undefined;
+    maxTokensSize?: number | undefined;
 }
 /**
  * Hook configuration in agent definition
@@ -90,6 +89,14 @@ export interface HookContext {
      * The model being used
      */
     model: string;
+    /**
+     * Session ID for the current session
+     */
+    sessionId?: string | undefined;
+    /**
+     * Storage interface for hooks that need to persist data
+     */
+    storage?: HookStorageInterface | undefined;
     /**
      * Tool response data (only for tool_response hooks)
      */
@@ -141,7 +148,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";
@@ -14,6 +14,7 @@ import { createModelFromString, detectProvider } from "./model-factory.js";
 import { makeOtelCallbacks } from "./otel-callbacks.js";
 import { makeArtifactsTools } from "./tools/artifacts";
 import { makeBrowserTools } from "./tools/browser";
+import { makeDocumentExtractTool } from "./tools/document_extract";
 import { makeFilesystemTools } from "./tools/filesystem";
 import { makeGenerateImageTool, makeTownGenerateImageTool, } from "./tools/generate_image";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
@@ -42,6 +43,7 @@ export const TOOL_REGISTRY = {
     generate_image: () => makeGenerateImageTool(),
     town_generate_image: () => makeTownGenerateImageTool(),
     browser: () => makeBrowserTools(),
+    document_extract: () => makeDocumentExtractTool(),
 };
 // ============================================================================
 // Custom tool loading
@@ -356,7 +358,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 +450,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 +1056,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 +1098,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 +1172,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 +1208,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)