@townco/agent 0.1.120 → 0.1.122

package/dist/acp-server/adapter.js

@@ -676,12 +676,23 @@ export class AgentAcpAdapter {
                     sources: session.sources,
                     nextId: session.sourceCounter + 1,
                 };
-                await this.storage.saveSession(sessionId, session.messages, session.context, citations);
+                // Pass session metadata for subagent sessions
+                const metadata = {
+                    ...(session.parentSessionId && {
+                        parentSessionId: session.parentSessionId,
+                    }),
+                    ...(session.isSubagentSession && {
+                        isSubagentSession: session.isSubagentSession,
+                    }),
+                };
+                await this.storage.saveSession(sessionId, session.messages, session.context, citations, Object.keys(metadata).length > 0 ? metadata : undefined);
                 logger.debug("Saved session to disk", {
                     sessionId,
                     messageCount: session.messages.length,
                     contextCount: session.context.length,
                     citationsCount: session.sources.length,
+                    isSubagentSession: session.isSubagentSession,
+                    parentSessionId: session.parentSessionId,
                 });
             }
             catch (error) {
@@ -1046,6 +1057,8 @@ export class AgentAcpAdapter {
         // If session not found (e.g., after server restart), create a new one
         if (!session) {
             logger.info(`Session ${params.sessionId} not found, creating new session`);
+            const parentSessionId = params._meta?.parentSessionId;
+            const isSubagentSession = params._meta?.isSubagentSession === true;
             session = {
                 pendingPrompt: null,
                 messages: [],
@@ -1054,6 +1067,9 @@ export class AgentAcpAdapter {
                 isCancelled: false,
                 sourceCounter: 0,
                 sources: [],
+                // Extract subagent metadata from _meta (only add if defined)
+                ...(parentSessionId && { parentSessionId }),
+                ...(isSubagentSession && { isSubagentSession }),
             };
             this.sessions.set(params.sessionId, session);
         }
@@ -1299,6 +1315,8 @@ export class AgentAcpAdapter {
                 ...(this.agentDir ? { agentDir: this.agentDir } : {}),
                 // Pass resolved context messages to agent
                 contextMessages,
+                // Pass context entries for hook execution (compaction tracking)
+                contextEntries: session.context,
                 // Pass abort signal for cancellation
                 abortSignal: session.pendingPrompt?.signal,
                 // Pass emitUpdate callback for file change events

package/dist/acp-server/session-storage.d.ts

@@ -142,6 +142,10 @@ export interface SessionMetadata {
     agentName: string;
     /** E2B sandbox ID for persistent sandbox reconnection */
     sandboxId?: string | undefined;
+    /** Parent session ID for subagent sessions (enables session linking) */
+    parentSessionId?: string | undefined;
+    /** Flag indicating this is a subagent session (for UI filtering) */
+    isSubagentSession?: boolean | undefined;
 }
 /**
  * Complete session data stored in JSON files
@@ -207,7 +211,7 @@ export declare class SessionStorage {
      * Save a session to disk
      * Uses atomic write (write to temp file, then rename)
      */
-    saveSession(sessionId: string, messages: SessionMessage[], context: ContextEntry[], citations?: CitationStorage): Promise<void>;
+    saveSession(sessionId: string, messages: SessionMessage[], context: ContextEntry[], citations?: CitationStorage, extraMetadata?: Partial<SessionMetadata>): Promise<void>;
     /**
      * Load a session from disk
      */
@@ -242,6 +246,8 @@ export declare class SessionStorage {
         updatedAt: string;
         messageCount: number;
         firstUserMessage?: string;
+        parentSessionId?: string;
+        isSubagentSession?: boolean;
     }>>;
     /**
      * Get the directory for storing large content files for a session (artifacts folder)

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

@@ -135,6 +135,8 @@ const sessionMetadataSchema = z.object({
     updatedAt: z.string(),
     agentName: z.string(),
     sandboxId: z.string().optional(),
+    parentSessionId: z.string().optional(),
+    isSubagentSession: z.boolean().optional(),
 });
 // Citation schemas - matches SourceSchema from packages/ui/src/core/schemas/source.ts
 const persistedCitationSourceSchema = z.object({
@@ -200,7 +202,7 @@ export class SessionStorage {
      * Save a session to disk
      * Uses atomic write (write to temp file, then rename)
      */
-    async saveSession(sessionId, messages, context, citations) {
+    async saveSession(sessionId, messages, context, citations, extraMetadata) {
         // Debug: log subagent data being saved
         const messagesWithSubagents = messages.filter((msg) => msg.content.some((block) => block.type === "tool_call" &&
             "subagentMessages" in block &&
@@ -239,6 +241,7 @@ export class SessionStorage {
                 createdAt: existingSession?.metadata.createdAt || now,
                 updatedAt: now,
                 agentName: this.agentName,
+                ...extraMetadata,
             },
             ...(citations && { citations }),
         };
@@ -386,6 +389,13 @@ export class SessionStorage {
                     if (firstUserText && "text" in firstUserText) {
                         entry.firstUserMessage = firstUserText.text.slice(0, 100);
                     }
+                    // Include sub-agent metadata if present
+                    if (session.metadata.parentSessionId) {
+                        entry.parentSessionId = session.metadata.parentSessionId;
+                    }
+                    if (session.metadata.isSubagentSession) {
+                        entry.isSubagentSession = session.metadata.isSubagentSession;
+                    }
                     sessions.push(entry);
                 }
             }

package/dist/runner/agent-runner.d.ts

@@ -1,7 +1,7 @@
 import type { PromptRequest, PromptResponse, SessionNotification } from "@agentclientprotocol/sdk";
 import type { Span } from "@opentelemetry/api";
 import { z } from "zod";
-import type { ContentBlock } from "../acp-server/session-storage.js";
+import type { ContentBlock, ContextEntry } from "../acp-server/session-storage.js";
 export declare const zAgentRunnerParams: z.ZodObject<{
     displayName: z.ZodOptional<z.ZodString>;
     version: z.ZodOptional<z.ZodString>;
@@ -99,6 +99,7 @@ export type InvokeRequest = Omit<PromptRequest, "_meta"> & {
     agentDir?: string;
     sessionMeta?: Record<string, unknown>;
     contextMessages?: SessionMessage[];
+    contextEntries?: ContextEntry[];
     configOverrides?: ConfigOverrides;
     /** Abort signal for cancellation - tools can listen for this to stop early */
     abortSignal?: AbortSignal;

package/dist/runner/langchain/index.js

@@ -412,122 +412,36 @@ export class LangchainAgent {
                 baseContextTokens,
                 modelContextWindow,
             });
-            // 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;
+            // Hook execution removed from tool wrapper - hooks are now executed only at the adapter layer
+            // The adapter has proper MidTurnRestartError handling that can restart the turn
+            // Executing hooks here in the runner was causing restart signals to be caught as tool failures
             // Counter for subagent calls - used to create unique source ID ranges
             // Each subagent call gets a unique offset (1000, 2000, 3000, etc.)
             // to ensure sources never conflict with parent's sources (typically < 100)
             let subagentCallCounter = 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
-                        // Uses accurate baseContextTokens calculated earlier (system prompt, tool overhead, MCP overhead, message history)
-                        // This ensures we account for multiple large tool calls in the same turn
-                        const currentTokens = baseContextTokens + cumulativeToolOutputTokens;
-                        // 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: modelContextWindow,
-                            percentage: (currentTokens / modelContextWindow) * 100,
-                            model: this.definition.model,
-                            agent: this.definition,
-                            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,
-                            });
-                            // 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;
-                        return result;
-                    };
-                    // Create new tool with wrapped function
-                    // biome-ignore lint/suspicious/noExplicitAny: Need to pass function with dynamic signature
-                    const wrappedTool = tool(wrappedFunc, {
-                        name: originalTool.name,
-                        description: originalTool.description,
-                        // biome-ignore lint/suspicious/noExplicitAny: Accessing internal schema property
-                        schema: originalTool.schema,
-                    });
-                    // Preserve metadata
-                    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-                    wrappedTool.prettyName = originalTool.prettyName;
-                    // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
-                    wrappedTool.icon = originalTool.icon;
-                    return wrappedTool;
+            // Simple tool wrapper that just passes through to the original tool
+            // All hook execution (compaction, restart logic) happens at the adapter layer
+            const wrappedTools = enabledTools.map((originalTool) => {
+                const wrappedFunc = async (input) => {
+                    // Execute the original tool and return raw result
+                    const result = await originalTool.invoke(input);
+                    return result;
+                };
+                // Create new tool with wrapped function
+                // biome-ignore lint/suspicious/noExplicitAny: Need to pass function with dynamic signature
+                const wrappedTool = tool(wrappedFunc, {
+                    name: originalTool.name,
+                    description: originalTool.description,
+                    // biome-ignore lint/suspicious/noExplicitAny: Accessing internal schema property
+                    schema: originalTool.schema,
                 });
-            }
+                // Preserve metadata
+                // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+                wrappedTool.prettyName = originalTool.prettyName;
+                // biome-ignore lint/suspicious/noExplicitAny: Need to add custom properties to LangChain tool
+                wrappedTool.icon = originalTool.icon;
+                return wrappedTool;
+            });
             // Filter tools if running in subagent mode
             const isSubagent = req.sessionMeta?.[SUBAGENT_MODE_KEY] === true;
             const filteredTools = isSubagent