goatchain 0.0.28 → 0.0.30

package/README.md

@@ -117,6 +117,10 @@ interface CreateSessionOptions {
   model?: ModelRef // Optional model override
   maxIterations?: number // Max agent loop iterations (default: 1000)
   cwd?: string // Working directory for file operations
+  messageQueueConfig?: {
+    autoProcessQueue?: boolean // Auto-process queued messages (default: true)
+    maxQueueSize?: number // Optional queue length limit
+  }
   requestParams?: {
     temperature?: number // Model temperature
     maxTokens?: number // Max output tokens
@@ -161,13 +165,70 @@ session.send('What is the weather today?')
 
 // Multiple messages in sequence
 session.send('First question')
-// Wait for response...
 session.send('Follow-up question')
 ```
 
 #### Send Options
 
-You can pass options to `send()` to control tool execution, approval, and more:
+You can pass options to `send()` to control priority, tool execution, approval, and more:
+
+```typescript
+// Higher priority messages are processed first (smaller number = higher priority)
+session.send('Low priority', { priority: 10 })
+session.send('High priority', { priority: 1 })
+```
+
+`send()` returns a message ID that can be used for queue management:
+
+```typescript
+const messageId = session.send('Can be cancelled later')
+session.cancelQueuedMessage(messageId)
+```
+
+#### Message Queue
+
+Session now supports queue-based messaging by default. You can enqueue multiple messages safely even while a previous `receive()` is running.
+
+```typescript
+const session = await agent.createSession()
+
+session.send('First message')
+session.send('Second message')
+
+// Batch enqueue with priority
+session.sendBatch([
+  { input: 'Task A', priority: 2 },
+  { input: 'Task B', priority: 1 },
+])
+
+// Inspect queue state
+const queue = session.getQueueStatus()
+console.log(queue.length, queue.isProcessing)
+
+// Remove queued messages
+session.clearQueue()
+```
+
+Manual queue mode:
+
+```typescript
+const session = await agent.createSession({
+  messageQueueConfig: { autoProcessQueue: false },
+})
+
+session.send('Message 1')
+session.send('Message 2')
+
+for await (const event of session.receive()) {
+  // only Message 1
+}
+
+for await (const event of session.receive()) {
+  // Message 2
+}
+```
+
+Tool context and approval options still work as before:
 
 ```typescript
 // Auto-approve all tools for this request
@@ -677,23 +738,48 @@ interface AgentHooks {
   sessionStart?: (ctx: SessionStartContext) => Promise<void>
   sessionEnd?: (ctx: SessionEndContext) => Promise<void>
   stop?: (ctx: StopContext) => Promise<void>
-  userPromptSubmit?: (ctx: UserPromptSubmitContext) => Promise<UserPromptSubmitResult>
+  userPromptSubmit?:
+    | ((ctx: UserPromptSubmitContext) => Promise<UserPromptSubmitResult>)
+    | PromptHookEntry
+    | Array<((ctx: UserPromptSubmitContext) => Promise<UserPromptSubmitResult>) | PromptHookEntry>
 
   // Tool lifecycle
   // - Can modify tool call with modifiedToolCall
-  preToolUse?: (ctx: ToolHookContext) => Promise<PreToolUseResult | void>
-  permissionRequest?: (ctx: ToolHookContext) => Promise<PermissionRequestResult>
-  postToolUse?: (ctx: ToolHookContext, result: unknown) => Promise<void>
-  postToolUseFailure?: (ctx: ToolHookContext, error: Error) => Promise<void>
+  preToolUse?:
+    | ((ctx: ToolHookContext) => Promise<PreToolUseResult | void>)
+    | PromptHookEntry
+    | Array<((ctx: ToolHookContext) => Promise<PreToolUseResult | void>) | PromptHookEntry>
+  permissionRequest?:
+    | ((ctx: ToolHookContext) => Promise<PermissionRequestResult>)
+    | PromptHookEntry
+    | Array<((ctx: ToolHookContext) => Promise<PermissionRequestResult>) | PromptHookEntry>
+  postToolUse?:
+    | ((ctx: ToolHookContext, result: unknown) => Promise<void>)
+    | PromptHookEntry
+    | Array<((ctx: ToolHookContext, result: unknown) => Promise<void>) | PromptHookEntry>
+  postToolUseFailure?:
+    | ((ctx: ToolHookContext, error: Error) => Promise<void>)
+    | PromptHookEntry
+    | Array<((ctx: ToolHookContext, error: Error) => Promise<void>) | PromptHookEntry>
 
   // Subagent lifecycle (used by parallel task/subagent middleware)
   subagentStart?: (ctx: SubagentStartContext) => Promise<void>
-  subagentStop?: (ctx: SubagentStopContext) => Promise<void>
+  subagentStop?:
+    | ((ctx: SubagentStopContext) => Promise<void>)
+    | PromptHookEntry
+    | Array<((ctx: SubagentStopContext) => Promise<void>) | PromptHookEntry>
 }
 
 // Backward-compatible alias
 type ToolHooks = AgentHooks
 
+interface PromptHookEntry {
+  type: 'prompt'
+  prompt: string // use $ARGUMENTS to inject serialized input
+  model?: { provider: string; modelId: string }
+  timeoutMs?: number // default: 30000
+}
+
 interface BaseHookContext {
   sessionId: string
 }
@@ -710,9 +796,6 @@ interface ToolHookContext extends BaseHookContext {
   toolContext: ToolExecutionContext
 }
 
-// `HookContext` is kept as a backward-compatible alias of ToolHookContext
-type HookContext = ToolHookContext
-
 interface PermissionRequestResult {
   // If true, passes permission checks and skips approval flow
   // (tool still goes through normal middleware/disabled checks)
@@ -785,6 +868,113 @@ interface SubagentStopContext extends BaseHookContext {
 }
 ```
 
+### Prompt Hook Evaluation
+
+Prompt hooks are evaluation-only in current SDK behavior:
+
+- Prompt evaluation does not change execution decisions or mutate input/tool calls
+- Supported prompt hooks: `userPromptSubmit`, `preToolUse`, `permissionRequest`, `postToolUse`, `postToolUseFailure`, `subagentStop`
+- `permissionRequest` prompt evaluation only runs when the approval path is entered
+- Each evaluation is persisted in `session.metadata._hookEvaluations`
+
+Prompt evaluation emits `hook_evaluation` stream events with `phase`:
+
+- `start`
+- `stream` (text delta)
+- `end` (status/result/error)
+
+`hook_evaluation` event shape:
+
+```typescript
+interface HookEvaluationEvent extends BaseEvent {
+  type: 'hook_evaluation'
+  evaluationId: string
+  hookName:
+    | 'permissionRequest'
+    | 'preToolUse'
+    | 'postToolUse'
+    | 'postToolUseFailure'
+    | 'subagentStop'
+    | 'userPromptSubmit'
+  phase: 'start' | 'stream' | 'end'
+  prompt?: string
+  input?: unknown
+  delta?: string
+  rawResponse?: string
+  result?: unknown
+  usage?: Usage
+  durationMs?: number
+  status?: 'success' | 'error' | 'timeout'
+  error?: { code?: string; message: string }
+  toolCallId?: string
+}
+```
+
+Metadata persistence shape:
+
+```typescript
+session.metadata._hookEvaluations = {
+  preToolUse: [
+    {
+      evaluationId: '...',
+      timestamp: 1730000000000,
+      hookName: 'preToolUse',
+      prompt: '...',
+      input: { ... },
+      status: 'success',
+      durationMs: 120,
+      rawResponse: '{"ok":true}',
+      result: { ok: true },
+      usage: { promptTokens: 100, completionTokens: 20, totalTokens: 120 },
+      toolCallId: 'call_123',
+    },
+  ],
+}
+```
+
+Complete prompt hook example (function hook + prompt hook + event handling):
+
+```typescript
+import { Agent } from 'goatchain'
+import type { HookEvaluationEvent } from 'goatchain'
+
+const session = await agent.createSession({
+  hooks: {
+    preToolUse: [
+      async (ctx) => {
+        // normal behavior hook
+        return undefined
+      },
+      {
+        type: 'prompt',
+        prompt: 'Analyze this tool call: $ARGUMENTS',
+      },
+    ],
+    permissionRequest: {
+      type: 'prompt',
+      prompt: 'Review approval context: $ARGUMENTS',
+    },
+  },
+})
+
+session.send('Do the task', {
+  toolContext: {
+    approval: { strategy: 'high_risk' },
+  },
+})
+
+for await (const event of session.receive()) {
+  if (event.type === 'hook_evaluation') {
+    const ev = event as HookEvaluationEvent
+    if (ev.phase === 'end') {
+      console.log('hook evaluation done:', ev.hookName, ev.status, ev.result)
+    }
+  }
+}
+
+console.log(session.metadata?._hookEvaluations)
+```
+
 ### Hook Execution Order
 
 Typical order in one run:
@@ -1827,12 +2017,39 @@ agent.setModel({ provider: 'openai', modelId: 'gpt-4o-mini' })
 
 #### Methods
 
-**`send(input): void`**
+**`send(input, options?): string`**
 
-Send a message to the session.
+Enqueue a message and return its queue message ID.
 
 ```typescript
-session.send('Hello!')
+const id = session.send('Hello!')
+```
+
+**`sendBatch(messages): string[]`**
+
+Batch enqueue messages and return queue message IDs.
+
+```typescript
+const ids = session.sendBatch([
+  { input: 'task-1', priority: 1 },
+  { input: 'task-2', priority: 2 },
+])
+```
+
+**`cancelQueuedMessage(messageId): boolean`**
+
+Cancel a queued message by ID.
+
+```typescript
+session.cancelQueuedMessage(id)
+```
+
+**`getQueueStatus(): MessageQueueStatus`**
+
+Query queue length, preview list, processing status, and config.
+
+```typescript
+console.log(session.getQueueStatus())
 ```
 
 **`receive(options?): AsyncGenerator<AgentEvent>`**
@@ -2026,7 +2243,7 @@ classDiagram
         +status: SessionStatus
         +messages: Message[]
         +usage: Usage
-        +send(input): void
+        +send(input, options?): string
         +receive(): AsyncGenerator~AgentEvent~
         +save(): Promise~void~
     }
@@ -2078,7 +2295,13 @@ See [docs/cli.md](./docs/cli.md) and [docs/server.md](./docs/server.md) for deta
 Expose DimCode as an Agent Client Protocol server for editor integrations:
 
 ```bash
-bun run acp-server
+dim acp
+```
+
+For source checkouts, use a cwd-independent command:
+
+```bash
+node /absolute/path/to/GoatChain/scripts/acpx-agent.mjs
 ```
 
 **Configuration for Zed** (`settings.json`):
@@ -2087,13 +2310,16 @@ bun run acp-server
 {
   "agent_servers": {
     "dimcode": {
-      "command": "pnpm",
-      "args": ["--dir", "/path/to/DimCode", "acp-server"]
+      "command": "/absolute/path/to/dim",
+      "args": ["acp"]
     }
   }
 }
 ```
 
+For OpenClaw `acpx`, use either `/absolute/path/to/dim acp` or `node /absolute/path/to/GoatChain/scripts/acpx-agent.mjs`.
+Do not use `bun run acp-server` there; it depends on the launcher cwd being the GoatChain repo root.
+
 See [docs/acp-server.md](./docs/acp-server.md) for details.
 
 ## 📚 Documentation

package/dist/acp-adapter/history-normalizer.d.ts

@@ -0,0 +1,10 @@
+import type { Message } from '../types';
+import type { ACPMessage } from './types';
+export type NormalizeAcpHistoryOptions = Readonly<{
+    dropTrailingPendingUserInput?: boolean;
+}>;
+type SessionLikeMessage = Exclude<Message, {
+    role: 'system';
+}>;
+export declare function normalizeAcpHistoryToSessionMessages(acpMessages: readonly ACPMessage[], options?: NormalizeAcpHistoryOptions): SessionLikeMessage[];
+export {};

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

@@ -7,6 +7,8 @@
  * @packageDocumentation
  */
 export { ACPAgent } from './ACPAgent';
+export { normalizeAcpHistoryToSessionMessages } from './history-normalizer';
+export type { NormalizeAcpHistoryOptions } from './history-normalizer';
 export { ProtocolConverter } from './ProtocolConverter';
 export { SessionRouter } from './SessionRouter';
 export type { ACPAgentOptions, ACPContent, ACPMessage, ACPMetadata, ACPRole, ACPToolCall, ExtendedAgentEvent, SessionContext, SubagentMetadata, } from './types';

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

@@ -40,6 +40,10 @@ export interface ACPMessage {
  */
 export interface ACPMetadata {
     session_id?: string;
+    stream_id?: string;
+    run_id?: string;
+    seq?: number;
+    replayed?: boolean;
     signal?: AbortSignal;
     [key: string]: unknown;
 }

package/dist/agent/agent.d.ts

@@ -95,8 +95,11 @@ export declare class Agent {
      * Middleware follows an immutable pattern - it receives state and returns new state via next().
      *
      * If the middleware provides a `__createTools` function, the tools will be automatically
-     * registered with a namespace prefix (`<middlewareName>_<toolName>`) and automatically
-     * unregistered when the middleware is removed.
+     * registered with a namespace prefix (`<middlewareName>_<toolName>`) by default and
+     * automatically unregistered when the middleware is removed.
+     *
+     * If middleware sets `__toolNamespacePrefix = false`, tools are registered with their
+     * original names (`tool.name`) without `<middlewareName>_` prefix.
      *
      * @param fn - Middleware function
      * @param name - Optional name for the middleware. If not provided:
@@ -120,13 +123,21 @@ export declare class Agent {
      * // Override default name
      * await agent.use(createPlanModeMiddleware(), 'my_plan_mode');
      *
-     * // Middleware with tools (auto-registers tools with namespace)
+     * // Middleware with tools (auto-registers tools with namespace by default)
      * const middleware: Middleware = async (state, next) => next(state);
      * middleware.__middlewareName = 'plan_mode';
      * middleware.__createTools = async () => [new EnterPlanModeTool()];
      * await agent.use(middleware);
      * // Tool registered as: 'plan_mode_EnterPlanMode'
      *
+     * // Register middleware tool without prefix
+     * const subagentMiddleware: Middleware = async (state, next) => next(state);
+     * subagentMiddleware.__middlewareName = 'parallel_subagent';
+     * subagentMiddleware.__toolNamespacePrefix = false;
+     * subagentMiddleware.__createTools = async () => [new TaskTool()];
+     * await agent.use(subagentMiddleware);
+     * // Tool registered as: 'Task'
+     *
      * // Anonymous middleware (auto-named)
      * const unsubscribe = await agent.use(async (state, next) => {
      *   const compressed = { ...state, messages: compress(state.messages) };

package/dist/agent/hooks/index.d.ts

@@ -1,2 +1,2 @@
 export { HookManager } from './manager';
-export type { AgentHooks, BaseHookContext, HookContext, PermissionRequestHook, PermissionRequestResult, PostToolUseFailureHook, PostToolUseHook, PreToolUseHook, PreToolUseResult, SessionEndContext, SessionEndHook, SessionStartContext, SessionStartHook, StopContext, StopHook, SubagentStartContext, SubagentStartHook, SubagentStopContext, SubagentStopHook, ToolHookContext, ToolHooks, UserPromptSubmitContext, UserPromptSubmitHook, UserPromptSubmitResult, } from './types';
+export type { AgentHooks, BaseHookContext, PermissionRequestHook, PermissionRequestHookEntry, PermissionRequestResult, PostToolUseFailureHook, PostToolUseFailureHookEntry, PostToolUseHook, PostToolUseHookEntry, PreToolUseHook, PreToolUseHookEntry, PreToolUseResult, PromptHookEntry, SessionEndContext, SessionEndHook, SessionStartContext, SessionStartHook, StopContext, StopHook, SubagentStartContext, SubagentStartHook, SubagentStopContext, SubagentStopHook, SubagentStopHookEntry, ToolHookContext, ToolHooks, UserPromptSubmitContext, UserPromptSubmitHook, UserPromptSubmitHookEntry, UserPromptSubmitResult, } from './types';

package/dist/agent/hooks/manager.d.ts

@@ -1,15 +1,32 @@
-import type { AgentHooks, HookContext, PermissionRequestResult, PreToolUseResult, SessionEndContext, SessionStartContext, SubagentStartContext, StopContext, SubagentStopContext, UserPromptSubmitContext, UserPromptSubmitResult } from './types';
+import type { AgentHooks, PermissionRequestResult, PreToolUseResult, SessionEndContext, SessionStartContext, SubagentStartContext, StopContext, SubagentStopContext, ToolHookContext, UserPromptSubmitContext, UserPromptSubmitResult } from './types';
+import type { ModelClient } from '../../model/types';
+import type { HookEvaluationEvent } from '../../types';
+interface HookManagerOptions {
+    modelClient?: ModelClient;
+    emitEvent?: (event: Omit<HookEvaluationEvent, 'sessionId'>) => void;
+    getSessionMetadata?: () => Record<string, unknown>;
+}
 export declare class HookManager {
     private readonly hooks;
-    constructor(hooks?: AgentHooks);
-    executePermissionRequest(context: HookContext): Promise<PermissionRequestResult>;
-    executePreToolUse(context: HookContext): Promise<PreToolUseResult | void>;
+    private readonly modelClient?;
+    private readonly emitEvent?;
+    private readonly getSessionMetadata?;
+    constructor(hooks?: AgentHooks, options?: HookManagerOptions);
+    hasPermissionRequestFunction(): boolean;
+    private toCompactUsage;
+    private getToolCallIdFromInput;
+    private recordEvaluation;
+    private evaluatePromptHook;
+    executePermissionRequest(context: ToolHookContext): Promise<PermissionRequestResult>;
+    evaluatePermissionRequestPrompt(context: ToolHookContext): Promise<void>;
+    executePreToolUse(context: ToolHookContext): Promise<PreToolUseResult | void>;
     executeUserPromptSubmit(context: UserPromptSubmitContext): Promise<UserPromptSubmitResult>;
     executeSessionStart(context: SessionStartContext): Promise<void>;
     executeSessionEnd(context: SessionEndContext): Promise<void>;
-    executePostToolUse(context: HookContext, result: unknown): Promise<void>;
-    executePostToolUseFailure(context: HookContext, error: Error): Promise<void>;
+    executePostToolUse(context: ToolHookContext, result: unknown): Promise<void>;
+    executePostToolUseFailure(context: ToolHookContext, error: Error): Promise<void>;
     executeStop(context: StopContext): Promise<void>;
     executeSubagentStart(context: SubagentStartContext): Promise<void>;
     executeSubagentStop(context: SubagentStopContext): Promise<void>;
 }
+export {};

package/dist/agent/hooks/prompt-executor.d.ts

@@ -0,0 +1,28 @@
+import type { ModelClient } from '../../model/types';
+import type { HookEvaluationEvent, Usage } from '../../types';
+import type { PromptHookEntry } from './types';
+export type PromptEvaluableHookName = 'permissionRequest' | 'preToolUse' | 'postToolUse' | 'postToolUseFailure' | 'subagentStop' | 'userPromptSubmit';
+export interface ExecutePromptHookOptions {
+    hookName: PromptEvaluableHookName;
+    sessionId: string;
+    input: unknown;
+    entry: PromptHookEntry;
+    modelClient?: ModelClient;
+    toolCallId?: string;
+    emitEvent?: (event: Omit<HookEvaluationEvent, 'sessionId'>) => void;
+}
+export interface PromptHookExecutionResult {
+    evaluationId: string;
+    hookName: PromptEvaluableHookName;
+    renderedPrompt: string;
+    status: 'success' | 'error' | 'timeout';
+    durationMs: number;
+    rawResponse?: string;
+    result?: unknown;
+    usage?: Usage;
+    error?: {
+        code?: string;
+        message: string;
+    };
+}
+export declare function executePromptHook(options: ExecutePromptHookOptions): Promise<PromptHookExecutionResult>;

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

@@ -1,4 +1,5 @@
 import type { ModelStopReason } from '../../model/types';
+import type { ModelRef } from '../../model/types';
 import type { ToolExecutionContext } from '../../tool';
 import type { Message, MessageContent, ToolCall, Usage } from '../../types';
 export interface BaseHookContext {
@@ -6,14 +7,11 @@ export interface BaseHookContext {
 }
 /**
  * Context for tool-level hooks (PermissionRequest, PreToolUse, PostToolUse, PostToolUseFailure).
- * Also exported as `HookContext` for backward compatibility.
  */
 export interface ToolHookContext extends BaseHookContext {
     toolCall: ToolCall;
     toolContext: ToolExecutionContext;
 }
-/** @deprecated Use `ToolHookContext` instead. Kept for backward compatibility. */
-export type HookContext = ToolHookContext;
 export interface SessionStartContext extends BaseHookContext {
     /** Whether this run starts from a new session or a resumed state/checkpoint. */
     startReason: 'new' | 'resume';
@@ -84,6 +82,25 @@ export interface UserPromptSubmitResult {
     allow: boolean;
     modifiedInput?: MessageContent;
 }
+export interface PromptHookEntry {
+    type: 'prompt';
+    /**
+     * Prompt template used for evaluation.
+     * `$ARGUMENTS` (if present) will be replaced with serialized hook input.
+     * If absent, serialized hook input is appended to the end of the prompt.
+     */
+    prompt: string;
+    /**
+     * Optional model override for this hook evaluation.
+     * Defaults to the session's configured model.
+     */
+    model?: ModelRef;
+    /**
+     * Optional timeout in milliseconds for this evaluation.
+     * Defaults to 30_000ms.
+     */
+    timeoutMs?: number;
+}
 export type PermissionRequestHook = (ctx: ToolHookContext) => Promise<PermissionRequestResult>;
 export type PreToolUseHook = (ctx: ToolHookContext) => Promise<PreToolUseResult | void>;
 export type PostToolUseHook = (ctx: ToolHookContext, result: unknown) => Promise<void>;
@@ -94,17 +111,23 @@ export type SessionEndHook = (ctx: SessionEndContext) => Promise<void>;
 export type SubagentStartHook = (ctx: SubagentStartContext) => Promise<void>;
 export type SubagentStopHook = (ctx: SubagentStopContext) => Promise<void>;
 export type UserPromptSubmitHook = (ctx: UserPromptSubmitContext) => Promise<UserPromptSubmitResult>;
+export type PermissionRequestHookEntry = PermissionRequestHook | PromptHookEntry;
+export type PreToolUseHookEntry = PreToolUseHook | PromptHookEntry;
+export type PostToolUseHookEntry = PostToolUseHook | PromptHookEntry;
+export type PostToolUseFailureHookEntry = PostToolUseFailureHook | PromptHookEntry;
+export type SubagentStopHookEntry = SubagentStopHook | PromptHookEntry;
+export type UserPromptSubmitHookEntry = UserPromptSubmitHook | PromptHookEntry;
 export interface AgentHooks {
     sessionStart?: SessionStartHook;
-    permissionRequest?: PermissionRequestHook;
-    preToolUse?: PreToolUseHook;
-    postToolUse?: PostToolUseHook;
-    postToolUseFailure?: PostToolUseFailureHook;
+    permissionRequest?: PermissionRequestHookEntry | PermissionRequestHookEntry[];
+    preToolUse?: PreToolUseHookEntry | PreToolUseHookEntry[];
+    postToolUse?: PostToolUseHookEntry | PostToolUseHookEntry[];
+    postToolUseFailure?: PostToolUseFailureHookEntry | PostToolUseFailureHookEntry[];
     sessionEnd?: SessionEndHook;
     stop?: StopHook;
     subagentStart?: SubagentStartHook;
-    subagentStop?: SubagentStopHook;
-    userPromptSubmit?: UserPromptSubmitHook;
+    subagentStop?: SubagentStopHookEntry | SubagentStopHookEntry[];
+    userPromptSubmit?: UserPromptSubmitHookEntry | UserPromptSubmitHookEntry[];
 }
 /** @deprecated Use `AgentHooks` instead. Kept for backward compatibility. */
 export type ToolHooks = AgentHooks;

package/dist/agent/index.d.ts

@@ -6,7 +6,7 @@ export type { ToCheckpointOptions } from '../session/handlers/CheckpointManager'
 export { Agent } from './agent';
 export { AgentAbortError, AgentMaxIterationsError, AgentPauseError, ensureNotAborted } from './errors';
 export { HookManager } from './hooks';
-export type { AgentHooks, BaseHookContext, HookContext, PermissionRequestHook, PermissionRequestResult, PostToolUseFailureHook, PostToolUseHook, PreToolUseHook, PreToolUseResult, SessionEndContext, SessionEndHook, SessionStartContext, SessionStartHook, StopContext, StopHook, SubagentStartContext, SubagentStartHook, SubagentStopContext, SubagentStopHook, ToolHookContext, ToolHooks, UserPromptSubmitContext, UserPromptSubmitHook, UserPromptSubmitResult, } from './hooks';
+export type { AgentHooks, BaseHookContext, PermissionRequestHook, PermissionRequestHookEntry, PermissionRequestResult, PostToolUseFailureHook, PostToolUseFailureHookEntry, PostToolUseHook, PostToolUseHookEntry, PreToolUseHook, PreToolUseHookEntry, PreToolUseResult, PromptHookEntry, SessionEndContext, SessionEndHook, SessionStartContext, SessionStartHook, StopContext, StopHook, SubagentStartContext, SubagentStartHook, SubagentStopContext, SubagentStopHook, SubagentStopHookEntry, ToolHookContext, ToolHooks, UserPromptSubmitContext, UserPromptSubmitHook, UserPromptSubmitHookEntry, UserPromptSubmitResult, } from './hooks';
 export { compose } from './middleware';
 export type { Middleware, NamedMiddleware, NextFunction } from './middleware';
 export { countContentTokens, countMessagesTokens, countMessageTokens, countTokens, createCachedTokenCounter, estimateMessagesTokens, estimateTokens, } from './tokenCounter';

package/dist/agent/middleware.d.ts

@@ -49,9 +49,11 @@ export interface Middleware<State = AgentLoopState> {
     /**
      * Optional factory function that creates tools to be registered with this middleware.
      * When the middleware is registered via agent.use(), this function will be called
-     * and the returned tools will be automatically registered with a namespace prefix.
+     * and the returned tools will be automatically registered with a namespace prefix
+     * by default.
      *
-     * Tools will be namespaced as: `<middlewareName>_<toolName>`
+     * Tools will be namespaced as: `<middlewareName>_<toolName>`.
+     * If `__toolNamespacePrefix === false`, tools are registered with original `tool.name`.
      * When the middleware is removed, all associated tools are automatically unregistered.
      *
      * Can be synchronous or asynchronous to support dynamic tool creation.
@@ -70,6 +72,12 @@ export interface Middleware<State = AgentLoopState> {
      * ```
      */
     __createTools?: () => BaseTool[] | Promise<BaseTool[]>;
+    /**
+     * Optional flag to control middleware tool namespace prefixing.
+     * Defaults to true/undefined, which registers tools as `<middlewareName>_<toolName>`.
+     * Set to false to register tools with their original `tool.name` (no middleware prefix).
+     */
+    __toolNamespacePrefix?: boolean;
     /**
      * Optional function that returns a list of tool names to block for the given state.
      * This allows middleware to dynamically control which tools should be unavailable

package/dist/agent/types.d.ts

@@ -1,6 +1,7 @@
 import type { McpServerConfig } from '../mcp-client';
 import type { ModelClient, ModelRef } from '../model';
 import type { ModelStopReason } from '../model/types';
+import type { MessageQueueConfig } from '../session/types';
 import type { StateStore } from '../state';
 import type { ToolExecutionContextInput, ToolRegistry } from '../tool';
 import type { CheckpointRequestParams, Message, MessageContent, ToolCall, Usage } from '../types';
@@ -294,10 +295,21 @@ export interface CreateSessionOptions extends SessionHandleOptions {
      * This value is persisted in session snapshots and restored on resume.
      */
     cwd?: string;
+    /**
+     * Optional message queue configuration for this session.
+     */
+    messageQueueConfig?: Partial<MessageQueueConfig>;
 }
 export interface SendOptions {
     /**
      * Optional tool execution context input
      */
     toolContext?: ToolExecutionContextInput;
+    /**
+     * Controls how receive() handles existing checkpoints.
+     * - auto: preserve current behavior
+     * - explicit_only: do not auto-resume a pending checkpoint
+     * - force_resume: require resuming from checkpoint flow first
+     */
+    resumeMode?: 'auto' | 'explicit_only' | 'force_resume';
 }