goatchain 0.0.29 → 0.0.31

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, 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,8 +1,24 @@
 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);
+    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>;
@@ -13,3 +29,4 @@ export declare class HookManager {
     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 {
@@ -81,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>;
@@ -91,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, 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';
 }

package/dist/index.d.ts

@@ -1,16 +1,20 @@
 export * from './acp-adapter';
 export { Agent, AgentAbortError, AgentMaxIterationsError, compose, compressSessionManually, createContextCompressionMiddleware, createInitialLoopState, ensureNotAborted, extractPersistentMetadata, extractPersistentState, fromLoopCheckpoint, HookManager, toLoopCheckpoint, } from './agent';
-export type { AgentHooks, AgentInput, AgentLoopState, AgentOptions, BaseHookContext, CompressionStats, ContextCompressionOptions, CreateSessionOptions, ManualCompressionOptions, ManualCompressionResult, Middleware, NextFunction, PermissionRequestHook, PermissionRequestResult, PostToolUseFailureHook, PostToolUseHook, PreToolUseHook, PreToolUseResult, SessionEndContext, SessionEndHook, SessionStartContext, SessionStartHook, SendOptions, SessionHandleOptions, StopContext, StopHook, SubagentStartContext, SubagentStartHook, SubagentStopContext, SubagentStopHook, ToCheckpointOptions, ToolCallWithResult, ToolHookContext, ToolHooks, UserPromptSubmitContext, UserPromptSubmitHook, UserPromptSubmitResult, } from './agent';
+export type { AgentHooks, AgentInput, AgentLoopState, AgentOptions, BaseHookContext, CompressionStats, ContextCompressionOptions, CreateSessionOptions, ManualCompressionOptions, ManualCompressionResult, Middleware, NextFunction, PermissionRequestHook, PermissionRequestHookEntry, PermissionRequestResult, PostToolUseFailureHook, PostToolUseFailureHookEntry, PostToolUseHook, PostToolUseHookEntry, PreToolUseHook, PreToolUseHookEntry, PreToolUseResult, PromptHookEntry, SendOptions, SessionEndContext, SessionEndHook, SessionHandleOptions, SessionStartContext, SessionStartHook, StopContext, StopHook, SubagentStartContext, SubagentStartHook, SubagentStopContext, SubagentStopHook, SubagentStopHookEntry, ToCheckpointOptions, ToolCallWithResult, ToolHookContext, ToolHooks, UserPromptSubmitContext, UserPromptSubmitHook, UserPromptSubmitHookEntry, UserPromptSubmitResult, } from './agent';
 export { applyCcMockSystemPrompt, CCMOCK_SYSTEM_PROMPT_PREFIX, isCcMockEnabled, readCcMockFlag, } from './ccmock';
+export { cacheTextToSessionBlob, cleanupExpiredSessionCaches, cleanupSessionCache, deleteSessionBlobByPath, normalizeSessionId, readBlobMeta, relocateSessionBlobPath, resolveBlobPathFromFileId, resolveSessionCacheDir, resolveStateDir, writeSessionBlob, } from './lib/session-blob';
+export type { BlobLogger, SessionBlobWriteResult } from './lib/session-blob';
 export * from './mcp-client';
 export { createAgentRulesMiddleware } from './middleware/agentRulesMiddleware';
 export type { AgentRulesMiddlewareOptions } from './middleware/agentRulesMiddleware';
-export { createCommitModeMiddleware } from './middleware/commitModeMiddleware';
-export type { CommitModeMiddlewareOptions } from './middleware/commitModeMiddleware';
 export { createAttachmentMiddleware } from './middleware/attachmentMiddleware';
 export type { AttachmentMiddlewareOptions } from './middleware/attachmentMiddleware';
+export { createCommitModeMiddleware } from './middleware/commitModeMiddleware';
+export type { CommitModeMiddlewareOptions } from './middleware/commitModeMiddleware';
 export { createEnvInfoMiddleware } from './middleware/envInfoMiddleware';
 export type { EnvInfoMiddlewareOptions } from './middleware/envInfoMiddleware';
+export { createLongRunningMiddleware } from './middleware/longRunningMiddleware';
+export type { LongRunningMiddlewareOptions, SelfReflectionOptions } from './middleware/longRunningMiddleware';
 export { createParallelSubagentMiddleware } from './middleware/parallelSubagentMiddleware';
 export type { ParallelSubagentMiddlewareOptions } from './middleware/parallelSubagentMiddleware';
 export { createPlanModeMiddleware } from './middleware/planModeMiddleware';
@@ -19,8 +23,6 @@ export { createReviewModeMiddleware } from './middleware/reviewMiddleware';
 export type { ReviewModeMiddlewareOptions } from './middleware/reviewMiddleware';
 export { createSkillsMiddleware, parseSkillFile, scanMultipleSkillsDirectories, scanSkillsDirectory } from './middleware/skillsMiddleware';
 export type { ParsedSkill, SkillsMiddlewareOptions } from './middleware/skillsMiddleware';
-export { createLongRunningMiddleware } from './middleware/longRunningMiddleware';
-export type { LongRunningMiddlewareOptions, SelfReflectionOptions } from './middleware/longRunningMiddleware';
 export { injectSystemReminderToLastUserMessage, } from './middleware/utils';
 export * from './model';
 export type { OpenAITool } from './model';
@@ -31,10 +33,8 @@ export { FileStateStore, InMemoryStateStore, StateKeys, StateStore, } from './st
 export type { CompressionState, FileStateStoreOptions, StateKey, StateStoreOptions, } from './state';
 export * from './subagent';
 export { BaseTool, errorContent, FilteredToolRegistry, imageContent, textContent, ToolRegistry } from './tool';
-export { AskUserTool, BashTool, EditTool, GlobTool, GrepTool, ReadTool, TodoPlanTool, TodoWriteTool, softWrapLines, WebFetchTool, WebSearchTool, WriteTool, } from './tool';
+export { AskUserTool, BashTool, EditTool, GlobTool, GrepTool, ReadTool, softWrapLines, TodoPlanTool, TodoWriteTool, WebFetchTool, WebSearchTool, WriteTool, } from './tool';
 export type { BashArgs, BashResult, RiskLevel, ToolApprovalResult, ToolApprovalSettings, ToolApprovalStrategy, ToolExecutionContext, ToolExecutionContextInput, ToolRunUsage, } from './tool';
-export type { AskUserArgs, AskUserResult, EditArgs, EditResult, DeliveryMode, FetchFormat, GlobArgs, GlobResult, GrepArgs, GrepOutputMode, GrepResult, Question, QuestionOption, ReadArgs, ReadResult, TodoItem, TodoPlanArgs, TodoPlanResult, TodoStatus, TodoWriteArgs, TodoWriteResult, WebFetchArgs, WebFetchResult, WebSearchArgs, WebSearchResult, WriteArgs, WriteResult, } from './tool';
+export type { AskUserArgs, AskUserResult, DeliveryMode, EditArgs, EditResult, FetchFormat, GlobArgs, GlobResult, GrepArgs, GrepOutputMode, GrepResult, Question, QuestionOption, ReadArgs, ReadResult, TodoItem, TodoPlanArgs, TodoPlanResult, TodoStatus, TodoWriteArgs, TodoWriteResult, WebFetchArgs, WebFetchResult, WebSearchArgs, WebSearchResult, WriteArgs, WriteResult, } from './tool';
 export * from './tool/converters';
-export { cacheTextToSessionBlob, cleanupExpiredSessionCaches, cleanupSessionCache, deleteSessionBlobByPath, normalizeSessionId, readBlobMeta, relocateSessionBlobPath, resolveBlobPathFromFileId, resolveSessionCacheDir, resolveStateDir, writeSessionBlob, } from './lib/session-blob';
-export type { BlobLogger, SessionBlobWriteResult } from './lib/session-blob';
-export type { AgentEvent, AgentEventType, AgentLoopCheckpoint, AssistantMessage, BaseEvent, CallToolResult, CompletionAssessedEvent, CompressionEndEvent, CompressionStartEvent, ContentBlock, DoneEvent, ImageContent, IterationEndEvent, IterationStartEvent, JSONSchemaProperty, Message, MessageContent, MessageRole, SystemMessage, TextContent, TextDeltaEvent, TextEndEvent, TextStartEvent, ThinkingDeltaEvent, Tool, ToolCall, ToolCallDeltaEvent, ToolCallEndEvent, ToolCallStartEvent, ToolMessage, ToolResultEvent, Usage, UserMessage, } from './types';
+export type { AgentEvent, AgentEventType, AgentLoopCheckpoint, AssistantMessage, BaseEvent, CallModelOnceOptions, CallModelOnceResult, CallToolResult, CompletionAssessedEvent, CompressionEndEvent, CompressionStartEvent, ContentBlock, DoneEvent, HookEvaluationEvent, ImageContent, IterationEndEvent, IterationStartEvent, JSONSchemaProperty, Message, MessageContent, MessageRole, SessionSnapshot, SystemMessage, TextContent, TextDeltaEvent, TextEndEvent, TextStartEvent, ThinkingDeltaEvent, Tool, ToolCall, ToolCallDeltaEvent, ToolCallEndEvent, ToolCallStartEvent, ToolMessage, ToolResultEvent, Usage, UserMessage, } from './types';