goatchain 0.0.29 → 0.0.31

package/dist/middleware/contextCompressionMiddleware.d.ts

@@ -3,187 +3,48 @@ import type { AgentLoopState } from '../agent/types';
 import type { ModelClient } from '../model';
 import type { StateStore } from '../state/stateStore';
 import type { Message } from '../types';
-/**
- * Configuration options for context compression middleware.
- */
 export interface ContextCompressionOptions {
-    /**
-     * Maximum token limit for the model (e.g., 128000 for GPT-4).
-     * - Tool compression triggers at 50% (maxTokens * 0.5)
-     * - Summary compression triggers at 80% (maxTokens * 0.8)
-     */
-    maxTokens: number;
-    /**
-     * Number of recent conversation turns to always protect (default: 2).
-     * A turn is a user message + assistant response pair.
-     * The last N turns will always be preserved from summary compression.
-     * Tool compression ignores this setting and only preserves tool results from
-     * the most recent completed turn.
-     */
-    protectedTurns?: number;
-    /**
-     * Model to use for generating summaries.
-     */
-    model: ModelClient;
-    /**
-     * State store for persisting compression state.
-     */
-    stateStore: StateStore;
-    /**
-     * Tool compression target (default: 0.45, meaning compress to 45% of maxTokens).
-     * When tool compression is triggered at 50%, it will compress until reaching this target.
-     */
-    toolCompressionTarget?: number;
-    /**
-     * Minimum number of recent tool results to keep (default: 5).
-     * The most recent N tool results will be protected from compression.
-     */
-    minKeepToolResults?: number;
-    /**
-     * Enable logging compression events to a file in the current working directory.
-     * If enabled, logs will be appended to 'compression-logs.jsonl' in JSONL format.
-     */
-    enableLogging?: boolean;
-    /**
-     * Custom log file path (relative to cwd or absolute).
-     * Default: 'compression-logs.jsonl'
-     */
-    logFilePath?: string;
-    /**
-     * Token limit of the model used for summarization.
-     * Used to determine when chunked summarization is needed.
-     * When the content to summarize exceeds this limit, the middleware
-     * automatically splits it into chunks and summarizes sequentially.
-     * Defaults to maxTokens if not specified.
-     */
-    summaryModelMaxTokens?: number;
-    /**
-     * Maximum characters per individual message when formatting for summary.
-     * More aggressive truncation reduces the chance of needing chunked summarization.
-     * Applies to tool outputs, user messages, and assistant messages.
-     * Default: 3000
-     */
-    maxMessageCharsForSummary?: number;
+    contextLength: number;
 }
-/**
- * Options for manual compression.
- */
 export interface ManualCompressionOptions {
-    /**
-     * Session ID for the compression.
-     */
     sessionId: string;
-    /**
-     * Full messages from the session (including all history).
-     * These should be the complete, uncompressed messages.
-     */
     fullMessages: Message[];
-    /**
-     * Model to use for generating summary.
-     */
     model: ModelClient;
-    /**
-     * State store for persisting compression state.
-     */
     stateStore: StateStore;
-    /**
-     * Custom prompt for summary generation (optional).
-     * If not provided, uses DEFAULT_SUMMARY_PROMPT.
-     */
-    summaryPrompt?: string;
-    /**
-     * Enable logging compression events to a file.
-     */
-    enableLogging?: boolean;
-    /**
-     * Custom log file path (relative to cwd or absolute).
-     * Default: 'compression-logs.jsonl'
-     */
-    logFilePath?: string;
-    /**
-     * Token limit of the model used for summarization.
-     * Used to determine when chunked summarization is needed.
-     * Defaults to 128000 if not specified.
-     */
-    summaryModelMaxTokens?: number;
-    /**
-     * Maximum characters per individual message when formatting for summary.
-     * Default: 3000
-     */
-    maxMessageCharsForSummary?: number;
+    contextLength: number;
 }
-/**
- * Result of manual compression.
- */
 export interface ManualCompressionResult {
-    /**
-     * Generated summary.
-     */
     summary: string;
-    /**
-     * Number of messages processed.
-     */
     messageCount: number;
-    /**
-     * Number of tool outputs found.
-     */
     toolOutputCount: number;
+    compressedMessages: Message[];
 }
-/**
- * Statistics about the compression operation.
- */
 export interface CompressionStats {
-    /** Token count before compression */
     tokensBefore: number;
-    /** Token count after compression */
     tokensAfter: number;
-    /** Number of tool outputs that were cleared */
     clearedToolOutputs: number;
-    /** Number of messages that were removed by summarization */
     removedMessages: number;
-    /** Whether a summary was generated */
     summaryGenerated: boolean;
-    /** Timestamp when this compression occurred */
     timestamp: number;
 }
-/**
- * Create a context compression middleware.
- *
- * This middleware automatically compresses conversation history using a two-stage strategy:
- *
- * **Stage 1 (Summary Compression) - Triggers at 80% of maxTokens:**
- * - Summarizes all messages before the last N protected turns
- * - Generates rolling summary (AI merges old + new summaries)
- * - Removes entire messages from array
- * - Injects summary into system message
- * - Saves summary + compressed range to stateStore
- * - On session resume: re-applies the message removal using saved range
- *
- * **Stage 2 (Tool Compression) - Triggers at 50% of maxTokens:**
- * - Iteratively clears tool output content → `[Old tool result content cleared]`
- * - Starts from oldest tool, clears until reaching target (default: 45% of maxTokens)
- * - Protects last N tool results (default: 5)
- * - NOT saved to state (transient compression)
- *
- * @param options - Compression configuration options
- * @returns Middleware function
- *
- * @example
- * ```ts
- * const agent = new Agent({ model, stateStore, ... })
- *
- * agent.use(createContextCompressionMiddleware({
- *   maxTokens: 128000,
- *   protectedTurns: 2,
- *   model: model,
- *   stateStore: agent.stateStore,
- *   toolCompressionTarget: 0.45,  // Compress to 45% of maxTokens
- *   minKeepToolResults: 5,         // Keep last 5 tool results
- * }))
- * ```
- */
+export type CompressionTraceStage = 'stage1' | 'stage2' | 'stage3' | 'stage4';
+export interface CompressionTraceSnapshot {
+    sessionId: string;
+    mode: CompressionMode;
+    stage: CompressionTraceStage;
+    contextLength: number;
+    triggerThreshold: number;
+    targetTokens: number;
+    tokens: number;
+    messages: Message[];
+    rawMessages: Message[];
+    summary: string;
+    coveredMessageCount: number;
+    clearedToolOutputs: number;
+    removedMessages: number;
+    summaryGenerated: boolean;
+}
+type CompressionMode = 'auto' | 'manual';
 export declare function createContextCompressionMiddleware(options: ContextCompressionOptions): Middleware<AgentLoopState>;
-/**
- * Manually compress a session by generating a summary from full message history.
- */
 export declare function compressSessionManually(options: ManualCompressionOptions): Promise<ManualCompressionResult>;
+export {};

package/dist/middleware/longRunningMiddleware.d.ts

@@ -34,6 +34,12 @@ export interface SelfReflectionOptions {
      * @default false
      */
     debug?: boolean;
+    /**
+     * Critic subagent context window / compression budget.
+     *
+     * @default 128000
+     */
+    maxTokens?: number;
 }
 /**
  * Options for the long_running middleware.

package/dist/middleware/parallelSubagentMiddleware.d.ts

@@ -31,6 +31,12 @@ export interface ParallelSubagentMiddlewareOptions {
      * 是否输出调试日志（默认: false）
      */
     debug?: boolean;
+    /**
+     * Subagent context window / compression budget.
+     *
+     * Defaults to 128000 when not provided.
+     */
+    maxTokens?: number;
     /**
      * 可选：middleware 名称（默认: 'parallel_subagent'）
      */
@@ -43,7 +49,7 @@ export interface ParallelSubagentMiddlewareOptions {
  * 1. 自动创建并注册 TaskTool（包含 subagent 定义和 executor）
  * 2. 启用并行执行模式：当 LLM 同时调用多个 Task 工具时自动并行执行
  *
- * TaskTool 会被注册为 `<middlewareName>_Task`，例如 `parallel_subagent_Task`
+ * TaskTool 会以 `Task` 注册（本 middleware 使用无前缀注册，提高辨识度）
  *
  * @example 使用默认 executor（推荐）
  * ```typescript

package/dist/model/anthropic/createAnthropicAdapter.d.ts

@@ -51,6 +51,11 @@ interface AnthropicThinkingBlock {
     thinking: string;
 }
 type AnthropicContentBlock = AnthropicTextBlock | AnthropicImageBlock | AnthropicDocumentBlock | AnthropicToolUseBlock | AnthropicToolResultBlock | AnthropicThinkingBlock;
+type AnthropicUsage = {
+    input_tokens?: number;
+    output_tokens?: number;
+};
 export declare function contentToBlocks(content: MessageContent): AnthropicContentBlock[];
+export declare function mergeAnthropicUsage(base?: AnthropicUsage, next?: AnthropicUsage | null): AnthropicUsage | undefined;
 export declare function createAnthropicAdapter(options: AnthropicAdapterOptions): ModelAdapter;
 export {};

package/dist/session/executors/ToolExecutor.d.ts

@@ -1,5 +1,6 @@
 import type { AgentHooks } from '../../agent/hooks';
 import type { AgentLoopState, ToolCallWithResult } from '../../agent/types';
+import type { ModelClient } from '../../model/types';
 import type { ToolExecutionContext, ToolExecutionContextInput, ToolRegistry } from '../../tool';
 import type { AgentEvent, AgentLoopCheckpoint, CheckpointModelConfig, CheckpointRequestParams, ToolCall } from '../../types';
 import type { ApprovalHandler } from '../handlers/ApprovalHandler';
@@ -21,6 +22,8 @@ interface ToolExecutorOptions {
     addAssistantMessageWithToolCalls: (state: AgentLoopState) => void;
     addToolResultToHistory: (state: AgentLoopState, tc: ToolCallWithResult) => void;
     persistSessionState: (state: AgentLoopState) => Promise<void>;
+    modelClient?: ModelClient;
+    getSessionMetadata?: () => Record<string, unknown>;
     log?: (...args: unknown[]) => void;
 }
 export declare class ToolExecutor {
@@ -28,6 +31,7 @@ export declare class ToolExecutor {
     private toolEventQueue;
     constructor(options: ToolExecutorOptions);
     private _log;
+    private createHookManager;
     createToolExecutionContext(state: AgentLoopState, signal?: AbortSignal, toolCallId?: string, toolName?: string): ToolExecutionContext;
     executeToolCall(tc: ToolCallWithResult, ctx: ToolExecutionContext, signal?: AbortSignal, hooks?: AgentHooks, permissionRequestResult?: {
         allow: boolean;

package/dist/session/index.d.ts

@@ -2,3 +2,4 @@ export { BaseSession } from './base';
 export { BaseSessionManager } from './manager';
 export { Session } from './session';
 export { StateStoreSessionManager } from './stateStoreSessionManager';
+export * from './types';

package/dist/session/session.d.ts

@@ -1,10 +1,19 @@
 import type { Middleware } from '../agent/middleware';
 import type { AgentLoopState, CreateSessionOptions, SendOptions } from '../agent/types';
-import type { ModelClient } from '../model';
+import type { ModelClient, ModelStreamEvent } from '../model';
 import type { StateStore } from '../state';
 import type { ToolApprovalResult, ToolRegistry } from '../tool';
-import type { AgentEvent, Message, MessageContent, ModelConfig, SessionConfigOverride, SessionSnapshot, SessionStatus } from '../types';
+import type { AgentEvent, CallModelOnceOptions, CallModelOnceResult, Message, MessageContent, ModelConfig, SessionConfigOverride, SessionSnapshot, SessionStatus } from '../types';
+import type { MessageQueueConfig, MessageQueueStatus } from './types/messageQueue';
 import { EventEmitter } from 'node:events';
+type QueuedSendOptions = SendOptions & {
+    priority?: number;
+};
+interface BatchMessageInput {
+    input: MessageContent;
+    options?: SendOptions;
+    priority?: number;
+}
 interface SessionRuntimeOptions extends CreateSessionOptions {
     modelClient?: ModelClient;
     systemPrompt?: string;
@@ -54,6 +63,7 @@ export declare class Session extends EventEmitter {
     private readonly _systemPrompt?;
     private readonly _agentName?;
     private readonly _onUsage?;
+    private _messageQueue;
     private _pendingInput;
     private _isReceiving;
     private readonly _hooks?;
@@ -69,6 +79,9 @@ export declare class Session extends EventEmitter {
     private _checkpointOriginalMessages?;
     private _checkpointNewMessages;
     private _checkpointSkipSnapshot?;
+    private _rawMessages;
+    private _rawOriginalMessages?;
+    private _rawNewMessages;
     private getDisabledToolNames;
     private isToolDisabled;
     private collectBlockedTools;
@@ -85,6 +98,7 @@ export declare class Session extends EventEmitter {
      * @private
      */
     private _syncCwdToTools;
+    private getOrCreateSessionMetadata;
     /**
      * Create a new Session or load from StateStore.
      *
@@ -98,7 +112,14 @@ export declare class Session extends EventEmitter {
      * This is an idempotent check that reads from StateStore each time.
      */
     hasCheckpoint(): Promise<boolean>;
-    send(input: MessageContent, options?: SendOptions): void;
+    send(input: MessageContent, options?: QueuedSendOptions): string;
+    sendBatch(messages: BatchMessageInput[]): string[];
+    cancelQueuedMessage(messageId: string): boolean;
+    getQueueStatus(): MessageQueueStatus;
+    clearQueue(): void;
+    updateQueueConfig(config: Partial<MessageQueueConfig>): void;
+    private _tryDequeueNext;
+    private _markCheckpointQueueMessageAsConsumed;
     /**
      * Cancel the current agent execution.
      *
@@ -123,6 +144,8 @@ export declare class Session extends EventEmitter {
      * ```
      */
     cancel(): void;
+    callModelOnceStream(options: CallModelOnceOptions): AsyncIterable<ModelStreamEvent>;
+    callModelOnce(options: CallModelOnceOptions): Promise<CallModelOnceResult>;
     receive(options?: SendOptions): AsyncIterable<AgentEvent>;
     /**
      * Convenience helper for "pause → decide → resume" flows.
@@ -144,16 +167,26 @@ export declare class Session extends EventEmitter {
      * This prevents the session from being stuck waiting for responses that will never come.
      */
     private buildAutoRejectToolContext;
+    private mergeToolContexts;
+    private hasMeaningfulToolContext;
     private getRuntimeModelRoute;
+    getRawMessages(): Message[];
+    getFullRawMessages(): Message[];
+    applyCommittedWorkingMessages(messages: Message[]): Promise<void>;
     private _ensureRuntimeConfigured;
     private extractTextFromContent;
     private stripLeadingMarkdownLinkPrefix;
     private createTitle;
+    private buildRawMessagesForCompression;
+    private seedCompressionMetadata;
     private _recordUsage;
+    private normalizeUsage;
     private executeModelStream;
     private mergeStateResults;
     private appendMessage;
     private getCheckpointMessages;
+    private commitRuntimeState;
+    private resetLoopSnapshots;
     private saveCheckpointForState;
     private addToolResultToHistory;
     private addAssistantMessageWithToolCalls;

package/dist/session/types/index.d.ts

@@ -0,0 +1 @@
+export * from './messageQueue';

package/dist/session/types/messageQueue.d.ts

@@ -0,0 +1,29 @@
+import type { SendOptions } from '../../agent/types';
+import type { MessageContent } from '../../types';
+export interface PendingMessage {
+    id: string;
+    input: MessageContent;
+    options?: SendOptions;
+    priority: number;
+    enqueuedAt: number;
+    status: 'pending' | 'cancelled';
+}
+export interface MessageQueueConfig {
+    autoProcessQueue: boolean;
+    maxQueueSize?: number;
+}
+export interface MessageQueueSnapshot {
+    messages: PendingMessage[];
+    config: MessageQueueConfig;
+}
+export interface MessageQueueStatus {
+    length: number;
+    messages: Array<{
+        id: string;
+        priority: number;
+        enqueuedAt: number;
+        preview: string;
+    }>;
+    isProcessing: boolean;
+    config: MessageQueueConfig;
+}

package/dist/session/utils/MessageQueue.d.ts

@@ -0,0 +1,23 @@
+import type { MessageContent } from '../../types';
+import type { SendOptions } from '../../agent/types';
+import type { MessageQueueConfig, MessageQueueSnapshot, MessageQueueStatus, PendingMessage } from '../types/messageQueue';
+export declare class MessageQueue {
+    private _messages;
+    private _config;
+    private _isProcessing;
+    constructor(config?: Partial<MessageQueueConfig>);
+    get config(): MessageQueueConfig;
+    updateConfig(config: Partial<MessageQueueConfig>): void;
+    setProcessing(isProcessing: boolean): void;
+    enqueue(input: MessageContent, options?: SendOptions, priority?: number): string;
+    dequeue(): PendingMessage | null;
+    peek(): PendingMessage | null;
+    cancel(messageId: string): boolean;
+    clear(): void;
+    isEmpty(): boolean;
+    size(): number;
+    getStatus(): MessageQueueStatus;
+    toSnapshot(): MessageQueueSnapshot;
+    static fromSnapshot(snapshot: MessageQueueSnapshot): MessageQueue;
+    private _sort;
+}

package/dist/state/types.d.ts

@@ -18,6 +18,8 @@ export declare const StateKeys: {
     readonly CHECKPOINT: "checkpoint";
     /** CompressionState data */
     readonly COMPRESSION: "compression";
+    /** Persisted compressed working view used for runtime resume/looping */
+    readonly COMPRESSION_VIEW: "compression-view";
     /** SessionSnapshot data */
     readonly SESSION: "session";
     /**
@@ -58,41 +60,49 @@ export interface CompressedMessagesSnapshot {
  * allowing the middleware to restore its state after a restart.
  */
 export interface CompressionState {
+    lastStats?: CompressionStats;
+    summary?: string;
+    coveredMessageCount?: number;
+    baseRawSignature?: string;
+    baseRawMessageCount?: number;
+    updatedAt: number;
+}
+/**
+ * Persisted compressed working view.
+ *
+ * This is the runtime baseline used for future loop iterations, checkpointing,
+ * and resume after a successful compression commit. Raw history is stored
+ * separately by the session snapshot for audit/rebuild purposes.
+ */
+export interface CommittedCompressionView {
     /**
-     * Statistics from the last compression operation.
+     * Number of full messages that were present in the raw view when this
+     * compressed working view was produced.
      */
-    lastStats?: CompressionStats;
+    baseMessageCount: number;
+    /**
+     * Deterministic signature of the raw base messages used to validate the
+     * committed view against rewrites/forks/truncation.
+     */
+    baseMessagesSignature: string;
     /**
-     * History of all compression operations.
+     * Compressed working view including system messages and any injected summary.
      */
-    history: CompressionStats[];
+    messages: import('../types').Message[];
     /**
-     * Rolling summary content from summarized messages.
-     * This can be used when resuming from a checkpoint to provide context.
+     * Rolling summary associated with this working view.
      */
     summary?: string;
     /**
-     * Last update timestamp (ms).
+     * Estimated tokens of the committed working view after compression.
      */
-    updatedAt: number;
+    tokensAfter: number;
+    /**
+     * Whether the view came from automatic or manual compression.
+     */
+    mode: 'auto' | 'manual';
     /**
-     * Record of which messages were compressed (removed) in the last summary compression.
-     * Used to remove the same messages when loading the summary on session resume.
+     * Creation timestamp (ms).
      */
-    compressedRange?: {
-        /**
-         * Index where summarization starts (first non-system message).
-         * Messages before this index (system messages) are always kept.
-         */
-        summarizeStart: number;
-        /**
-         * Index where protected turns start (messages from this onward are kept).
-         */
-        protectedStart: number;
-        /**
-         * Total number of messages at the time of compression.
-         * Used to validate if the range is still applicable.
-         */
-        totalMessagesAtCompression: number;
-    };
+    createdAt: number;
 }

package/dist/types/common.d.ts

@@ -1,4 +1,5 @@
 import type { CallToolResult, ContentBlock, ImageContent, TextContent, Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { ModelStopReason } from '../model/types';
 /**
  * Re-export MCP types
  */
@@ -52,6 +53,17 @@ export interface Usage {
     completionTokens: number;
     totalTokens: number;
 }
+export interface CallModelOnceOptions {
+    input: string | MessageContent;
+    systemPrompt?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+export interface CallModelOnceResult {
+    text: string;
+    usage?: Usage;
+    stopReason: ModelStopReason;
+}
 /**
  * Small reference stored in checkpoint metadata (JSON-safe).
  *

package/dist/types/event.d.ts

@@ -5,7 +5,7 @@ import type { AgentLoopCheckpoint } from './snapshot';
 /**
  * Event types for streaming responses
  */
-export type AgentEventType = 'text_start' | 'text_delta' | 'text_end' | 'tool_call_start' | 'tool_call_delta' | 'tool_call_end' | 'tool_result' | 'tool_output_start' | 'tool_output_delta' | 'tool_approval_requested' | 'requires_action' | 'tool_skipped' | 'thinking_start' | 'thinking_delta' | 'thinking_end' | 'done' | 'iteration_start' | 'iteration_end' | 'session_created' | 'subagent_event' | 'completion_assessed' | 'compression_start' | 'compression_end';
+export type AgentEventType = 'text_start' | 'text_delta' | 'text_end' | 'tool_call_start' | 'tool_call_delta' | 'tool_call_end' | 'tool_result' | 'tool_output_start' | 'tool_output_delta' | 'tool_approval_requested' | 'requires_action' | 'tool_skipped' | 'thinking_start' | 'thinking_delta' | 'thinking_end' | 'done' | 'iteration_start' | 'iteration_end' | 'session_created' | 'subagent_event' | 'completion_assessed' | 'compression_start' | 'compression_end' | 'hook_evaluation';
 /**
  * Base event interface
  */
@@ -13,6 +13,20 @@ export interface BaseEvent {
     type: AgentEventType;
     /** Session identifier for this event */
     sessionId: string;
+    /**
+     * Stream identifier for this prompt/run.
+     * Optional for backward compatibility with existing emitters.
+     */
+    streamId?: string;
+    /**
+     * Monotonic sequence number within a stream.
+     * Starts from 1 when present.
+     */
+    seq?: number;
+    /**
+     * Whether this event is replayed history rather than live output.
+     */
+    replayed?: boolean;
 }
 /**
  * Text start event - marks beginning of a text response
@@ -107,6 +121,10 @@ export interface ToolApprovalRequestedEvent extends BaseEvent {
 export interface RequiresActionEvent extends BaseEvent {
     type: 'requires_action';
     kind: 'tool_approval' | 'ask_user';
+    /**
+     * Stable action identifier used for resume routing.
+     */
+    actionId?: string;
     /**
      * Checkpoint to resume from.
      * If a checkpoint store is configured, this may be omitted in favor of `checkpointRef`.
@@ -134,6 +152,14 @@ export interface RequiresActionEvent extends BaseEvent {
         }>;
         multiSelect: boolean;
     }>;
+    /**
+     * Structured action error.
+     */
+    error?: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
 }
 /**
  * Tool skipped event - emitted when a tool execution is skipped (e.g., approval denied)
@@ -266,6 +292,14 @@ export interface CompressionStartEvent extends BaseEvent {
     tokensBefore: number;
     /** Token threshold that triggered compression */
     threshold: number;
+    lastTurnTokens?: number;
+    compressAfterLastUser?: boolean;
+    summaryProtectedStart?: number;
+    toolProtectedStart?: number;
+    protectedToolCount?: number;
+    latestToolIndex?: number;
+    latestToolTokens?: number;
+    latestToolOversized?: boolean;
 }
 /**
  * Compression end event - emitted when AI-based summary compression completes.
@@ -287,7 +321,34 @@ export interface CompressionEndEvent extends BaseEvent {
     /** Time taken for compression in milliseconds */
     elapsedMs: number;
 }
+/**
+ * Hook evaluation event - emitted during prompt-based hook evaluation.
+ *
+ * Uses a single event type with `phase` for easier integration:
+ * - `start`: prompt evaluation request started
+ * - `stream`: incremental text delta from model
+ * - `end`: evaluation finished (success/error/timeout)
+ */
+export 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;
+}
 /**
  * Union type for all agent events
  */
-export type AgentEvent = TextStartEvent | TextDeltaEvent | TextEndEvent | ToolCallStartEvent | ToolCallDeltaEvent | ToolCallEndEvent | ToolResultEvent | ToolOutputStartEvent | ToolOutputDeltaEvent | ToolApprovalRequestedEvent | RequiresActionEvent | ToolSkippedEvent | ThinkingStartEvent | ThinkingDeltaEvent | ThinkingEndEvent | DoneEvent | IterationStartEvent | IterationEndEvent | SessionCreatedEvent | SubagentEvent | CompletionAssessedEvent | CompressionStartEvent | CompressionEndEvent;
+export type AgentEvent = TextStartEvent | TextDeltaEvent | TextEndEvent | ToolCallStartEvent | ToolCallDeltaEvent | ToolCallEndEvent | ToolResultEvent | ToolOutputStartEvent | ToolOutputDeltaEvent | ToolApprovalRequestedEvent | RequiresActionEvent | ToolSkippedEvent | ThinkingStartEvent | ThinkingDeltaEvent | ThinkingEndEvent | DoneEvent | IterationStartEvent | IterationEndEvent | SessionCreatedEvent | SubagentEvent | CompletionAssessedEvent | CompressionStartEvent | CompressionEndEvent | HookEvaluationEvent;

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from '../session/types/messageQueue';
 export * from './common';
 export * from './event';
 export * from './message';