@townco/agent 0.1.101 → 0.1.104

package/dist/acp-server/adapter.d.ts

@@ -1,5 +1,6 @@
 import * as acp from "@agentclientprotocol/sdk";
 import type { AgentRunner } from "../runner";
+import { type ContextEntry } from "./session-storage.js";
 /**
  * ACP extension key for subagent mode indicator
  * Following ACP extensibility pattern with namespaced key
@@ -23,6 +24,15 @@ export interface CitationSource {
     toolCallId: string;
     sourceName?: string;
 }
+/**
+ * Error thrown when mid-turn compaction requires the turn to be restarted
+ * with compacted context. The adapter catches this error and restarts
+ * the invocation with the updated context.
+ */
+export declare class MidTurnRestartError extends Error {
+    newContextEntry: ContextEntry;
+    constructor(message: string, newContextEntry: ContextEntry);
+}
 /** Adapts an Agent to speak the ACP protocol */
 export declare class AgentAcpAdapter implements acp.Agent {
     private connection;

package/dist/acp-server/adapter.js

@@ -13,6 +13,19 @@ const logger = createLogger("adapter");
  * Following ACP extensibility pattern with namespaced key
  */
 export const SUBAGENT_MODE_KEY = "town.com/isSubagent";
+/**
+ * Error thrown when mid-turn compaction requires the turn to be restarted
+ * with compacted context. The adapter catches this error and restarts
+ * the invocation with the updated context.
+ */
+export class MidTurnRestartError extends Error {
+    newContextEntry;
+    constructor(message, newContextEntry) {
+        super(message);
+        this.name = "MidTurnRestartError";
+        this.newContextEntry = newContextEntry;
+    }
+}
 /**
  * Create a context snapshot based on the previous context
  * Preserves full messages from previous context and adds new pointers
@@ -1456,31 +1469,35 @@ export class AgentAcpAdapter {
                             typeof rawOutput === "object" &&
                             "_compactionMeta" in rawOutput) {
                             const compactionMeta = rawOutput._compactionMeta;
-                            // Store in _meta for UI persistence
-                            if (!toolCallBlock._meta) {
-                                toolCallBlock._meta = {};
-                            }
-                            if (compactionMeta.action) {
+                            // Determine if actual compaction occurred:
+                            // 1. Action is a compaction action (not "none" or "no_action_needed")
+                            // 2. Tokens were actually saved (finalTokens < originalTokens)
+                            const isCompactionAction = compactionMeta.action === "compacted" ||
+                                compactionMeta.action === "truncated" ||
+                                compactionMeta.action === "compacted_then_truncated";
+                            const actuallyCompacted = isCompactionAction &&
+                                compactionMeta.originalTokens !== undefined &&
+                                compactionMeta.finalTokens !== undefined &&
+                                compactionMeta.finalTokens < compactionMeta.originalTokens;
+                            // Store in _meta for UI persistence only if actual compaction occurred
+                            if (actuallyCompacted) {
+                                if (!toolCallBlock._meta) {
+                                    toolCallBlock._meta = {};
+                                }
                                 toolCallBlock._meta.compactionAction = compactionMeta.action;
-                            }
-                            if (compactionMeta.originalTokens !== undefined) {
                                 toolCallBlock._meta.originalTokens =
                                     compactionMeta.originalTokens;
-                            }
-                            if (compactionMeta.finalTokens !== undefined) {
                                 toolCallBlock._meta.finalTokens = compactionMeta.finalTokens;
                             }
-                            // Store original content only if compaction or truncation actually occurred
-                            const wasCompacted = compactionMeta.action === "compacted" ||
-                                compactionMeta.action === "truncated" ||
-                                compactionMeta.action === "compacted_then_truncated";
                             if (compactionMeta.originalContent &&
-                                wasCompacted &&
+                                actuallyCompacted &&
                                 this.storage) {
                                 try {
                                     const toolName = toolCallBlock.title || "unknown";
                                     const originalContentPath = this.storage.saveToolOriginal(params.sessionId, toolName, outputMsg.toolCallId, compactionMeta.originalContent);
-                                    toolCallBlock._meta.originalContentPath = originalContentPath;
+                                    // _meta is guaranteed to be initialized since actuallyCompacted is true
+                                    toolCallBlock._meta.originalContentPath =
+                                        originalContentPath;
                                     logger.info("Saved original content to artifacts", {
                                         toolCallId: outputMsg.toolCallId,
                                         toolName,
@@ -1577,23 +1594,25 @@ export class AgentAcpAdapter {
                                     if (!toolCallBlock._meta) {
                                         toolCallBlock._meta = {};
                                     }
-                                    // Store compaction action and stats
-                                    if (hookResult.metadata.action) {
-                                        toolCallBlock._meta.compactionAction = hookResult.metadata
-                                            .action;
+                                    // Store compaction action and stats only when actual compaction occurred
+                                    // Skip "none" and "no_action_needed" which mean no compaction was performed
+                                    // Also verify that tokens were actually saved (finalTokens < originalTokens)
+                                    const action = hookResult.metadata.action;
+                                    const originalTokens = hookResult.metadata.originalTokens;
+                                    const finalTokens = hookResult.metadata.finalTokens;
+                                    const actuallyCompacted = action &&
+                                        action !== "none" &&
+                                        action !== "no_action_needed" &&
+                                        originalTokens !== undefined &&
+                                        finalTokens !== undefined &&
+                                        finalTokens < originalTokens;
+                                    if (actuallyCompacted) {
+                                        toolCallBlock._meta.compactionAction = action;
+                                        toolCallBlock._meta.originalTokens = originalTokens;
+                                        toolCallBlock._meta.finalTokens = finalTokens;
                                     }
-                                    if (hookResult.metadata.originalTokens !== undefined) {
-                                        toolCallBlock._meta.originalTokens = hookResult.metadata
-                                            .originalTokens;
-                                    }
-                                    if (hookResult.metadata.finalTokens !== undefined) {
-                                        toolCallBlock._meta.finalTokens = hookResult.metadata
-                                            .finalTokens;
-                                    }
-                                    // Store original content if compaction occurred (action !== "none")
-                                    if (hookResult.metadata.action &&
-                                        hookResult.metadata.action !== "none" &&
-                                        this.storage) {
+                                    // Store original content only if actual compaction occurred
+                                    if (actuallyCompacted && this.storage) {
                                         try {
                                             const toolName = toolCallBlock.title || "unknown";
                                             const originalContentPath = this.storage.saveToolOriginal(params.sessionId, toolName, outputMsg.toolCallId, originalContentStr);
@@ -1615,6 +1634,34 @@ export class AgentAcpAdapter {
                                         }
                                     }
                                 }
+                                // Apply context compaction if hook returned a new context entry
+                                // This happens when compaction_tool runs in the tool_response chain
+                                if (hookResult.newContextEntry) {
+                                    session.context.push(hookResult.newContextEntry);
+                                    logger.info("Context compacted by tool_response hook, new context entry added", {
+                                        toolCallId: outputMsg.toolCallId,
+                                        contextSize: hookResult.newContextEntry.context_size?.totalEstimated,
+                                        compactedUpTo: hookResult.newContextEntry.compactedUpTo,
+                                    });
+                                    // Check if mid-turn compaction requires a restart
+                                    if (hookResult.metadata?.requiresRestart) {
+                                        logger.warn("Mid-turn compaction requires restart - aborting current turn", {
+                                            toolCallId: outputMsg.toolCallId,
+                                            tokensSaved: hookResult.metadata.tokensSaved,
+                                            summaryTokens: hookResult.metadata.summaryTokens,
+                                        });
+                                        // Store the pending tool output in session for replay after restart
+                                        // We'll include this as part of the compacted context
+                                        session.pendingToolOutput = {
+                                            toolCallId: outputMsg.toolCallId,
+                                            toolName: toolCallBlock.title || "unknown",
+                                            rawOutput,
+                                        };
+                                        // Throw an error to abort the current turn
+                                        // The handlePrompt method will catch this and restart
+                                        throw new MidTurnRestartError("Context compacted mid-turn, restart required", hookResult.newContextEntry);
+                                    }
+                                }
                             }
                         }
                         // Store the (potentially modified) output
@@ -1877,6 +1924,29 @@ export class AgentAcpAdapter {
                 await saveCancelledMessage();
                 return { stopReason: "cancelled" };
             }
+            // Handle mid-turn compaction restart
+            if (err instanceof MidTurnRestartError) {
+                logger.warn("Mid-turn compaction restart triggered - rebuilding context and restarting invocation", {
+                    sessionId: params.sessionId,
+                    newContextSize: err.newContextEntry.context_size?.totalEstimated,
+                });
+                // Clear the pending tool output since it's now part of the context
+                delete session.pendingToolOutput;
+                // Notify UI that a restart is happening
+                this.connection.sessionUpdate({
+                    sessionId: params.sessionId,
+                    update: {
+                        sessionUpdate: "agent_message_chunk",
+                        content: {
+                            type: "text",
+                            text: "\n\n---\n*Context compacted mid-turn. Continuing from summary...*\n\n",
+                        },
+                    },
+                });
+                // Recursive call with the updated session (already modified in place)
+                // _promptImpl will resolve the updated context from session.context
+                return this._promptImpl(params);
+            }
             throw err;
         }
         // Store the complete assistant response in session messages

package/dist/definition/index.d.ts

@@ -12,6 +12,11 @@ export declare const McpConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
     url: z.ZodString;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>, z.ZodString]>;
+/** Individual callback configuration schema. */
+export declare const CallbackConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    setting: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
 /** Hook configuration schema. */
 export declare const HookConfigSchema: z.ZodObject<{
     type: z.ZodEnum<{
@@ -22,8 +27,12 @@ export declare const HookConfigSchema: z.ZodObject<{
         threshold: z.ZodNumber;
     }, z.core.$strip>, z.ZodObject<{
         maxTokensSize: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>]>>;
-    callback: z.ZodString;
+    }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    callback: z.ZodOptional<z.ZodString>;
+    callbacks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        setting: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 /** Initial message configuration schema. */
 export declare const InitialMessageSchema: z.ZodObject<{
@@ -96,8 +105,12 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
             threshold: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
             maxTokensSize: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>]>>;
-        callback: z.ZodString;
+        }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        callback: z.ZodOptional<z.ZodString>;
+        callbacks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            setting: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>>;
     initialMessage: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodBoolean;

package/dist/definition/index.js

@@ -53,9 +53,18 @@ const ToolSchema = z.union([
     FilesystemToolSchema,
     DirectToolSchema,
 ]);
+/** Individual callback configuration schema. */
+export const CallbackConfigSchema = z.object({
+    /** Callback reference - predefined hook name or file path */
+    name: z.string(),
+    /** Callback-specific settings */
+    setting: z.record(z.string(), z.unknown()).optional(),
+});
 /** Hook configuration schema. */
-export const HookConfigSchema = z.object({
+export const HookConfigSchema = z
+    .object({
     type: z.enum(["context_size", "tool_response"]),
+    /** @deprecated Use callbacks array instead */
     setting: z
         .union([
         // For context_size hooks
@@ -66,9 +75,17 @@ export const HookConfigSchema = z.object({
         z.object({
             maxTokensSize: z.number().min(0).optional(),
         }),
+        // Generic settings for callbacks
+        z.record(z.string(), z.unknown()),
     ])
         .optional(),
-    callback: z.string(),
+    /** @deprecated Use callbacks array instead */
+    callback: z.string().optional(),
+    /** Array of callback configurations to execute in order */
+    callbacks: z.array(CallbackConfigSchema).optional(),
+})
+    .refine((data) => data.callback || data.callbacks, {
+    message: "Either 'callback' or 'callbacks' must be provided",
 });
 /** Initial message configuration schema. */
 export const InitialMessageSchema = z.object({

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

@@ -49,8 +49,12 @@ export declare const zAgentRunnerParams: z.ZodObject<{
             threshold: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
             maxTokensSize: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>]>>;
-        callback: z.ZodString;
+        }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        callback: z.ZodOptional<z.ZodString>;
+        callbacks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            setting: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>>;
     initialMessage: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodBoolean;

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

@@ -16,7 +16,8 @@ export declare class HookExecutor {
     private agentDefinition;
     private storage;
     private sessionId;
-    constructor(hooks: HookConfig[], model: string, loadCallback: (callbackRef: string) => Promise<HookCallback>, onNotification?: OnHookNotification, agentDefinition?: Readonly<AgentDefinition>, storage?: HookStorageInterface, sessionId?: string);
+    private agentDir;
+    constructor(hooks: HookConfig[], model: string, loadCallback: (callbackRef: string) => Promise<HookCallback>, onNotification?: OnHookNotification, agentDefinition?: Readonly<AgentDefinition>, storage?: HookStorageInterface, sessionId?: string, agentDir?: string);
     /**
      * Emit a notification - sends immediately if callback provided, otherwise collects for batch return
      */
@@ -31,7 +32,8 @@ export declare class HookExecutor {
     }>;
     private executeContextSizeHook;
     /**
-     * Execute tool_response hooks when a tool returns output
+     * Execute tool_response hooks when a tool returns output.
+     * Chains callbacks in order, passing modified output between them.
      */
     executeToolResponseHooks(session: ReadonlySession, currentContextTokens: number, toolResponse: {
         toolCallId: string;
@@ -43,7 +45,7 @@ export declare class HookExecutor {
         modifiedOutput?: Record<string, unknown>;
         truncationWarning?: string;
         metadata?: Record<string, unknown>;
+        newContextEntry?: ContextEntry;
         notifications: HookNotification[];
     }>;
-    private executeToolResponseHook;
 }