@cuylabs/agent-core 0.9.0 → 0.11.0

package/dist/index.d.ts

@@ -1,83 +1,280 @@
-import { A as AgentConfig, a as Agent } from './index-DQuTZ8xL.js';
-export { b as AgentDiscoveryOptions, c as AgentDiscoveryResult, d as AgentProfile, e as AgentSource, C as CompactionConfig, D as DEFAULT_MAX_CONCURRENT, f as DEFAULT_MAX_SPAWN_DEPTH, g as DEFAULT_SESSION_TITLE_PREFIX, h as DiscoveredProfile, M as MarkdownAgentFrontmatter, i as MarkdownAgentProfile, P as PRUNE_PROTECTED_TOOLS, j as ParsedMarkdownAgent, k as ParsedToolSpec, l as ProfileResolvers, S as SubAgentCompletedResult, m as SubAgentHandle, n as SubAgentStatus, o as SubAgentToolConfig, p as SubAgentTracker, q as SubAgentUsage, T as ToolModifier, r as TracingConfig, s as createAgent, t as createSubAgentTools, u as discoverAgentProfiles, v as getProjectAgentsDir, w as getUserAgentsDir, x as isMarkdownProfile, y as parseAgentFrontmatter, z as parseMarkdownAgent, B as parseToolSpec, E as toAgentProfile } from './index-DQuTZ8xL.js';
-import { LanguageModel, Tool as Tool$1, TelemetrySettings, ModelMessage } from 'ai';
-import { M as Message, T as TokenUsage } from './messages-BYWGn8TY.js';
-export { A as AssistantMessage, a as MessageBase, b as MessageError, c as MessageRole, S as Session, d as SystemMessage, e as ToolMessage, U as UserMessage } from './messages-BYWGn8TY.js';
-import { T as Tool } from './tool-CZWN3KbO.js';
-export { C as CompatibleSchema, I as InferSchemaOutput, d as defineTool } from './tool-CZWN3KbO.js';
-import { T as ToolHost } from './types-CHiPh8U2.js';
-export { D as DirEntry, E as ExecOptions, a as ExecResult, F as FileStat } from './types-CHiPh8U2.js';
-import { M as MiddlewareRunner } from './runner-CI-XeR16.js';
-import { n as InterventionController } from './types-BlOKk-Bb.js';
-export { A as AnyInferenceResult, a as AnyStreamResult, C as CustomStreamProvider, b as CustomStreamResult, D as DEFAULT_MAX_OUTPUT_TOKENS, c as DEFAULT_RETRY_CONFIG, d as InferenceCustomResult, e as InferenceStepInfo, I as InferenceStreamInput, f as InferenceStreamResult, L as LLMStreamInput, g as LLMStreamResult, O as OUTPUT_TOKEN_MAX, o as OnInterventionApplied, P as PendingIntervention, R as RetryConfig, h as RetryHandlerOptions, i as RetryState, S as StepInfo, T as ToolExecutionMode, j as calculateDelay, k as createRetryHandler, l as createRetryState, s as shouldRetry, m as sleep, w as withRetry } from './types-BlOKk-Bb.js';
+import { H as HumanInputController, p as HumanInputConfig, T as Tool, M as Message, S as SessionManager, E as EffectiveAgentConfig, q as TurnChangeTracker, r as InterventionController, b as MiddlewareRunner, P as PromptBuilder, c as ToolExecutionMode, A as AgentEvent, t as StreamProvider, u as Scope, v as ScopeSnapshot, x as ScopeOptions, F as FileOperationMeta, y as AgentSignal, z as TypedHandler, U as Unsubscribe, W as WildcardHandler } from './instance-DzPiv6EK.js';
+export { B as Agent, C as AgentConfig, G as AgentDefaults, J as AgentDefaultsContext, K as AgentDefaultsProvider, L as AgentMiddleware, N as AgentModelHooks, O as AgentStatus, Q as AgentTurnActiveToolCall, V as AgentTurnBoundaryKind, X as AgentTurnBoundaryMetadata, Y as AgentTurnBoundarySnapshot, Z as AgentTurnCommitApplier, _ as AgentTurnCommitBatch, $ as AgentTurnCommitOptions, a0 as AgentTurnEngine, a1 as AgentTurnEngineOptions, a2 as AgentTurnPhase, a3 as AgentTurnResolvedToolCall, a4 as AgentTurnState, a5 as AgentTurnStateAdvanceOptions, a6 as AgentTurnStepCommitSnapshot, a7 as AgentTurnStepCommitToolCall, a8 as AgentTurnStepCommitToolResult, a9 as AgentTurnStepRuntimeConfig, e as AnyInferenceResult, aa as AppliedProfile, ab as ApprovalAction, ac as ApprovalAgentMiddleware, ad as ApprovalCascadeMode, ae as ApprovalCascadePolicy, af as ApprovalConfig, ag as ApprovalCorrection, ah as ApprovalDecision, ai as ApprovalEvaluation, aj as ApprovalEvent, ak as ApprovalHandler, al as ApprovalMiddlewareConfig, am as ApprovalRememberScope, an as ApprovalRequest, ao as ApprovalResolution, ap as ApprovalRule, aq as ApprovalRuleContext, ar as AssistantMessage, as as BlockedModelCall, at as BranchEntry, au as ChatLifecycleContext, av as CommitOutputOptions, aw as CommitStepOptions, ax as CompactionConfig, ay as CompactionEntry, az as CompatibleSchema, aA as ConfigChangeEntry, aB as CoordinatorNotification, aC as CoordinatorNotificationKind, aD as CoordinatorRoundEvent, aE as CreateAgentTurnStateOptions, aF as CreateAgentTurnStepCommitBatchOptions, aG as CreateSessionOptions, aH as DEFAULT_AGENT_NAME, aI as DEFAULT_DISPATCH_TOOL_IDS, aJ as DEFAULT_LOCAL_DISPATCH_CONCURRENCY, aK as DEFAULT_LOCAL_DISPATCH_DEPTH, aL as DEFAULT_LOCAL_DISPATCH_TITLE_PREFIX, D as DEFAULT_MAX_OUTPUT_TOKENS, aM as DEFAULT_MAX_STEPS, D as DEFAULT_MAX_TOKENS, f as DEFAULT_RETRY_CONFIG, aN as DEFAULT_SYSTEM_PROMPT, aO as DISPATCH_STATES, aP as DispatchCheckOptions, aQ as DispatchListOptions, aR as DispatchRecord, aS as DispatchResult, aT as DispatchRole, aU as DispatchRuntime, aV as DispatchStartInput, aW as DispatchState, aX as DispatchTarget, aY as DispatchTargetInspection, aZ as DispatchTargetStartInput, a_ as DispatchTargetStartResult, a$ as DispatchTargetSummary, b0 as DispatchUsage, b1 as DoomLoopAction, b2 as DoomLoopHandler, b3 as DoomLoopRequest, b4 as EnhancedTools, b5 as EntryBase, b6 as EnvironmentInfo, b7 as ExternalTaskControl, b8 as FileEntry, b9 as GuidancePayload, ba as HumanInputEventContext, bb as HumanInputOption, bc as HumanInputRequest, bd as HumanInputRequestKind, be as HumanInputRequestListOptions, bf as HumanInputRequestRecord, bg as HumanInputRequestStatus, bh as HumanInputResponse, bi as HumanInputTimeoutError, bj as HumanInputToolArgs, bk as HumanInputUnavailableError, bl as IdleNotificationPayload, bm as InMemoryMailboxStore, bn as InMemoryTaskBoardStore, bo as InferSchemaOutput, g as InferenceCustomResult, h as InferenceStepInfo, I as InferenceStreamInput, i as InferenceStreamResult, bp as InputCheckResult, bq as InstructionFile, br as LocalDispatchRuntimeOptions, bs as Mailbox, bt as MailboxStore, bu as MailboxSubscriber, bv as MemberRegisteredEvent, bw as MemberRuntime, bx as MemberStats, by as MemberStatus, bz as MemberStatusChangedEvent, bA as MessageBase, bB as MessageEntry, bC as MessageError, bD as MessageInput, bE as MessageKind, bF as MessageListFilter, bG as MessagePayload, bH as MessageRole, bI as MessageSentEvent, bJ as MetadataEntry, d as ModelCallContext, bK as ModelCallInput, bL as ModelCallOutput, bM as ModelFamily, bN as NormalizedToolReplayPolicy, bO as NotificationPriority, bP as OnFollowUpQueued, bQ as OnInterventionApplied, bR as OtelMiddlewareConfig, bS as PRUNE_PROTECTED_TOOLS, bT as PendingIntervention, bU as PermissionForwardedEvent, bV as PermissionHandler, bW as PermissionRequestPayload, bX as PermissionResolvedEvent, bY as PermissionResponsePayload, bZ as PlanCreatedEvent, b_ as PlannedTask, b$ as PrepareModelStepOptions, c0 as PreparedAgentModelStep, c1 as PreparedExternalTask, c2 as Profile, c3 as PromptBuildContext, c4 as PromptConfig, c5 as PromptSection, c6 as QueueTaskInput, c7 as RemoteSkillEntry, c8 as RemoteSkillIndex, R as RetryConfig, j as RetryHandlerOptions, k as RetryState, c9 as RiskLevel, ca as RuleSource, cb as RunModelStepOptions, cc as RunToolBatchOptions, cd as RunToolBatchResult, ce as STORAGE_VERSION, cf as SerializedMessage, cg as Session, ch as SessionContext, ci as SessionEntry, cj as SessionHeader, ck as SessionInfo, cl as SessionStorage, cm as ShutdownRequestPayload, cn as ShutdownRequestedEvent, co as ShutdownResolvedEvent, cp as ShutdownResponsePayload, cq as SkillConfig, cr as SkillContent, cs as SkillDiscoveryError, ct as SkillDiscoveryResult, cu as SkillMetadata, cv as SkillRegistry, cw as SkillResource, cx as SkillResourceType, cy as SkillScope, cz as SkillSource, cA as SkillSourceType, cB as StepProcessingOptions, cC as StepProcessingOutput, cD as StepProcessingResult, cE as StreamChunk, cF as StreamInput, cG as StreamProviderConfig, cH as StreamProviderFactory, cI as StreamProviderInput, cJ as StreamProviderResult, cK as SynthesisCompleteEvent, cL as SynthesisResult, cM as SystemMessage, cN as TERMINAL_STATUSES, cO as TaskAbortedEvent, cP as TaskBoard, cQ as TaskBoardStore, cR as TaskCompletedEvent, cS as TaskCompletion, cT as TaskConflictError, cU as TaskCreateInput, cV as TaskCreatedEvent, cW as TaskDispatchMode, cX as TaskExecutor, cY as TaskExecutorInput, cZ as TaskFailedEvent, c_ as TaskListFilter, c$ as TaskResult, d0 as TaskStatus, d1 as TaskTransition, d2 as TaskTransitionEvent, d3 as TaskTransitionReason, d4 as TeamCoordinatorConfig, d5 as TeamEvent, d6 as TeamMember, d7 as TeamMessage, d8 as TeamNotificationEvent, d9 as TeamPlan, da as TeamSnapshot, db as TeamStartedEvent, dc as TeamStoppedEvent, dd as TeamTask, de as TelemetryConfig, df as TelemetryConfigResult, dg as TokenUsage, dh as ToolCallDecision, di as ToolCallOutput, dj as ToolCapabilities, dk as ToolContext, dl as ToolHostRequirements, dm as ToolMessage, dn as ToolMetadata, dp as ToolReplayMode, dq as ToolReplayPolicy, dr as ToolResult, ds as ToolSideEffectLevel, dt as TracingConfig, a as TurnTrackerContext, du as UndoResult, dv as UserMessage, dw as WorkerReportPayload, dx as accumulateUsage, dy as advanceAgentTurnState, dz as approvalMiddleware, dA as buildCoordinatorNotificationEvent, l as calculateDelay, dB as createAgent, dC as createAgentTurnEngine, dD as createAgentTurnState, dE as createApprovalHandler, dF as createHumanInputController, dG as createPromptBuilder, m as createRetryHandler, n as createRetryState, dH as createSkillRegistry, dI as createTurnTracker, dJ as emptySkillRegistry, dK as failAgentTurnState, dL as getRequiredToolHost, dM as isApprovalMiddleware, dN as isBlockedModelCall, dO as isHumanInputController, dP as requiresToolHost, dQ as resolveAgentDefaults, dR as resolveCapability, dS as sandboxDefaultsProvider, s as shouldRetry, w as withRetry } from './instance-DzPiv6EK.js';
+import { LanguageModel, ModelMessage, Tool as Tool$1, TelemetrySettings } from 'ai';
+import { T as ToolHost } from './types-C_LCeYNg.js';
+export { D as DirEntry, E as ExecOptions, a as ExecResult, F as FileStat } from './types-C_LCeYNg.js';
+import { L as Logger } from './types-RSCv7nQ4.js';
+export { C as ConsoleLoggerOptions, F as FileLoggerOptions, a as LogLevel, b as LogMeta } from './types-RSCv7nQ4.js';
 import { R as ReasoningLevel } from './types-CQaXbRsS.js';
 export { E as EXTENDED_LEVELS, F as FIXED_LEVELS, a as ReasoningConfig, S as STANDARD_LEVELS, s as shouldIncludeReasoningSummary } from './types-CQaXbRsS.js';
-import { ContextManager } from './context/index.js';
-export { ContextLimits, DEFAULT_CONTEXT_LIMITS, PruneContextOptions, PruneResult, SummarizationOptions, estimateConversationTokens, estimateMessageTokens, estimateTokens, findCutPoint, generateSummary, isContextOverflowing, pruneContext, pruneToolResults, shouldPruneContext } from './context/index.js';
-import { T as TurnChangeTracker } from './tracker-DClqYqTj.js';
-export { F as FileBaseline, a as TurnFileChange, b as TurnSummary, c as TurnTrackerConfig, U as UndoResult, d as createTurnTracker } from './tracker-DClqYqTj.js';
-import { P as PromptBuilder } from './builder-BgZ_j4Vs.js';
-export { c as createPromptBuilder } from './builder-BgZ_j4Vs.js';
-import { S as SessionManager } from './session-manager-KbYt2WUh.js';
-export { B as BranchEntry, C as CompactionEntry, a as ConfigChangeEntry, b as CreateSessionOptions, E as EntryBase, F as FileEntry, M as MessageEntry, c as MetadataEntry, d as STORAGE_VERSION, e as SerializedMessage, f as SessionContext, g as SessionEntry, h as SessionHeader, i as SessionInfo, j as SessionStorage } from './session-manager-KbYt2WUh.js';
-import { A as AgentEvent } from './events-CE72w8W4.js';
-export { a as AgentStatus, b as AgentTurnBoundaryKind, c as ApprovalEvent, P as ProcessorResult, S as StepProcessingResult, d as StreamInput } from './events-CE72w8W4.js';
-import { f as StreamProvider, E as EnhancedTools } from './types-DTSkxakL.js';
-export { A as AgentMiddleware, g as AgentModelHooks, B as BlockedModelCall, h as EnvironmentInfo, I as InstructionFile, a as ModelCallContext, M as ModelCallInput, b as ModelCallOutput, e as ModelFamily, P as PromptBuildContext, d as PromptConfig, c as PromptSection, S as StreamChunk, i as StreamProviderConfig, j as StreamProviderFactory, k as StreamProviderInput, l as StreamProviderResult, T as ToolCallDecision } from './types-DTSkxakL.js';
-export { A as AgentTurnActiveToolCall, a as AgentTurnBoundaryMetadata, b as AgentTurnBoundarySnapshot, c as AgentTurnCommitApplier, d as AgentTurnCommitBatch, e as AgentTurnCommitOptions, f as AgentTurnEngine, g as AgentTurnEngineOptions, h as AgentTurnPhase, i as AgentTurnResolvedToolCall, j as AgentTurnState, k as AgentTurnStateAdvanceOptions, l as AgentTurnStepCommitSnapshot, m as AgentTurnStepCommitToolCall, n as AgentTurnStepCommitToolResult, o as AgentTurnStepRuntimeConfig, C as CommitOutputOptions, p as CommitStepOptions, q as CreateAgentTurnStateOptions, r as CreateAgentTurnStepCommitBatchOptions, D as DoomLoopAction, s as DoomLoopHandler, t as DoomLoopRequest, P as PrepareModelStepOptions, u as PreparedAgentModelStep, v as ProcessorOptions, w as ProcessorOutput, R as RunModelStepOptions, x as RunToolBatchOptions, y as RunToolBatchResult, S as StepProcessingOptions, z as StepProcessingOutput, B as advanceAgentTurnState, E as createAgentTurnEngine, F as createAgentTurnState, G as failAgentTurnState } from './types-DmDwi2zI.js';
-export { ExecuteAgentToolCallOptions, ExecuteAgentToolCallResult, MAX_BYTES, MAX_LINES, TRUNCATE_DIR, TRUNCATE_GLOB, ToolRegistry, ToolSpec, TruncateResult, defaultRegistry, executeAgentToolCall, formatSize, normalizeToolReplayPolicy, truncateOutput } from './tool/index.js';
-export { AdapterSettings, CacheCapabilitySource, CapabilityCache, CapabilityOverrides, Directory, EngineSpec, ModelCapabilityResolver, Directory as ModelDirectory, Resolver as ModelResolver, ModelSpec, NetworkStatus, PatternCapabilitySource, RemoteCapabilityFetcher, RemoteCapabilitySource, ResolutionResult, Resolver, applyCapabilityOverride, configureResolver, createResolver, extractModelId, extractProvider, findCapabilityOverride, getDefaultResolver, getModelId, getNetworkStatus, getProviderCompatibility, getProviderId, inferContextWindow, inferProvider, likelySupportsReasoning } from './models/index.js';
+export { ExecuteAgentToolCallOptions, ExecuteAgentToolCallResult, MAX_BYTES, MAX_LINES, ToolRegistry, ToolSearchOptions, ToolSpec, TruncateResult, createToolSearchTool, defaultRegistry, executeAgentToolCall, normalizeToolReplayPolicy, truncateOutput } from './tool/index.js';
+export { ToolHostProvider, ToolHostProviderSummary, ToolHostRegistry, defaultToolHostRegistry, localHost } from './tool/host/index.js';
+export { AdapterSettings, CacheCapabilitySource, CapabilityCache, CapabilityOverrides, Directory, EngineSpec, ModelCapabilityResolver, ModelSpec, NetworkStatus, PatternCapabilitySource, RemoteCapabilityFetcher, RemoteCapabilitySource, ResolutionResult, Resolver, applyCapabilityOverride, configureResolver, createResolver, extractModelId, extractProvider, findCapabilityOverride, getDefaultResolver, getModelId, getNetworkStatus, getProviderCompatibility, getProviderId, inferContextWindow, inferProvider, likelySupportsReasoning } from './models/index.js';
 export { C as CapabilitySource, D as DEFAULT_RESOLVER_OPTIONS, I as InputModality, M as ModelCapabilities, a as ModelEntry, O as OutputModality, P as ProviderCompatibility, R as ResolverOptions, S as SourcePriority, b as SourceResult, c as buildAnthropicOptions, d as buildBedrockOptions, e as buildGoogleOptions, f as buildGroqOptions, g as buildOpenAIOptions, h as buildOpenRouterOptions, i as buildReasoningOptions, j as buildReasoningOptionsSync, k as buildXAIOptions, l as getProviderOptionsKey, m as getReasoningConfig, n as getReasoningConfigSync, s as supportsReasoning, o as supportsReasoningSync } from './index-BCqEGzBj.js';
-export { H as HttpTransportConfig, M as MCPConfig, a as MCPManager, b as MCPPrompt, c as MCPResource, d as MCPServerConfig, e as MCPServerStatus, S as SseTransportConfig, f as StdioTransportConfig } from './types-VQgymC1N.js';
-export { createMCPManager, defineServer, httpServer, sseServer, stdioServer } from './mcp/index.js';
-export { AgentTaskChatAdapter, AgentTaskCheckpointReason, AgentTaskCheckpointStrategy, AgentTaskCheckpointStrategyInput, AgentTaskExecutionCheckpoint, AgentTaskExecutionContext, AgentTaskExecutionRun, AgentTaskExecutionSnapshot, AgentTaskObserver, AgentTaskPayload, AgentTaskResult, AgentTaskRunner, AgentTaskRunnerOptions, AgentWorkflowAssistantMessageSnapshot, AgentWorkflowCommitResult, AgentWorkflowMessageSnapshot, AgentWorkflowModelStepPlan, AgentWorkflowModelStepResult, AgentWorkflowOperationPlan, AgentWorkflowOutputCommitPlan, AgentWorkflowReplayDecision, AgentWorkflowStepCommitPlan, AgentWorkflowSystemMessageSnapshot, AgentWorkflowToolBatchResult, AgentWorkflowToolCallPlan, AgentWorkflowToolCallResult, AgentWorkflowToolCallSnapshot, AgentWorkflowToolMessageSnapshot, AgentWorkflowTurnPhase, AgentWorkflowTurnState, AgentWorkflowUserMessageSnapshot, ContextOverflowError, CreateAgentWorkflowTurnStateOptions, DoomLoopError, applyAgentWorkflowCommitResult, applyAgentWorkflowModelStepResult, applyAgentWorkflowToolBatchResult, applyAgentWorkflowToolCallResult, cloneAgentWorkflowTurnState, commitOutput, commitStep, convertAgentMessagesToModelMessages, createAgentTaskRunner, createAgentTurnStepCommitBatch, createAgentWorkflowTurnState, defaultAgentTaskCheckpointStrategy, failAgentWorkflowTurnState, planNextAgentWorkflowOperation, prepareModelStep, processStepStream, processStream, recordAgentWorkflowReplayDecision, restoreAgentWorkflowMessage, restoreAgentWorkflowMessages, runModelStep, runToolBatch, snapshotAgentWorkflowMessage, snapshotAgentWorkflowMessages } from './runtime/index.js';
-export { ApprovalMiddlewareConfig, CacheTTL, OtelMiddlewareConfig, PromptCacheConfig, TelemetryConfig, TelemetryConfigResult, approvalMiddleware, createTelemetryConfig, otelMiddleware, promptCacheMiddleware } from './middleware/index.js';
+export { H as HttpTransportConfig, M as MCPConfig, a as MCPManager, b as MCPServerConfig, c as MCPServerStatus, R as RemoteTransportConfig, S as SseTransportConfig, d as StdioTransportConfig } from './types-Bj_J8u_W.js';
+export { createMCPManager, httpServer, sseServer, stdioServer } from './mcp/index.js';
+export { AgentTaskChatAdapter, AgentTaskCheckpointReason, AgentTaskCheckpointStrategy, AgentTaskCheckpointStrategyInput, AgentTaskExecutionCheckpoint, AgentTaskExecutionContext, AgentTaskExecutionRun, AgentTaskExecutionSnapshot, AgentTaskObserver, AgentTaskPayload, AgentTaskResult, AgentTaskResumeSnapshot, AgentTaskRunner, AgentTaskRunnerOptions, AgentWorkflowAssistantMessageSnapshot, AgentWorkflowCommitResult, AgentWorkflowInputCommitPlan, AgentWorkflowInterventionSnapshot, AgentWorkflowMessageSnapshot, AgentWorkflowModelStepPlan, AgentWorkflowModelStepResult, AgentWorkflowOperationPlan, AgentWorkflowOutputCommitPlan, AgentWorkflowReplayDecision, AgentWorkflowStepCommitPlan, AgentWorkflowSystemMessageSnapshot, AgentWorkflowToolBatchPlan, AgentWorkflowToolBatchResult, AgentWorkflowToolCallPlan, AgentWorkflowToolCallResult, AgentWorkflowToolCallSnapshot, AgentWorkflowToolMessageSnapshot, AgentWorkflowTurnPhase, AgentWorkflowTurnState, AgentWorkflowUserMessageSnapshot, ContextOverflowError, CreateAgentWorkflowTurnStateOptions, DoomLoopError, applyAgentWorkflowCommitResult, applyAgentWorkflowModelStepResult, applyAgentWorkflowToolBatchResult, applyAgentWorkflowToolCallResult, applyWorkflowInterventions, cloneAgentWorkflowTurnState, commitOutput, commitStep, createAgentTaskRunner, createAgentTurnStepCommitBatch, createAgentWorkflowTurnState, defaultAgentTaskCheckpointStrategy, drainWorkflowInterventions, failAgentWorkflowTurnState, planNextAgentWorkflowOperation, prepareModelStep, processStepStream, queueWorkflowFollowUps, recordAgentWorkflowReplayDecision, restoreAgentWorkflowMessage, restoreAgentWorkflowMessages, runModelStep, runToolBatch, snapshotAgentWorkflowMessage, snapshotAgentWorkflowMessages } from './execution/index.js';
+export { c as convertAgentMessagesToModelMessages } from './model-messages-CJfwfzGe.js';
+export { CacheTTL, PromptCacheConfig, createTelemetryConfig, otelMiddleware, promptCacheMiddleware } from './middleware/index.js';
 export { DEFAULT_INSTRUCTION_PATTERNS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_FILE_SIZE, PRIORITY_BASE, PRIORITY_CUSTOM, PRIORITY_ENVIRONMENT, PRIORITY_INSTRUCTIONS, PRIORITY_OVERRIDE, PRIORITY_SKILLS, detectModelFamily, discoverInstructions, formatEnvironment, formatInstructions, gatherEnvironment, getAvailableFamilies, getTemplate, loadGlobalInstructions, summarizeEnvironment } from './prompt/index.js';
-export { R as RemoteSkillEntry, e as RemoteSkillIndex, d as SkillConfig, b as SkillContent, f as SkillDiscoveryError, S as SkillDiscoveryResult, a as SkillMetadata, c as SkillResource, g as SkillResourceType, h as SkillScope, i as SkillSource, j as SkillSourceType } from './types-BfNpU8NS.js';
-export { A as AppliedPreset, P as Preset } from './types-BlZwmnuW.js';
-export { Presets, applyPreset, careful, code, createPreset, explore, filterTools, mergePresets, plan, quick, review, watch } from './presets/index.js';
-export { DockerHostOptions, dockerHost, localHost } from './host/index.js';
-export { a as Scope, b as ScopeAttributeValue, c as ScopeAttributes, d as ScopeKind, e as ScopeOptions, S as ScopeSnapshot } from './types-CQL-SvTn.js';
-export { createScope, currentScope, restoreScope, snapshotScope, withinScope } from './scope/index.js';
-export { Inference, LLM, buildToolSet, stream, streamOnce, streamStep } from './inference/index.js';
+export { Profiles, applyProfile, careful, code, createProfile, explore, filterTools, mergeProfiles, plan, quick, review, watch } from './profiles/index.js';
+export { SandboxPreview, SandboxProvider, SandboxSession, SandboxSessionMetadata, SandboxSnapshotResult } from './sandbox/index.js';
+export { Inference, buildModelCallContext, buildToolSet, stream, streamOnce, streamStep } from './inference/index.js';
 export { FileStorage, FileStorageOptions, MemoryStorage, buildEntryPath, buildMessagesFromEntries, configureDefaultSessionManager, createMessageEntry, createMetadataEntry, deserializeMessage, extractSessionInfo, generateEntryId, getDataDir, getDefaultSessionManager, getGitRootHash, getLeafId, getProjectId, getProjectSessionsDir, getSessionsDir, parseJSONL, serializeMessage, toJSONL, toJSONLBatch } from './storage/index.js';
-export { ChangeSet, Checkpoint, CheckpointConfig, CheckpointManager, FileChange, TrackedToolMetadata, clearCheckpoints, createCheckpointManager, extractFilePathsFromArgs, shouldCaptureBaseline, withFileTracking } from './tracking/index.js';
-export { A as ApprovalAction, a as ApprovalConfig, b as ApprovalRequest, c as ApprovalRule, R as RiskLevel } from './types-CWm-7rvB.js';
-export { ApprovalDeniedError, ApprovalHandler, ApprovalTimeoutError, createApprovalHandler, getToolRisk } from './safety/index.js';
+export { ApprovalDeniedError, ApprovalPolicyPresetName, ApprovalPolicyPresetOptions, ApprovalRuleCondition, ApprovalTimeoutError, RiskTierApprovalPolicyOptions, ThresholdApprovalRuleOptions, TrustedSessionApprovalPolicyOptions, allApprovalConditions, anyApprovalConditions, approvalRequestsOverlap, buildApprovalRuleContext, createApprovalCorrection, createApprovalPolicyPreset, createConditionalApprovalRule, createDangerouslyAllowAllApprovalPolicy, createHeadlessDenyApprovalPolicy, createInteractiveApprovalPolicy, createRememberedApprovalRules, createRiskTierApprovalPolicy, createThresholdApprovalRule, createTrustedSessionApprovalPolicy, describeApprovalOperation, extractApprovalPatterns, formatApprovalDeniedReason, getToolRisk, matchApprovalArgValue, matchApprovalNumericArg, matchApprovalPattern, matchApprovalRisks, matchApprovalSessions, matchApprovalStringPrefixes, normalizeApprovalCascadePolicy, normalizeRememberScopes, selectRememberScope, shouldCascadeApprovalDecision } from './safety/index.js';
 export { E as ErrorCategory, L as LLMError, a as LLMErrorOptions, R as ResponseHeaders } from './llm-error-D93FNNLY.js';
 export { getErrorCategory, getRetryDelay, isRetryable, isRetryableCategory, parseRetryDelay } from './inference/errors/index.js';
 export { DEFAULT_EXTERNAL_DIRS, DEFAULT_MAX_SCAN_DEPTH, DEFAULT_SKILL_MAX_SIZE, SKILL_FILENAME, createSkillResourceTool, createSkillTool, createSkillTools, discoverSkills, inferResourceType, loadResourceContent, loadSkillContent, loadSkillMetadata, parseFrontmatter } from './skill/index.js';
-export { S as SkillRegistry, c as createSkillRegistry, e as emptySkillRegistry } from './registry-DwYqsQkX.js';
-export { A as AgentSignal, E as EventOf, T as TypedHandler, U as Unsubscribe, W as WildcardHandler } from './types-YuWV4ag7.js';
-export { LocalSignal } from './signal/index.js';
-export { DefinePluginInit, DiscoveredPlugin, LayeredSettings, NullSettings, PluginActivateContext, PluginCommand, PluginCompatibility, PluginContext, PluginContributions, PluginDefinition, PluginEventBus, PluginEventBusAPI, PluginEventHandler, PluginInit, PluginLifecycleHooks, PluginLoaderOptions, PluginManifest, PluginRegistry, PluginRegistryCompatibilityOptions, PluginRegistryOptions, PluginRegistryTimeoutOptions, PluginSessionContext, PluginSettingsDefinition, PluginSettingsProvider, PluginSettingsSchema, PluginUnsubscribe, StaticSettings, ValidatedSettings, definePlugin, discoverPlugins, getPluginLoader, isDefinedPlugin, loadPluginModule, resetFrameworkAliases, resetPluginLoader, resolveFrameworkAliases } from './plugin/index.js';
-export { F as FileOperationMeta, N as NormalizedToolReplayPolicy, T as ToolContext, a as ToolMetadata, e as ToolReplayMode, b as ToolReplayPolicy, c as ToolResult, f as ToolSideEffectLevel, d as TurnTrackerContext } from './tool-DkhSCV2Y.js';
+export { CompositeDispatchTaskExecutorOptions, DispatchExternalTaskControlOptions, DispatchTaskExecutorOptions, DispatchTaskExecutorRoute, RuntimeDispatchExecutorOptions, RuntimeDispatchTargetOptions, createCompositeDispatchTaskExecutor, createDispatchExternalTaskControl, createDispatchTaskExecutor, createDispatchTools, createLocalDispatchRuntime, createRuntimeDispatchExecutor, createRuntimeDispatchTargets, ensureNonEmpty, mergeInspection } from './dispatch/index.js';
+export { DEFAULT_SUBAGENT_CONCURRENCY, DEFAULT_SUBAGENT_DEPTH, DEFAULT_SUBAGENT_SESSION_PREFIX, DiscoveredSubAgentRole, LOCAL_SUBAGENT_BACKEND, MarkdownSubAgentRole, MarkdownSubAgentRoleFrontmatter, ParsedMarkdownSubAgentRole, ParsedSubAgentToolSpec, SUBAGENT_TOOL_IDS, SubAgentCompletedResult, SubAgentConfig, SubAgentRole, SubAgentRoleDiscoveryOptions, SubAgentRoleDiscoveryResult, SubAgentRoleResolvers, SubAgentRoleSource, SubAgentToolModifier, SubAgentToolsOptions, clearInstalledSubAgents, configureSubAgents, createCloseAgentTool, createInvokeAgentTool, createSubAgentTools, createWaitAgentTool, discoverSubAgentRoles, formatAsyncSpawnedResult, formatCancelledAgentResult, formatCloseAlreadyResolvedResult, formatCloseMissingAgentResult, formatInvalidAgentTypeResult, formatMissingAgentsResult, formatSpawnBlockedResult, formatSyncSubAgentErrorResult, formatSyncSubAgentResult, formatWaitErrorResult, formatWaitResult, formatWaitTimeoutResult, getConfiguredSubAgents, getInstalledSubAgentBackend, getProjectSubAgentRolesDir, getUserSubAgentRolesDir, installLocalSubAgents, installSubAgentTools, isMarkdownSubAgentRole, parseMarkdownSubAgentRole, parseSubAgentRoleFrontmatter, parseSubAgentToolSpec, toSubAgentRole } from './subagents/index.js';
+export { DefinePluginInit, DiscoveredPlugin, LayeredSettings, NullSettings, PluginActivateContext, PluginCapabilityTag, PluginCommand, PluginCommandMetadata, PluginCompatibility, PluginContext, PluginContributions, PluginDefinition, PluginEventBus, PluginEventBusAPI, PluginEventHandler, PluginInit, PluginLifecycleHooks, PluginLoaderOptions, PluginManifest, PluginRegistry, PluginRegistryCompatibilityOptions, PluginRegistryOptions, PluginRegistryTimeoutOptions, PluginSessionContext, PluginSettingsDefinition, PluginSettingsProvider, PluginSettingsSchema, PluginSurfaceContract, PluginUnsubscribe, StaticSettings, ValidatedSettings, definePlugin, discoverPlugins, getPluginLoader, isDefinedPlugin, loadPluginModule, resetFrameworkAliases, resetPluginLoader, resolveFrameworkAliases } from './plugin/index.js';
+export { EventBus, EventBusMessage, EventBusOptions, EventBusSubscribeOptions, EventBusSubscription, createEventBus } from './events/index.js';
+export { ApprovalForwarder, CoordinatorInboxItem, CoordinatorLoopOptions, CoordinatorLoopResult, CoordinatorRosterMember, CoordinatorRound, CoordinatorRoundTransition, CoordinatorRoundTransitionInput, CoordinatorRuntimeStatus, CoordinatorStatus, CoordinatorTaskNotificationLike, CoordinatorWorkerReportLike, TeamCoordinator, TeamPermissionPolicyConfig, TeamPermissionRule, WorkerReport, addTokenUsage, buildCoordinatorSystemPrompt, coordinatorToolDescriptions, createTeamCoordinator, evaluateCoordinatorRoundTransition, formatCoordinatorRoundMessage, formatCoordinatorTaskNotifications, formatCoordinatorWorkerReports, teamPermissionPolicy } from './team/index.js';
+export { createConsoleLogger, createFileLogger, silentLogger } from './logger/index.js';
 import 'zod';
 import '@ai-sdk/provider-utils';
 import 'jiti';
 
+/**
+ * Promise-based sleep utility.
+ *
+ * @param ms - Duration to wait in milliseconds.
+ */
+declare function sleep(ms: number): Promise<void>;
+
+/**
+ * Backward-compatible alias for the controller-backed human input primitive.
+ *
+ * Prefer `createHumanInputController(...)` in new code.
+ */
+type HumanInputHandler = HumanInputController;
+/**
+ * Backward-compatible alias for `createHumanInputController(...)`.
+ *
+ * Prefer `createHumanInputController(...)` in new code.
+ */
+declare function createHumanInputHandler(config?: HumanInputConfig): HumanInputHandler;
+
+interface CreateHumanInputToolOptions extends HumanInputConfig {
+    controller?: HumanInputController;
+    name?: string;
+    description?: string;
+}
+declare function createHumanInputTool(options?: CreateHumanInputToolOptions): Tool.AnyInfo;
+declare function createHumanInputToolWithController(controller?: HumanInputController, options?: Pick<CreateHumanInputToolOptions, "name" | "description">): Tool.AnyInfo;
+/**
+ * Backward-compatible alias for `createHumanInputToolWithController(...)`.
+ *
+ * Prefer the controller name in new code.
+ */
+declare const createHumanInputToolWithHandler: typeof createHumanInputToolWithController;
+
 /**
  * Mutable runtime state held by an `Agent` instance.
+ *
+ * Only fields that are actually read at runtime belong here.
+ * Configuration-level values (systemPrompt, cwd) live on
+ * `EffectiveAgentConfig`; computed values (isStreaming) are
+ * derived from instance counters.
  */
 interface AgentState {
     model: LanguageModel;
-    systemPrompt: string;
-    cwd: string;
-    isStreaming: boolean;
     /** Current reasoning level */
     reasoningLevel: ReasoningLevel;
-    error?: Error;
+}
+
+/**
+ * Token Estimation Utilities
+ *
+ * Provides lightweight heuristic-based token counting for messages
+ * and conversations. Uses the chars/4 approximation — simple but
+ * effective for context-window planning decisions.
+ *
+ * These are *estimates*, not exact counts. For billing or hard limits,
+ * use the provider's native tokeniser instead.
+ */
+
+/**
+ * Estimate token count for a plain string.
+ *
+ * Uses the widely-accepted `chars / 4` heuristic.
+ *
+ * @param text - Text to estimate
+ * @returns Estimated token count (always ≥ 1 for non-empty input)
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Estimate token count for a single message.
+ *
+ * Handles:
+ * - Plain string content
+ * - Multi-part / multimodal arrays (text parts + images)
+ *
+ * @param message - A `Message` (internal) or `ModelMessage` (AI SDK)
+ * @returns Estimated token count
+ */
+declare function estimateMessageTokens(message: Message | ModelMessage): number;
+/**
+ * Estimate total tokens for an entire conversation.
+ *
+ * Adds a small per-message overhead (≈ 4 tokens) for message
+ * framing (`role`, delimiters, etc.).
+ *
+ * @param messages - Array of messages to estimate
+ * @returns Estimated total token count
+ */
+declare function estimateConversationTokens(messages: (Message | ModelMessage)[]): number;
+
+/**
+ * Context Overflow Detection & Pruning
+ *
+ * Detects when a conversation is approaching the model's context-window
+ * limit and prunes old / redundant content to stay within bounds.
+ *
+ * Two pruning strategies are available:
+ * 1. **Tool-result pruning** — replaces large, stale tool outputs with
+ *    compact placeholders (lightweight, no model call).
+ * 2. **Conversation cutting** — identifies a safe cut-point and removes
+ *    older messages entirely (optionally summarised by the manager).
+ */
+
+/**
+ * Context limits configuration.
+ *
+ * All values are in *estimated* tokens (see {@link estimateTokens}).
+ */
+interface ContextLimits {
+    /** Maximum context window size in tokens */
+    contextWindow: number;
+    /** Reserve tokens for output generation */
+    reserveTokens: number;
+    /** Protect this many recent tokens from pruning */
+    protectedTokens: number;
+    /** Minimum tokens to trigger pruning (avoid pruning tiny contexts) */
+    pruneMinimum: number;
+}
+/**
+ * Default context limits.
+ * Based on typical 128 k context-window models.
+ */
+declare const DEFAULT_CONTEXT_LIMITS: ContextLimits;
+/**
+ * Compute the usable token budget: the context window minus reserved output tokens.
+ *
+ * This is the single formula for the "safe input threshold" used by
+ * overflow detection, auto-compaction event emission, and step-processing limits.
+ */
+declare function getUsableTokenLimit(limits: Pick<ContextLimits, "contextWindow" | "reserveTokens">): number;
+/**
+ * Result of a pruning operation.
+ */
+interface PruneResult {
+    /** Messages after pruning (may include a summary message) */
+    messages: Message[];
+    /** Number of messages removed */
+    removedCount: number;
+    /** Estimated tokens removed */
+    tokensRemoved: number;
+    /** Whether summarisation was used */
+    summarized: boolean;
+    /** The summary content, if generated */
+    summary?: string;
+}
+/**
+ * Find a safe index at which the conversation can be "cut".
+ *
+ * Rules:
+ * - Never cut in the middle of a tool-call sequence
+ * - Prefer cutting after assistant / user messages
+ * - Keep at least {@link protectedTokens} tokens at the end
+ *
+ * @param messages       - Full message array
+ * @param protectedTokens - Tokens to preserve at the end
+ * @returns Cut index (exclusive — remove messages *before* this index).
+ *          Returns `0` when no safe cut-point exists.
+ */
+declare function findCutPoint(messages: Message[], protectedTokens?: number): number;
+
+/**
+ * Context Manager
+ *
+ * Stateful wrapper around the context-management primitives.
+ * Tracks per-session context limits and provides a single entry
+ * point for token estimation, overflow detection, and pruning.
+ */
+
+/**
+ * Per-session context manager.
+ *
+ * Holds the active context-window limits and provides convenience
+ * methods for checking, reporting, and pruning context.
+ *
+ * @example
+ * ```typescript
+ * const ctx = new ContextManager({ limits: { contextWindow: 200_000 } });
+ *
+ * if (ctx.shouldPrune(messages)) {
+ *   const result = await ctx.prune(messages);
+ *   console.log(`Removed ${result.removedCount} messages`);
+ * }
+ * ```
+ */
+declare class ContextManager {
+    private limits;
+    private model?;
+    private summaryPrompt?;
+    constructor(options?: {
+        limits?: Partial<ContextLimits>;
+        model?: LanguageModel;
+        summaryPrompt?: string;
+    });
+    /** Get a copy of the current context limits. */
+    getLimits(): ContextLimits;
+    /** Update context limits (e.g. when switching models). */
+    setLimits(limits: Partial<ContextLimits>): void;
+    /** Set the model used for summarisation. */
+    setModel(model: LanguageModel): void;
+    /** Estimate total tokens for a message array. */
+    estimateTokens(messages: (Message | ModelMessage)[]): number;
+    /** Check whether the context is overflowing. */
+    isOverflowing(messages: (Message | ModelMessage)[]): boolean;
+    /** Check whether pruning should be triggered. */
+    shouldPrune(messages: (Message | ModelMessage)[]): boolean;
+    /** Prune context to fit within limits. */
+    prune(messages: Message[]): Promise<PruneResult>;
+    /**
+     * Get a snapshot of token statistics.
+     *
+     * Useful for dashboards, logging, or deciding whether to prune.
+     */
+    getStats(messages: (Message | ModelMessage)[]): {
+        tokens: number;
+        limit: number;
+        available: number;
+        utilizationPercent: number;
+        isOverflowing: boolean;
+        shouldPrune: boolean;
+    };
 }
 
 /** Everything the chat loop needs from the Agent instance. */
 interface ChatLoopDeps {
     sessionId: string;
+    turnId: string;
     message: string;
     abort: AbortSignal;
     systemOverride?: string;
     sessions: SessionManager;
-    tools: Record<string, Tool.Info>;
-    config: Required<Pick<AgentConfig, "model" | "systemPrompt" | "cwd" | "maxOutputTokens" | "maxSteps">> & AgentConfig;
+    /**
+     * Live reference to the agent's tools Map.
+     *
+     * The loop rebuilds a `Record<string, Tool.Info>` from this Map at
+     * the start of each model step so that mid-turn additions (e.g.
+     * tools loaded by `tool_search` via `agent.addTool()`) are visible
+     * to the next step without restarting the turn.
+     */
+    tools: Map<string, Tool.AnyInfo>;
+    config: EffectiveAgentConfig;
     turnTracker: TurnChangeTracker;
     interventionCtrl: InterventionController;
     middlewareRunner: MiddlewareRunner;
@@ -86,10 +283,19 @@ interface ChatLoopDeps {
     reasoningLevel: ReasoningLevel;
     promptBuilder?: PromptBuilder;
     host: ToolHost;
+    humanInputController?: HumanInputController;
     mcpTools: Record<string, Tool$1>;
     telemetrySettings?: TelemetrySettings;
     toModelMessages: (messages: Message[]) => ModelMessage[];
     setIsStreaming: (value: boolean) => void;
+    /**
+     * Tool execution mode for this chat loop.
+     * - `"auto"` — tools auto-execute via AI SDK (default)
+     * - `"plan"` — tools are planned, then dispatched via `runToolBatch()`
+     */
+    toolExecutionMode?: ToolExecutionMode;
+    /** Logger for diagnostic output. */
+    logger?: Logger;
 }
 
 /**
@@ -98,93 +304,261 @@ interface ChatLoopDeps {
  */
 declare function runChatLoop(deps: ChatLoopDeps): AsyncGenerator<AgentEvent>;
 
-/**
- * Concurrent sub-agent execution.
- */
+declare function ensureSessionLoaded(options: {
+    sessionId: string;
+    sessions: SessionManager;
+    cwd: string;
+}): Promise<void>;
 
 /**
- * Sub-agent run result
+ * CLI-friendly event printer for `agent.chat()` streams.
+ *
+ * Provides a zero-config function that handles the full `AgentEvent`
+ * union, writing text deltas to stdout, tool calls with emoji prefixes,
+ * and lifecycle events to stderr.  Covers the same ground as the
+ * 80-line `handleEvent()` in example 03–streaming but as a reusable
+ * one-liner:
+ *
+ * ```ts
+ * const print = createEventPrinter();
+ * for await (const event of agent.chat("demo", "Hello")) {
+ *   print(event);
+ * }
+ * ```
+ *
+ * All options are optional — sensible defaults work out of the box.
  */
-interface SubAgentResult {
-    /** Final response text */
-    response: string;
-    /** Sub-agent session ID */
-    sessionId: string;
-    /** Token usage */
-    usage: TokenUsage;
-    /** Tool calls made */
-    toolCalls: Array<{
-        name: string;
-        result: unknown;
-    }>;
+
+/** Controls which event categories the printer renders. */
+interface EventPrinterOptions {
+    /**
+     * Show tool start/result/error events.
+     * @default true
+     */
+    tools?: boolean;
+    /**
+     * Show reasoning tokens (thinking models like o3, o4-mini).
+     * @default true
+     */
+    reasoning?: boolean;
+    /**
+     * Show step/lifecycle banners.
+     * @default false
+     */
+    steps?: boolean;
+    /**
+     * Show approval, intervention, and safety events.
+     * @default true
+     */
+    safety?: boolean;
+    /**
+     * Show the completion summary line.
+     * @default true
+     */
+    completion?: boolean;
+    /**
+     * Show team coordination events (team-*).
+     * @default false
+     */
+    team?: boolean;
+    /**
+     * Writable stream for text output.
+     * @default process.stdout
+     */
+    stdout?: NodeJS.WritableStream;
+    /**
+     * Writable stream for diagnostic/lifecycle output.
+     * @default process.stderr
+     */
+    stderr?: NodeJS.WritableStream;
 }
 /**
- * Run multiple sub-agent tasks concurrently.
- *
- * Useful for parallelizing independent research or analysis tasks.
- * Results are returned in the same order as tasks.
+ * Create a stateless event handler for printing `AgentEvent`s to the
+ * terminal.
  *
- * Distinct sub-agent sessions can run in parallel safely. Turns targeting the
- * same session are serialized to preserve history order.
+ * @param options - Fine-tune which event categories are rendered.
+ * @returns A function that accepts one `AgentEvent` and writes to stdout/stderr.
  *
  * @example
- * ```typescript
- * const explorer = agent.fork({ name: "explore", ... });
+ * ```ts
+ * import { createAgent, createEventPrinter } from "@cuylabs/agent-core";
+ *
+ * const agent = createAgent({ model, systemPrompt: "Be concise." });
+ * const print = createEventPrinter();
  *
- * const results = await runConcurrent([
- *   { agent: explorer, message: "Find all API endpoints" },
- *   { agent: explorer, message: "Find all database queries" },
- *   { agent: explorer, message: "Find all auth middleware" },
- * ], { maxConcurrency: 3 });
+ * for await (const event of agent.chat("demo", "Hello")) {
+ *   print(event);
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Quiet mode — text only, no tool or lifecycle output
+ * const print = createEventPrinter({
+ *   tools: false,
+ *   reasoning: false,
+ *   steps: false,
+ *   completion: false,
+ * });
  * ```
  */
-declare function runConcurrent(tasks: Array<{
-    agent: Agent;
-    message: string;
-    parentSessionId?: string;
-    title?: string;
-}>, options?: {
-    /** Maximum concurrent tasks (default: 5) */
-    maxConcurrency?: number;
-    /** Abort signal for all tasks */
-    abort?: AbortSignal;
-}): Promise<SubAgentResult[]>;
+declare function createEventPrinter(options?: EventPrinterOptions): (event: AgentEvent) => void;
 
 /**
- * Agent defaults — constants used by the Agent constructor.
+ * Auto-detect and configure stream provider from model and tools.
+ *
+ * Returns the configured stream provider, or undefined if standard
+ * AI SDK streaming should be used.
  */
+declare function autoDetectStreamProvider(model: LanguageModel, tools: unknown, explicitProvider: unknown): StreamProvider | undefined;
+
 /**
- * Generic fallback system prompt.
+ * Shared intervention/follow-up types for @cuylabs/agent-core.
  *
- * Only used when the consumer provides a flat `systemPrompt` string
- * without any value (i.e. the field exists but is empty/undefined).
- * When the prompt pipeline is active, this is never used.
+ * These types give runtimes (agent-server, agent-runtime-dapr) a common
+ * vocabulary for user-directed turn control:
+ * - immediate mid-turn steering
+ * - deferred follow-ups queued for the next turn
  *
- * Domain-specific prompts (coding, browsing, etc.) belong in
- * consumer packages like agent-code, not here.
+ * The `InterventionController` remains the in-process implementation;
+ * these types are the protocol-level representation for cross-process
+ * and durable scenarios.
  */
-declare const DEFAULT_SYSTEM_PROMPT = "You are a capable AI assistant with access to tools.\n\nThink step by step about what you need to do.\nUse the available tools to accomplish tasks.\nVerify your results after each action.\n\nIf a tool fails, try an alternative approach \u2014 do not give up after a single error.\nKeep working until the task is fully resolved or you have exhausted all options.";
-/** Default max steps */
-declare const DEFAULT_MAX_STEPS = 50;
-/** Default max output tokens */
-declare const DEFAULT_MAX_TOKENS = 32000;
+/**
+ * A steering request surfaced to runtime consumers.
+ *
+ * Created when a client calls `steerTurn()` (agent-server) or
+ * `POST /agents/:id/steer` (agent-runtime-dapr). Runtimes publish
+ * an `intervention-applied` event so UIs can show the injection.
+ */
+interface SteeringRequest {
+    /** Unique identifier (maps to `PendingIntervention.id` in direct mode) */
+    id: string;
+    /** Session the steering targets */
+    sessionId: string;
+    /** The user message to inject */
+    message: string;
+    /** When the steering was requested */
+    timestamp: number;
+}
+/**
+ * Acknowledgement returned after a steering message is accepted.
+ *
+ * In direct mode, the message is already queued in the
+ * `InterventionController`. In durable mode, it is persisted in
+ * state and will be picked up at the next workflow activity boundary.
+ */
+interface SteeringResponse {
+    /** The steering request ID */
+    id: string;
+    /** Whether the message was accepted */
+    accepted: boolean;
+}
+/**
+ * A deferred follow-up request surfaced to runtime consumers.
+ *
+ * Created when a client calls `followUpTurn()` (agent-server) or
+ * `POST /agents/:id/follow-up` (agent-runtime-dapr). Runtimes publish
+ * a `follow-up-queued` event so UIs can show that the message will be
+ * available after the current turn completes.
+ */
+interface FollowUpRequest {
+    /** Unique identifier (maps to `PendingIntervention.id` in direct mode) */
+    id: string;
+    /** Session the follow-up targets */
+    sessionId: string;
+    /** The user message to queue for the next turn */
+    message: string;
+    /** When the follow-up was requested */
+    timestamp: number;
+}
+/**
+ * Acknowledgement returned after a follow-up message is accepted.
+ *
+ * In direct mode, the message is queued in the `InterventionController`.
+ * In durable mode, it is persisted in the runtime's durable follow-up store
+ * and becomes seedable on the next turn for the same session.
+ */
+interface FollowUpResponse {
+    /** The follow-up request ID */
+    id: string;
+    /** Whether the message was accepted */
+    accepted: boolean;
+}
+
+type FollowUpMode = "suggest" | "confirm" | "auto-run";
+type FollowUpStatus = "queued" | "accepted" | "discarded" | "applied";
+type FollowUpDecisionAction = "accept" | "discard";
+interface FollowUpPolicy {
+    /**
+     * `suggest`:
+     *   queue the follow-up and expose it for the host/UI to surface.
+     * `confirm`:
+     *   queue it, but require an explicit accept/discard decision before seeding.
+     * `auto-run`:
+     *   automatically seed the next turn with queued follow-ups for the session.
+     */
+    mode?: FollowUpMode;
+}
+interface QueuedFollowUpRecord {
+    id: string;
+    sessionId: string;
+    message: string;
+    createdAt: string;
+    updatedAt: string;
+    mode: FollowUpMode;
+    status: FollowUpStatus;
+    sourceTurnId?: string;
+    workflowInstanceId?: string;
+    decidedAt?: string;
+    appliedAt?: string;
+    seededTurnId?: string;
+}
+declare function normalizeFollowUpMode(mode?: FollowUpMode): FollowUpMode;
+declare function createQueuedFollowUpRecord(request: FollowUpRequest, options?: {
+    mode?: FollowUpMode;
+    sourceTurnId?: string;
+    workflowInstanceId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}): QueuedFollowUpRecord;
+declare function resolveQueuedFollowUp(record: QueuedFollowUpRecord, action: FollowUpDecisionAction, updatedAt: string): QueuedFollowUpRecord;
+declare function markQueuedFollowUpApplied(record: QueuedFollowUpRecord, updatedAt: string, seededTurnId?: string): QueuedFollowUpRecord;
+declare function canSeedQueuedFollowUp(record: QueuedFollowUpRecord): boolean;
+
+declare function currentScope(): Scope | undefined;
+declare function snapshotScope(scope?: Scope | undefined): ScopeSnapshot | undefined;
+declare function withinScope<T>(options: ScopeOptions, fn: () => T | Promise<T>): Promise<T>;
+declare function restoreScope<T>(snapshot: ScopeSnapshot | undefined, fn: () => T | Promise<T>): Promise<T>;
 
 /**
- * Check if a model requires a custom stream provider.
+ * Extract file paths from tool arguments based on metadata.
  */
-declare function needsCustomStreamProvider(model: LanguageModel, customPatterns?: string[]): boolean;
+declare function extractFilePathsFromArgs(args: Record<string, unknown>, meta: FileOperationMeta): string[];
 /**
- * Check if tools array has stream provider factory attached.
+ * Check whether a tool operation should trigger baseline capture.
  */
-declare function hasStreamProviderFactory(tools: unknown): tools is EnhancedTools & {
-    __streamProviderFactory: NonNullable<EnhancedTools["__streamProviderFactory"]>;
-};
+declare function shouldCaptureBaseline(meta: FileOperationMeta): boolean;
+
 /**
- * Auto-detect and configure stream provider from model and tools.
+ * LocalSignal — in-process event dispatch.
  *
- * Returns the configured stream provider, or undefined if standard
- * AI SDK streaming should be used.
+ * Dispatches events synchronously via direct function calls.
+ * Zero dependencies, zero serialization, zero network.
+ *
+ * Handler errors are caught silently — a broken listener must never
+ * interrupt the agent's streaming pipeline.
  */
-declare function autoDetectStreamProvider(model: LanguageModel, tools: unknown, explicitProvider: unknown): StreamProvider | undefined;
 
-export { Agent, AgentConfig, AgentEvent, type AgentState, type ChatLoopDeps, ContextManager, DEFAULT_MAX_STEPS, DEFAULT_MAX_TOKENS, DEFAULT_SYSTEM_PROMPT, EnhancedTools, InterventionController, Message, MiddlewareRunner, PromptBuilder, ReasoningLevel, SessionManager, StreamProvider, type SubAgentResult, TokenUsage, Tool, ToolHost, TurnChangeTracker, autoDetectStreamProvider, hasStreamProviderFactory, needsCustomStreamProvider, runChatLoop, runConcurrent };
+declare class LocalSignal implements AgentSignal {
+    /** type → Set<handler> for typed subscriptions */
+    private readonly typed;
+    /** handlers that receive every event */
+    private readonly wildcard;
+    on<T extends AgentEvent["type"]>(type: T, handler: TypedHandler<T>): Unsubscribe;
+    onAny(handler: WildcardHandler): Unsubscribe;
+    emit(event: AgentEvent): void;
+    clear(): void;
+}
+
+export { AgentEvent, AgentSignal, type AgentState, type ChatLoopDeps, type ContextLimits, ContextManager, type CreateHumanInputToolOptions, DEFAULT_CONTEXT_LIMITS, EffectiveAgentConfig, type EventPrinterOptions, FileOperationMeta, type FollowUpDecisionAction, type FollowUpMode, type FollowUpPolicy, type FollowUpRequest, type FollowUpResponse, type FollowUpStatus, HumanInputConfig, HumanInputController, type HumanInputHandler, InterventionController, LocalSignal, Logger, Message, MiddlewareRunner, PromptBuilder, type QueuedFollowUpRecord, ReasoningLevel, ScopeSnapshot, SessionManager, type SteeringRequest, type SteeringResponse, StreamProvider, Tool, ToolExecutionMode, ToolHost, TurnChangeTracker, autoDetectStreamProvider, canSeedQueuedFollowUp, createEventPrinter, createHumanInputHandler, createHumanInputTool, createHumanInputToolWithController, createHumanInputToolWithHandler, createQueuedFollowUpRecord, currentScope, ensureSessionLoaded, estimateConversationTokens, estimateMessageTokens, estimateTokens, extractFilePathsFromArgs, findCutPoint, getUsableTokenLimit, markQueuedFollowUpApplied, normalizeFollowUpMode, resolveQueuedFollowUp, restoreScope, runChatLoop, shouldCaptureBaseline, sleep, snapshotScope, withinScope };