@polos/sdk 0.1.2 → 0.2.0

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { ZodSchema, ZodTypeDef } from 'zod';
+import { ZodType } from 'zod';
 import { ModelMessage, LanguageModel, jsonSchema } from 'ai';
 export { LanguageModel } from 'ai';
 import { Span, Tracer } from '@opentelemetry/api';
@@ -157,8 +157,6 @@ declare class AgentRunConfig {
     readonly input: string | Record<string, unknown>[];
     /** Session ID */
     readonly sessionId: string | undefined;
-    /** Conversation ID for history tracking */
-    readonly conversationId: string | undefined;
     /** User ID */
     readonly userId: string | undefined;
     /** Whether to stream the response */
@@ -173,7 +171,6 @@ declare class AgentRunConfig {
         agent: Workflow;
         input: string | Record<string, unknown>[];
         sessionId?: string;
-        conversationId?: string;
         userId?: string;
         streaming?: boolean;
         initialState?: Record<string, unknown>;
@@ -370,8 +367,302 @@ interface AgentContext<TState = unknown> extends WorkflowContext<TState> {
     readonly temperature?: number | undefined;
     /** Maximum output tokens */
     readonly maxTokens?: number | undefined;
-    /** Conversation ID (mutable — set by agent handler, matching Python) */
-    conversationId?: string | undefined;
+}
+
+/**
+ * Event-related type definitions.
+ *
+ * Types match sdk/python/polos/features/events.py exactly.
+ */
+/**
+ * Event data structure for publishing events.
+ * Matches Python EventData.
+ */
+interface EventData {
+    /** Type of event */
+    eventType?: string | undefined;
+    /** Event payload */
+    data: Record<string, unknown>;
+}
+/**
+ * Event payload received when waiting for events in workflows.
+ * Returned by ctx.step.waitForEvent() when an event is received.
+ * Matches Python EventPayload.
+ */
+interface EventPayload {
+    /** Event ID (UUID string) */
+    id: string;
+    /** Global sequence ID for ordering */
+    sequenceId: number;
+    /** Event topic */
+    topic: string;
+    /** Type of event */
+    eventType?: string | undefined;
+    /** Event payload */
+    data: Record<string, unknown>;
+    /** Timestamp when event was created */
+    createdAt: string;
+}
+/**
+ * Single event item in a batch of events.
+ * Used in BatchEventPayload for event-triggered workflows with batching.
+ * Matches Python EventItem.
+ */
+interface EventItem {
+    /** Event ID (UUID string) */
+    id: string;
+    /** Global sequence ID for ordering */
+    sequenceId: number;
+    /** Event topic */
+    topic: string;
+    /** Type of event */
+    eventType?: string | undefined;
+    /** Event payload */
+    data: Record<string, unknown>;
+    /** Timestamp when event was created */
+    createdAt: string;
+}
+/**
+ * Batch event payload for event-triggered workflows with batching.
+ * Matches Python BatchEventPayload.
+ */
+interface BatchEventPayload {
+    /** List of events in the batch */
+    events: EventItem[];
+}
+/**
+ * Event received from an SSE stream.
+ * Matches Python StreamEvent.
+ */
+interface StreamEvent {
+    /** Event ID */
+    id: string;
+    /** Sequence ID for ordering */
+    sequenceId: number;
+    /** Event topic */
+    topic: string;
+    /** Event type (optional categorization) */
+    eventType?: string | undefined;
+    /** Event data */
+    data: Record<string, unknown>;
+    /** Creation timestamp (RFC3339 string) */
+    createdAt?: string | undefined;
+}
+/**
+ * Represents an event in the event system.
+ * Matches Python Event class.
+ */
+interface Event {
+    /** Unique event identifier */
+    id: string;
+    /** Global sequence ID for ordering */
+    sequenceId: number;
+    /** Event topic */
+    topic: string;
+    /** Event type */
+    eventType?: string | undefined;
+    /** Event data */
+    data?: Record<string, unknown> | undefined;
+    /** Event status */
+    status: string;
+    /** Source workflow execution ID */
+    executionId?: string | undefined;
+    /** Attempt number */
+    attemptNumber: number;
+    /** When the event was created */
+    createdAt?: string | undefined;
+}
+/**
+ * Options for streaming events from a topic.
+ */
+interface StreamTopicOptions {
+    /** Topic to stream from */
+    topic: string;
+    /** Start streaming after this sequence ID */
+    lastSequenceId?: number;
+    /** Start streaming after this timestamp */
+    lastTimestamp?: Date;
+}
+/**
+ * Options for streaming events from a workflow run.
+ */
+interface StreamWorkflowOptions {
+    /** Workflow ID (name) */
+    workflowId: string;
+    /** Workflow run ID (execution ID) */
+    workflowRunId: string;
+    /** Start streaming after this sequence ID */
+    lastSequenceId?: number;
+    /** Start streaming after this timestamp */
+    lastTimestamp?: Date;
+}
+/**
+ * Payload for event-triggered workflows.
+ */
+interface EventTriggerPayload {
+    /** The events that triggered this execution */
+    events: EventItem[];
+    /** Batch information */
+    batch: {
+        /** Batch index (0-based) */
+        index: number;
+        /** Total events in this batch */
+        size: number;
+        /** Whether this is the last batch */
+        isLast: boolean;
+    };
+}
+/**
+ * Internal workflow lifecycle events.
+ */
+type WorkflowEvent = WorkflowStartEvent | WorkflowFinishEvent | StepStartEvent | StepFinishEvent | TextDeltaEvent | ToolCallEvent;
+interface WorkflowStartEvent {
+    type: 'workflow_start';
+    _metadata: {
+        workflowId: string;
+        executionId: string;
+    };
+    timestamp: Date;
+    payload: unknown;
+}
+interface WorkflowFinishEvent {
+    type: 'workflow_finish';
+    _metadata: {
+        workflowId: string;
+        executionId: string;
+    };
+    timestamp: Date;
+    result?: unknown;
+    error?: string;
+    durationMs: number;
+}
+interface StepStartEvent {
+    type: 'step_start';
+    _metadata: {
+        workflowId: string;
+        executionId: string;
+    };
+    stepKey: string;
+    timestamp: Date;
+}
+interface StepFinishEvent {
+    type: 'step_finish';
+    _metadata: {
+        workflowId: string;
+        executionId: string;
+    };
+    stepKey: string;
+    timestamp: Date;
+    result?: unknown;
+    error?: string;
+    durationMs: number;
+}
+interface TextDeltaEvent {
+    type: 'text_delta';
+    _metadata: {
+        workflowId: string;
+        executionId: string;
+    };
+    step: number;
+    chunkIndex: number;
+    content?: string;
+    timestamp: Date;
+}
+interface ToolCallEvent {
+    type: 'tool_call';
+    _metadata: {
+        workflowId: string;
+        executionId: string;
+    };
+    step: number;
+    chunkIndex: number;
+    toolCall?: {
+        id: string;
+        callId?: string;
+        type: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    };
+    timestamp: Date;
+}
+
+/**
+ * Channel abstraction for delivering notifications when agents suspend.
+ *
+ * Channels are registered on the Worker and called automatically when any
+ * workflow suspends (e.g., via ask_user or tool approval). Implementations
+ * should be stateless and safe to call concurrently.
+ */
+
+/**
+ * Originating channel context — identifies where a trigger came from
+ * so that output and notifications can be routed back.
+ */
+interface ChannelContext {
+    /** Channel type: "slack", "discord", etc. */
+    channelId: string;
+    /** Channel-specific source metadata (e.g., { channel: "#general", threadTs: "..." }) */
+    source: Record<string, unknown>;
+}
+/**
+ * Controls how output events are streamed back to the originating channel.
+ * - `per_step`: Stream text_delta, tool_call, step_finish, and finish events
+ * - `final`: Only stream workflow_finish / agent_finish events
+ * - `none`: Do not stream output
+ */
+type ChannelOutputMode = 'per_step' | 'final' | 'none';
+/**
+ * Data passed to channels when an agent suspends for user input.
+ */
+interface SuspendNotification {
+    /** Root workflow ID */
+    workflowId: string;
+    /** Root execution ID */
+    executionId: string;
+    /** Step key used in suspend() */
+    stepKey: string;
+    /** URL to the approval page */
+    approvalUrl: string;
+    /** Title from _form schema */
+    title?: string;
+    /** Description from _form schema */
+    description?: string;
+    /** Source: "ask_user", "ask_before_use", or custom */
+    source?: string;
+    /** Tool name if triggered by ask_before_use */
+    tool?: string;
+    /** Read-only context data from _form */
+    context?: Record<string, unknown>;
+    /** Form field definitions from _form.fields */
+    formFields?: Record<string, unknown>[];
+    /** ISO timestamp when the approval expires */
+    expiresAt?: string;
+    /** Channel-specific overrides from _notify */
+    channelOverrides?: Record<string, unknown>;
+    /** Originating channel context — used for thread routing */
+    channelContext?: ChannelContext;
+}
+/**
+ * A notification channel for delivering suspend notifications to users.
+ *
+ * Channels are registered on the Worker and called automatically when any
+ * workflow suspends. Implementations should be stateless and safe to call
+ * concurrently.
+ */
+interface Channel {
+    /** Unique channel identifier (e.g., "slack", "discord", "email") */
+    readonly id: string;
+    /**
+     * Send a notification when an agent suspends for user input.
+     * Implementations should throw on failure — the SDK catches and logs errors.
+     */
+    notify(notification: SuspendNotification): Promise<void>;
+    /** Default output mode for this channel. */
+    readonly outputMode?: ChannelOutputMode;
+    /** Send output events back to the originating channel. */
+    sendOutput?(context: ChannelContext, event: StreamEvent): Promise<void>;
 }
 
 /**
@@ -550,15 +841,17 @@ interface WorkflowConfig<TPayload = unknown, TState = unknown, TResult = unknown
     /** Batch timeout in seconds for event-triggered workflows */
     batchTimeoutSeconds?: number | undefined;
     /** Zod schema for payload validation */
-    payloadSchema?: ZodSchema<TPayload, ZodTypeDef, unknown> | undefined;
+    payloadSchema?: ZodType<TPayload> | undefined;
     /** Zod schema for state validation and defaults */
-    stateSchema?: ZodSchema<TState, ZodTypeDef, unknown> | undefined;
+    stateSchema?: ZodType<TState> | undefined;
     /** Zod schema for output/result validation */
-    outputSchema?: ZodSchema<TResult, ZodTypeDef, unknown> | undefined;
+    outputSchema?: ZodType<TResult> | undefined;
     /** Hook(s) to run before workflow execution (bare function or Hook object) */
     onStart?: HookHandler<TPayload, TState> | Hook<TPayload, TState> | (HookHandler<TPayload, TState> | Hook<TPayload, TState>)[] | undefined;
     /** Hook(s) to run after workflow completion (bare function or Hook object) */
     onEnd?: HookHandler<TPayload, TState> | Hook<TPayload, TState> | (HookHandler<TPayload, TState> | Hook<TPayload, TState>)[] | undefined;
+    /** Notification channels for suspend events. Overrides Worker-level channels. */
+    channels?: Channel[] | undefined;
 }
 /**
  * Workflow handler function type.
@@ -635,11 +928,11 @@ interface Workflow<TPayload = unknown, TState = unknown, TResult = unknown> {
     /** Workflow handler function */
     readonly handler: WorkflowHandler<TPayload, TState, TResult>;
     /** Payload schema (if provided) */
-    readonly payloadSchema?: ZodSchema<TPayload, ZodTypeDef, unknown> | undefined;
+    readonly payloadSchema?: ZodType<TPayload> | undefined;
     /** State schema (if provided) */
-    readonly stateSchema?: ZodSchema<TState, ZodTypeDef, unknown> | undefined;
+    readonly stateSchema?: ZodType<TState> | undefined;
     /** Output schema (if provided) */
-    readonly outputSchema?: ZodSchema<TResult, ZodTypeDef, unknown> | undefined;
+    readonly outputSchema?: ZodType<TResult> | undefined;
     /**
      * Run workflow and wait for result (invoke + poll until complete).
      * Cannot be called from within a workflow; use step.invokeAndWait() instead.
@@ -697,11 +990,11 @@ interface DefineToolConfig<TInput = unknown, TOutput = unknown, TState = unknown
     /** Tool description shown to LLMs */
     description: string;
     /** Zod schema for input validation (optional — some tools take no input) */
-    inputSchema?: ZodSchema<TInput, ZodTypeDef, unknown> | undefined;
+    inputSchema?: ZodType<TInput> | undefined;
     /** Zod schema for output validation */
-    outputSchema?: ZodSchema<TOutput, ZodTypeDef, unknown> | undefined;
+    outputSchema?: ZodType<TOutput> | undefined;
     /** Zod schema for state validation and defaults */
-    stateSchema?: ZodSchema<TState, ZodTypeDef, unknown> | undefined;
+    stateSchema?: ZodType<TState> | undefined;
     /** Queue assignment */
     queue?: string | QueueConfig$1 | undefined;
     /** Hook(s) to run before tool execution */
@@ -712,6 +1005,8 @@ interface DefineToolConfig<TInput = unknown, TOutput = unknown, TState = unknown
     autoRegister?: boolean | undefined;
     /** Require human approval before tool execution. @default undefined (no approval) */
     approval?: ToolApproval | undefined;
+    /** Notification channels for suspend events. Overrides Worker-level channels. */
+    channels?: Channel[] | undefined;
 }
 /**
  * A Workflow with tool-specific LLM metadata.
@@ -854,9 +1149,9 @@ interface Tool<TInput = unknown, TOutput = unknown> {
     /** Tool description (shown to LLM) */
     description: string;
     /** Zod schema for input validation */
-    inputSchema: ZodSchema<TInput>;
+    inputSchema: ZodType<TInput>;
     /** Zod schema for output validation */
-    outputSchema: ZodSchema<TOutput>;
+    outputSchema: ZodType<TOutput>;
     /** Tool handler function */
     handler: ToolHandler<TInput, TOutput>;
 }
@@ -873,9 +1168,9 @@ interface ToolConfig<TInput = unknown, TOutput = unknown> {
     /** Tool description (shown to LLM) */
     description: string;
     /** Zod schema for input validation */
-    inputSchema: ZodSchema<TInput>;
+    inputSchema: ZodType<TInput>;
     /** Zod schema for output validation */
-    outputSchema: ZodSchema<TOutput>;
+    outputSchema: ZodType<TOutput>;
 }
 /**
  * Guardrail function type for validating LLM outputs.
@@ -935,7 +1230,7 @@ interface AgentConfig<TOutput = string, TState = unknown> {
     /** Queue assignment for execution */
     queue?: string | QueueConfig$1;
     /** Zod schema for structured output */
-    outputSchema?: ZodSchema<TOutput>;
+    outputSchema?: ZodType<TOutput>;
     /** Lifecycle hooks */
     onStart?: Hook<string, TState>;
     onEnd?: Hook<string, TState>;
@@ -947,8 +1242,6 @@ interface AgentConfig<TOutput = string, TState = unknown> {
     guardrails?: Guardrail$1[];
     /** Max retries when guardrail fails */
     guardrailMaxRetries?: number;
-    /** Number of messages to retain for context */
-    conversationHistory?: number;
 }
 /**
  * Result from running an agent (client-side).
@@ -1044,229 +1337,10 @@ type AgentStreamEvent = {
 };
 
 /**
- * Event-related type definitions.
- *
- * Types match sdk/python/polos/features/events.py exactly.
+ * Type definitions for orchestrator API requests and responses.
  */
 /**
- * Event data structure for publishing events.
- * Matches Python EventData.
- */
-interface EventData {
-    /** Type of event */
-    eventType?: string | undefined;
-    /** Event payload */
-    data: Record<string, unknown>;
-}
-/**
- * Event payload received when waiting for events in workflows.
- * Returned by ctx.step.waitForEvent() when an event is received.
- * Matches Python EventPayload.
- */
-interface EventPayload {
-    /** Event ID (UUID string) */
-    id: string;
-    /** Global sequence ID for ordering */
-    sequenceId: number;
-    /** Event topic */
-    topic: string;
-    /** Type of event */
-    eventType?: string | undefined;
-    /** Event payload */
-    data: Record<string, unknown>;
-    /** Timestamp when event was created */
-    createdAt: string;
-}
-/**
- * Single event item in a batch of events.
- * Used in BatchEventPayload for event-triggered workflows with batching.
- * Matches Python EventItem.
- */
-interface EventItem {
-    /** Event ID (UUID string) */
-    id: string;
-    /** Global sequence ID for ordering */
-    sequenceId: number;
-    /** Event topic */
-    topic: string;
-    /** Type of event */
-    eventType?: string | undefined;
-    /** Event payload */
-    data: Record<string, unknown>;
-    /** Timestamp when event was created */
-    createdAt: string;
-}
-/**
- * Batch event payload for event-triggered workflows with batching.
- * Matches Python BatchEventPayload.
- */
-interface BatchEventPayload {
-    /** List of events in the batch */
-    events: EventItem[];
-}
-/**
- * Event received from an SSE stream.
- * Matches Python StreamEvent.
- */
-interface StreamEvent {
-    /** Event ID */
-    id: string;
-    /** Sequence ID for ordering */
-    sequenceId: number;
-    /** Event topic */
-    topic: string;
-    /** Event type (optional categorization) */
-    eventType?: string | undefined;
-    /** Event data */
-    data: Record<string, unknown>;
-    /** Creation timestamp (RFC3339 string) */
-    createdAt?: string | undefined;
-}
-/**
- * Represents an event in the event system.
- * Matches Python Event class.
- */
-interface Event {
-    /** Unique event identifier */
-    id: string;
-    /** Global sequence ID for ordering */
-    sequenceId: number;
-    /** Event topic */
-    topic: string;
-    /** Event type */
-    eventType?: string | undefined;
-    /** Event data */
-    data?: Record<string, unknown> | undefined;
-    /** Event status */
-    status: string;
-    /** Source workflow execution ID */
-    executionId?: string | undefined;
-    /** Attempt number */
-    attemptNumber: number;
-    /** When the event was created */
-    createdAt?: string | undefined;
-}
-/**
- * Options for streaming events from a topic.
- */
-interface StreamTopicOptions {
-    /** Topic to stream from */
-    topic: string;
-    /** Start streaming after this sequence ID */
-    lastSequenceId?: number;
-    /** Start streaming after this timestamp */
-    lastTimestamp?: Date;
-}
-/**
- * Options for streaming events from a workflow run.
- */
-interface StreamWorkflowOptions {
-    /** Workflow ID (name) */
-    workflowId: string;
-    /** Workflow run ID (execution ID) */
-    workflowRunId: string;
-    /** Start streaming after this sequence ID */
-    lastSequenceId?: number;
-    /** Start streaming after this timestamp */
-    lastTimestamp?: Date;
-}
-/**
- * Payload for event-triggered workflows.
- */
-interface EventTriggerPayload {
-    /** The events that triggered this execution */
-    events: EventItem[];
-    /** Batch information */
-    batch: {
-        /** Batch index (0-based) */
-        index: number;
-        /** Total events in this batch */
-        size: number;
-        /** Whether this is the last batch */
-        isLast: boolean;
-    };
-}
-/**
- * Internal workflow lifecycle events.
- */
-type WorkflowEvent = WorkflowStartEvent | WorkflowFinishEvent | StepStartEvent | StepFinishEvent | TextDeltaEvent | ToolCallEvent;
-interface WorkflowStartEvent {
-    type: 'workflow_start';
-    _metadata: {
-        workflowId: string;
-        executionId: string;
-    };
-    timestamp: Date;
-    payload: unknown;
-}
-interface WorkflowFinishEvent {
-    type: 'workflow_finish';
-    _metadata: {
-        workflowId: string;
-        executionId: string;
-    };
-    timestamp: Date;
-    result?: unknown;
-    error?: string;
-    durationMs: number;
-}
-interface StepStartEvent {
-    type: 'step_start';
-    _metadata: {
-        workflowId: string;
-        executionId: string;
-    };
-    stepKey: string;
-    timestamp: Date;
-}
-interface StepFinishEvent {
-    type: 'step_finish';
-    _metadata: {
-        workflowId: string;
-        executionId: string;
-    };
-    stepKey: string;
-    timestamp: Date;
-    result?: unknown;
-    error?: string;
-    durationMs: number;
-}
-interface TextDeltaEvent {
-    type: 'text_delta';
-    _metadata: {
-        workflowId: string;
-        executionId: string;
-    };
-    step: number;
-    chunkIndex: number;
-    content?: string;
-    timestamp: Date;
-}
-interface ToolCallEvent {
-    type: 'tool_call';
-    _metadata: {
-        workflowId: string;
-        executionId: string;
-    };
-    step: number;
-    chunkIndex: number;
-    toolCall?: {
-        id: string;
-        callId?: string;
-        type: string;
-        function: {
-            name: string;
-            arguments: string;
-        };
-    };
-    timestamp: Date;
-}
-
-/**
- * Type definitions for orchestrator API requests and responses.
- */
-/**
- * Worker capabilities sent during registration.
+ * Worker capabilities sent during registration.
  */
 interface WorkerCapabilities {
     runtime: 'typescript' | 'python';
@@ -1362,6 +1436,10 @@ interface ExecutionContext {
     initialState?: Record<string, unknown> | undefined;
     runTimeoutSeconds?: number | undefined;
     createdAt?: string | undefined;
+    channelContext?: {
+        channelId: string;
+        source: Record<string, unknown>;
+    } | undefined;
 }
 /**
  * Request to complete an execution.
@@ -1513,6 +1591,10 @@ interface InvokeWorkflowRequest {
     otelTraceparent?: string | undefined;
     initialState?: Record<string, unknown> | undefined;
     runTimeoutSeconds?: number | undefined;
+    channelContext?: {
+        channelId: string;
+        source: Record<string, unknown>;
+    } | undefined;
 }
 /**
  * Invoke workflow response.
@@ -1609,6 +1691,20 @@ interface ConversationMessage {
     role: string;
     content: unknown;
 }
+/**
+ * Response from GET /internal/session/{sessionId}/memory.
+ */
+interface SessionMemoryResponse {
+    summary: string | null;
+    messages: ConversationMessage[];
+}
+/**
+ * Request body for PUT /internal/session/{sessionId}/memory.
+ */
+interface PutSessionMemoryRequest {
+    summary: string | null;
+    messages: ConversationMessage[];
+}
 
 /**
  * HTTP client for orchestrator API communication.
@@ -1667,6 +1763,11 @@ declare class OrchestratorClient {
      * Register a worker with the orchestrator.
      */
     registerWorker(request: RegisterWorkerRequest): Promise<RegisterWorkerResponse>;
+    /**
+     * Get active worker IDs for the current project.
+     * Uses the X-Project-ID header already set on all requests.
+     */
+    getActiveWorkerIds(): Promise<string[]>;
     /**
      * Register a deployment.
      */
@@ -1774,6 +1875,16 @@ declare class OrchestratorClient {
      * GET /api/v1/conversation/{conversationId}/get
      */
     getConversationHistory(conversationId: string, params: GetConversationHistoryParams): Promise<ConversationMessage[]>;
+    /**
+     * Get session memory (summary + metadata).
+     * GET /internal/session/{sessionId}/memory
+     */
+    getSessionMemory(sessionId: string): Promise<SessionMemoryResponse>;
+    /**
+     * Store session memory (summary + messages).
+     * PUT /internal/session/{sessionId}/memory
+     */
+    putSessionMemory(sessionId: string, request: PutSessionMemoryRequest): Promise<void>;
     /**
      * Create or update a schedule. Returns schedule_id.
      */
@@ -1898,6 +2009,11 @@ interface ClientInvokeOptions {
     rootExecutionId?: string | undefined;
     /** Step key (when invoked from a step) */
     stepKey?: string | undefined;
+    /** Channel context for bidirectional channels (e.g., originating Slack thread) */
+    channelContext?: {
+        channelId: string;
+        source: Record<string, unknown>;
+    } | undefined;
 }
 /**
  * Input for batch workflow invocation via PolosClient.
@@ -2100,46 +2216,161 @@ declare class PolosClient {
 }
 
 /**
- * State management for workflows.
- *
- * Handles state initialization, validation, and serialization using Zod schemas.
+ * Unified Polos class that combines PolosClient (submit/stream work) and Worker
+ * (receive/execute work) into a single object.
  */
 
 /**
- * Error thrown when state validation fails.
- */
-declare class StateValidationError extends Error {
-    readonly issues: unknown[];
-    constructor(message: string, issues: unknown[]);
-}
-/**
- * Error thrown when state exceeds size limit.
+ * Configuration for the unified Polos class.
+ * All fields are optional — defaults come from environment variables.
  */
-declare class StateSizeError extends Error {
-    readonly size: number;
-    readonly maxSize: number;
-    constructor(size: number, maxSize: number);
+interface PolosConfig {
+    /** Project ID (default: POLOS_PROJECT_ID env var) */
+    projectId?: string | undefined;
+    /** Orchestrator API URL (default: POLOS_API_URL or http://localhost:8080) */
+    apiUrl?: string | undefined;
+    /** API key (default: POLOS_API_KEY env var) */
+    apiKey?: string | undefined;
+    /** Deployment ID (default: POLOS_DEPLOYMENT_ID or "default") */
+    deploymentId?: string | undefined;
+    /** Worker server port (default: 8000) */
+    port?: number | undefined;
+    /** Maximum concurrent workflow executions */
+    maxConcurrentWorkflows?: number | undefined;
+    /** Notification channels for suspend events */
+    channels?: Channel[] | undefined;
+    /** Path to a log file. When set, SDK logs are written here instead of stdout. */
+    logFile?: string | undefined;
 }
 /**
- * Initialize state from a Zod schema.
- * Uses schema defaults to create the initial state.
- */
-declare function initializeState<TState>(schema: ZodSchema<TState, ZodTypeDef, unknown>): TState;
-/**
- * Validate state against a Zod schema.
- */
-declare function validateState<TState>(state: unknown, schema: ZodSchema<TState, ZodTypeDef, unknown>): TState;
-
-/**
- * Workflow registry for tracking registered workflows.
+ * Unified Polos client + worker.
  *
- * Used by Worker to find workflows to execute based on workflow ID.
- */
-
-/**
- * Error thrown when a workflow is not found in the registry.
- */
-declare class WorkflowNotFoundError extends Error {
+ * @example
+ * ```typescript
+ * import { Polos, defineAgent } from '@polos/sdk';
+ * import { openai } from '@ai-sdk/openai';
+ *
+ * const agent = defineAgent({
+ *   id: 'weather',
+ *   model: openai('gpt-4o'),
+ *   systemPrompt: 'You are a weather assistant.',
+ * });
+ *
+ * const polos = new Polos();
+ * await polos.start();
+ * const result = await agent.run(polos, { input: "What's the weather?" });
+ * await polos.stop();
+ * ```
+ */
+declare class Polos implements WorkflowRunClient {
+    private readonly client;
+    private readonly worker;
+    private started;
+    private serverPromise;
+    /**
+     * Events API for publishing and subscribing to events.
+     */
+    readonly events: EventsApi;
+    /**
+     * Schedules API for managing workflow schedules.
+     */
+    readonly schedules: SchedulesApi;
+    constructor(config?: PolosConfig);
+    /**
+     * Start the worker in background (non-blocking).
+     *
+     * Registers with orchestrator, starts worker server, begins heartbeat.
+     * Returns once registration is complete so the caller can immediately
+     * invoke workflows.
+     */
+    start(): Promise<void>;
+    /**
+     * Start the worker and block until shutdown signal (SIGINT/SIGTERM).
+     *
+     * This is the deployment mode — equivalent to Worker.run().
+     * Use for servers, Kubernetes, Docker, etc.
+     */
+    serve(): Promise<void>;
+    /**
+     * Gracefully stop the worker and clean up.
+     */
+    stop(): Promise<void>;
+    /**
+     * Get the underlying PolosClient.
+     * Needed for APIs that require PolosClient explicitly (e.g., agent.stream()).
+     */
+    getClient(): PolosClient;
+    /**
+     * Invoke a workflow (fire and forget).
+     */
+    invoke(workflow: string | Workflow, payload?: unknown, options?: ClientInvokeOptions): Promise<ExecutionHandle>;
+    /**
+     * Invoke multiple workflows in batch.
+     */
+    batchInvoke(items: ClientBatchWorkflowInput[], options?: {
+        sessionId?: string;
+        userId?: string;
+        parentExecutionId?: string;
+        rootWorkflowId?: string;
+        rootExecutionId?: string;
+        stepKey?: string;
+        waitForSubworkflow?: boolean;
+    }): Promise<ExecutionHandle[]>;
+    /**
+     * Resume a suspended execution.
+     */
+    resume(suspendWorkflowId: string, suspendExecutionId: string, suspendStepKey: string, data: unknown): Promise<void>;
+    /**
+     * Get execution details.
+     */
+    getExecution(executionId: string): Promise<GetExecutionResponse>;
+    /**
+     * Cancel an execution.
+     */
+    cancelExecution(executionId: string): Promise<boolean>;
+}
+
+/**
+ * State management for workflows.
+ *
+ * Handles state initialization, validation, and serialization using Zod schemas.
+ */
+
+/**
+ * Error thrown when state validation fails.
+ */
+declare class StateValidationError extends Error {
+    readonly issues: unknown[];
+    constructor(message: string, issues: unknown[]);
+}
+/**
+ * Error thrown when state exceeds size limit.
+ */
+declare class StateSizeError extends Error {
+    readonly size: number;
+    readonly maxSize: number;
+    constructor(size: number, maxSize: number);
+}
+/**
+ * Initialize state from a Zod schema.
+ * Uses schema defaults to create the initial state.
+ */
+declare function initializeState<TState>(schema: ZodType<TState>): TState;
+/**
+ * Validate state against a Zod schema.
+ */
+declare function validateState<TState>(state: unknown, schema: ZodType<TState>): TState;
+
+/**
+ * Workflow registry for tracking registered workflows.
+ *
+ * Used by Worker to find workflows to execute based on workflow ID.
+ */
+
+/**
+ * Error thrown when a workflow is not found in the registry.
+ */
+declare class WorkflowNotFoundError extends Error {
     readonly workflowId: string;
     constructor(workflowId: string);
 }
@@ -2155,8 +2386,8 @@ declare class DuplicateWorkflowError extends Error {
  */
 interface WorkflowRegistry {
     /**
-     * Register a workflow.
-     * @throws DuplicateWorkflowError if workflow ID is already registered
+     * Register a workflow. If a workflow with the same ID is already
+     * registered, it is silently replaced.
      */
     register(workflow: Workflow): void;
     /**
@@ -2189,10 +2420,6 @@ interface WorkflowRegistry {
  * Create a workflow registry.
  */
 declare function createWorkflowRegistry(): WorkflowRegistry;
-/**
- * Global workflow registry instance.
- * Used for automatic workflow registration when using defineWorkflow.
- */
 declare const globalRegistry: WorkflowRegistry;
 
 /**
@@ -2245,6 +2472,380 @@ interface QueueConfig {
     concurrencyLimit?: number | undefined;
 }
 
+/**
+ * Shared types for the execution framework.
+ *
+ * Defines interfaces for execution environments, command results,
+ * file operations, and configuration.
+ */
+/**
+ * Abstract interface for an execution environment (Docker, E2B, Local).
+ * All sandbox tools operate against this interface.
+ */
+interface ExecutionEnvironment {
+    /** Environment type discriminator */
+    readonly type: 'local' | 'docker' | 'e2b';
+    /** Execute a shell command in the environment */
+    exec(command: string, opts?: ExecOptions): Promise<ExecResult>;
+    /** Read a file's contents as UTF-8 text */
+    readFile(path: string): Promise<string>;
+    /** Write content to a file, creating parent directories as needed */
+    writeFile(path: string, content: string): Promise<void>;
+    /** Check whether a file exists */
+    fileExists(path: string): Promise<boolean>;
+    /** Find files matching a glob pattern */
+    glob(pattern: string, opts?: GlobOptions): Promise<string[]>;
+    /** Search file contents for a pattern */
+    grep(pattern: string, opts?: GrepOptions): Promise<GrepMatch[]>;
+    /** Initialize the environment (create container, connect to sandbox, etc.) */
+    initialize(): Promise<void>;
+    /** Tear down the environment (remove container, kill sandbox, etc.) */
+    destroy(): Promise<void>;
+    /** Get the current working directory inside the environment */
+    getCwd(): string;
+    /** Get environment metadata */
+    getInfo(): EnvironmentInfo;
+}
+/**
+ * Options for command execution.
+ */
+interface ExecOptions {
+    /** Working directory for the command */
+    cwd?: string | undefined;
+    /** Environment variables to set */
+    env?: Record<string, string> | undefined;
+    /** Timeout in seconds (default: 300) */
+    timeout?: number | undefined;
+    /** Data to pipe to stdin */
+    stdin?: string | undefined;
+}
+/**
+ * Result of a command execution.
+ */
+interface ExecResult {
+    /** Process exit code (0 = success) */
+    exitCode: number;
+    /** Standard output */
+    stdout: string;
+    /** Standard error */
+    stderr: string;
+    /** Execution duration in milliseconds */
+    durationMs: number;
+    /** Whether output was truncated due to size limits */
+    truncated: boolean;
+}
+/**
+ * Options for glob file search.
+ */
+interface GlobOptions {
+    /** Working directory for the search */
+    cwd?: string | undefined;
+    /** Glob patterns to exclude */
+    ignore?: string[] | undefined;
+}
+/**
+ * Options for grep content search.
+ */
+interface GrepOptions {
+    /** Working directory for the search */
+    cwd?: string | undefined;
+    /** File glob patterns to include (e.g., "*.ts") */
+    include?: string[] | undefined;
+    /** Maximum number of matches to return */
+    maxResults?: number | undefined;
+    /** Number of context lines around each match */
+    contextLines?: number | undefined;
+}
+/**
+ * A single grep match result.
+ */
+interface GrepMatch {
+    /** File path (relative to search root) */
+    path: string;
+    /** Line number of the match */
+    line: number;
+    /** The matching line text */
+    text: string;
+    /** Context lines around the match */
+    context?: string | undefined;
+}
+/**
+ * Metadata about an execution environment.
+ */
+interface EnvironmentInfo {
+    /** Environment type */
+    type: 'local' | 'docker' | 'e2b';
+    /** Current working directory */
+    cwd: string;
+    /** Sandbox/container identifier (container ID for Docker, sandbox ID for E2B) */
+    sandboxId?: string | undefined;
+    /** Operating system info */
+    os?: string | undefined;
+}
+/**
+ * Configuration for a Docker execution environment.
+ */
+interface DockerEnvironmentConfig {
+    /** Docker image to use (e.g., "node:20-slim") */
+    image: string;
+    /** Host directory to mount as workspace */
+    workspaceDir: string;
+    /** Working directory inside the container (default: "/workspace") */
+    containerWorkdir?: string | undefined;
+    /** Environment variables to set in the container */
+    env?: Record<string, string> | undefined;
+    /** Memory limit (e.g., "512m", "2g") */
+    memory?: string | undefined;
+    /** CPU limit (e.g., "1", "0.5") */
+    cpus?: string | undefined;
+    /** Network mode (default: "none") */
+    network?: string | undefined;
+    /** Command to run after container creation (e.g., "npm install") */
+    setupCommand?: string | undefined;
+}
+/**
+ * Configuration for an E2B execution environment.
+ */
+interface E2BEnvironmentConfig {
+    /** E2B template name (default: "base") */
+    template?: string | undefined;
+    /** E2B API key (defaults to E2B_API_KEY env var) */
+    apiKey?: string | undefined;
+    /** Sandbox timeout in seconds (default: 3600) */
+    timeout?: number | undefined;
+    /** Working directory inside the sandbox */
+    cwd?: string | undefined;
+    /** Environment variables */
+    env?: Record<string, string> | undefined;
+    /** Setup command to run after sandbox creation */
+    setupCommand?: string | undefined;
+}
+/**
+ * Configuration for a local execution environment.
+ */
+interface LocalEnvironmentConfig {
+    /** Working directory (default: auto-provisioned workspace) */
+    cwd?: string | undefined;
+    /**
+     * Restrict file operations to this directory.
+     * Defaults to `cwd` when running inside a managed sandbox.
+     * Set to `false` to explicitly disable path restriction.
+     */
+    pathRestriction?: string | false | undefined;
+}
+/**
+ * Configuration for the exec tool's security and behavior.
+ */
+interface ExecToolConfig {
+    /** Security mode: allow-always (default), allowlist, or always require approval */
+    security?: 'allow-always' | 'allowlist' | 'approval-always' | undefined;
+    /** Allowed command patterns (for allowlist mode) */
+    allowlist?: string[] | undefined;
+    /** Default command timeout in seconds (default: 300) */
+    timeout?: number | undefined;
+    /** Maximum output characters before truncation (default: 100000) */
+    maxOutputChars?: number | undefined;
+}
+/**
+ * Sandbox lifecycle scope.
+ *
+ * - `'execution'` — sandbox created on first tool use, destroyed when execution completes.
+ * - `'session'` — sandbox persists across executions sharing the same sessionId.
+ */
+type SandboxScope = 'execution' | 'session';
+/**
+ * Configuration for a managed sandbox.
+ */
+interface SandboxConfig {
+    /** Custom sandbox ID. Auto-generated if omitted. */
+    id?: string | undefined;
+    /** Lifecycle scope. Default: 'execution'. */
+    scope?: SandboxScope | undefined;
+    /** Environment type. Default: 'docker'. */
+    env?: 'local' | 'docker' | 'e2b' | undefined;
+    /** Docker environment configuration. */
+    docker?: DockerEnvironmentConfig | undefined;
+    /** E2B environment configuration. */
+    e2b?: E2BEnvironmentConfig | undefined;
+    /** Local environment configuration. */
+    local?: LocalEnvironmentConfig | undefined;
+    /** Exec tool configuration (security, timeout, etc). */
+    exec?: ExecToolConfig | undefined;
+    /** Approval mode for file-mutating tools (write, edit). Defaults to 'always' for local env. */
+    fileApproval?: 'always' | 'none' | undefined;
+    /**
+     * Idle destruction timeout for session-scoped sandboxes.
+     * Container destroyed after this duration of no tool calls.
+     * Default: '1h'. Only applies to scope: 'session'.
+     * Examples: '1h', '24h', '3d'.
+     */
+    idleDestroyTimeout?: string | undefined;
+}
+/**
+ * Configuration for the sandboxTools() factory.
+ */
+interface SandboxToolsConfig extends SandboxConfig {
+    /** Working directory override */
+    cwd?: string | undefined;
+    /** Subset of tools to include (default: all) */
+    tools?: ('exec' | 'read' | 'write' | 'edit' | 'glob' | 'grep')[] | undefined;
+}
+
+/**
+ * Managed sandbox — wraps an ExecutionEnvironment with identity,
+ * lifecycle tracking, and crash recovery.
+ */
+
+/**
+ * A managed sandbox wrapping an ExecutionEnvironment.
+ */
+interface Sandbox {
+    readonly id: string;
+    readonly scope: SandboxScope;
+    readonly config: SandboxConfig;
+    readonly workerId: string;
+    readonly sessionId?: string | undefined;
+    readonly activeExecutionIds: ReadonlySet<string>;
+    readonly initialized: boolean;
+    readonly destroyed: boolean;
+    readonly lastActivityAt: Date;
+    /** Get or lazily initialize the environment. Updates lastActivityAt. */
+    getEnvironment(): Promise<ExecutionEnvironment>;
+    /** Record that an execution is using this sandbox. */
+    attachExecution(executionId: string): void;
+    /** Record that an execution is done with this sandbox. */
+    detachExecution(executionId: string): void;
+    /** Destroy the sandbox. Safe to call multiple times. */
+    destroy(): Promise<void>;
+    /** Recreate after container crash. Filesystem survives via bind mount. */
+    recreate(): Promise<void>;
+}
+/**
+ * Concrete implementation of the Sandbox interface.
+ */
+declare class ManagedSandbox implements Sandbox {
+    readonly id: string;
+    readonly scope: SandboxScope;
+    readonly config: SandboxConfig;
+    private _workerId;
+    readonly projectId: string;
+    readonly sessionId?: string | undefined;
+    private readonly _activeExecutionIds;
+    private _lastActivityAt;
+    private _destroyed;
+    private _env;
+    private _envPromise;
+    private _lastHealthCheckAt;
+    constructor(config: SandboxConfig, workerId: string, projectId: string, sessionId?: string);
+    get workerId(): string;
+    get activeExecutionIds(): ReadonlySet<string>;
+    get initialized(): boolean;
+    get destroyed(): boolean;
+    get lastActivityAt(): Date;
+    getEnvironment(): Promise<ExecutionEnvironment>;
+    attachExecution(executionId: string): void;
+    detachExecution(executionId: string): void;
+    destroy(): Promise<void>;
+    recreate(): Promise<void>;
+    /**
+     * Create the execution environment based on config.
+     */
+    /**
+     * Compute the default workspace directory for Docker.
+     * Uses `POLOS_WORKSPACES_DIR/{projectId}/{sessionId || sandboxId}`.
+     */
+    private _getDefaultWorkspaceDir;
+    private _initializeEnvironment;
+    /**
+     * Health check with 30s debounce. Only probes Docker containers.
+     */
+    private _healthCheck;
+}
+
+/**
+ * SandboxManager — manages sandbox creation, reuse, auto-cleanup,
+ * and orphan detection. Lives on the Worker.
+ */
+
+/**
+ * Manages sandbox lifecycle across executions.
+ */
+declare class SandboxManager {
+    private _workerId;
+    private _projectId;
+    private readonly _orchestratorClient;
+    private readonly sandboxes;
+    private readonly sessionSandboxes;
+    private readonly sessionCreationLocks;
+    private sweepTimer;
+    constructor(workerId: string, projectId: string, orchestratorClient?: OrchestratorClient);
+    /**
+     * Update the worker ID (called after registration or re-registration).
+     */
+    setWorkerId(workerId: string): void;
+    /**
+     * Create or retrieve a sandbox.
+     *
+     * - Session-scoped: returns existing sandbox for the session if available.
+     * - Execution-scoped: always creates a new sandbox.
+     */
+    getOrCreateSandbox(config: SandboxConfig, ctx: {
+        executionId: string;
+        sessionId?: string | undefined;
+    }): Promise<Sandbox>;
+    /**
+     * Notify that an execution completed. Triggers cleanup for execution-scoped sandboxes.
+     */
+    onExecutionComplete(executionId: string): Promise<void>;
+    /**
+     * Destroy a specific sandbox by ID.
+     */
+    destroySandbox(sandboxId: string): Promise<void>;
+    /**
+     * Destroy all managed sandboxes. Called during worker shutdown.
+     */
+    destroyAll(): Promise<void>;
+    /**
+     * Start periodic sweep. Each cycle:
+     * 1. Destroys own sandboxes idle past their idleDestroyTimeout.
+     * 2. Removes orphan Docker containers from dead workers (orchestrator-based).
+     */
+    startSweep(intervalMs?: number): void;
+    /**
+     * Stop the periodic sweep.
+     */
+    stopSweep(): void;
+    /**
+     * Lookup a sandbox by ID.
+     */
+    getSandbox(sandboxId: string): Sandbox | undefined;
+    /**
+     * Lookup a session sandbox by session ID.
+     */
+    getSessionSandbox(sessionId: string): Sandbox | undefined;
+    private _createExecutionSandbox;
+    private _createSessionSandbox;
+    private _destroyAndRemove;
+    /**
+     * Unified sweep: Phase 1 cleans own idle sandboxes, Phase 2 cleans orphan containers.
+     */
+    private _sweep;
+    /**
+     * Phase 1: Destroy own sandboxes that have been idle past their timeout.
+     */
+    private _sweepIdleSandboxes;
+    /**
+     * Phase 2: Remove Docker containers from dead workers.
+     *
+     * Queries the orchestrator for active worker IDs, lists all polos-managed
+     * Docker containers, and removes any whose worker-id is not in the active set
+     * AND whose age exceeds ORPHAN_GRACE_PERIOD_MS.
+     *
+     * If the orchestrator is unavailable, this phase is skipped entirely.
+     */
+    private _sweepOrphanContainers;
+}
+
 /**
  * Worker class for executing Polos workflows.
  *
@@ -2278,6 +2879,8 @@ interface WorkerConfig {
     localMode?: boolean | undefined;
     /** Request timeout in milliseconds (default: 30000) */
     timeout?: number | undefined;
+    /** Default notification channels for suspend events (e.g., Slack, Discord) */
+    channels?: Channel[] | undefined;
 }
 /**
  * Worker state.
@@ -2313,9 +2916,12 @@ declare class Worker {
     private readonly config;
     private readonly orchestratorClient;
     private readonly workflowRegistry;
+    private readonly channels;
     private readonly maxConcurrentWorkflows;
     private readonly workerServerUrl;
     private readonly port;
+    /** Sandbox manager for managed sandbox lifecycle. */
+    readonly sandboxManager: SandboxManager;
     private workerId;
     private workerServer;
     private state;
@@ -2343,6 +2949,16 @@ declare class Worker {
      * Run the worker (blocks until shutdown).
      */
     run(): Promise<void>;
+    /**
+     * Phase 1: Initialize tracing and register with orchestrator.
+     * @internal
+     */
+    registerAll(): Promise<void>;
+    /**
+     * Phase 2: Start worker server, heartbeat, and signal handlers (blocks until shutdown).
+     * @internal
+     */
+    runServer(): Promise<void>;
     /**
      * Gracefully shutdown the worker.
      */
@@ -2434,7 +3050,11 @@ declare class Worker {
     /**
      * Confirm cancellation.
      */
-    private confirmCancellation;
+    private confirmCancellation;
+    /**
+     * Start a channel bridge that streams execution events back to the originating channel.
+     */
+    private startChannelBridge;
 }
 
 /**
@@ -2462,6 +3082,10 @@ interface WorkerExecutionData {
     otelSpanId?: string | undefined;
     initialState?: Record<string, unknown> | undefined;
     runTimeoutSeconds?: number | undefined;
+    channelContext?: {
+        channelId: string;
+        source: Record<string, unknown>;
+    } | undefined;
 }
 /**
  * Callback for handling received work.
@@ -2552,6 +3176,15 @@ interface ExecuteWorkflowOptions {
     workerId: string;
     /** Abort signal for cancellation */
     abortSignal?: AbortSignal | undefined;
+    /** Notification channels for suspend events */
+    channels?: Channel[] | undefined;
+    /** Sandbox manager for managed sandbox lifecycle */
+    sandboxManager?: SandboxManager | undefined;
+    /** Originating channel context for bidirectional channels */
+    channelContext?: {
+        channelId: string;
+        source: Record<string, unknown>;
+    } | undefined;
 }
 /**
  * Result of workflow execution.
@@ -3006,6 +3639,8 @@ interface LLMUsage {
     input_tokens: number;
     output_tokens: number;
     total_tokens: number;
+    cache_read_input_tokens?: number | undefined;
+    cache_creation_input_tokens?: number | undefined;
 }
 /**
  * A tool call made by the LLM
@@ -3148,6 +3783,10 @@ declare function convertVercelUsageToPython(usage: {
     inputTokens: number | undefined;
     outputTokens: number | undefined;
     totalTokens?: number | undefined;
+    inputTokenDetails?: {
+        cacheReadTokens?: number | undefined;
+        cacheWriteTokens?: number | undefined;
+    };
 }): LLMUsage;
 /**
  * Convert Vercel finish reason (kebab-case) to Python format (snake_case).
@@ -3346,6 +3985,64 @@ declare const hasText: StopConditionFactory<{
     texts: string[];
 }>;
 
+/**
+ * Types for the session compaction memory system.
+ *
+ * Two-tier memory:
+ * - Tier 1: Rolling summary of older messages (compacted via LLM)
+ * - Tier 2: Recent raw messages kept verbatim
+ */
+
+/**
+ * Full session memory state.
+ */
+interface SessionMemory {
+    /** Compacted summary of older messages, or null if no compaction has occurred */
+    summary: string | null;
+    /** Recent messages kept verbatim */
+    messages: ConversationMessage[];
+}
+/**
+ * User-facing compaction configuration.
+ */
+interface CompactionConfig {
+    /** Maximum total conversation tokens before compaction triggers (default: 80000) */
+    maxConversationTokens?: number | undefined;
+    /** Maximum tokens for the summary (default: 20000) */
+    maxSummaryTokens?: number | undefined;
+    /** Minimum recent messages to always keep verbatim (default: 4) */
+    minRecentMessages?: number | undefined;
+    /** Model to use for compaction (default: agent's own model) */
+    compactionModel?: LanguageModel | undefined;
+    /** Whether compaction is enabled (default: true) */
+    enabled?: boolean | undefined;
+}
+/**
+ * Internal — all fields resolved to concrete values.
+ */
+interface NormalizedCompactionConfig {
+    maxConversationTokens: number;
+    maxSummaryTokens: number;
+    minRecentMessages: number;
+    compactionModel: LanguageModel;
+    enabled: boolean;
+}
+/**
+ * Result from compactIfNeeded.
+ */
+interface CompactionResult {
+    /** Whether compaction was performed */
+    compacted: boolean;
+    /** The (possibly shortened) messages array */
+    messages: ConversationMessage[];
+    /** The current summary text (null if no summary) */
+    summary: string | null;
+    /** Estimated token count of the summary */
+    summaryTokens: number;
+    /** Total conversation turns */
+    totalTurns: number;
+}
+
 /**
  * Agent stream function — core execution loop.
  *
@@ -3372,7 +4069,6 @@ interface AgentStreamPayload {
     agent_config: AgentStreamConfig;
     input: string | Record<string, unknown>[];
     streaming: boolean;
-    conversation_id?: string | undefined;
 }
 /**
  * Definition of an agent for the stream function.
@@ -3390,7 +4086,8 @@ interface AgentDefinition {
     };
     guardrails: Guardrail[];
     guardrailMaxRetries: number;
-    conversationHistory: number;
+    /** Session compaction configuration — always enabled */
+    compaction: CompactionConfig;
     outputSchema?: unknown;
     /** Original Zod schema for Vercel AI SDK structured output (Output.object()) */
     outputZodSchema?: unknown;
@@ -3401,7 +4098,6 @@ interface AgentDefinition {
  */
 interface AgentStreamResult {
     agent_run_id: string;
-    conversation_id: string | undefined;
     result: unknown;
     result_schema: string | null;
     tool_results: ToolResultInfo[];
@@ -3508,7 +4204,7 @@ interface DefineAgentConfig {
     /** Conditions to stop agent execution */
     stopConditions?: StopCondition[] | undefined;
     /** Zod schema for structured output */
-    outputSchema?: ZodSchema<unknown, ZodTypeDef, unknown> | undefined;
+    outputSchema?: ZodType | undefined;
     /** Hook(s) to run before workflow execution */
     onStart?: HookOrHandler | undefined;
     /** Hook(s) to run after workflow completion */
@@ -3525,8 +4221,12 @@ interface DefineAgentConfig {
     guardrails?: (Guardrail | GuardrailHandler)[] | undefined;
     /** Maximum guardrail retries (default: 2) */
     guardrailMaxRetries?: number | undefined;
-    /** Number of conversation history messages to retain (default: 10) */
-    conversationHistory?: number | undefined;
+    /** Session compaction configuration — always enabled with sensible defaults */
+    compaction?: CompactionConfig | undefined;
+    /** Publish text_delta and tool_call events to the workflow topic for all invocations */
+    streamToWorkflow?: boolean | undefined;
+    /** Notification channels for suspend events. Overrides Worker-level channels. */
+    channels?: Channel[] | undefined;
 }
 /**
  * Payload for agent run() and stream() calls.
@@ -3535,8 +4235,6 @@ interface DefineAgentConfig {
 interface AgentRunPayload {
     /** Input for the agent (string message or message array) */
     input: string | Record<string, unknown>[];
-    /** Conversation ID for history tracking */
-    conversationId?: string | undefined;
 }
 /**
  * A Workflow extended with agent-specific properties.
@@ -3577,7 +4275,6 @@ interface AgentWorkflow extends Workflow {
      * Matches Python Agent.with_input().
      */
     withInput(input: string | Record<string, unknown>[], options?: {
-        conversationId?: string;
         sessionId?: string;
         userId?: string;
         initialState?: Record<string, unknown>;
@@ -3740,6 +4437,25 @@ interface LoggerOptions {
     /** Custom log handler */
     handler?: ((entry: LogEntry) => void) | undefined;
 }
+interface ConfigureLoggingOptions {
+    /** Custom log handler for all SDK loggers */
+    handler?: ((entry: LogEntry) => void) | undefined;
+    /** Path to a log file. SDK logs will be appended to this file instead of stdout. */
+    file?: string | undefined;
+}
+/**
+ * Configure logging for all SDK loggers globally.
+ *
+ * @example
+ * ```typescript
+ * // Redirect all SDK logs to a file
+ * configureLogging({ file: 'polos.log' });
+ *
+ * // Use a custom handler
+ * configureLogging({ handler: (entry) => myLogger.log(entry) });
+ * ```
+ */
+declare function configureLogging(options: ConfigureLoggingOptions): void;
 /**
  * Create a logger instance.
  *
@@ -3918,209 +4634,18 @@ interface WebSearchToolConfig extends TavilySearchConfig {
  */
 declare function createWebSearchTool(config?: WebSearchToolConfig): ToolWorkflow;
 
-/**
- * Shared types for the execution framework.
- *
- * Defines interfaces for execution environments, command results,
- * file operations, and configuration.
- */
-/**
- * Abstract interface for an execution environment (Docker, E2B, Local).
- * All sandbox tools operate against this interface.
- */
-interface ExecutionEnvironment {
-    /** Environment type discriminator */
-    readonly type: 'local' | 'docker' | 'e2b';
-    /** Execute a shell command in the environment */
-    exec(command: string, opts?: ExecOptions): Promise<ExecResult>;
-    /** Read a file's contents as UTF-8 text */
-    readFile(path: string): Promise<string>;
-    /** Write content to a file, creating parent directories as needed */
-    writeFile(path: string, content: string): Promise<void>;
-    /** Check whether a file exists */
-    fileExists(path: string): Promise<boolean>;
-    /** Find files matching a glob pattern */
-    glob(pattern: string, opts?: GlobOptions): Promise<string[]>;
-    /** Search file contents for a pattern */
-    grep(pattern: string, opts?: GrepOptions): Promise<GrepMatch[]>;
-    /** Initialize the environment (create container, connect to sandbox, etc.) */
-    initialize(): Promise<void>;
-    /** Tear down the environment (remove container, kill sandbox, etc.) */
-    destroy(): Promise<void>;
-    /** Get the current working directory inside the environment */
-    getCwd(): string;
-    /** Get environment metadata */
-    getInfo(): EnvironmentInfo;
-}
-/**
- * Options for command execution.
- */
-interface ExecOptions {
-    /** Working directory for the command */
-    cwd?: string | undefined;
-    /** Environment variables to set */
-    env?: Record<string, string> | undefined;
-    /** Timeout in seconds (default: 300) */
-    timeout?: number | undefined;
-    /** Data to pipe to stdin */
-    stdin?: string | undefined;
-}
-/**
- * Result of a command execution.
- */
-interface ExecResult {
-    /** Process exit code (0 = success) */
-    exitCode: number;
-    /** Standard output */
-    stdout: string;
-    /** Standard error */
-    stderr: string;
-    /** Execution duration in milliseconds */
-    durationMs: number;
-    /** Whether output was truncated due to size limits */
-    truncated: boolean;
-}
-/**
- * Options for glob file search.
- */
-interface GlobOptions {
-    /** Working directory for the search */
-    cwd?: string | undefined;
-    /** Glob patterns to exclude */
-    ignore?: string[] | undefined;
-}
-/**
- * Options for grep content search.
- */
-interface GrepOptions {
-    /** Working directory for the search */
-    cwd?: string | undefined;
-    /** File glob patterns to include (e.g., "*.ts") */
-    include?: string[] | undefined;
-    /** Maximum number of matches to return */
-    maxResults?: number | undefined;
-    /** Number of context lines around each match */
-    contextLines?: number | undefined;
-}
-/**
- * A single grep match result.
- */
-interface GrepMatch {
-    /** File path (relative to search root) */
-    path: string;
-    /** Line number of the match */
-    line: number;
-    /** The matching line text */
-    text: string;
-    /** Context lines around the match */
-    context?: string | undefined;
-}
-/**
- * Metadata about an execution environment.
- */
-interface EnvironmentInfo {
-    /** Environment type */
-    type: 'local' | 'docker' | 'e2b';
-    /** Current working directory */
-    cwd: string;
-    /** Sandbox/container identifier (container ID for Docker, sandbox ID for E2B) */
-    sandboxId?: string | undefined;
-    /** Operating system info */
-    os?: string | undefined;
-}
-/**
- * Configuration for a Docker execution environment.
- */
-interface DockerEnvironmentConfig {
-    /** Docker image to use (e.g., "node:20-slim") */
-    image: string;
-    /** Host directory to mount as workspace */
-    workspaceDir: string;
-    /** Working directory inside the container (default: "/workspace") */
-    containerWorkdir?: string | undefined;
-    /** Environment variables to set in the container */
-    env?: Record<string, string> | undefined;
-    /** Memory limit (e.g., "512m", "2g") */
-    memory?: string | undefined;
-    /** CPU limit (e.g., "1", "0.5") */
-    cpus?: string | undefined;
-    /** Network mode (default: "none") */
-    network?: string | undefined;
-    /** Command to run after container creation (e.g., "npm install") */
-    setupCommand?: string | undefined;
-}
-/**
- * Configuration for an E2B execution environment.
- */
-interface E2BEnvironmentConfig {
-    /** E2B template name (default: "base") */
-    template?: string | undefined;
-    /** E2B API key (defaults to E2B_API_KEY env var) */
-    apiKey?: string | undefined;
-    /** Sandbox timeout in seconds (default: 3600) */
-    timeout?: number | undefined;
-    /** Working directory inside the sandbox */
-    cwd?: string | undefined;
-    /** Environment variables */
-    env?: Record<string, string> | undefined;
-    /** Setup command to run after sandbox creation */
-    setupCommand?: string | undefined;
-}
-/**
- * Configuration for a local execution environment.
- */
-interface LocalEnvironmentConfig {
-    /** Working directory (default: process.cwd()) */
-    cwd?: string | undefined;
-    /** Restrict file operations to this directory */
-    pathRestriction?: string | undefined;
-}
-/**
- * Configuration for the exec tool's security and behavior.
- */
-interface ExecToolConfig {
-    /** Security mode: allow-always (default), allowlist, or always require approval */
-    security?: 'allow-always' | 'allowlist' | 'approval-always' | undefined;
-    /** Allowed command patterns (for allowlist mode) */
-    allowlist?: string[] | undefined;
-    /** Default command timeout in seconds (default: 300) */
-    timeout?: number | undefined;
-    /** Maximum output characters before truncation (default: 100000) */
-    maxOutputChars?: number | undefined;
-}
-/**
- * Configuration for the sandboxTools() factory.
- */
-interface SandboxToolsConfig {
-    /** Environment type (default: "docker") */
-    env?: 'local' | 'docker' | 'e2b' | undefined;
-    /** Working directory override */
-    cwd?: string | undefined;
-    /** Subset of tools to include (default: all) */
-    tools?: ('exec' | 'read' | 'write' | 'edit' | 'glob' | 'grep')[] | undefined;
-    /** Docker environment configuration */
-    docker?: DockerEnvironmentConfig | undefined;
-    /** E2B environment configuration */
-    e2b?: E2BEnvironmentConfig | undefined;
-    /** Local environment configuration */
-    local?: LocalEnvironmentConfig | undefined;
-    /** Exec tool configuration */
-    exec?: ExecToolConfig | undefined;
-    /** Approval mode for file-mutating tools (write, edit). Defaults to 'always' for local env. */
-    fileApproval?: 'always' | 'none' | undefined;
-}
-
 /**
  * Sandbox tools factory.
  *
  * Creates a set of tools (exec, read, write, edit, glob, grep) that share
- * a lazily-initialized execution environment via closure. The environment
- * is created on first tool use and reused for all subsequent calls.
+ * a managed sandbox. The sandbox is created lazily on first tool use
+ * via the SandboxManager injected through the execution context.
  *
  * @example
  * ```typescript
  * import { defineAgent, sandboxTools } from '@polos/sdk';
  *
+ * // Per-execution (default) — sandbox dies when the workflow finishes
  * const agent = defineAgent({
  *   id: 'solver',
  *   tools: sandboxTools({
@@ -4128,25 +4653,27 @@ interface SandboxToolsConfig {
  *     docker: { image: 'node:20', workspaceDir: '/path/to/project' },
  *   }),
  * });
+ *
+ * // Per-session — sandbox lives across turns
+ * const agent2 = defineAgent({
+ *   id: 'coder',
+ *   tools: sandboxTools({
+ *     scope: 'session',
+ *     env: 'docker',
+ *     docker: { image: 'node:20', workspaceDir: '/path/to/project' },
+ *   }),
+ * });
  * ```
  */
 
-/**
- * Return type for sandboxTools — an array of ToolWorkflow with a cleanup method.
- */
-interface SandboxToolsResult extends Array<ToolWorkflow> {
-    /** Destroy the shared execution environment (remove container, etc.) */
-    cleanup(): Promise<void>;
-}
 /**
  * Create sandbox tools for AI agents.
  *
  * Returns an array of ToolWorkflow that can be passed directly to defineAgent().
- * All tools share a single execution environment that is lazily created on first use.
- *
- * The returned array has a `cleanup()` method for destroying the environment.
+ * All tools share a single managed sandbox that is lazily created on first use.
+ * Lifecycle is managed by the SandboxManager — no manual cleanup needed.
  */
-declare function sandboxTools(config?: SandboxToolsConfig): SandboxToolsResult;
+declare function sandboxTools(config?: SandboxToolsConfig): ToolWorkflow[];
 
 /**
  * Docker execution environment.
@@ -4171,7 +4698,11 @@ declare class DockerEnvironment implements ExecutionEnvironment {
     private readonly containerWorkdir;
     private readonly maxOutputChars;
     constructor(config: DockerEnvironmentConfig, maxOutputChars?: number);
-    initialize(): Promise<void>;
+    /**
+     * Get the container name (useful for health checking and identification).
+     */
+    getContainerName(): string;
+    initialize(labels?: Record<string, string>): Promise<void>;
     exec(command: string, opts?: ExecOptions): Promise<ExecResult>;
     readFile(filePath: string): Promise<string>;
     writeFile(filePath: string, content: string): Promise<void>;
@@ -4325,4 +4856,84 @@ declare function createGlobTool(getEnv: () => Promise<ExecutionEnvironment>, pat
  */
 declare function createGrepTool(getEnv: () => Promise<ExecutionEnvironment>, pathConfig?: PathRestrictionConfig): ToolWorkflow;
 
-export { type Agent, type AgentConfig, type AgentContext, type AgentResult, AgentRunConfig, type AgentRunOptions, type AgentRunPayload, type AgentStep, type AgentStream, type AgentStreamEvent, type AgentStreamPayload, type AgentStreamResult, type AgentWorkflow, type BatchEventPayload, type BatchStepResult, type BatchWorkflowInput, type ClientBatchWorkflowInput, type ClientInvokeOptions, type CoreMessage$1 as CoreMessage, type DefineAgentConfig, type DefineGuardrailOptions, type DefineHookOptions, type DefineToolConfig, DockerEnvironment, type DockerEnvironmentConfig, DuplicateWorkflowError, type E2BEnvironmentConfig, type EnvironmentInfo, type Event, type EventData, type EventItem, type EventPayload, type EventTriggerPayload, type EventsApi, type ExecOptions, type ExecResult, type ExecToolConfig, type ExecuteGuardrailsOptions, type ExecuteHooksOptions, type ExecuteWorkflowOptions, type ExecutionContext, type ExecutionData, type ExecutionEnvironment, ExecutionHandle, type ExecutionHandleFields, type ExecutionResult, type FinishReason, type GenerateConfig, type GlobOptions, type GrepMatch, type GrepOptions, type Guardrail$1 as Guardrail, type GuardrailChainResult, type GuardrailContext$1 as GuardrailContext, GuardrailError, type GuardrailHandler, GuardrailResult$1 as GuardrailResult, type GuardrailResultType, type Hook, type HookChainResult, type HookContext, HookExecutionError, type HookHandler, HookResult, type HookResultType, type InferPayload, type InferResult, type InferState, type InvokeOptions, LLM, type LLMGenerateOptions, type LLMGeneratePayload, type LLMGenerateResult, type LLMProvider, type LLMResponse, type LLMStreamEvent, type LLMStreamPayload, type LLMToolCall, type LLMToolResult, type LLMUsage, type LlmToolDefinition, type LocalEnvironmentConfig, type Logger, type Guardrail as MiddlewareGuardrail, type GuardrailContext as MiddlewareGuardrailContext, GuardrailResult as MiddlewareGuardrailResult, OrchestratorApiError, OrchestratorClient, type OrchestratorClientConfig, type OtelConfig, PolosClient, type PolosClientConfig, type PublishEventFn, type PublishEventOptions, Queue, type QueueConfig$1 as QueueConfig, type QueueOptions, type ResumeOptions, type SandboxToolsConfig, type SandboxToolsResult, type ScheduleConfig, type SchedulePayload, type SchedulesApi, StateSizeError, StateValidationError, StepExecutionError, type StepHelper, type StepInfo, type StepOptions, type StepStore, type StopCondition, type StopConditionContext, type StreamEvent, StreamResult, type StreamTopicOptions, type StreamWorkflowOptions, type SuspendOptions, type TavilySearchConfig, type TextDeltaEvent, type TokenUsage, type Tool, type ToolApproval, type ToolCall, type ToolCallEvent, type ToolConfig, type ToolHandler, type ToolResult, type ToolResultInfo, type ToolWorkflow, WaitError, type WaitForEventOptions, type WaitForOptions, type WebSearchFunction, type WebSearchOptions, type WebSearchResult, type WebSearchResultItem, type WebSearchToolConfig, Worker, type WorkerConfig, type WorkerExecutionData, WorkerServer, type WorkerServerConfig, type Workflow, type WorkflowConfig, type WorkflowContext, type WorkflowEvent, type WorkflowHandle, type WorkflowHandler, WorkflowNotFoundError, type WorkflowRegistry, type WorkflowRunClient, type WorkflowRunOptions, type WorkflowStatus, agentStreamFunction, assertSafePath, batchAgentInvoke, batchInvoke, composeGuardrails, composeHooks, conditionalHook, convertFinishReason, convertMiddlewareToolCallToPython, convertPythonToolCallToMiddleware, convertToolResultsToMessages, convertToolsToVercel, convertVercelToolCallToPython, convertVercelUsageToPython, createAskUserTool, createEditTool, createExecTool, createGlobTool, createGrepTool, createLogger, createReadTool, createStepHelper, createStepStore, createWebSearchTool, createWorkflowRegistry, createWriteTool, defineAgent, defineGuardrail, defineHook, defineTool, defineWorkflow, evaluateAllowlist, executeGuardrailChain, executeGuardrailsOrThrow, executeHookChain, executeHooksOrThrow, executeWorkflow, executedTool, extractTraceparent, generateTraceIdFromExecutionId, getTracer, globalRegistry, hasText, initializeOtel, initializeState, isAgentWorkflow, isBinary, isGuardrail, isHook, isOtelAvailable, isToolWorkflow, isWaitError, llmGenerate, llmStream, maxSteps, maxTokens, normalizeGuardrail, normalizeGuardrails, normalizeHook, normalizeHooks, parseGrepOutput, retry, sandboxTools, serializeFinalState, sleep, stopCondition, stripAnsi, truncateOutput, validateState };
+/**
+ * Token estimation utilities for session compaction.
+ *
+ * Uses a simple heuristic: ~4 characters per token.
+ */
+
+/**
+ * Estimate token count for a string using the ~4 chars/token heuristic.
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Estimate token count for a single conversation message.
+ */
+declare function estimateMessageTokens(message: ConversationMessage): number;
+/**
+ * Estimate total token count for an array of conversation messages.
+ */
+declare function estimateMessagesTokens(messages: ConversationMessage[]): number;
+
+/**
+ * Core session compaction logic.
+ *
+ * Compacts older conversation messages into a rolling summary via an LLM call,
+ * keeping the last N recent messages verbatim.
+ */
+
+/**
+ * Build the user/assistant summary pair to inject at the start of conversation.
+ */
+declare function buildSummaryMessages(summary: string): [ConversationMessage, ConversationMessage];
+/**
+ * Compact conversation messages if they exceed the token budget.
+ *
+ * 1. Estimate total tokens of all messages
+ * 2. If under maxConversationTokens -> return as-is (no-op)
+ * 3. Otherwise:
+ *    - Find summary pair at start (if present)
+ *    - Determine messages to fold (between summary pair and last minRecentMessages)
+ *    - Call compaction model to generate summary
+ *    - If summary exceeds maxSummaryTokens, re-summarize
+ *    - Replace folded messages + old summary pair with new summary pair
+ * 4. On failure -> log warning, fall back to naive truncation
+ */
+declare function compactIfNeeded(messages: ConversationMessage[], currentSummary: string | null, config: NormalizedCompactionConfig): Promise<CompactionResult>;
+
+/**
+ * Slack channel implementation — sends a Block Kit message with a "Respond"
+ * link button when an agent suspends.
+ *
+ * Uses native `fetch` (Node 18+) — no @slack/web-api dependency required.
+ */
+
+/**
+ * Configuration for the Slack notification channel.
+ */
+interface SlackChannelConfig {
+    /** Slack bot token (xoxb-...) */
+    botToken: string;
+    /** Default Slack channel for notifications (e.g., "#agent-notifications") */
+    defaultChannel: string;
+    /** Slack signing secret for verifying inbound webhooks */
+    signingSecret?: string;
+}
+/**
+ * Slack notification channel that posts Block Kit messages with a "Respond"
+ * link button pointing to the approval page.
+ */
+declare class SlackChannel implements Channel {
+    readonly id = "slack";
+    readonly outputMode: ChannelOutputMode;
+    private readonly config;
+    constructor(config: SlackChannelConfig);
+    notify(notification: SuspendNotification): Promise<void>;
+    sendOutput(context: ChannelContext, event: StreamEvent): Promise<void>;
+    private postMessage;
+    private formatOutputEvent;
+    private buildBlocks;
+    private isSimpleApproval;
+}
+
+export { type Agent, type AgentConfig, type AgentContext, type AgentResult, AgentRunConfig, type AgentRunOptions, type AgentRunPayload, type AgentStep, type AgentStream, type AgentStreamEvent, type AgentStreamPayload, type AgentStreamResult, type AgentWorkflow, type BatchEventPayload, type BatchStepResult, type BatchWorkflowInput, type Channel, type ChannelContext, type ChannelOutputMode, type ClientBatchWorkflowInput, type ClientInvokeOptions, type CompactionConfig, type CompactionResult, type ConfigureLoggingOptions, type CoreMessage$1 as CoreMessage, type DefineAgentConfig, type DefineGuardrailOptions, type DefineHookOptions, type DefineToolConfig, DockerEnvironment, type DockerEnvironmentConfig, DuplicateWorkflowError, type E2BEnvironmentConfig, type EnvironmentInfo, type Event, type EventData, type EventItem, type EventPayload, type EventTriggerPayload, type EventsApi, type ExecOptions, type ExecResult, type ExecToolConfig, type ExecuteGuardrailsOptions, type ExecuteHooksOptions, type ExecuteWorkflowOptions, type ExecutionContext, type ExecutionData, type ExecutionEnvironment, ExecutionHandle, type ExecutionHandleFields, type ExecutionResult, type FinishReason, type GenerateConfig, type GlobOptions, type GrepMatch, type GrepOptions, type Guardrail$1 as Guardrail, type GuardrailChainResult, type GuardrailContext$1 as GuardrailContext, GuardrailError, type GuardrailHandler, GuardrailResult$1 as GuardrailResult, type GuardrailResultType, type Hook, type HookChainResult, type HookContext, HookExecutionError, type HookHandler, HookResult, type HookResultType, type InferPayload, type InferResult, type InferState, type InvokeOptions, LLM, type LLMGenerateOptions, type LLMGeneratePayload, type LLMGenerateResult, type LLMProvider, type LLMResponse, type LLMStreamEvent, type LLMStreamPayload, type LLMToolCall, type LLMToolResult, type LLMUsage, type LlmToolDefinition, type LocalEnvironmentConfig, type Logger, ManagedSandbox, type Guardrail as MiddlewareGuardrail, type GuardrailContext as MiddlewareGuardrailContext, GuardrailResult as MiddlewareGuardrailResult, type NormalizedCompactionConfig, OrchestratorApiError, OrchestratorClient, type OrchestratorClientConfig, type OtelConfig, Polos, PolosClient, type PolosClientConfig, type PolosConfig, type PublishEventFn, type PublishEventOptions, Queue, type QueueConfig$1 as QueueConfig, type QueueOptions, type ResumeOptions, type Sandbox, type SandboxConfig, SandboxManager, type SandboxScope, type SandboxToolsConfig, type ScheduleConfig, type SchedulePayload, type SchedulesApi, type SessionMemory, SlackChannel, type SlackChannelConfig, StateSizeError, StateValidationError, StepExecutionError, type StepHelper, type StepInfo, type StepOptions, type StepStore, type StopCondition, type StopConditionContext, type StreamEvent, StreamResult, type StreamTopicOptions, type StreamWorkflowOptions, type SuspendNotification, type SuspendOptions, type TavilySearchConfig, type TextDeltaEvent, type TokenUsage, type Tool, type ToolApproval, type ToolCall, type ToolCallEvent, type ToolConfig, type ToolHandler, type ToolResult, type ToolResultInfo, type ToolWorkflow, WaitError, type WaitForEventOptions, type WaitForOptions, type WebSearchFunction, type WebSearchOptions, type WebSearchResult, type WebSearchResultItem, type WebSearchToolConfig, Worker, type WorkerConfig, type WorkerExecutionData, WorkerServer, type WorkerServerConfig, type Workflow, type WorkflowConfig, type WorkflowContext, type WorkflowEvent, type WorkflowHandle, type WorkflowHandler, WorkflowNotFoundError, type WorkflowRegistry, type WorkflowRunClient, type WorkflowRunOptions, type WorkflowStatus, agentStreamFunction, assertSafePath, batchAgentInvoke, batchInvoke, buildSummaryMessages, compactIfNeeded, composeGuardrails, composeHooks, conditionalHook, configureLogging, convertFinishReason, convertMiddlewareToolCallToPython, convertPythonToolCallToMiddleware, convertToolResultsToMessages, convertToolsToVercel, convertVercelToolCallToPython, convertVercelUsageToPython, createAskUserTool, createEditTool, createExecTool, createGlobTool, createGrepTool, createLogger, createReadTool, createStepHelper, createStepStore, createWebSearchTool, createWorkflowRegistry, createWriteTool, defineAgent, defineGuardrail, defineHook, defineTool, defineWorkflow, estimateMessageTokens, estimateMessagesTokens, estimateTokens, evaluateAllowlist, executeGuardrailChain, executeGuardrailsOrThrow, executeHookChain, executeHooksOrThrow, executeWorkflow, executedTool, extractTraceparent, generateTraceIdFromExecutionId, getTracer, globalRegistry, hasText, initializeOtel, initializeState, isAgentWorkflow, isBinary, isGuardrail, isHook, isOtelAvailable, isToolWorkflow, isWaitError, llmGenerate, llmStream, maxSteps, maxTokens, normalizeGuardrail, normalizeGuardrails, normalizeHook, normalizeHooks, parseGrepOutput, retry, sandboxTools, serializeFinalState, sleep, stopCondition, stripAnsi, truncateOutput, validateState };