@cuylabs/agent-core 4.9.0 → 5.0.0

package/dist/events/index.js

@@ -1,6 +1,11 @@
+import "../chunk-3NBTQHVV.js";
 import {
   createEventBus
-} from "../chunk-2TTOLHBT.js";
+} from "../chunk-CFBSQLP5.js";
+import {
+  LocalSignal
+} from "../chunk-UG5PVNZV.js";
 export {
+  LocalSignal,
   createEventBus
 };

package/dist/events/signal/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Signal — typed multi-consumer event dispatch for agent-core.
+ *
+ * @example
+ * ```ts
+ * import { createAgent, LocalSignal } from "@cuylabs/agent-core";
+ *
+ * const agent = createAgent({ model, signal: new LocalSignal() });
+ *
+ * // Subscribe before kicking off a chat
+ * const off = agent.signal.on("text-delta", (e) => process.stdout.write(e.text));
+ * await agent.send("s1", "hello");
+ * off();
+ * ```
+ */
+export type { AgentSignal } from "./types.js";
+export { LocalSignal } from "./local.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/events/signal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/events/signal/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/events/signal/index.js

@@ -0,0 +1,6 @@
+import {
+  LocalSignal
+} from "../../chunk-UG5PVNZV.js";
+export {
+  LocalSignal
+};

package/dist/events/signal/local.d.ts

@@ -0,0 +1,22 @@
+/**
+ * LocalSignal — in-process event dispatch.
+ *
+ * Dispatches events synchronously via direct function calls.
+ * Zero dependencies, zero serialization, zero network.
+ *
+ * Handler errors are caught silently — a broken listener must never
+ * interrupt the agent's streaming pipeline.
+ */
+import type { AgentEvent } from "../../types/events.js";
+import type { AgentSignal, TypedHandler, Unsubscribe, WildcardHandler } from "./types.js";
+export declare class LocalSignal implements AgentSignal {
+    /** type → Set<handler> for typed subscriptions */
+    private readonly typed;
+    /** handlers that receive every event */
+    private readonly wildcard;
+    on<T extends AgentEvent["type"]>(type: T, handler: TypedHandler<T>): Unsubscribe;
+    onAny(handler: WildcardHandler): Unsubscribe;
+    emit(event: AgentEvent): void;
+    clear(): void;
+}
+//# sourceMappingURL=local.d.ts.map

package/dist/events/signal/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../../src/events/signal/local.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EACV,WAAW,EAEX,YAAY,EACZ,WAAW,EACX,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,qBAAa,WAAY,YAAW,WAAW;IAC7C,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuD;IAC7E,wCAAwC;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IAEvD,EAAE,CAAC,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,EAC7B,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GACvB,WAAW;IAiBd,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,WAAW;IAO5C,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAuB7B,KAAK,IAAI,IAAI;CAId"}

package/dist/events/signal/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Agent Signal — typed event dispatch interface.
+ *
+ * Defines how consumers subscribe to {@link AgentEvent}s without being
+ * part of the middleware stack.  Each Agent owns a signal; events are
+ * scoped to that agent instance.
+ *
+ * The default implementation (`LocalSignal`) dispatches in-process via
+ * plain function calls.  A distributed runtime can supply its own
+ * implementation that bridges to external infrastructure.
+ */
+import type { AgentEvent } from "../../types/events.js";
+/**
+ * Extract a single variant from the AgentEvent union by its `type` tag.
+ */
+export type EventOf<T extends AgentEvent["type"]> = Extract<AgentEvent, {
+    type: T;
+}>;
+/** Handler for a specific event type. */
+export type TypedHandler<T extends AgentEvent["type"]> = (event: EventOf<T>) => void;
+/** Handler that receives every event regardless of type. */
+export type WildcardHandler = (event: AgentEvent) => void;
+/** Call to remove a previously registered handler. */
+export type Unsubscribe = () => void;
+/**
+ * Typed, multi-consumer event dispatch.
+ *
+ * Subscribe to agent events from anywhere — SSE routes, TUI renderers,
+ * plugins, tests.  The interface is deliberately minimal so that backend
+ * implementations (in-process, Dapr, Redis, …) have a small contract to
+ * fulfil.
+ *
+ * @example
+ * ```ts
+ * // Subscribe to a specific event
+ * const off = agent.signal.on("text-delta", (e) => process.stdout.write(e.text));
+ *
+ * // Subscribe to everything
+ * const off2 = agent.signal.onAny((e) => logger.info(e.type));
+ *
+ * // Clean up
+ * off();
+ * off2();
+ * ```
+ */
+export interface AgentSignal {
+    /**
+     * Subscribe to a specific event type.
+     *
+     * @returns An unsubscribe function.
+     */
+    on<T extends AgentEvent["type"]>(type: T, handler: TypedHandler<T>): Unsubscribe;
+    /**
+     * Subscribe to all events.
+     *
+     * @returns An unsubscribe function.
+     */
+    onAny(handler: WildcardHandler): Unsubscribe;
+    /**
+     * Dispatch an event to every matching handler.
+     *
+     * Called internally by the Agent — but nothing prevents external code
+     * from injecting a synthetic event (useful for testing or bridging).
+     */
+    emit(event: AgentEvent): void;
+    /** Remove all handlers.  Called during agent disposal. */
+    clear(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/events/signal/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/events/signal/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAMxD;;GAEG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,IAAI,OAAO,CACzD,UAAU,EACV;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CACZ,CAAC;AAEF,yCAAyC;AACzC,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,IAAI,CACvD,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KACd,IAAI,CAAC;AAEV,4DAA4D;AAC5D,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;AAE1D,sDAAsD;AACtD,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAMrC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,EAAE,CAAC,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,EAC7B,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GACvB,WAAW,CAAC;IAEf;;;;OAIG;IACH,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,WAAW,CAAC;IAE7C;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IAE9B,0DAA0D;IAC1D,KAAK,IAAI,IAAI,CAAC;CACf"}

package/dist/execution/index.d.ts

@@ -1,482 +1,34 @@
-import { e as AnyInferenceResult, cO as StepProcessingOptions, cP as StepProcessingOutput, a9 as AgentTurnStepCommitSnapshot, aM as CreateAgentTurnStepCommitBatchOptions, $ as AgentTurnCommitBatch, c8 as PrepareModelStepOptions, c9 as PreparedAgentModelStep, cm as RunModelStepOptions, A as AgentEvent, cn as RunToolBatchOptions, co as RunToolBatchResult, aC as CommitOutputOptions, aD as CommitStepOptions, du as TokenUsage, x as ScopeSnapshot, a7 as AgentTurnState, dB as ToolMetadata, ab as AgentTurnStepCommitToolResult, aa as AgentTurnStepCommitToolCall, M as Message, dI as UserMessage, ay as AssistantMessage, dA as ToolMessage, cZ as SystemMessage } from '../instance-Bg61WSyz.js';
-export { V as AgentTurnActiveToolCall, Y as AgentTurnBoundaryMetadata, Z as AgentTurnBoundarySnapshot, _ as AgentTurnCommitApplier, a0 as AgentTurnCommitOptions, a1 as AgentTurnEngine, a2 as AgentTurnEngineOptions, a3 as AgentTurnPhase, a4 as AgentTurnResolvedToolCall, a8 as AgentTurnStateAdvanceOptions, ac as AgentTurnStepRuntimeConfig, aL as CreateAgentTurnStateOptions, dL as advanceAgentTurnState, dP as createAgentTurnEngine, dQ as createAgentTurnState, dX as failAgentTurnState } from '../instance-Bg61WSyz.js';
-import { L as Logger } from '../types-RSCv7nQ4.js';
-export { c as convertAgentMessagesToModelMessages } from '../model-messages-n_ZMZwIm.js';
-import '../types-C_LCeYNg.js';
-import 'ai';
-import 'zod';
-import '../types-CQaXbRsS.js';
-import '../types-DMjoFKKv.js';
-import '@modelcontextprotocol/sdk/client/auth.js';
-import '@modelcontextprotocol/sdk/types.js';
-import '@ai-sdk/provider-utils';
-import '../sandbox/index.js';
-import '../llm-error-D93FNNLY.js';
-
 /**
- * Doom loop error thrown when repeated tool calls are detected.
- */
-declare class DoomLoopError extends Error {
-    readonly toolName: string;
-    readonly repeatCount: number;
-    readonly input: unknown;
-    constructor(toolName: string, repeatCount: number, input: unknown);
-}
-
-/**
- * Context overflow error.
- */
-declare class ContextOverflowError extends Error {
-    readonly inputTokens: number;
-    readonly limit: number;
-    constructor(inputTokens: number, limit: number);
-}
-
-/**
- * Process an inference stream into runtime step events.
- */
-declare function processStepStream(stream: AnyInferenceResult, options: StepProcessingOptions): Promise<StepProcessingOutput>;
-
-declare function createAgentTurnStepCommitBatch(step: number, snapshot: AgentTurnStepCommitSnapshot, options?: CreateAgentTurnStepCommitBatchOptions): AgentTurnCommitBatch | undefined;
-
-/**
- * Prepare the next model step from the current committed messages.
- */
-declare function prepareModelStep(options: PrepareModelStepOptions): PreparedAgentModelStep;
-
-/**
- * Execute exactly one model/tool step and stream its events.
- */
-declare function runModelStep(options: RunModelStepOptions): AsyncGenerator<AgentEvent, StepProcessingOutput>;
-
-/**
- * Execute planned tool calls outside the AI SDK loop.
- *
- * When multiple tool calls are pending, the batch is partitioned:
- *  - Tools that declare `capabilities.parallelSafe` run concurrently
- *  - All other tools run serially (in original order)
- *
- * Serial tools always run after the parallel batch completes, preserving
- * the invariant that non-parallel-safe tools never overlap with anything.
- */
-declare function runToolBatch(options: RunToolBatchOptions): Promise<RunToolBatchResult>;
-
-/**
- * Persist the assistant tool-call message and tool-result messages for a step.
- */
-declare function commitStep(options: CommitStepOptions): AsyncGenerator<AgentEvent, boolean>;
-/**
- * Persist the final assistant output for a turn.
- */
-declare function commitOutput(options: CommitOutputOptions): AsyncGenerator<AgentEvent, boolean>;
-
-interface AgentTaskPayload {
-    /** Prompt/message passed to the agent. */
-    message: string;
-    /** Optional explicit session id. If omitted, a runtime session id is generated. */
-    sessionId?: string;
-    /** Optional per-run system override forwarded to agent.chat(). */
-    system?: string;
-}
-interface AgentTaskExecutionContext {
-    /** Abort signal propagated to agent.chat(). */
-    signal?: AbortSignal;
-    /** Stable identifier for this task execution when supplied by the caller. */
-    executionId?: string;
-    /** Optional trigger descriptor from caller (for logging/routing). */
-    trigger?: string;
-    /**
-     * Optional stable key used when auto-generating session ids.
-     * For scheduled jobs, a job ID is a good candidate.
-     */
-    fallbackSessionKey?: string;
-    /**
-     * Optional prior execution state to resume from. When provided, the task
-     * runner restores accumulated response, usage, tool results, and step
-     * counter from this snapshot before streaming the next agent.chat() turn.
-     *
-     * This enables runtime providers (e.g. Dapr) to implement crash recovery
-     * on the direct (non-workflow) execution path: load the last checkpoint
-     * from the execution store, then re-run with `restoreFrom` so the turn
-     * continues from where it left off rather than starting fresh.
-     *
-     * The snapshot only provides accumulated bookkeeping — the actual
-     * conversation context is recovered through the session storage layer
-     * (same sessionId → same persisted messages).
-     */
-    restoreFrom?: AgentTaskResumeSnapshot;
-}
-/**
- * Portable snapshot of prior execution state used for resume.
- *
- * This is intentionally a minimal subset — just enough for the task runner
- * to restore its accumulators. The full `AgentTaskExecutionSnapshot` (with
- * turn state, events, scope) lives in the runtime provider's execution store.
- */
-interface AgentTaskResumeSnapshot {
-    /** Accumulated response text from prior execution. */
-    response: string;
-    /** Accumulated token usage from prior execution. */
-    usage: TokenUsage;
-    /** Tool calls completed in the prior execution. */
-    toolCalls: Array<{
-        name: string;
-        result: unknown;
-    }>;
-    /** Step counter to resume from. */
-    step: number;
-    /** Event counter to resume from. */
-    eventCount: number;
-    /** ISO timestamp of the original execution start. */
-    startedAt: string;
-}
-interface AgentTaskResult {
-    response: string;
-    sessionId: string;
-    usage: TokenUsage;
-    toolCalls: Array<{
-        name: string;
-        result: unknown;
-    }>;
-}
-type AgentTaskRunner<TPayload extends AgentTaskPayload = AgentTaskPayload> = (payload: TPayload, context?: AgentTaskExecutionContext) => Promise<AgentTaskResult>;
-/**
- * Minimal chat surface required by `createAgentTaskRunner(...)`.
- *
- * The concrete `Agent` class already satisfies this contract. Keeping the
- * requirement this small makes runtime integration easier to test and reuse.
- */
-interface AgentTaskChatAdapter {
-    chat(sessionId: string, message: string, options?: {
-        abort?: AbortSignal;
-        system?: string;
-    }): AsyncIterable<AgentEvent>;
-}
-
-type AgentTaskCheckpointReason = "task-start" | "input-commit-start" | "input-commit-finish" | "intervention-commit-start" | "intervention-commit-finish" | "step-finish" | "step-commit-start" | "step-commit-finish" | "tool-result" | "tool-error" | "output-commit-start" | "output-commit-finish" | "task-complete" | "task-error";
-interface AgentTaskExecutionRun<TPayload extends AgentTaskPayload = AgentTaskPayload> {
-    payload: Readonly<TPayload>;
-    context: Readonly<AgentTaskExecutionContext>;
-    sessionId: string;
-    executionId: string;
-    startedAt: string;
-    scope?: ScopeSnapshot;
-}
-interface AgentTaskExecutionSnapshot {
-    sessionId: string;
-    response: string;
-    usage: TokenUsage;
-    toolCalls: Array<{
-        name: string;
-        result: unknown;
-    }>;
-    eventCount: number;
-    activeStep?: number;
-    lastEvent?: AgentEvent;
-    error?: string;
-    startedAt: string;
-    updatedAt: string;
-    turnState: AgentTurnState;
-    scope?: ScopeSnapshot;
-}
-interface AgentTaskExecutionCheckpoint<TPayload extends AgentTaskPayload = AgentTaskPayload> {
-    run: AgentTaskExecutionRun<TPayload>;
-    reason: AgentTaskCheckpointReason;
-    snapshot: AgentTaskExecutionSnapshot;
-    event?: AgentEvent;
-    createdAt: string;
-}
-interface AgentTaskObserver<TPayload extends AgentTaskPayload = AgentTaskPayload> {
-    onTaskStart?(run: AgentTaskExecutionRun<TPayload>, snapshot: AgentTaskExecutionSnapshot): void | Promise<void>;
-    onTaskEvent?(run: AgentTaskExecutionRun<TPayload>, event: AgentEvent, snapshot: AgentTaskExecutionSnapshot): void | Promise<void>;
-    onCheckpoint?(checkpoint: AgentTaskExecutionCheckpoint<TPayload>): void | Promise<void>;
-    onTaskComplete?(run: AgentTaskExecutionRun<TPayload>, result: AgentTaskResult, snapshot: AgentTaskExecutionSnapshot): void | Promise<void>;
-    onTaskError?(run: AgentTaskExecutionRun<TPayload>, error: Error, snapshot: AgentTaskExecutionSnapshot): void | Promise<void>;
-    /**
-     * Get the active OTel context for a session.
-     *
-     * Used for trace context propagation between layers — e.g. the
-     * workflow bridge retrieves the observer's span context and injects
-     * it into activities so child spans (AI SDK, tool calls) are
-     * correlated under the observer's root span.
-     */
-    getOtelContext?(sessionId: string, executionId?: string): unknown;
-    /**
-     * Activate the OTel context for a session around a function call.
-     *
-     * Used by the task runner to ensure child spans (from middleware,
-     * AI SDK) are parented under the observer's root span in direct
-     * execution mode. The observer wraps `fn` in `context.with()` so
-     * that `context.active()` returns the session's trace context.
-     */
-    activateContext?<T>(sessionId: string, executionId: string, fn: () => T): T;
-}
-interface AgentTaskCheckpointStrategyInput<TPayload extends AgentTaskPayload = AgentTaskPayload> {
-    run: AgentTaskExecutionRun<TPayload>;
-    event: AgentEvent;
-    snapshot: AgentTaskExecutionSnapshot;
-}
-type AgentTaskCheckpointStrategy<TPayload extends AgentTaskPayload = AgentTaskPayload> = (input: AgentTaskCheckpointStrategyInput<TPayload>) => AgentTaskCheckpointReason | undefined;
-/**
- * Default checkpoint strategy for runtime integrations.
- *
- * This intentionally checkpoints at coarse-grained boundaries that are useful
- * for external runtimes and durable adapters without creating excessive churn:
- * - step completion
- * - tool results/errors
- * - task completion
- */
-declare function defaultAgentTaskCheckpointStrategy<TPayload extends AgentTaskPayload = AgentTaskPayload>(input: AgentTaskCheckpointStrategyInput<TPayload>): AgentTaskCheckpointReason | undefined;
-
-interface AgentTaskRunnerOptions<TPayload extends AgentTaskPayload = AgentTaskPayload> {
-    /** Prefix used for generated runtime session IDs. Defaults to "runtime". */
-    sessionPrefix?: string;
-    /**
-     * Optional callback for resolving session IDs from payload/context.
-     * Ignored when payload.sessionId is provided.
-     */
-    resolveSessionId?: (payload: TPayload, context: AgentTaskExecutionContext) => string | undefined;
-    /**
-     * Optional execution observers. These are generic lifecycle hooks that can be
-     * consumed by runtime adapters (in-memory, Dapr, queues, etc.) without
-     * introducing infrastructure dependencies into `@cuylabs/agent-core`.
-     */
-    observers?: AgentTaskObserver<TPayload>[];
-    /**
-     * Optional checkpoint strategy for converting streamed agent events into
-     * coarse-grained execution checkpoints. Defaults to
-     * `defaultAgentTaskCheckpointStrategy(...)`.
-     */
-    checkpointStrategy?: AgentTaskCheckpointStrategy<TPayload>;
-    /** Logger for diagnostic output. Defaults to silent. */
-    logger?: Logger;
-}
-/**
- * Create a reusable task runner that maps generic task payloads to `agent.chat()`.
- *
- * This helper is intentionally infrastructure-agnostic. It can be used by any
- * runtime/orchestration package (in-memory, Dapr, queues, cron, etc.) without
- * introducing infrastructure dependencies into `@cuylabs/agent-core`.
- *
- * The runner also exposes a neutral execution observer/checkpoint surface so
- * external runtimes can persist progress, react to lifecycle events, or map
- * streamed execution milestones into their own durability layer.
- */
-declare function createAgentTaskRunner<TPayload extends AgentTaskPayload = AgentTaskPayload>(agent: AgentTaskChatAdapter, options?: AgentTaskRunnerOptions<TPayload>): AgentTaskRunner<TPayload>;
-
-interface AgentWorkflowToolCallSnapshot {
-    toolCallId: string;
-    toolName: string;
-    args: unknown;
-}
-interface AgentWorkflowUserMessageSnapshot {
-    id: string;
-    role: "user";
-    createdAt: string;
-    content: string;
-    system?: string;
-}
-interface AgentWorkflowAssistantMessageSnapshot {
-    id: string;
-    role: "assistant";
-    createdAt: string;
-    content: string;
-    finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown";
-    tokens?: TokenUsage;
-    cost?: number;
-    error?: {
-        name: string;
-        message: string;
-        code?: string;
-        status?: number;
-    };
-    toolCalls?: AgentWorkflowToolCallSnapshot[];
-}
-interface AgentWorkflowToolMessageSnapshot {
-    id: string;
-    role: "tool";
-    createdAt: string;
-    content: string;
-    toolCallId: string;
-    toolName: string;
-    result: unknown;
-    metadata?: ToolMetadata;
-    compactedAt?: number;
-}
-interface AgentWorkflowSystemMessageSnapshot {
-    id: string;
-    role: "system";
-    createdAt: string;
-    content: string;
-}
-type AgentWorkflowMessageSnapshot = AgentWorkflowUserMessageSnapshot | AgentWorkflowAssistantMessageSnapshot | AgentWorkflowToolMessageSnapshot | AgentWorkflowSystemMessageSnapshot;
-type AgentWorkflowTurnPhase = "input-commit" | "model-step" | "tool-batch" | "step-commit" | "output-commit" | "completed" | "failed";
-interface AgentWorkflowReplayDecision {
-    toolCallId: string;
-    toolName: string;
-    action: "replay" | "skip";
-    source: "policy" | "runtime" | "operator";
-    decidedAt: string;
-    reason?: string;
-}
-interface AgentWorkflowModelStepResult {
-    text: string;
-    usage?: TokenUsage;
-    finishReason?: string;
-    turnState: AgentTurnState;
-    stepCommit?: AgentTurnStepCommitSnapshot;
-}
-interface AgentWorkflowCommitResult {
-    messages: AgentWorkflowMessageSnapshot[];
-}
-interface AgentWorkflowToolBatchResult {
-    stepCommit: AgentTurnStepCommitSnapshot;
-    turnState?: AgentTurnState;
-}
-interface AgentWorkflowToolCallResult {
-    toolResult: AgentTurnStepCommitToolResult;
-    turnState?: AgentTurnState;
-}
-interface AgentWorkflowInterventionSnapshot {
-    id: string;
-    message: string;
-    createdAt: string;
-}
-interface AgentWorkflowTurnState {
-    sessionId: string;
-    systemPrompts: string[];
-    messages: AgentWorkflowMessageSnapshot[];
-    phase: AgentWorkflowTurnPhase;
-    pendingInput?: AgentWorkflowUserMessageSnapshot;
-    step: number;
-    maxSteps: number;
-    usage?: TokenUsage;
-    turnState?: AgentTurnState;
-    lastModelStep?: AgentWorkflowModelStepResult;
-    replayDecisions: Record<string, AgentWorkflowReplayDecision>;
-    finalResponse?: string;
-    error?: string;
-    startedAt: string;
-    updatedAt: string;
-    /**
-     * Pending steering messages injected by an external client.
-     * In direct execution, the `InterventionController` handles this.
-     * In durable execution, pending messages are drained at each
-     * model-step boundary and injected as user messages.
-     */
-    pendingInterventions?: AgentWorkflowInterventionSnapshot[];
-    /**
-     * Deferred follow-up messages queued by an external client.
-     * These are held until the current turn completes and can then be
-     * surfaced by the host as candidate next-turn messages.
-     */
-    queuedFollowUps?: AgentWorkflowInterventionSnapshot[];
-}
-interface CreateAgentWorkflowTurnStateOptions {
-    sessionId: string;
-    startedAt: string;
-    maxSteps: number;
-    systemPrompts?: string[];
-    initialMessages?: AgentWorkflowMessageSnapshot[];
-    initialInput?: AgentWorkflowUserMessageSnapshot;
-    initialStep?: number;
-}
-declare function createAgentWorkflowTurnState(options: CreateAgentWorkflowTurnStateOptions): AgentWorkflowTurnState;
-declare function cloneAgentWorkflowTurnState(state: AgentWorkflowTurnState): AgentWorkflowTurnState;
-declare function applyWorkflowInterventions(state: AgentWorkflowTurnState, interventions: readonly AgentWorkflowInterventionSnapshot[], updatedAt: string): AgentWorkflowTurnState;
-/**
- * Drain pending intervention messages from the workflow state,
- * injecting each as a user message into `state.messages`.
- *
- * Returns the updated state with `pendingInterventions` cleared.
- * If there are no pending interventions, returns the state unchanged.
- *
- * This is the durable-execution equivalent of
- * `InterventionController.drainImmediate()` in the direct path.
- */
-declare function drainWorkflowInterventions(state: AgentWorkflowTurnState, updatedAt: string): AgentWorkflowTurnState;
-declare function queueWorkflowFollowUps(state: AgentWorkflowTurnState, followUps: readonly AgentWorkflowInterventionSnapshot[], updatedAt: string): AgentWorkflowTurnState;
-
-interface AgentWorkflowInputCommitPlan {
-    kind: "input-commit";
-    sessionId: string;
-    messages: AgentWorkflowMessageSnapshot[];
-}
-interface AgentWorkflowModelStepPlan {
-    kind: "model-step";
-    sessionId: string;
-    step: number;
-    maxSteps: number;
-    systemPrompts: string[];
-    messages: AgentWorkflowMessageSnapshot[];
-}
-interface AgentWorkflowStepCommitPlan {
-    kind: "step-commit";
-    sessionId: string;
-    step: number;
-    snapshot: AgentTurnStepCommitSnapshot;
-}
-interface AgentWorkflowToolCallPlan {
-    kind: "tool-call";
-    step: number;
-    sessionId: string;
-    toolCall: AgentTurnStepCommitToolCall;
-    turnState: AgentWorkflowTurnState["turnState"];
-    replayDecision?: AgentWorkflowReplayDecision;
-}
-interface AgentWorkflowToolBatchPlan {
-    kind: "tool-batch";
-    step: number;
-    sessionId: string;
-    toolCalls: AgentTurnStepCommitToolCall[];
-    turnState: AgentWorkflowTurnState["turnState"];
-    replayDecisions: Record<string, AgentWorkflowReplayDecision>;
-}
-interface AgentWorkflowOutputCommitPlan {
-    kind: "output-commit";
-    sessionId: string;
-    text: string;
-    usage?: TokenUsage;
-}
-type AgentWorkflowOperationPlan = AgentWorkflowInputCommitPlan | AgentWorkflowModelStepPlan | AgentWorkflowToolCallPlan | AgentWorkflowToolBatchPlan | AgentWorkflowStepCommitPlan | AgentWorkflowOutputCommitPlan;
-
-/**
- * Decide which deterministic workflow operation should run next.
- */
-declare function planNextAgentWorkflowOperation(state: AgentWorkflowTurnState): AgentWorkflowOperationPlan | undefined;
-
-/**
- * Advance serializable workflow state after the model-step activity completes.
- */
-declare function applyAgentWorkflowModelStepResult(state: AgentWorkflowTurnState, result: AgentWorkflowModelStepResult, updatedAt: string): AgentWorkflowTurnState;
-/**
- * Advance serializable workflow state after a separate tool-batch activity.
- */
-declare function applyAgentWorkflowToolBatchResult(state: AgentWorkflowTurnState, result: AgentWorkflowToolBatchResult, updatedAt: string): AgentWorkflowTurnState;
-/**
- * Advance serializable workflow state after a single tool-call activity.
- */
-declare function applyAgentWorkflowToolCallResult(state: AgentWorkflowTurnState, result: AgentWorkflowToolCallResult, updatedAt: string): AgentWorkflowTurnState;
-/**
- * Advance serializable workflow state after a commit activity persists messages.
- */
-declare function applyAgentWorkflowCommitResult(state: AgentWorkflowTurnState, result: AgentWorkflowCommitResult, updatedAt: string): AgentWorkflowTurnState;
-/**
- * Record a concrete replay decision chosen by a runtime or operator.
- */
-declare function recordAgentWorkflowReplayDecision(state: AgentWorkflowTurnState, decision: AgentWorkflowReplayDecision, updatedAt: string): AgentWorkflowTurnState;
-/**
- * Mark the workflow-side turn state as failed.
- */
-declare function failAgentWorkflowTurnState(state: AgentWorkflowTurnState, error: Error, updatedAt: string): AgentWorkflowTurnState;
-
-declare function snapshotAgentWorkflowMessage(message: UserMessage): AgentWorkflowUserMessageSnapshot;
-declare function snapshotAgentWorkflowMessage(message: AssistantMessage): AgentWorkflowAssistantMessageSnapshot;
-declare function snapshotAgentWorkflowMessage(message: ToolMessage): AgentWorkflowToolMessageSnapshot;
-declare function snapshotAgentWorkflowMessage(message: SystemMessage): AgentWorkflowSystemMessageSnapshot;
-declare function snapshotAgentWorkflowMessage(message: Message): AgentWorkflowMessageSnapshot;
-declare function snapshotAgentWorkflowMessages(messages: Message[]): AgentWorkflowMessageSnapshot[];
-declare function restoreAgentWorkflowMessage(snapshot: AgentWorkflowMessageSnapshot): Message;
-declare function restoreAgentWorkflowMessages(snapshots: AgentWorkflowMessageSnapshot[]): Message[];
-
-export { type AgentTaskChatAdapter, type AgentTaskCheckpointReason, type AgentTaskCheckpointStrategy, type AgentTaskCheckpointStrategyInput, type AgentTaskExecutionCheckpoint, type AgentTaskExecutionContext, type AgentTaskExecutionRun, type AgentTaskExecutionSnapshot, type AgentTaskObserver, type AgentTaskPayload, type AgentTaskResult, type AgentTaskResumeSnapshot, type AgentTaskRunner, type AgentTaskRunnerOptions, AgentTurnCommitBatch, AgentTurnState, AgentTurnStepCommitSnapshot, AgentTurnStepCommitToolCall, AgentTurnStepCommitToolResult, type AgentWorkflowAssistantMessageSnapshot, type AgentWorkflowCommitResult, type AgentWorkflowInputCommitPlan, type AgentWorkflowInterventionSnapshot, type AgentWorkflowMessageSnapshot, type AgentWorkflowModelStepPlan, type AgentWorkflowModelStepResult, type AgentWorkflowOperationPlan, type AgentWorkflowOutputCommitPlan, type AgentWorkflowReplayDecision, type AgentWorkflowStepCommitPlan, type AgentWorkflowSystemMessageSnapshot, type AgentWorkflowToolBatchPlan, type AgentWorkflowToolBatchResult, type AgentWorkflowToolCallPlan, type AgentWorkflowToolCallResult, type AgentWorkflowToolCallSnapshot, type AgentWorkflowToolMessageSnapshot, type AgentWorkflowTurnPhase, type AgentWorkflowTurnState, type AgentWorkflowUserMessageSnapshot, CommitOutputOptions, CommitStepOptions, ContextOverflowError, CreateAgentTurnStepCommitBatchOptions, type CreateAgentWorkflowTurnStateOptions, DoomLoopError, PrepareModelStepOptions, PreparedAgentModelStep, RunModelStepOptions, RunToolBatchOptions, RunToolBatchResult, StepProcessingOptions, StepProcessingOutput, applyAgentWorkflowCommitResult, applyAgentWorkflowModelStepResult, applyAgentWorkflowToolBatchResult, applyAgentWorkflowToolCallResult, applyWorkflowInterventions, cloneAgentWorkflowTurnState, commitOutput, commitStep, createAgentTaskRunner, createAgentTurnStepCommitBatch, createAgentWorkflowTurnState, defaultAgentTaskCheckpointStrategy, drainWorkflowInterventions, failAgentWorkflowTurnState, planNextAgentWorkflowOperation, prepareModelStep, processStepStream, queueWorkflowFollowUps, recordAgentWorkflowReplayDecision, restoreAgentWorkflowMessage, restoreAgentWorkflowMessages, runModelStep, runToolBatch, snapshotAgentWorkflowMessage, snapshotAgentWorkflowMessages };
+ * Execution Integration Module
+ *
+ * This subpath groups the infrastructure-facing execution surface in four
+ * layers:
+ * - `task` adapts an `Agent` into a resumable task boundary
+ * - `scope` captures ambient execution lineage across async boundaries
+ * - `turn` decomposes one agent turn into replayable state, engine, runner,
+ *   and step-processing units
+ * - `workflow` snapshots and advances durable workflow turns
+ *
+ * Tool execution itself now lives in `@cuylabs/agent-core/tool`, so this
+ * module stays focused on execution orchestration rather than tool ownership.
+ */
+export type { AgentTaskChatAdapter, AgentTaskPayload, AgentTaskExecutionContext, AgentTaskResumeSnapshot, AgentTaskResult, AgentTaskRunner, } from "./task/index.js";
+export type { AgentTaskCheckpointReason, AgentTaskCheckpointStrategy, AgentTaskCheckpointStrategyInput, AgentTaskExecutionCheckpoint, AgentTaskExecutionRun, AgentTaskExecutionSnapshot, AgentTaskObserver, } from "./task/index.js";
+export type { AgentTaskRunnerOptions } from "./task/index.js";
+export type { ScopeSnapshot } from "./scope/index.js";
+export type { AgentTurnActiveToolCall, AgentTurnBoundaryMetadata, AgentTurnBoundarySnapshot, AgentTurnCommitApplier, AgentTurnCommitBatch, AgentTurnCommitOptions, AgentTurnEngineOptions, AgentTurnPhase, AgentTurnResolvedToolCall, AgentTurnState, AgentTurnStateAdvanceOptions, AgentTurnStateConflict, AgentTurnStepCommitKind, AgentTurnStepCommitRecord, AgentTurnStepCommitSnapshot, AgentTurnStepCommitStatus, AgentTurnStepCommitToolCall, AgentTurnStepCommitToolResult, AgentTurnStepRuntimeConfig, AgentTurnStepRecord, AgentTurnStepStatus, AgentTurnStepToolRecord, AgentTurnStepToolResultCaptureMode, AgentTurnStepToolResultCaptureOptions, AgentTurnStepToolResultFormat, AgentTurnStepToolResultSummary, AgentTurnStepToolStatus, CommitOutputOptions, CommitStepOptions, CreateAgentTurnStateOptions, CreateAgentTurnStepCommitBatchOptions, PreparedAgentModelStep, PrepareModelStepOptions, RunModelStepOptions, RunToolBatchOptions, RunToolBatchResult, StepProcessingOptions, StepProcessingOutput, } from "./turn/index.js";
+export type { AgentWorkflowAssistantMessageSnapshot, AgentWorkflowCommitResult, AgentWorkflowContextCompactionResult, AgentWorkflowInterventionSnapshot, AgentWorkflowMessageSnapshot, AgentWorkflowModelStepResult, AgentWorkflowReplayDecision, AgentWorkflowSystemMessageSnapshot, AgentWorkflowToolBatchResult, AgentWorkflowToolCallResult, AgentWorkflowToolCallSnapshot, AgentWorkflowToolMessageSnapshot, AgentWorkflowTurnPhase, AgentWorkflowTurnState, AgentWorkflowUserMessageSnapshot, CreateAgentWorkflowTurnStateOptions, AgentWorkflowInputCommitPlan, AgentWorkflowModelStepPlan, AgentWorkflowOperationPlan, AgentWorkflowOutputCommitPlan, AgentWorkflowStepCommitPlan, AgentWorkflowToolBatchPlan, AgentWorkflowToolCallPlan, } from "./workflow/index.js";
+export { defaultAgentTaskCheckpointStrategy } from "./task/index.js";
+export { createAgentTaskRunner } from "./task/index.js";
+export { convertAgentMessagesToModelMessages } from "../inference/model-messages.js";
+export { currentScope, restoreScope, snapshotScope, withinScope, } from "./scope/index.js";
+export { advanceAgentTurnState, createAgentTurnState, failAgentTurnState, mergeAgentTurnStateProgress, } from "./turn/index.js";
+export { AgentTurnStateConflictError, getCurrentAgentTurnStepRecord, } from "./turn/index.js";
+export { AgentTurnEngine, createAgentTurnEngine } from "./turn/index.js";
+export { createAgentTurnStepCommitBatch } from "./turn/index.js";
+export { commitOutput, commitStep, prepareModelStep, runToolBatch, runModelStep, } from "./turn/index.js";
+export { processStepStream, DoomLoopError, ContextOverflowError, } from "./turn/index.js";
+export { applyWorkflowInterventions, cloneAgentWorkflowTurnState, createAgentWorkflowTurnState, drainWorkflowInterventions, queueWorkflowFollowUps, } from "./workflow/index.js";
+export { restoreAgentWorkflowMessage, restoreAgentWorkflowMessages, snapshotAgentWorkflowMessage, snapshotAgentWorkflowMessages, } from "./workflow/index.js";
+export { applyAgentWorkflowCommitResult, applyAgentWorkflowContextCompactionResult, applyAgentWorkflowModelStepResult, applyAgentWorkflowToolCallResult, applyAgentWorkflowToolBatchResult, failAgentWorkflowTurnState, planNextAgentWorkflowOperation, recordAgentWorkflowReplayDecision, } from "./workflow/index.js";
+//# sourceMappingURL=index.d.ts.map