@agentforge/core 0.5.1 → 0.5.2

package/dist/index.cjs

@@ -65,16 +65,19 @@ __export(index_exports, {
   composeWithOptions: () => composeWithOptions,
   conditional: () => conditional,
   configureLangSmith: () => configureLangSmith,
+  createApprovalRequiredInterrupt: () => createApprovalRequiredInterrupt,
   createBatchProcessor: () => createBatchProcessor,
   createBinaryRouter: () => createBinaryRouter,
   createCircuitBreaker: () => createCircuitBreaker,
   createConditionalRouter: () => createConditionalRouter,
   createConnectionPool: () => createConnectionPool,
   createConversationConfig: () => createConversationConfig,
+  createCustomInterrupt: () => createCustomInterrupt,
   createDatabasePool: () => createDatabasePool,
   createErrorReporter: () => createErrorReporter,
   createHeartbeat: () => createHeartbeat,
   createHttpPool: () => createHttpPool,
+  createHumanRequestInterrupt: () => createHumanRequestInterrupt,
   createLogger: () => createLogger,
   createManagedTool: () => createManagedTool,
   createMemoryCheckpointer: () => createMemoryCheckpointer,
@@ -99,13 +102,23 @@ __export(index_exports, {
   createWebSocketHandler: () => createWebSocketHandler,
   development: () => development,
   filter: () => filter,
+  formatAgentResumedEvent: () => formatAgentResumedEvent,
+  formatAgentWaitingEvent: () => formatAgentWaitingEvent,
+  formatHumanRequestEvent: () => formatHumanRequestEvent,
+  formatHumanResponseEvent: () => formatHumanResponseEvent,
+  formatInterruptEvent: () => formatInterruptEvent,
+  formatResumeEvent: () => formatResumeEvent,
   generateThreadId: () => generateThreadId,
   getCheckpointHistory: () => getCheckpointHistory,
   getLangSmithConfig: () => getLangSmithConfig,
   getLatestCheckpoint: () => getLatestCheckpoint,
   getMissingDescriptions: () => getMissingDescriptions,
+  getThreadStatus: () => getThreadStatus,
   getToolDescription: () => getToolDescription,
   getToolJsonSchema: () => getToolJsonSchema,
+  isApprovalRequiredInterrupt: () => isApprovalRequiredInterrupt,
+  isCustomInterrupt: () => isCustomInterrupt,
+  isHumanRequestInterrupt: () => isHumanRequestInterrupt,
   isMemoryCheckpointer: () => isMemoryCheckpointer,
   isTracingEnabled: () => isTracingEnabled,
   map: () => map,
@@ -2961,6 +2974,52 @@ var presets = {
   testing
 };
 
+// src/langgraph/interrupts/utils.ts
+function createHumanRequestInterrupt(request) {
+  return {
+    type: "human_request",
+    id: request.id,
+    createdAt: request.createdAt,
+    data: request
+  };
+}
+function createApprovalRequiredInterrupt(action, description, context) {
+  return {
+    type: "approval_required",
+    id: `approval-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+    createdAt: Date.now(),
+    data: {
+      action,
+      description,
+      context
+    }
+  };
+}
+function createCustomInterrupt(id, data, metadata) {
+  return {
+    type: "custom",
+    id,
+    createdAt: Date.now(),
+    data,
+    metadata
+  };
+}
+function isHumanRequestInterrupt(interrupt) {
+  return interrupt.type === "human_request";
+}
+function isApprovalRequiredInterrupt(interrupt) {
+  return interrupt.type === "approval_required";
+}
+function isCustomInterrupt(interrupt) {
+  return interrupt.type === "custom";
+}
+function getThreadStatus(hasInterrupts, isComplete, hasError) {
+  if (hasError) return "error";
+  if (isComplete) return "completed";
+  if (hasInterrupts) return "interrupted";
+  return "running";
+}
+
 // src/streaming/transformers.ts
 async function* chunk(stream, options) {
   const { size } = options;
@@ -3297,6 +3356,79 @@ ${data}` : data;
   return event.data !== void 0 ? event : null;
 }
 
+// src/streaming/human-in-loop.ts
+function formatHumanRequestEvent(request, threadId) {
+  const data = {
+    type: "human_request",
+    request,
+    threadId
+  };
+  return {
+    event: "human_request",
+    data: JSON.stringify(data),
+    id: request.id
+  };
+}
+function formatHumanResponseEvent(requestId, response, threadId) {
+  const data = {
+    type: "human_response",
+    requestId,
+    response,
+    threadId
+  };
+  return {
+    event: "human_response",
+    data: JSON.stringify(data),
+    id: `response-${requestId}`
+  };
+}
+function formatInterruptEvent(interrupt, threadId) {
+  const data = {
+    type: "interrupt",
+    interrupt,
+    threadId
+  };
+  return {
+    event: "interrupt",
+    data: JSON.stringify(data),
+    id: interrupt.id
+  };
+}
+function formatResumeEvent(interruptId, value, threadId) {
+  const data = {
+    type: "resume",
+    interruptId,
+    value,
+    threadId
+  };
+  return {
+    event: "resume",
+    data: JSON.stringify(data),
+    id: `resume-${interruptId}`
+  };
+}
+function formatAgentWaitingEvent(reason, threadId) {
+  const data = {
+    type: "agent_waiting",
+    reason,
+    threadId
+  };
+  return {
+    event: "agent_waiting",
+    data: JSON.stringify(data)
+  };
+}
+function formatAgentResumedEvent(threadId) {
+  const data = {
+    type: "agent_resumed",
+    threadId
+  };
+  return {
+    event: "agent_resumed",
+    data: JSON.stringify(data)
+  };
+}
+
 // src/streaming/websocket.ts
 function createWebSocketHandler(options) {
   const { onConnect, onMessage, onError, onClose, heartbeat = 0 } = options;
@@ -4160,16 +4292,19 @@ function createCircuitBreaker(options) {
   composeWithOptions,
   conditional,
   configureLangSmith,
+  createApprovalRequiredInterrupt,
   createBatchProcessor,
   createBinaryRouter,
   createCircuitBreaker,
   createConditionalRouter,
   createConnectionPool,
   createConversationConfig,
+  createCustomInterrupt,
   createDatabasePool,
   createErrorReporter,
   createHeartbeat,
   createHttpPool,
+  createHumanRequestInterrupt,
   createLogger,
   createManagedTool,
   createMemoryCheckpointer,
@@ -4194,13 +4329,23 @@ function createCircuitBreaker(options) {
   createWebSocketHandler,
   development,
   filter,
+  formatAgentResumedEvent,
+  formatAgentWaitingEvent,
+  formatHumanRequestEvent,
+  formatHumanResponseEvent,
+  formatInterruptEvent,
+  formatResumeEvent,
   generateThreadId,
   getCheckpointHistory,
   getLangSmithConfig,
   getLatestCheckpoint,
   getMissingDescriptions,
+  getThreadStatus,
   getToolDescription,
   getToolJsonSchema,
+  isApprovalRequiredInterrupt,
+  isCustomInterrupt,
+  isHumanRequestInterrupt,
   isMemoryCheckpointer,
   isTracingEnabled,
   map,

package/dist/index.d.cts

@@ -3695,6 +3695,292 @@ declare const presets: {
     testing: typeof testing;
 };
 
+/**
+ * Types for LangGraph interrupt handling
+ * @module langgraph/interrupts/types
+ */
+/**
+ * Priority level for human requests
+ */
+type HumanRequestPriority = 'low' | 'normal' | 'high' | 'critical';
+/**
+ * Status of a human request
+ */
+type HumanRequestStatus = 'pending' | 'answered' | 'timeout' | 'cancelled';
+/**
+ * Human request stored in state
+ */
+interface HumanRequest {
+    /**
+     * Unique ID for this request
+     */
+    id: string;
+    /**
+     * The question being asked
+     */
+    question: string;
+    /**
+     * Optional context
+     */
+    context?: Record<string, any>;
+    /**
+     * Priority level
+     */
+    priority: HumanRequestPriority;
+    /**
+     * When the request was created
+     */
+    createdAt: number;
+    /**
+     * Timeout in milliseconds (0 = no timeout)
+     */
+    timeout: number;
+    /**
+     * Default response if timeout occurs
+     */
+    defaultResponse?: string;
+    /**
+     * Suggested responses
+     */
+    suggestions?: string[];
+    /**
+     * Current status
+     */
+    status: HumanRequestStatus;
+    /**
+     * The response (if answered)
+     */
+    response?: string;
+    /**
+     * When the response was received
+     */
+    respondedAt?: number;
+}
+/**
+ * Interrupt type - identifies what kind of interrupt occurred
+ */
+type InterruptType = 'human_request' | 'approval_required' | 'custom';
+/**
+ * Interrupt data stored in the checkpoint
+ */
+interface InterruptData {
+    /**
+     * Type of interrupt
+     */
+    type: InterruptType;
+    /**
+     * Unique ID for this interrupt
+     */
+    id: string;
+    /**
+     * When the interrupt was created
+     */
+    createdAt: number;
+    /**
+     * The data associated with this interrupt
+     */
+    data: any;
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Human request interrupt data
+ */
+interface HumanRequestInterrupt extends InterruptData {
+    type: 'human_request';
+    data: HumanRequest;
+}
+/**
+ * Approval required interrupt data
+ */
+interface ApprovalRequiredInterrupt extends InterruptData {
+    type: 'approval_required';
+    data: {
+        action: string;
+        description: string;
+        context?: Record<string, any>;
+    };
+}
+/**
+ * Custom interrupt data
+ */
+interface CustomInterrupt extends InterruptData {
+    type: 'custom';
+    data: any;
+}
+/**
+ * Union type of all interrupt types
+ */
+type AnyInterrupt = HumanRequestInterrupt | ApprovalRequiredInterrupt | CustomInterrupt;
+/**
+ * Resume command for continuing after an interrupt
+ */
+interface ResumeCommand {
+    /**
+     * The response to the interrupt
+     */
+    resume: any;
+    /**
+     * Optional metadata about the response
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Thread status
+ */
+type ThreadStatus = 'running' | 'interrupted' | 'completed' | 'error';
+/**
+ * Thread info with interrupt status
+ */
+interface ThreadInfo {
+    /**
+     * Thread ID
+     */
+    threadId: string;
+    /**
+     * Current status
+     */
+    status: ThreadStatus;
+    /**
+     * Active interrupts (if any)
+     */
+    interrupts?: AnyInterrupt[];
+    /**
+     * Last updated timestamp
+     */
+    updatedAt: number;
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Options for checking interrupt status
+ */
+interface CheckInterruptOptions {
+    /**
+     * Thread ID to check
+     */
+    threadId: string;
+    /**
+     * Filter by interrupt type
+     */
+    type?: InterruptType;
+}
+/**
+ * Options for resuming from an interrupt
+ */
+interface ResumeOptions {
+    /**
+     * Thread ID to resume
+     */
+    threadId: string;
+    /**
+     * Interrupt ID to resume from
+     */
+    interruptId?: string;
+    /**
+     * The response/value to resume with
+     */
+    value: any;
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, any>;
+}
+
+/**
+ * Utilities for working with LangGraph interrupts
+ * @module langgraph/interrupts/utils
+ */
+
+/**
+ * Create a human request interrupt
+ *
+ * @param request - The human request data
+ * @returns A human request interrupt object
+ *
+ * @example
+ * ```typescript
+ * const interrupt = createHumanRequestInterrupt({
+ *   id: 'req-123',
+ *   question: 'Should I proceed?',
+ *   priority: 'high',
+ *   createdAt: Date.now(),
+ *   timeout: 0,
+ *   status: 'pending',
+ * });
+ * ```
+ */
+declare function createHumanRequestInterrupt(request: HumanRequest): HumanRequestInterrupt;
+/**
+ * Create an approval required interrupt
+ *
+ * @param action - The action requiring approval
+ * @param description - Description of the action
+ * @param context - Optional context
+ * @returns An approval required interrupt object
+ *
+ * @example
+ * ```typescript
+ * const interrupt = createApprovalRequiredInterrupt(
+ *   'delete-database',
+ *   'Delete production database',
+ *   { database: 'prod-db-1' }
+ * );
+ * ```
+ */
+declare function createApprovalRequiredInterrupt(action: string, description: string, context?: Record<string, any>): ApprovalRequiredInterrupt;
+/**
+ * Create a custom interrupt
+ *
+ * @param id - Unique ID for the interrupt
+ * @param data - Custom data
+ * @param metadata - Optional metadata
+ * @returns A custom interrupt object
+ *
+ * @example
+ * ```typescript
+ * const interrupt = createCustomInterrupt(
+ *   'custom-123',
+ *   { type: 'review', content: 'Please review this' }
+ * );
+ * ```
+ */
+declare function createCustomInterrupt(id: string, data: any, metadata?: Record<string, any>): CustomInterrupt;
+/**
+ * Check if an interrupt is a human request
+ *
+ * @param interrupt - The interrupt to check
+ * @returns True if the interrupt is a human request
+ */
+declare function isHumanRequestInterrupt(interrupt: AnyInterrupt): interrupt is HumanRequestInterrupt;
+/**
+ * Check if an interrupt is an approval request
+ *
+ * @param interrupt - The interrupt to check
+ * @returns True if the interrupt is an approval request
+ */
+declare function isApprovalRequiredInterrupt(interrupt: AnyInterrupt): interrupt is ApprovalRequiredInterrupt;
+/**
+ * Check if an interrupt is a custom interrupt
+ *
+ * @param interrupt - The interrupt to check
+ * @returns True if the interrupt is a custom interrupt
+ */
+declare function isCustomInterrupt(interrupt: AnyInterrupt): interrupt is CustomInterrupt;
+/**
+ * Get the status of a thread based on its state
+ *
+ * @param hasInterrupts - Whether the thread has active interrupts
+ * @param isComplete - Whether the thread has completed
+ * @param hasError - Whether the thread has an error
+ * @returns The thread status
+ */
+declare function getThreadStatus(hasInterrupts: boolean, isComplete: boolean, hasError: boolean): ThreadStatus;
+
 /**
  * Streaming utilities for LangGraph applications
  * @module streaming
@@ -4020,6 +4306,125 @@ declare function createHeartbeat(): string;
  */
 declare function parseSSEEvent(eventString: string): SSEEvent | null;
 
+/**
+ * SSE utilities for human-in-the-loop workflows
+ * @module streaming/human-in-loop
+ */
+
+/**
+ * Human-in-the-loop SSE event types
+ */
+type HumanInLoopEventType = 'human_request' | 'human_response' | 'interrupt' | 'resume' | 'agent_waiting' | 'agent_resumed';
+/**
+ * Human request SSE event data
+ */
+interface HumanRequestEventData {
+    type: 'human_request';
+    request: HumanRequest;
+    threadId: string;
+}
+/**
+ * Human response SSE event data
+ */
+interface HumanResponseEventData {
+    type: 'human_response';
+    requestId: string;
+    response: string;
+    threadId: string;
+}
+/**
+ * Interrupt SSE event data
+ */
+interface InterruptEventData {
+    type: 'interrupt';
+    interrupt: AnyInterrupt;
+    threadId: string;
+}
+/**
+ * Resume SSE event data
+ */
+interface ResumeEventData {
+    type: 'resume';
+    interruptId: string;
+    value: any;
+    threadId: string;
+}
+/**
+ * Agent waiting SSE event data
+ */
+interface AgentWaitingEventData {
+    type: 'agent_waiting';
+    reason: string;
+    threadId: string;
+}
+/**
+ * Agent resumed SSE event data
+ */
+interface AgentResumedEventData {
+    type: 'agent_resumed';
+    threadId: string;
+}
+/**
+ * Union type of all human-in-the-loop event data
+ */
+type HumanInLoopEventData = HumanRequestEventData | HumanResponseEventData | InterruptEventData | ResumeEventData | AgentWaitingEventData | AgentResumedEventData;
+/**
+ * Format a human request as an SSE event
+ *
+ * @param request - The human request
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ *
+ * @example
+ * ```typescript
+ * const event = formatHumanRequestEvent(humanRequest, 'thread-123');
+ * // Send to client via SSE
+ * res.write(formatSSEEvent(event));
+ * ```
+ */
+declare function formatHumanRequestEvent(request: HumanRequest, threadId: string): SSEEvent;
+/**
+ * Format a human response as an SSE event
+ *
+ * @param requestId - The request ID
+ * @param response - The human's response
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ */
+declare function formatHumanResponseEvent(requestId: string, response: string, threadId: string): SSEEvent;
+/**
+ * Format an interrupt as an SSE event
+ *
+ * @param interrupt - The interrupt data
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ */
+declare function formatInterruptEvent(interrupt: AnyInterrupt, threadId: string): SSEEvent;
+/**
+ * Format a resume event as an SSE event
+ *
+ * @param interruptId - The interrupt ID being resumed
+ * @param value - The resume value
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ */
+declare function formatResumeEvent(interruptId: string, value: any, threadId: string): SSEEvent;
+/**
+ * Format an agent waiting event as an SSE event
+ *
+ * @param reason - Why the agent is waiting
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ */
+declare function formatAgentWaitingEvent(reason: string, threadId: string): SSEEvent;
+/**
+ * Format an agent resumed event as an SSE event
+ *
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ */
+declare function formatAgentResumedEvent(threadId: string): SSEEvent;
+
 /**
  * WebSocket support for bidirectional streaming
  * @module streaming/websocket
@@ -4352,4 +4757,4 @@ declare class CircuitBreaker {
 }
 declare function createCircuitBreaker(options: CircuitBreakerOptions): CircuitBreaker;
 
-export { AgentError, type AggregateNode, type BackoffStrategy, type BatchOptions, BatchProcessor, type BatchProcessorOptions, type BatchStats, type CheckpointHistoryOptions, type CheckpointerOptions, type ChunkOptions, CircuitBreaker, type CircuitBreakerOptions, type CircuitBreakerStats, type CircuitState, type ComposeGraphsOptions, type ComposeOptions, type ComposeToolConfig, type ComposedTool, type ConditionalConfig, type ConditionalRouter, type ConditionalRouterConfig, ConnectionPool, type ConnectionPoolOptions, type ConversationConfig, type DatabaseConfig, type DatabaseConnection, DatabasePool, type DatabasePoolOptions, type DevelopmentPresetOptions, type ErrorContext, type ErrorHandlerOptions, type ErrorReporter, type ErrorReporterOptions, type EventHandler, type ExecutionMetrics, type HealthCheckConfig, type HealthCheckResult, type HttpClient, type HttpConfig, HttpPool, type HttpPoolConfig, type HttpPoolOptions, type HttpResponse, type LangSmithConfig, type LogEntry, LogLevel, type Logger, type LoggerOptions, ManagedTool, type ManagedToolConfig, type ManagedToolStats, MemoryManager, type MemoryManagerOptions, type MemoryStats, type MetricEntry, MetricType, type Metrics, type MetricsNodeOptions, type Middleware, MiddlewareChain, type MiddlewareContext, type MiddlewareFactory, type MiddlewareMetadata, type MiddlewareWithMetadata, MissingDescriptionError, type MockToolConfig, type MockToolResponse, type NodeFunction, type NodeFunctionWithContext, type ParallelNode, type ParallelWorkflowConfig, type ParallelWorkflowOptions, type PoolConfig, type PoolStats, type Priority, type ProductionPresetOptions, type Progress, type ProgressTracker, type ProgressTrackerOptions, type PromptOptions, type ReducerFunction, RegistryEvent, type RequestConfig, type RetryOptions, type RetryPolicy, type RouteCondition, type RouteMap, type RouteName, type SSEEvent, type SSEFormatter, type SSEFormatterOptions, type SequentialNode, type SequentialWorkflowOptions, type SimpleMiddleware, type SqliteCheckpointerOptions, type StateChannelConfig, type SubgraphBuilder, type TestingPresetOptions, type ThreadConfig, type ThrottleOptions, TimeoutError, type TimeoutOptions, type Timer, type Tool, type BackoffStrategy$1 as ToolBackoffStrategy, ToolBuilder, ToolCategory, ToolCategorySchema, type ToolExample, ToolExampleSchema, type ToolExecution, type ToolExecutorConfig, type ToolInvocation, type ToolMetadata, ToolMetadataSchema, ToolNameSchema, ToolRegistry, type ToolRelations, ToolRelationsSchema, type ToolSimulatorConfig, type TracingOptions, type WebSocketHandlerOptions, type WebSocketMessage, batch, broadcast, cache, chain, chunk, clearThread, collect, compose, composeGraphs, composeTool, composeWithOptions, conditional, configureLangSmith, createBatchProcessor, createBinaryRouter, createCircuitBreaker, createConditionalRouter, createConnectionPool, createConversationConfig, createDatabasePool, createErrorReporter, createHeartbeat, createHttpPool, createLogger, createManagedTool, createMemoryCheckpointer, createMemoryManager, createMessage, createMetrics, createMiddlewareContext, createMockTool, createMultiRouter, createParallelWorkflow, createProgressTracker, createSSEFormatter, createSequentialWorkflow, createSqliteCheckpointer, createStateAnnotation, createSubgraph, createThreadConfig, createTool, createToolExecutor, createToolSimulator, createToolUnsafe, createWebSocketHandler, development, filter, generateThreadId, getCheckpointHistory, getLangSmithConfig, getLatestCheckpoint, getMissingDescriptions, getToolDescription, getToolJsonSchema, isMemoryCheckpointer, isTracingEnabled, map, merge, mergeState, parallel, parseSSEEvent, presets, production, reduce, retry, safeValidateSchemaDescriptions, sendMessage, sequential, sequentialBuilder, take, testing, throttle, timeout, toLangChainTool, toLangChainTools, toolBuilder, validateSchemaDescriptions, validateState, validateTool, validateToolMetadata, validateToolName, withErrorHandler, withMetrics, withRetry, withTimeout, withTracing };
+export { AgentError, type AgentResumedEventData, type AgentWaitingEventData, type AggregateNode, type AnyInterrupt, type ApprovalRequiredInterrupt, type BackoffStrategy, type BatchOptions, BatchProcessor, type BatchProcessorOptions, type BatchStats, type CheckInterruptOptions, type CheckpointHistoryOptions, type CheckpointerOptions, type ChunkOptions, CircuitBreaker, type CircuitBreakerOptions, type CircuitBreakerStats, type CircuitState, type ComposeGraphsOptions, type ComposeOptions, type ComposeToolConfig, type ComposedTool, type ConditionalConfig, type ConditionalRouter, type ConditionalRouterConfig, ConnectionPool, type ConnectionPoolOptions, type ConversationConfig, type CustomInterrupt, type DatabaseConfig, type DatabaseConnection, DatabasePool, type DatabasePoolOptions, type DevelopmentPresetOptions, type ErrorContext, type ErrorHandlerOptions, type ErrorReporter, type ErrorReporterOptions, type EventHandler, type ExecutionMetrics, type HealthCheckConfig, type HealthCheckResult, type HttpClient, type HttpConfig, HttpPool, type HttpPoolConfig, type HttpPoolOptions, type HttpResponse, type HumanInLoopEventData, type HumanInLoopEventType, type HumanRequest, type HumanRequestEventData, type HumanRequestInterrupt, type HumanRequestPriority, type HumanRequestStatus, type HumanResponseEventData, type InterruptData, type InterruptEventData, type InterruptType, type LangSmithConfig, type LogEntry, LogLevel, type Logger, type LoggerOptions, ManagedTool, type ManagedToolConfig, type ManagedToolStats, MemoryManager, type MemoryManagerOptions, type MemoryStats, type MetricEntry, MetricType, type Metrics, type MetricsNodeOptions, type Middleware, MiddlewareChain, type MiddlewareContext, type MiddlewareFactory, type MiddlewareMetadata, type MiddlewareWithMetadata, MissingDescriptionError, type MockToolConfig, type MockToolResponse, type NodeFunction, type NodeFunctionWithContext, type ParallelNode, type ParallelWorkflowConfig, type ParallelWorkflowOptions, type PoolConfig, type PoolStats, type Priority, type ProductionPresetOptions, type Progress, type ProgressTracker, type ProgressTrackerOptions, type PromptOptions, type ReducerFunction, RegistryEvent, type RequestConfig, type ResumeCommand, type ResumeEventData, type ResumeOptions, type RetryOptions, type RetryPolicy, type RouteCondition, type RouteMap, type RouteName, type SSEEvent, type SSEFormatter, type SSEFormatterOptions, type SequentialNode, type SequentialWorkflowOptions, type SimpleMiddleware, type SqliteCheckpointerOptions, type StateChannelConfig, type SubgraphBuilder, type TestingPresetOptions, type ThreadConfig, type ThreadInfo, type ThreadStatus, type ThrottleOptions, TimeoutError, type TimeoutOptions, type Timer, type Tool, type BackoffStrategy$1 as ToolBackoffStrategy, ToolBuilder, ToolCategory, ToolCategorySchema, type ToolExample, ToolExampleSchema, type ToolExecution, type ToolExecutorConfig, type ToolInvocation, type ToolMetadata, ToolMetadataSchema, ToolNameSchema, ToolRegistry, type ToolRelations, ToolRelationsSchema, type ToolSimulatorConfig, type TracingOptions, type WebSocketHandlerOptions, type WebSocketMessage, batch, broadcast, cache, chain, chunk, clearThread, collect, compose, composeGraphs, composeTool, composeWithOptions, conditional, configureLangSmith, createApprovalRequiredInterrupt, createBatchProcessor, createBinaryRouter, createCircuitBreaker, createConditionalRouter, createConnectionPool, createConversationConfig, createCustomInterrupt, createDatabasePool, createErrorReporter, createHeartbeat, createHttpPool, createHumanRequestInterrupt, createLogger, createManagedTool, createMemoryCheckpointer, createMemoryManager, createMessage, createMetrics, createMiddlewareContext, createMockTool, createMultiRouter, createParallelWorkflow, createProgressTracker, createSSEFormatter, createSequentialWorkflow, createSqliteCheckpointer, createStateAnnotation, createSubgraph, createThreadConfig, createTool, createToolExecutor, createToolSimulator, createToolUnsafe, createWebSocketHandler, development, filter, formatAgentResumedEvent, formatAgentWaitingEvent, formatHumanRequestEvent, formatHumanResponseEvent, formatInterruptEvent, formatResumeEvent, generateThreadId, getCheckpointHistory, getLangSmithConfig, getLatestCheckpoint, getMissingDescriptions, getThreadStatus, getToolDescription, getToolJsonSchema, isApprovalRequiredInterrupt, isCustomInterrupt, isHumanRequestInterrupt, isMemoryCheckpointer, isTracingEnabled, map, merge, mergeState, parallel, parseSSEEvent, presets, production, reduce, retry, safeValidateSchemaDescriptions, sendMessage, sequential, sequentialBuilder, take, testing, throttle, timeout, toLangChainTool, toLangChainTools, toolBuilder, validateSchemaDescriptions, validateState, validateTool, validateToolMetadata, validateToolName, withErrorHandler, withMetrics, withRetry, withTimeout, withTracing };

package/dist/index.d.ts

@@ -3695,6 +3695,292 @@ declare const presets: {
     testing: typeof testing;
 };
 
+/**
+ * Types for LangGraph interrupt handling
+ * @module langgraph/interrupts/types
+ */
+/**
+ * Priority level for human requests
+ */
+type HumanRequestPriority = 'low' | 'normal' | 'high' | 'critical';
+/**
+ * Status of a human request
+ */
+type HumanRequestStatus = 'pending' | 'answered' | 'timeout' | 'cancelled';
+/**
+ * Human request stored in state
+ */
+interface HumanRequest {
+    /**
+     * Unique ID for this request
+     */
+    id: string;
+    /**
+     * The question being asked
+     */
+    question: string;
+    /**
+     * Optional context
+     */
+    context?: Record<string, any>;
+    /**
+     * Priority level
+     */
+    priority: HumanRequestPriority;
+    /**
+     * When the request was created
+     */
+    createdAt: number;
+    /**
+     * Timeout in milliseconds (0 = no timeout)
+     */
+    timeout: number;
+    /**
+     * Default response if timeout occurs
+     */
+    defaultResponse?: string;
+    /**
+     * Suggested responses
+     */
+    suggestions?: string[];
+    /**
+     * Current status
+     */
+    status: HumanRequestStatus;
+    /**
+     * The response (if answered)
+     */
+    response?: string;
+    /**
+     * When the response was received
+     */
+    respondedAt?: number;
+}
+/**
+ * Interrupt type - identifies what kind of interrupt occurred
+ */
+type InterruptType = 'human_request' | 'approval_required' | 'custom';
+/**
+ * Interrupt data stored in the checkpoint
+ */
+interface InterruptData {
+    /**
+     * Type of interrupt
+     */
+    type: InterruptType;
+    /**
+     * Unique ID for this interrupt
+     */
+    id: string;
+    /**
+     * When the interrupt was created
+     */
+    createdAt: number;
+    /**
+     * The data associated with this interrupt
+     */
+    data: any;
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Human request interrupt data
+ */
+interface HumanRequestInterrupt extends InterruptData {
+    type: 'human_request';
+    data: HumanRequest;
+}
+/**
+ * Approval required interrupt data
+ */
+interface ApprovalRequiredInterrupt extends InterruptData {
+    type: 'approval_required';
+    data: {
+        action: string;
+        description: string;
+        context?: Record<string, any>;
+    };
+}
+/**
+ * Custom interrupt data
+ */
+interface CustomInterrupt extends InterruptData {
+    type: 'custom';
+    data: any;
+}
+/**
+ * Union type of all interrupt types
+ */
+type AnyInterrupt = HumanRequestInterrupt | ApprovalRequiredInterrupt | CustomInterrupt;
+/**
+ * Resume command for continuing after an interrupt
+ */
+interface ResumeCommand {
+    /**
+     * The response to the interrupt
+     */
+    resume: any;
+    /**
+     * Optional metadata about the response
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Thread status
+ */
+type ThreadStatus = 'running' | 'interrupted' | 'completed' | 'error';
+/**
+ * Thread info with interrupt status
+ */
+interface ThreadInfo {
+    /**
+     * Thread ID
+     */
+    threadId: string;
+    /**
+     * Current status
+     */
+    status: ThreadStatus;
+    /**
+     * Active interrupts (if any)
+     */
+    interrupts?: AnyInterrupt[];
+    /**
+     * Last updated timestamp
+     */
+    updatedAt: number;
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Options for checking interrupt status
+ */
+interface CheckInterruptOptions {
+    /**
+     * Thread ID to check
+     */
+    threadId: string;
+    /**
+     * Filter by interrupt type
+     */
+    type?: InterruptType;
+}
+/**
+ * Options for resuming from an interrupt
+ */
+interface ResumeOptions {
+    /**
+     * Thread ID to resume
+     */
+    threadId: string;
+    /**
+     * Interrupt ID to resume from
+     */
+    interruptId?: string;
+    /**
+     * The response/value to resume with
+     */
+    value: any;
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, any>;
+}
+
+/**
+ * Utilities for working with LangGraph interrupts
+ * @module langgraph/interrupts/utils
+ */
+
+/**
+ * Create a human request interrupt
+ *
+ * @param request - The human request data
+ * @returns A human request interrupt object
+ *
+ * @example
+ * ```typescript
+ * const interrupt = createHumanRequestInterrupt({
+ *   id: 'req-123',
+ *   question: 'Should I proceed?',
+ *   priority: 'high',
+ *   createdAt: Date.now(),
+ *   timeout: 0,
+ *   status: 'pending',
+ * });
+ * ```
+ */
+declare function createHumanRequestInterrupt(request: HumanRequest): HumanRequestInterrupt;
+/**
+ * Create an approval required interrupt
+ *
+ * @param action - The action requiring approval
+ * @param description - Description of the action
+ * @param context - Optional context
+ * @returns An approval required interrupt object
+ *
+ * @example
+ * ```typescript
+ * const interrupt = createApprovalRequiredInterrupt(
+ *   'delete-database',
+ *   'Delete production database',
+ *   { database: 'prod-db-1' }
+ * );
+ * ```
+ */
+declare function createApprovalRequiredInterrupt(action: string, description: string, context?: Record<string, any>): ApprovalRequiredInterrupt;
+/**
+ * Create a custom interrupt
+ *
+ * @param id - Unique ID for the interrupt
+ * @param data - Custom data
+ * @param metadata - Optional metadata
+ * @returns A custom interrupt object
+ *
+ * @example
+ * ```typescript
+ * const interrupt = createCustomInterrupt(
+ *   'custom-123',
+ *   { type: 'review', content: 'Please review this' }
+ * );
+ * ```
+ */
+declare function createCustomInterrupt(id: string, data: any, metadata?: Record<string, any>): CustomInterrupt;
+/**
+ * Check if an interrupt is a human request
+ *
+ * @param interrupt - The interrupt to check
+ * @returns True if the interrupt is a human request
+ */
+declare function isHumanRequestInterrupt(interrupt: AnyInterrupt): interrupt is HumanRequestInterrupt;
+/**
+ * Check if an interrupt is an approval request
+ *
+ * @param interrupt - The interrupt to check
+ * @returns True if the interrupt is an approval request
+ */
+declare function isApprovalRequiredInterrupt(interrupt: AnyInterrupt): interrupt is ApprovalRequiredInterrupt;
+/**
+ * Check if an interrupt is a custom interrupt
+ *
+ * @param interrupt - The interrupt to check
+ * @returns True if the interrupt is a custom interrupt
+ */
+declare function isCustomInterrupt(interrupt: AnyInterrupt): interrupt is CustomInterrupt;
+/**
+ * Get the status of a thread based on its state
+ *
+ * @param hasInterrupts - Whether the thread has active interrupts
+ * @param isComplete - Whether the thread has completed
+ * @param hasError - Whether the thread has an error
+ * @returns The thread status
+ */
+declare function getThreadStatus(hasInterrupts: boolean, isComplete: boolean, hasError: boolean): ThreadStatus;
+
 /**
  * Streaming utilities for LangGraph applications
  * @module streaming
@@ -4020,6 +4306,125 @@ declare function createHeartbeat(): string;
  */
 declare function parseSSEEvent(eventString: string): SSEEvent | null;
 
+/**
+ * SSE utilities for human-in-the-loop workflows
+ * @module streaming/human-in-loop
+ */
+
+/**
+ * Human-in-the-loop SSE event types
+ */
+type HumanInLoopEventType = 'human_request' | 'human_response' | 'interrupt' | 'resume' | 'agent_waiting' | 'agent_resumed';
+/**
+ * Human request SSE event data
+ */
+interface HumanRequestEventData {
+    type: 'human_request';
+    request: HumanRequest;
+    threadId: string;
+}
+/**
+ * Human response SSE event data
+ */
+interface HumanResponseEventData {
+    type: 'human_response';
+    requestId: string;
+    response: string;
+    threadId: string;
+}
+/**
+ * Interrupt SSE event data
+ */
+interface InterruptEventData {
+    type: 'interrupt';
+    interrupt: AnyInterrupt;
+    threadId: string;
+}
+/**
+ * Resume SSE event data
+ */
+interface ResumeEventData {
+    type: 'resume';
+    interruptId: string;
+    value: any;
+    threadId: string;
+}
+/**
+ * Agent waiting SSE event data
+ */
+interface AgentWaitingEventData {
+    type: 'agent_waiting';
+    reason: string;
+    threadId: string;
+}
+/**
+ * Agent resumed SSE event data
+ */
+interface AgentResumedEventData {
+    type: 'agent_resumed';
+    threadId: string;
+}
+/**
+ * Union type of all human-in-the-loop event data
+ */
+type HumanInLoopEventData = HumanRequestEventData | HumanResponseEventData | InterruptEventData | ResumeEventData | AgentWaitingEventData | AgentResumedEventData;
+/**
+ * Format a human request as an SSE event
+ *
+ * @param request - The human request
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ *
+ * @example
+ * ```typescript
+ * const event = formatHumanRequestEvent(humanRequest, 'thread-123');
+ * // Send to client via SSE
+ * res.write(formatSSEEvent(event));
+ * ```
+ */
+declare function formatHumanRequestEvent(request: HumanRequest, threadId: string): SSEEvent;
+/**
+ * Format a human response as an SSE event
+ *
+ * @param requestId - The request ID
+ * @param response - The human's response
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ */
+declare function formatHumanResponseEvent(requestId: string, response: string, threadId: string): SSEEvent;
+/**
+ * Format an interrupt as an SSE event
+ *
+ * @param interrupt - The interrupt data
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ */
+declare function formatInterruptEvent(interrupt: AnyInterrupt, threadId: string): SSEEvent;
+/**
+ * Format a resume event as an SSE event
+ *
+ * @param interruptId - The interrupt ID being resumed
+ * @param value - The resume value
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ */
+declare function formatResumeEvent(interruptId: string, value: any, threadId: string): SSEEvent;
+/**
+ * Format an agent waiting event as an SSE event
+ *
+ * @param reason - Why the agent is waiting
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ */
+declare function formatAgentWaitingEvent(reason: string, threadId: string): SSEEvent;
+/**
+ * Format an agent resumed event as an SSE event
+ *
+ * @param threadId - The thread ID
+ * @returns An SSE event
+ */
+declare function formatAgentResumedEvent(threadId: string): SSEEvent;
+
 /**
  * WebSocket support for bidirectional streaming
  * @module streaming/websocket
@@ -4352,4 +4757,4 @@ declare class CircuitBreaker {
 }
 declare function createCircuitBreaker(options: CircuitBreakerOptions): CircuitBreaker;
 
-export { AgentError, type AggregateNode, type BackoffStrategy, type BatchOptions, BatchProcessor, type BatchProcessorOptions, type BatchStats, type CheckpointHistoryOptions, type CheckpointerOptions, type ChunkOptions, CircuitBreaker, type CircuitBreakerOptions, type CircuitBreakerStats, type CircuitState, type ComposeGraphsOptions, type ComposeOptions, type ComposeToolConfig, type ComposedTool, type ConditionalConfig, type ConditionalRouter, type ConditionalRouterConfig, ConnectionPool, type ConnectionPoolOptions, type ConversationConfig, type DatabaseConfig, type DatabaseConnection, DatabasePool, type DatabasePoolOptions, type DevelopmentPresetOptions, type ErrorContext, type ErrorHandlerOptions, type ErrorReporter, type ErrorReporterOptions, type EventHandler, type ExecutionMetrics, type HealthCheckConfig, type HealthCheckResult, type HttpClient, type HttpConfig, HttpPool, type HttpPoolConfig, type HttpPoolOptions, type HttpResponse, type LangSmithConfig, type LogEntry, LogLevel, type Logger, type LoggerOptions, ManagedTool, type ManagedToolConfig, type ManagedToolStats, MemoryManager, type MemoryManagerOptions, type MemoryStats, type MetricEntry, MetricType, type Metrics, type MetricsNodeOptions, type Middleware, MiddlewareChain, type MiddlewareContext, type MiddlewareFactory, type MiddlewareMetadata, type MiddlewareWithMetadata, MissingDescriptionError, type MockToolConfig, type MockToolResponse, type NodeFunction, type NodeFunctionWithContext, type ParallelNode, type ParallelWorkflowConfig, type ParallelWorkflowOptions, type PoolConfig, type PoolStats, type Priority, type ProductionPresetOptions, type Progress, type ProgressTracker, type ProgressTrackerOptions, type PromptOptions, type ReducerFunction, RegistryEvent, type RequestConfig, type RetryOptions, type RetryPolicy, type RouteCondition, type RouteMap, type RouteName, type SSEEvent, type SSEFormatter, type SSEFormatterOptions, type SequentialNode, type SequentialWorkflowOptions, type SimpleMiddleware, type SqliteCheckpointerOptions, type StateChannelConfig, type SubgraphBuilder, type TestingPresetOptions, type ThreadConfig, type ThrottleOptions, TimeoutError, type TimeoutOptions, type Timer, type Tool, type BackoffStrategy$1 as ToolBackoffStrategy, ToolBuilder, ToolCategory, ToolCategorySchema, type ToolExample, ToolExampleSchema, type ToolExecution, type ToolExecutorConfig, type ToolInvocation, type ToolMetadata, ToolMetadataSchema, ToolNameSchema, ToolRegistry, type ToolRelations, ToolRelationsSchema, type ToolSimulatorConfig, type TracingOptions, type WebSocketHandlerOptions, type WebSocketMessage, batch, broadcast, cache, chain, chunk, clearThread, collect, compose, composeGraphs, composeTool, composeWithOptions, conditional, configureLangSmith, createBatchProcessor, createBinaryRouter, createCircuitBreaker, createConditionalRouter, createConnectionPool, createConversationConfig, createDatabasePool, createErrorReporter, createHeartbeat, createHttpPool, createLogger, createManagedTool, createMemoryCheckpointer, createMemoryManager, createMessage, createMetrics, createMiddlewareContext, createMockTool, createMultiRouter, createParallelWorkflow, createProgressTracker, createSSEFormatter, createSequentialWorkflow, createSqliteCheckpointer, createStateAnnotation, createSubgraph, createThreadConfig, createTool, createToolExecutor, createToolSimulator, createToolUnsafe, createWebSocketHandler, development, filter, generateThreadId, getCheckpointHistory, getLangSmithConfig, getLatestCheckpoint, getMissingDescriptions, getToolDescription, getToolJsonSchema, isMemoryCheckpointer, isTracingEnabled, map, merge, mergeState, parallel, parseSSEEvent, presets, production, reduce, retry, safeValidateSchemaDescriptions, sendMessage, sequential, sequentialBuilder, take, testing, throttle, timeout, toLangChainTool, toLangChainTools, toolBuilder, validateSchemaDescriptions, validateState, validateTool, validateToolMetadata, validateToolName, withErrorHandler, withMetrics, withRetry, withTimeout, withTracing };
+export { AgentError, type AgentResumedEventData, type AgentWaitingEventData, type AggregateNode, type AnyInterrupt, type ApprovalRequiredInterrupt, type BackoffStrategy, type BatchOptions, BatchProcessor, type BatchProcessorOptions, type BatchStats, type CheckInterruptOptions, type CheckpointHistoryOptions, type CheckpointerOptions, type ChunkOptions, CircuitBreaker, type CircuitBreakerOptions, type CircuitBreakerStats, type CircuitState, type ComposeGraphsOptions, type ComposeOptions, type ComposeToolConfig, type ComposedTool, type ConditionalConfig, type ConditionalRouter, type ConditionalRouterConfig, ConnectionPool, type ConnectionPoolOptions, type ConversationConfig, type CustomInterrupt, type DatabaseConfig, type DatabaseConnection, DatabasePool, type DatabasePoolOptions, type DevelopmentPresetOptions, type ErrorContext, type ErrorHandlerOptions, type ErrorReporter, type ErrorReporterOptions, type EventHandler, type ExecutionMetrics, type HealthCheckConfig, type HealthCheckResult, type HttpClient, type HttpConfig, HttpPool, type HttpPoolConfig, type HttpPoolOptions, type HttpResponse, type HumanInLoopEventData, type HumanInLoopEventType, type HumanRequest, type HumanRequestEventData, type HumanRequestInterrupt, type HumanRequestPriority, type HumanRequestStatus, type HumanResponseEventData, type InterruptData, type InterruptEventData, type InterruptType, type LangSmithConfig, type LogEntry, LogLevel, type Logger, type LoggerOptions, ManagedTool, type ManagedToolConfig, type ManagedToolStats, MemoryManager, type MemoryManagerOptions, type MemoryStats, type MetricEntry, MetricType, type Metrics, type MetricsNodeOptions, type Middleware, MiddlewareChain, type MiddlewareContext, type MiddlewareFactory, type MiddlewareMetadata, type MiddlewareWithMetadata, MissingDescriptionError, type MockToolConfig, type MockToolResponse, type NodeFunction, type NodeFunctionWithContext, type ParallelNode, type ParallelWorkflowConfig, type ParallelWorkflowOptions, type PoolConfig, type PoolStats, type Priority, type ProductionPresetOptions, type Progress, type ProgressTracker, type ProgressTrackerOptions, type PromptOptions, type ReducerFunction, RegistryEvent, type RequestConfig, type ResumeCommand, type ResumeEventData, type ResumeOptions, type RetryOptions, type RetryPolicy, type RouteCondition, type RouteMap, type RouteName, type SSEEvent, type SSEFormatter, type SSEFormatterOptions, type SequentialNode, type SequentialWorkflowOptions, type SimpleMiddleware, type SqliteCheckpointerOptions, type StateChannelConfig, type SubgraphBuilder, type TestingPresetOptions, type ThreadConfig, type ThreadInfo, type ThreadStatus, type ThrottleOptions, TimeoutError, type TimeoutOptions, type Timer, type Tool, type BackoffStrategy$1 as ToolBackoffStrategy, ToolBuilder, ToolCategory, ToolCategorySchema, type ToolExample, ToolExampleSchema, type ToolExecution, type ToolExecutorConfig, type ToolInvocation, type ToolMetadata, ToolMetadataSchema, ToolNameSchema, ToolRegistry, type ToolRelations, ToolRelationsSchema, type ToolSimulatorConfig, type TracingOptions, type WebSocketHandlerOptions, type WebSocketMessage, batch, broadcast, cache, chain, chunk, clearThread, collect, compose, composeGraphs, composeTool, composeWithOptions, conditional, configureLangSmith, createApprovalRequiredInterrupt, createBatchProcessor, createBinaryRouter, createCircuitBreaker, createConditionalRouter, createConnectionPool, createConversationConfig, createCustomInterrupt, createDatabasePool, createErrorReporter, createHeartbeat, createHttpPool, createHumanRequestInterrupt, createLogger, createManagedTool, createMemoryCheckpointer, createMemoryManager, createMessage, createMetrics, createMiddlewareContext, createMockTool, createMultiRouter, createParallelWorkflow, createProgressTracker, createSSEFormatter, createSequentialWorkflow, createSqliteCheckpointer, createStateAnnotation, createSubgraph, createThreadConfig, createTool, createToolExecutor, createToolSimulator, createToolUnsafe, createWebSocketHandler, development, filter, formatAgentResumedEvent, formatAgentWaitingEvent, formatHumanRequestEvent, formatHumanResponseEvent, formatInterruptEvent, formatResumeEvent, generateThreadId, getCheckpointHistory, getLangSmithConfig, getLatestCheckpoint, getMissingDescriptions, getThreadStatus, getToolDescription, getToolJsonSchema, isApprovalRequiredInterrupt, isCustomInterrupt, isHumanRequestInterrupt, isMemoryCheckpointer, isTracingEnabled, map, merge, mergeState, parallel, parseSSEEvent, presets, production, reduce, retry, safeValidateSchemaDescriptions, sendMessage, sequential, sequentialBuilder, take, testing, throttle, timeout, toLangChainTool, toLangChainTools, toolBuilder, validateSchemaDescriptions, validateState, validateTool, validateToolMetadata, validateToolName, withErrorHandler, withMetrics, withRetry, withTimeout, withTracing };

package/dist/index.js

@@ -2818,6 +2818,52 @@ var presets = {
   testing
 };
 
+// src/langgraph/interrupts/utils.ts
+function createHumanRequestInterrupt(request) {
+  return {
+    type: "human_request",
+    id: request.id,
+    createdAt: request.createdAt,
+    data: request
+  };
+}
+function createApprovalRequiredInterrupt(action, description, context) {
+  return {
+    type: "approval_required",
+    id: `approval-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+    createdAt: Date.now(),
+    data: {
+      action,
+      description,
+      context
+    }
+  };
+}
+function createCustomInterrupt(id, data, metadata) {
+  return {
+    type: "custom",
+    id,
+    createdAt: Date.now(),
+    data,
+    metadata
+  };
+}
+function isHumanRequestInterrupt(interrupt) {
+  return interrupt.type === "human_request";
+}
+function isApprovalRequiredInterrupt(interrupt) {
+  return interrupt.type === "approval_required";
+}
+function isCustomInterrupt(interrupt) {
+  return interrupt.type === "custom";
+}
+function getThreadStatus(hasInterrupts, isComplete, hasError) {
+  if (hasError) return "error";
+  if (isComplete) return "completed";
+  if (hasInterrupts) return "interrupted";
+  return "running";
+}
+
 // src/streaming/transformers.ts
 async function* chunk(stream, options) {
   const { size } = options;
@@ -3154,6 +3200,79 @@ ${data}` : data;
   return event.data !== void 0 ? event : null;
 }
 
+// src/streaming/human-in-loop.ts
+function formatHumanRequestEvent(request, threadId) {
+  const data = {
+    type: "human_request",
+    request,
+    threadId
+  };
+  return {
+    event: "human_request",
+    data: JSON.stringify(data),
+    id: request.id
+  };
+}
+function formatHumanResponseEvent(requestId, response, threadId) {
+  const data = {
+    type: "human_response",
+    requestId,
+    response,
+    threadId
+  };
+  return {
+    event: "human_response",
+    data: JSON.stringify(data),
+    id: `response-${requestId}`
+  };
+}
+function formatInterruptEvent(interrupt, threadId) {
+  const data = {
+    type: "interrupt",
+    interrupt,
+    threadId
+  };
+  return {
+    event: "interrupt",
+    data: JSON.stringify(data),
+    id: interrupt.id
+  };
+}
+function formatResumeEvent(interruptId, value, threadId) {
+  const data = {
+    type: "resume",
+    interruptId,
+    value,
+    threadId
+  };
+  return {
+    event: "resume",
+    data: JSON.stringify(data),
+    id: `resume-${interruptId}`
+  };
+}
+function formatAgentWaitingEvent(reason, threadId) {
+  const data = {
+    type: "agent_waiting",
+    reason,
+    threadId
+  };
+  return {
+    event: "agent_waiting",
+    data: JSON.stringify(data)
+  };
+}
+function formatAgentResumedEvent(threadId) {
+  const data = {
+    type: "agent_resumed",
+    threadId
+  };
+  return {
+    event: "agent_resumed",
+    data: JSON.stringify(data)
+  };
+}
+
 // src/streaming/websocket.ts
 function createWebSocketHandler(options) {
   const { onConnect, onMessage, onError, onClose, heartbeat = 0 } = options;
@@ -4016,16 +4135,19 @@ export {
   composeWithOptions,
   conditional,
   configureLangSmith,
+  createApprovalRequiredInterrupt,
   createBatchProcessor,
   createBinaryRouter,
   createCircuitBreaker,
   createConditionalRouter,
   createConnectionPool,
   createConversationConfig,
+  createCustomInterrupt,
   createDatabasePool,
   createErrorReporter,
   createHeartbeat,
   createHttpPool,
+  createHumanRequestInterrupt,
   createLogger,
   createManagedTool,
   createMemoryCheckpointer,
@@ -4050,13 +4172,23 @@ export {
   createWebSocketHandler,
   development,
   filter,
+  formatAgentResumedEvent,
+  formatAgentWaitingEvent,
+  formatHumanRequestEvent,
+  formatHumanResponseEvent,
+  formatInterruptEvent,
+  formatResumeEvent,
   generateThreadId,
   getCheckpointHistory,
   getLangSmithConfig,
   getLatestCheckpoint,
   getMissingDescriptions,
+  getThreadStatus,
   getToolDescription,
   getToolJsonSchema,
+  isApprovalRequiredInterrupt,
+  isCustomInterrupt,
+  isHumanRequestInterrupt,
   isMemoryCheckpointer,
   isTracingEnabled,
   map,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/core",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Core abstractions for AgentForge - production-ready deep agents framework",
   "type": "module",
   "main": "./dist/index.cjs",