@linnlabs/linnkit 0.8.0

package/dist/index-Cm-JbzTH.d.cts

@@ -0,0 +1,1450 @@
+import { a as LLMPolicy, b as LLMPolicyRequestContext, c as LLMPolicyResponseContext, d as LLMPolicyMatchContext, e as LLMPolicyErrorDecision, f as LlmCaller, M as ModelCatalogEntry, g as ModelCatalogLike, h as ModelResolver, E as ExecutorLocalState, S as StandardToolCall, i as ModelResolverLike, T as TelemetryPort, G as GraphNode, j as EngineState, N as NodeResult, C as Checkpointer, k as CheckpointMeta, l as CheckpointListFilter, m as CheckpointSummary, n as ENGINE_STATE_SCHEMA_VERSION, o as GraphExecutor, p as MemoryEventStore, s as summarizeCheckpoint, q as ToolContextPatch, D as DefaultRunSupervisor, r as DefaultRunSupervisorOptions, F as FindActiveByConversationOptions, t as MemoryRunRegistryStore, R as RunExecutionContext, u as RunExecutorPort, v as RunOutcome, x as RunRegistrationSpec, y as RunSnapshot, z as RunSupervisor, A as RunTerminalError, B as RunTerminalEvent, H as RunTerminalStatus, I as RunWaitForTerminalOptions, J as TELEMETRY_EVENT_KINDS, K as TelemetryEvent, O as TelemetryScope, P as DefaultGraphExecutorOptions, Q as GraphLoopHarness, U as GraphLoopHarnessOptions, V as GraphLoopHarnessRunResult, W as GraphLoopLlmNodeFactoryParams, X as createDefaultGraphExecutor, Y as createGraphLoopHarness } from './defaultGraphExecutor-BIjJj7WF.cjs';
+import { b as AuditPort } from './audit-LeOrm2hX.cjs';
+import { T as ToolCatalogPort, a as ToolPresentationPort, b as ToolExecutionPort, O as ObservationPreviewPort, C as ConversationArtifactContext, c as ObservationPreviewContext, d as ObservationPreviewMeta, e as ObservationPreviewResult, f as ToolExecutionResult, g as ToolRuntimeDefinition, h as ToolRuntimePort, i as ToolSchemaContext } from './ports-DaatKJXp.cjs';
+import { A as AgentInvocationRequest } from './agent-invocation-BHcNfrBV.cjs';
+import { a as LlmRequestMessage, L as LlmCallOptions, b as LlmResponseContent, c as LlmRetryConfig, P as ProviderReasoningDetails, T as ToolCall, d as ToolCallChunk, e as ToolCallExtraContent } from './ai-engine.types-BpeU_XQG.cjs';
+import { e as RuntimeEvent, E as ErrorEvent } from './todo-B1PmDlp3.cjs';
+import { A as AnyAgentEvent } from './agentEvents-DEB7Fy_J.cjs';
+import { T as ToolExecutionContext, B as BaseTool, a as ToolArgs, b as ToolParameterSchema, c as ToolParameterProperty, d as ToolContextConversationView, A as AgentTool, C as CommonParameterTypes, J as JsonObjectSchema, O as OpenAIToolSchema, S as StructuredToolResult, e as ToolCallResult, f as ToolContextCompatibilityFields, g as ToolControlInfo, h as ToolDisplayOptions, i as ToolLayoutOptions, j as ToolRegistryEntry, k as ToolResult, U as UnifiedToolResult, l as computeToolIdempotencyKey, m as findCachedToolOutputByIdempotencyKey, r as readToolContextModelId, n as readToolContextRunContext, o as readToolContextUserQuery, R as RunContext, p as createDefaultRunContext, q as ChildRunParentContext, s as SubRunTracePublisher, t as ChildRunHistoryPolicy, u as ChildRunInvokerPort, v as ChildRunRequest, w as ChildRunResult, x as SubRunTraceEnvelope } from './toolContracts-CLkQmhTG.cjs';
+import { E as EventRangeOptions, a as EventStore, P as PersistedEvent, c as createMonotonicEventIdFactory, b as EventBus, C as CancelOpts, D as DefaultRunHandle, d as DefaultRunHandleOptions, L as ListRunsFilter, R as RunAwaitingUserPatch, e as RunCost, f as RunCostCollector, g as RunFailureInfo, h as RunHandle, i as RunLifecyclePatch, j as RunMeta, k as RunObserveFilter, l as RunRecord, m as RunRegistryStore, n as RunRequestSnapshot, o as RunStatus, r as runMetaFromRecord } from './runHandle-D3gPsD7B.cjs';
+import { C as CHECKPOINT_MARKER_TYPE, D as DEFAULT_CONTEXT_CHECKPOINT_TOOL_NAME } from './checkpointMarker-DAI3wUQu.cjs';
+import { a as ExecutionTraceContext, E as EventEnvelope } from './execution-CAIypb41.cjs';
+import { i as index$d } from './index-DO4dQgf2.cjs';
+import { T as TokenizerPort } from './tokenizer-DH_JXv-H.cjs';
+import { e as AgentSpecContextPolicy, p as AgentSpecSystemReminderPolicy, q as AgentSpecSystemReminderTrigger, o as AgentSpecSystemReminderExtraRule } from './agentSpec-EkmviZjy.cjs';
+import { e as AuditEnvelope, b as AuditActor, d as AuditDecision, f as AuditEvidence, c as AuditCostDelta, g as AuditScope } from './audit-BaRUGaqv.cjs';
+
+interface DefaultTokenizerPortConfig {
+    /** tiktoken encoding 名，默认沿用 TokenCalculator 的 cl100k_base 近似路径。 */
+    encoding?: string;
+    /** tiktoken 不可用或不指定 encoding 时的字符/token 兜底比。 */
+    avgCharsPerToken?: number;
+    /** 单个 tool_call 的额外 token 开销估算。 */
+    toolCallOverhead?: number;
+}
+/**
+ * linnkit 默认 tokenizer。
+ *
+ * 中文备注：
+ * - 这是 TokenCalculator 的薄包装，保持 0.7.x 默认行为；
+ * - host 不注入 TokenizerPort 时，context-manager 自动使用该实现；
+ * - 只用于上下文 budget 估算，不用于计费。
+ */
+declare class DefaultTokenizerPort implements TokenizerPort {
+    private readonly config;
+    constructor(config?: DefaultTokenizerPortConfig);
+    estimateText(text: string, _modelId?: string): number;
+    estimateMessage(message: LlmRequestMessage, _modelId?: string): number;
+}
+declare function createDefaultTokenizerPort(config?: DefaultTokenizerPortConfig): TokenizerPort;
+
+/**
+ * @file src/agent/runtime-kernel/llm/policies/policyEngine.ts
+ *
+ * @description
+ * 统一的 LLM Policy Engine：
+ * - 按 match 条件筛选 policies
+ * - 固定调用点：beforeRequest / afterResponse / onError
+ *
+ * 主链路通过调用 PolicyEngine 达到“可扩展但不膨胀”的效果。
+ */
+
+declare class LLMPolicyEngine {
+    private readonly policies;
+    constructor(policies: LLMPolicy[]);
+    private matched;
+    applyBeforeRequest(ctx: LLMPolicyRequestContext): {
+        requestData: unknown;
+        headers?: Record<string, string>;
+    };
+    applyAfterResponse(ctx: LLMPolicyResponseContext): {
+        responseData: unknown;
+    };
+    decideOnError(error: Error, ctx: LLMPolicyMatchContext): LLMPolicyErrorDecision;
+}
+
+/**
+ * @file src/agent/runtime-kernel/llm/policies/defaultPolicyEngine.ts
+ *
+ * @description
+ * linnkit 的默认 PolicyEngine 不注册任何 provider/model 策略。
+ *
+ * provider 适配属于宿主集成层职责。宿主可以复用 `LLMPolicyEngine`
+ * 并显式注入自己的 policies。
+ */
+
+declare const defaultPolicyEngine: LLMPolicyEngine;
+
+type index$c_DefaultTokenizerPort = DefaultTokenizerPort;
+declare const index$c_DefaultTokenizerPort: typeof DefaultTokenizerPort;
+type index$c_DefaultTokenizerPortConfig = DefaultTokenizerPortConfig;
+declare const index$c_LLMPolicy: typeof LLMPolicy;
+type index$c_LLMPolicyEngine = LLMPolicyEngine;
+declare const index$c_LLMPolicyEngine: typeof LLMPolicyEngine;
+declare const index$c_LLMPolicyErrorDecision: typeof LLMPolicyErrorDecision;
+declare const index$c_LLMPolicyMatchContext: typeof LLMPolicyMatchContext;
+declare const index$c_LLMPolicyRequestContext: typeof LLMPolicyRequestContext;
+declare const index$c_LLMPolicyResponseContext: typeof LLMPolicyResponseContext;
+declare const index$c_LlmCallOptions: typeof LlmCallOptions;
+declare const index$c_LlmCaller: typeof LlmCaller;
+declare const index$c_LlmRequestMessage: typeof LlmRequestMessage;
+declare const index$c_LlmResponseContent: typeof LlmResponseContent;
+declare const index$c_LlmRetryConfig: typeof LlmRetryConfig;
+declare const index$c_ModelCatalogEntry: typeof ModelCatalogEntry;
+declare const index$c_ModelCatalogLike: typeof ModelCatalogLike;
+declare const index$c_ModelResolver: typeof ModelResolver;
+declare const index$c_ProviderReasoningDetails: typeof ProviderReasoningDetails;
+declare const index$c_ToolCall: typeof ToolCall;
+declare const index$c_ToolCallChunk: typeof ToolCallChunk;
+declare const index$c_ToolCallExtraContent: typeof ToolCallExtraContent;
+declare const index$c_createDefaultTokenizerPort: typeof createDefaultTokenizerPort;
+declare const index$c_defaultPolicyEngine: typeof defaultPolicyEngine;
+declare namespace index$c {
+  export { index$c_DefaultTokenizerPort as DefaultTokenizerPort, type index$c_DefaultTokenizerPortConfig as DefaultTokenizerPortConfig, index$c_LLMPolicy as LLMPolicy, index$c_LLMPolicyEngine as LLMPolicyEngine, index$c_LLMPolicyErrorDecision as LLMPolicyErrorDecision, index$c_LLMPolicyMatchContext as LLMPolicyMatchContext, index$c_LLMPolicyRequestContext as LLMPolicyRequestContext, index$c_LLMPolicyResponseContext as LLMPolicyResponseContext, index$c_LlmCallOptions as LlmCallOptions, index$c_LlmCaller as LlmCaller, index$c_LlmRequestMessage as LlmRequestMessage, index$c_LlmResponseContent as LlmResponseContent, index$c_LlmRetryConfig as LlmRetryConfig, index$c_ModelCatalogEntry as ModelCatalogEntry, index$c_ModelCatalogLike as ModelCatalogLike, index$c_ModelResolver as ModelResolver, index$c_ProviderReasoningDetails as ProviderReasoningDetails, index$c_ToolCall as ToolCall, index$c_ToolCallChunk as ToolCallChunk, index$c_ToolCallExtraContent as ToolCallExtraContent, index$c_createDefaultTokenizerPort as createDefaultTokenizerPort, index$c_defaultPolicyEngine as defaultPolicyEngine };
+}
+
+interface GraphExecutorSummarizationCallbacks {
+    onSummarizationStart?: () => void;
+    onSummarizationEnd?: (summaryInfo: unknown) => void;
+}
+interface PendingContextRuntimeEvent extends Record<string, unknown> {
+    id: string;
+    type: string;
+}
+interface GraphExecutorContextBuildInput {
+    request: AgentInvocationRequest;
+    history: RuntimeEvent[];
+    summarizationCallbacks?: GraphExecutorSummarizationCallbacks;
+    modelId: string;
+    signal?: AbortSignal;
+}
+interface GraphExecutorContextBuildOutput {
+    mode: 'agent' | 'chat';
+    llmMessages: LlmRequestMessage[];
+    summaryEvents: PendingContextRuntimeEvent[];
+    /**
+     * 上下文构建旁路 trace。
+     *
+     * 中文备注：runtime-kernel 只负责透传，不理解 context-manager 的具体 trace 类型，
+     * 避免 graph-engine 反向依赖 context-manager。
+     */
+    contextTrace?: unknown;
+}
+interface GraphExecutorContextBuilder {
+    build(input: GraphExecutorContextBuildInput): Promise<GraphExecutorContextBuildOutput>;
+}
+
+type TickEvent$1 = AnyAgentEvent | RuntimeEvent;
+type AgentStepDecision = {
+    kind: 'tool_calls';
+    toolCalls: StandardToolCall[];
+} | {
+    kind: 'final_answer';
+    answer: string;
+} | {
+    kind: 'wait_user';
+    pendingInteractionSpec: Record<string, unknown>;
+    lastToolResult: Record<string, unknown>;
+} | {
+    kind: 'yield';
+} | {
+    kind: 'error';
+    error: Error;
+};
+interface TickInput {
+    request: AgentInvocationRequest;
+    toolContext?: ToolExecutionContext;
+    stream?: boolean;
+    history: RuntimeEvent[];
+    signal?: AbortSignal;
+    /**
+     * 🔥 达到最大步数时的强制收尾开关：
+     * - true 时：禁用工具（不下发 tools schema，tool_choice=none）
+     * - 并注入 system 指令，要求模型必须直接输出最终答案
+     */
+    forceFinalAnswer?: boolean;
+    /**
+     * 执行阶段信号（由 GraphExecutor 注入到 local.executorLocal）
+     *
+     * 中文备注：
+     * - SystemReminder 引擎会基于它生成 <system-reminder> 并追加到最后一条消息末尾
+     * - 该字段仅用于“本次 tick 的 LLM 输入”，不得写入历史事件或持久化
+     */
+    executorLocal?: ExecutorLocalState;
+    summarizationCallbacks?: GraphExecutorSummarizationCallbacks;
+}
+interface TickOutput {
+    decision: AgentStepDecision;
+    newEvents: RuntimeEvent[];
+}
+
+/**
+ * @file src/agent/runtime-kernel/graph-engine/executor.ts
+ *
+ * @brief 图执行引擎的单步推理执行器
+ */
+
+interface GraphAgentExecutorOptions {
+    cloudQuotaFallbackModelId?: string;
+    modelCatalog?: ModelCatalogLike;
+    modelResolver?: Pick<ModelResolverLike, 'resolveModelId'>;
+}
+interface GraphAgentExecutorToolRuntime extends Pick<ToolCatalogPort, 'getToolSchemas'>, Pick<ToolPresentationPort, 'getDisplayOptions'> {
+}
+interface GraphAgentExecutorLlmCaller extends Pick<LlmCaller, 'callWithRetries'> {
+}
+interface GraphAgentExecutorDependencies extends GraphAgentExecutorOptions {
+    llmCaller: GraphAgentExecutorLlmCaller;
+    toolRuntime: GraphAgentExecutorToolRuntime;
+    contextBuilder: GraphExecutorContextBuilder;
+    /**
+     * 可选：宿主提供的 TelemetryPort 实现。
+     * 不传时使用 noopTelemetry（保持当前行为：observability 默认关闭，零业务影响）。
+     */
+    telemetryPort?: TelemetryPort;
+    auditPort?: AuditPort;
+}
+declare class GraphAgentExecutor {
+    private readonly llmCaller;
+    private readonly toolRuntime;
+    private readonly contextBuilder;
+    private readonly cloudQuotaFallbackModelId?;
+    private readonly modelResolver;
+    private readonly modelCatalog;
+    private readonly telemetryPort;
+    private readonly auditPort;
+    private readonly stages;
+    private readonly middlewares;
+    constructor(dependencies: GraphAgentExecutorDependencies);
+    tick(input: TickInput, eventHandler?: (event: TickEvent$1) => void): Promise<TickOutput>;
+}
+
+/**
+ * @file src/core/graph-engine/nodes/llmNode.eventBridge.ts
+ *
+ * @description
+ * LlmNode 事件桥接对象 —— Phase 1.5-2b 的核心产物。
+ *
+ * 动机：
+ * - Phase 1.5-2a 把状态变更收口为 reducer，但 SSE 分发、事件映射、
+ *   stream_chunk 增强、final_answer 去重等副作用逻辑仍以闭包形式
+ *   留在 LlmNode.run() 中，占据约一半的方法体。
+ * - 本模块把这些"事件分发职责"抽为独立的 LlmNodeEventBridge 对象，
+ *   使 LlmNode.run() 精简为：状态初始化 → 阶段/请求解析 → 创建 bridge
+ *   → tick → 决策 dispatch → 状态回写 → 路由。
+ *
+ * 约束：
+ * - bridge 不持有可变状态，所有状态读写通过 deps.getState / deps.dispatch 完成。
+ * - bridge 不知晓 EngineState / NodeResult 等图执行概念，只负责单事件处理。
+ * - 不依赖 features 层任何类型。
+ */
+
+/** reasoner.tick 的事件类型（AnyAgentEvent 或 RuntimeEvent） */
+type TickEvent = AnyAgentEvent | RuntimeEvent;
+
+/**
+ * LlmNode 只依赖"单步推理"能力，不直接依赖具体执行器实现。
+ *
+ * 中文备注：
+ * - 这样节点本身只关注图节点职责，不负责组装 `LlmCaller` / `ToolRegistry`；
+ * - 默认依赖装配放到工厂里，方便测试替换，也降低构造函数耦合。
+ */
+interface LlmNodeReasoner {
+    tick(input: TickInput, eventHandler?: (event: TickEvent) => void): Promise<TickOutput>;
+}
+interface LlmNodeDependencies {
+    reasoner: LlmNodeReasoner;
+}
+declare class LlmNode implements GraphNode {
+    id: string;
+    private readonly reasoner;
+    constructor(dependencies: LlmNodeDependencies);
+    run(state: EngineState): Promise<NodeResult>;
+}
+
+interface ToolNodeDependencies {
+    toolRuntime: Pick<ToolCatalogPort, 'getToolDefinition'> & Pick<ToolExecutionPort, 'executeTool'>;
+    observationPreview: ObservationPreviewPort;
+    /**
+     * 可选：宿主提供的 TelemetryPort 实现。
+     * 不传时使用 noopTelemetry（observability 默认关闭，业务零影响）。
+     */
+    telemetryPort?: TelemetryPort;
+    auditPort?: AuditPort;
+}
+declare class ToolNode implements GraphNode {
+    id: string;
+    private readonly toolRuntime;
+    private readonly observationPreview;
+    private readonly telemetryPort;
+    private readonly auditPort;
+    constructor(dependencies: ToolNodeDependencies);
+    /**
+     * B2-engine Batch 2: 上报 tool_call 事件到宿主侧 TelemetryPort。
+     * 在 handleSuccess / handleError 入口处调用。
+     */
+    private emitToolCallTelemetry;
+    private emitToolDecisionAudit;
+    run(state: EngineState): Promise<NodeResult>;
+    private handleSuccess;
+    private handleRequireUserSuccess;
+    private handleError;
+}
+
+declare class UserNode implements GraphNode {
+    id: string;
+    run(state: EngineState): Promise<NodeResult>;
+}
+
+interface WaitUserNodeDependencies {
+    auditPort?: AuditPort;
+}
+declare class WaitUserNode implements GraphNode {
+    id: string;
+    private readonly auditPort;
+    constructor(dependencies?: WaitUserNodeDependencies);
+    run(state: EngineState): Promise<NodeResult>;
+}
+
+declare class AnswerNode implements GraphNode {
+    id: string;
+    run(state: EngineState): Promise<NodeResult>;
+}
+
+declare class MemoryCheckpointer implements Checkpointer {
+    private store;
+    private cloneState;
+    load(conversationId: string): Promise<EngineState | null>;
+    save(conversationId: string, state: EngineState): Promise<void>;
+    clear(conversationId: string): Promise<void>;
+    peekMeta(conversationId: string): Promise<CheckpointMeta | null>;
+    list(filter?: CheckpointListFilter): Promise<CheckpointSummary[]>;
+}
+
+type index$b_AnswerNode = AnswerNode;
+declare const index$b_AnswerNode: typeof AnswerNode;
+declare const index$b_CheckpointListFilter: typeof CheckpointListFilter;
+declare const index$b_CheckpointMeta: typeof CheckpointMeta;
+declare const index$b_CheckpointSummary: typeof CheckpointSummary;
+declare const index$b_Checkpointer: typeof Checkpointer;
+declare const index$b_ENGINE_STATE_SCHEMA_VERSION: typeof ENGINE_STATE_SCHEMA_VERSION;
+declare const index$b_EngineState: typeof EngineState;
+declare const index$b_EventRangeOptions: typeof EventRangeOptions;
+declare const index$b_EventStore: typeof EventStore;
+declare const index$b_ExecutorLocalState: typeof ExecutorLocalState;
+type index$b_GraphAgentExecutor = GraphAgentExecutor;
+declare const index$b_GraphAgentExecutor: typeof GraphAgentExecutor;
+type index$b_GraphAgentExecutorDependencies = GraphAgentExecutorDependencies;
+declare const index$b_GraphExecutor: typeof GraphExecutor;
+type index$b_GraphExecutorContextBuildInput = GraphExecutorContextBuildInput;
+type index$b_GraphExecutorContextBuildOutput = GraphExecutorContextBuildOutput;
+type index$b_GraphExecutorContextBuilder = GraphExecutorContextBuilder;
+declare const index$b_GraphNode: typeof GraphNode;
+type index$b_LlmNode = LlmNode;
+declare const index$b_LlmNode: typeof LlmNode;
+type index$b_MemoryCheckpointer = MemoryCheckpointer;
+declare const index$b_MemoryCheckpointer: typeof MemoryCheckpointer;
+declare const index$b_MemoryEventStore: typeof MemoryEventStore;
+type index$b_PendingContextRuntimeEvent = PendingContextRuntimeEvent;
+declare const index$b_PersistedEvent: typeof PersistedEvent;
+type index$b_ToolNode = ToolNode;
+declare const index$b_ToolNode: typeof ToolNode;
+type index$b_UserNode = UserNode;
+declare const index$b_UserNode: typeof UserNode;
+type index$b_WaitUserNode = WaitUserNode;
+declare const index$b_WaitUserNode: typeof WaitUserNode;
+declare const index$b_createMonotonicEventIdFactory: typeof createMonotonicEventIdFactory;
+declare const index$b_summarizeCheckpoint: typeof summarizeCheckpoint;
+declare namespace index$b {
+  export { index$b_AnswerNode as AnswerNode, index$b_CheckpointListFilter as CheckpointListFilter, index$b_CheckpointMeta as CheckpointMeta, index$b_CheckpointSummary as CheckpointSummary, index$b_Checkpointer as Checkpointer, index$b_ENGINE_STATE_SCHEMA_VERSION as ENGINE_STATE_SCHEMA_VERSION, index$b_EngineState as EngineState, index$b_EventRangeOptions as EventRangeOptions, index$b_EventStore as EventStore, index$b_ExecutorLocalState as ExecutorLocalState, index$b_GraphAgentExecutor as GraphAgentExecutor, type index$b_GraphAgentExecutorDependencies as GraphAgentExecutorDependencies, index$b_GraphExecutor as GraphExecutor, type index$b_GraphExecutorContextBuildInput as GraphExecutorContextBuildInput, type index$b_GraphExecutorContextBuildOutput as GraphExecutorContextBuildOutput, type index$b_GraphExecutorContextBuilder as GraphExecutorContextBuilder, index$b_GraphNode as GraphNode, index$b_LlmNode as LlmNode, index$b_MemoryCheckpointer as MemoryCheckpointer, index$b_MemoryEventStore as MemoryEventStore, type index$b_PendingContextRuntimeEvent as PendingContextRuntimeEvent, index$b_PersistedEvent as PersistedEvent, index$b_ToolNode as ToolNode, index$b_UserNode as UserNode, index$b_WaitUserNode as WaitUserNode, index$b_createMonotonicEventIdFactory as createMonotonicEventIdFactory, index$b_summarizeCheckpoint as summarizeCheckpoint };
+}
+
+interface ContextCheckpointToolArgs extends ToolArgs {
+    summary?: unknown;
+}
+interface ContextCheckpointPayload extends Record<string, unknown> {
+    _type: typeof CHECKPOINT_MARKER_TYPE;
+    summary: string;
+}
+interface ContextCheckpointToolHookParams {
+    args: ContextCheckpointToolArgs;
+    context: ToolExecutionContext;
+    summary: string;
+}
+type ContextCheckpointPayloadExtension = Record<string, unknown> | void | undefined;
+interface ContextCheckpointToolOptions {
+    /**
+     * 工具名。必须与 `AgentSpec.contextPolicy.checkpoint.triggerToolName` 保持一致。
+     */
+    name?: string;
+    /**
+     * 工具描述。host 可以替换成更贴合自己状态系统的文案。
+     */
+    description?: string;
+    /**
+     * summary 最大字符数。
+     */
+    summaryMaxLength?: number;
+    /**
+     * host 额外参数 schema，例如 taskstate / references。
+     */
+    extraParameters?: Record<string, ToolParameterProperty>;
+    /**
+     * host 额外 required 字段。`summary` 永远必填。
+     */
+    requiredExtraParameters?: string[];
+    /**
+     * 扩展 checkpoint payload。返回值会被合并到 data 中，但 `_type` 与 `summary`
+     * 由 framework 最后写入，host 不能覆盖协议核心字段。
+     */
+    buildPayloadExtension?: (params: ContextCheckpointToolHookParams) => Promise<ContextCheckpointPayloadExtension> | ContextCheckpointPayloadExtension;
+    /**
+     * 自定义给模型看的 observation 文本。不影响 provider 识别；provider 只读 raw output marker。
+     */
+    buildObservation?: (params: ContextCheckpointToolHookParams & {
+        payload: ContextCheckpointPayload;
+    }) => Promise<string> | string;
+}
+/**
+ * host-neutral 的最小 checkpoint 工具。
+ *
+ * 中文备注：
+ * - 它只负责输出 linnkit 能识别的 checkpoint marker；
+ * - TaskState / SharedMemory / 外部文档写入属于 host 能力，可通过 hook 扩展；
+ * - host 不注册这个工具时，主动 checkpoint 行为不会启用。
+ */
+declare class ContextCheckpointTool extends BaseTool<ContextCheckpointToolArgs, string> {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: ToolParameterSchema;
+    private readonly summaryMaxLength;
+    private readonly buildPayloadExtension?;
+    private readonly buildObservation?;
+    constructor(options?: ContextCheckpointToolOptions);
+    run(args: ContextCheckpointToolArgs, context: ToolExecutionContext): Promise<string>;
+}
+declare function createContextCheckpointTool(options?: ContextCheckpointToolOptions): ContextCheckpointTool;
+
+type UnknownRecord = Record<string, unknown>;
+type NormalizeToolArgsOptions = {
+    toolName?: string;
+    path?: string;
+};
+declare function normalizeToolArgs(schema: ToolParameterSchema, args: UnknownRecord, options?: NormalizeToolArgsOptions): UnknownRecord;
+
+type RuntimeEventSource = () => ReadonlyArray<RuntimeEvent>;
+interface ToolContextExecutionMeta {
+    conversationId?: string;
+    turnId?: string;
+    runId?: string;
+    parentRunId?: string;
+    parentToolCallId?: string;
+    citationOffset?: number;
+}
+interface ToolContextRuntimeBinding {
+    readonly conversationView: ToolContextConversationView;
+    getWorkingHistoryEvents(): ReadonlyArray<RuntimeEvent>;
+    getPersistedHistoryEvents(): ReadonlyArray<RuntimeEvent>;
+    setWorkingHistorySource(source: ReadonlyArray<RuntimeEvent> | RuntimeEventSource): void;
+    setPersistedHistorySource(source: ReadonlyArray<RuntimeEvent> | RuntimeEventSource): void;
+    bindExecutionMeta(meta: ToolContextExecutionMeta): void;
+    readExecutionMeta(): Readonly<ToolContextExecutionMeta>;
+}
+declare function ensureToolContextRuntimeCapability(params: {
+    context: ToolExecutionContext;
+    persistedHistory?: ReadonlyArray<RuntimeEvent> | RuntimeEventSource;
+    workingHistory?: ReadonlyArray<RuntimeEvent> | RuntimeEventSource;
+    executionMeta?: ToolContextExecutionMeta;
+}): ToolContextRuntimeBinding;
+declare function getToolContextRuntimeBinding(context: ToolExecutionContext): ToolContextRuntimeBinding | undefined;
+declare function readToolContextWorkingHistory(context: ToolExecutionContext): ReadonlyArray<RuntimeEvent>;
+declare function readToolContextPersistedHistory(context: ToolExecutionContext): ReadonlyArray<RuntimeEvent>;
+declare function stripRuntimeReservedToolContextPatch(patch: Partial<ToolExecutionContext> | Record<string, unknown> | undefined): Record<string, unknown>;
+
+declare const index$a_AgentTool: typeof AgentTool;
+declare const index$a_BaseTool: typeof BaseTool;
+declare const index$a_CommonParameterTypes: typeof CommonParameterTypes;
+type index$a_ContextCheckpointPayload = ContextCheckpointPayload;
+type index$a_ContextCheckpointPayloadExtension = ContextCheckpointPayloadExtension;
+type index$a_ContextCheckpointTool = ContextCheckpointTool;
+declare const index$a_ContextCheckpointTool: typeof ContextCheckpointTool;
+type index$a_ContextCheckpointToolArgs = ContextCheckpointToolArgs;
+type index$a_ContextCheckpointToolHookParams = ContextCheckpointToolHookParams;
+type index$a_ContextCheckpointToolOptions = ContextCheckpointToolOptions;
+declare const index$a_ConversationArtifactContext: typeof ConversationArtifactContext;
+declare const index$a_JsonObjectSchema: typeof JsonObjectSchema;
+declare const index$a_ObservationPreviewContext: typeof ObservationPreviewContext;
+declare const index$a_ObservationPreviewMeta: typeof ObservationPreviewMeta;
+declare const index$a_ObservationPreviewPort: typeof ObservationPreviewPort;
+declare const index$a_ObservationPreviewResult: typeof ObservationPreviewResult;
+declare const index$a_OpenAIToolSchema: typeof OpenAIToolSchema;
+declare const index$a_StructuredToolResult: typeof StructuredToolResult;
+declare const index$a_ToolArgs: typeof ToolArgs;
+declare const index$a_ToolCallResult: typeof ToolCallResult;
+declare const index$a_ToolCatalogPort: typeof ToolCatalogPort;
+declare const index$a_ToolContextCompatibilityFields: typeof ToolContextCompatibilityFields;
+declare const index$a_ToolContextConversationView: typeof ToolContextConversationView;
+declare const index$a_ToolContextPatch: typeof ToolContextPatch;
+declare const index$a_ToolControlInfo: typeof ToolControlInfo;
+declare const index$a_ToolDisplayOptions: typeof ToolDisplayOptions;
+declare const index$a_ToolExecutionContext: typeof ToolExecutionContext;
+declare const index$a_ToolExecutionPort: typeof ToolExecutionPort;
+declare const index$a_ToolExecutionResult: typeof ToolExecutionResult;
+declare const index$a_ToolLayoutOptions: typeof ToolLayoutOptions;
+declare const index$a_ToolParameterProperty: typeof ToolParameterProperty;
+declare const index$a_ToolParameterSchema: typeof ToolParameterSchema;
+declare const index$a_ToolPresentationPort: typeof ToolPresentationPort;
+declare const index$a_ToolRegistryEntry: typeof ToolRegistryEntry;
+declare const index$a_ToolResult: typeof ToolResult;
+declare const index$a_ToolRuntimeDefinition: typeof ToolRuntimeDefinition;
+declare const index$a_ToolRuntimePort: typeof ToolRuntimePort;
+declare const index$a_ToolSchemaContext: typeof ToolSchemaContext;
+declare const index$a_UnifiedToolResult: typeof UnifiedToolResult;
+declare const index$a_computeToolIdempotencyKey: typeof computeToolIdempotencyKey;
+declare const index$a_createContextCheckpointTool: typeof createContextCheckpointTool;
+declare const index$a_ensureToolContextRuntimeCapability: typeof ensureToolContextRuntimeCapability;
+declare const index$a_findCachedToolOutputByIdempotencyKey: typeof findCachedToolOutputByIdempotencyKey;
+declare const index$a_getToolContextRuntimeBinding: typeof getToolContextRuntimeBinding;
+declare const index$a_normalizeToolArgs: typeof normalizeToolArgs;
+declare const index$a_readToolContextModelId: typeof readToolContextModelId;
+declare const index$a_readToolContextPersistedHistory: typeof readToolContextPersistedHistory;
+declare const index$a_readToolContextRunContext: typeof readToolContextRunContext;
+declare const index$a_readToolContextUserQuery: typeof readToolContextUserQuery;
+declare const index$a_readToolContextWorkingHistory: typeof readToolContextWorkingHistory;
+declare const index$a_stripRuntimeReservedToolContextPatch: typeof stripRuntimeReservedToolContextPatch;
+declare namespace index$a {
+  export { index$a_AgentTool as AgentTool, index$a_BaseTool as BaseTool, index$a_CommonParameterTypes as CommonParameterTypes, type index$a_ContextCheckpointPayload as ContextCheckpointPayload, type index$a_ContextCheckpointPayloadExtension as ContextCheckpointPayloadExtension, index$a_ContextCheckpointTool as ContextCheckpointTool, type index$a_ContextCheckpointToolArgs as ContextCheckpointToolArgs, type index$a_ContextCheckpointToolHookParams as ContextCheckpointToolHookParams, type index$a_ContextCheckpointToolOptions as ContextCheckpointToolOptions, index$a_ConversationArtifactContext as ConversationArtifactContext, index$a_JsonObjectSchema as JsonObjectSchema, index$a_ObservationPreviewContext as ObservationPreviewContext, index$a_ObservationPreviewMeta as ObservationPreviewMeta, index$a_ObservationPreviewPort as ObservationPreviewPort, index$a_ObservationPreviewResult as ObservationPreviewResult, index$a_OpenAIToolSchema as OpenAIToolSchema, index$a_StructuredToolResult as StructuredToolResult, index$a_ToolArgs as ToolArgs, index$a_ToolCallResult as ToolCallResult, index$a_ToolCatalogPort as ToolCatalogPort, index$a_ToolContextCompatibilityFields as ToolContextCompatibilityFields, index$a_ToolContextConversationView as ToolContextConversationView, index$a_ToolContextPatch as ToolContextPatch, index$a_ToolControlInfo as ToolControlInfo, index$a_ToolDisplayOptions as ToolDisplayOptions, index$a_ToolExecutionContext as ToolExecutionContext, index$a_ToolExecutionPort as ToolExecutionPort, index$a_ToolExecutionResult as ToolExecutionResult, index$a_ToolLayoutOptions as ToolLayoutOptions, index$a_ToolParameterProperty as ToolParameterProperty, index$a_ToolParameterSchema as ToolParameterSchema, index$a_ToolPresentationPort as ToolPresentationPort, index$a_ToolRegistryEntry as ToolRegistryEntry, index$a_ToolResult as ToolResult, index$a_ToolRuntimeDefinition as ToolRuntimeDefinition, index$a_ToolRuntimePort as ToolRuntimePort, index$a_ToolSchemaContext as ToolSchemaContext, index$a_UnifiedToolResult as UnifiedToolResult, index$a_computeToolIdempotencyKey as computeToolIdempotencyKey, index$a_createContextCheckpointTool as createContextCheckpointTool, index$a_ensureToolContextRuntimeCapability as ensureToolContextRuntimeCapability, index$a_findCachedToolOutputByIdempotencyKey as findCachedToolOutputByIdempotencyKey, index$a_getToolContextRuntimeBinding as getToolContextRuntimeBinding, index$a_normalizeToolArgs as normalizeToolArgs, index$a_readToolContextModelId as readToolContextModelId, index$a_readToolContextPersistedHistory as readToolContextPersistedHistory, index$a_readToolContextRunContext as readToolContextRunContext, index$a_readToolContextUserQuery as readToolContextUserQuery, index$a_readToolContextWorkingHistory as readToolContextWorkingHistory, index$a_stripRuntimeReservedToolContextPatch as stripRuntimeReservedToolContextPatch };
+}
+
+/**
+ * @file src/agent/runtime-kernel/execution/sequencer.ts
+ * @description 事件序列器 - 为事件分配序号和执行上下文
+ *
+ * 功能 (What):
+ * - 为每个执行流程生成唯一的 execution_id
+ * - 为事件分配单调递增的序号 (seq)
+ * - 将 RuntimeEvent 包装为 EventEnvelope，提供追踪和渲染元数据
+ *
+ * 输入 (Input):
+ * - RuntimeEvent 或原始事件数据
+ * - source 信息（事件来源）
+ *
+ * 输出 (Output):
+ * - EventEnvelope 包装的事件
+ *
+ * 副作用 (Side-effects):
+ * - 维护内存中的序号状态
+ */
+
+/**
+ * 事件序列器类
+ *
+ * 职责：
+ * - 管理执行上下文（execution_id, trace_id）
+ * - 为事件分配严格递增的序号
+ * - 提供事件包装功能
+ */
+declare class EventSequencer {
+    private readonly executionId;
+    private readonly traceId;
+    private currentSeq;
+    constructor(conversationId: string, traceId?: string);
+    /**
+     * 获取执行上下文
+     */
+    getExecutionContext(): ExecutionTraceContext;
+    /**
+     * 获取下一个序号
+     * 这个方法是线程安全的，因为 Node.js 是单线程的
+     */
+    private getNextSeq;
+    /**
+     * 将 RuntimeEvent 包装为 EventEnvelope
+     *
+     * @param runtimeEvent - 需要包装的运行时事件
+     * @param source - 事件来源标识
+     * @param renderHint - 可选的渲染建议
+     * @param runLocation - 可选的执行位置
+     * @returns 包装后的事件信封
+     */
+    wrapEvent(runtimeEvent: RuntimeEvent, source: string, options?: {
+        renderHint?: EventEnvelope<RuntimeEvent>['render_hint'];
+        runLocation?: EventEnvelope<RuntimeEvent>['run_location'];
+    }): EventEnvelope<RuntimeEvent>;
+    /**
+     * 获取当前序号（调试用）
+     */
+    getCurrentSeq(): number;
+    /**
+     * 获取执行ID（调试用）
+     */
+    getExecutionId(): string;
+}
+
+interface CreateRuntimeErrorEventInput {
+    /**
+     * 可选：由调用方提供稳定 id（例如 generateMessageId()）。
+     * 若不提供，工厂会生成一个临时 id。
+     */
+    id?: string;
+    conversationId: string;
+    turnId: string;
+    error: unknown;
+    /**
+     * 事件来源，用于排查（不会直接展示给用户）。
+     */
+    source?: string;
+    /**
+     * 可选：覆盖 error_code（例如 SUMMARIZATION_FAILED）。
+     */
+    errorCode?: string;
+    /**
+     * 可选：覆盖 retryable。
+     */
+    retryable?: boolean;
+    /**
+     * 可选：覆盖 error 文本（默认使用原始 error.message）。
+     * 注意：这不是“用户友好化文案”，只是允许在系统级错误里加上更明确的上下文前缀。
+     */
+    errorText?: string;
+    /**
+     * 可选：合并到 details 的附加字段（便于调用方补充上下文信息）。
+     */
+    detailsPatch?: Record<string, unknown>;
+}
+/**
+ * 统一创建 RuntimeEvent(type='error')。
+ *
+ * 中文备注：
+ * - `error` 字段保留原始 message（前端负责友好化）；
+ * - `error_code` 尽量稳定：优先上游结构化 type，否则 fallback 到分类结果；
+ * - `retryable` 与 `details.classification` 使用同一份 classifier 输出，避免重复判断。
+ */
+declare function createRuntimeErrorEvent(input: CreateRuntimeErrorEventInput): ErrorEvent;
+
+declare const index$9_EventBus: typeof EventBus;
+type index$9_EventSequencer = EventSequencer;
+declare const index$9_EventSequencer: typeof EventSequencer;
+declare const index$9_createRuntimeErrorEvent: typeof createRuntimeErrorEvent;
+declare namespace index$9 {
+  export { index$9_EventBus as EventBus, index$9_EventSequencer as EventSequencer, index$9_createRuntimeErrorEvent as createRuntimeErrorEvent };
+}
+
+declare const index$8_RunContext: typeof RunContext;
+declare const index$8_createDefaultRunContext: typeof createDefaultRunContext;
+declare namespace index$8 {
+  export { index$8_RunContext as RunContext, index$8_createDefaultRunContext as createDefaultRunContext };
+}
+
+/**
+ * @file src/agent/runtime-kernel/child-runs/childRunInvoker.ts
+ * @description child-run 调用器
+ */
+
+interface ChildRunAgentConfig {
+    id: string;
+    promptKey: string;
+    availableTools?: readonly string[];
+    modelPolicy?: {
+        kind: 'fixed';
+        modelId: string;
+    };
+    stepPolicy?: {
+        kind: 'final_answer' | 'force_tools';
+        lastStepsHintThreshold?: number;
+        forcedTools?: readonly string[];
+    };
+    contextPolicy?: AgentSpecContextPolicy;
+    systemReminderPolicy?: AgentSpecSystemReminderPolicy;
+    systemPromptBuilder?: (request: AgentInvocationRequest) => string;
+    judgeToolName?: string;
+}
+interface ChildRunInvokeConfig {
+    agentConfig: ChildRunAgentConfig;
+    userMessage: string;
+    parentToolContext: ChildRunParentContext;
+    runId?: string;
+    parentRunId?: string;
+    abortSignal?: AbortSignal;
+    subrunTracePublisher?: SubRunTracePublisher;
+    seedHistoryEvents?: RuntimeEvent[];
+    maxSteps?: number;
+    modelId?: string;
+}
+interface ChildRunInvokeResult {
+    runId?: string;
+    parentRunId?: string;
+    success: boolean;
+    judgeToolOutput?: string;
+    finalAnswer?: string;
+    events: RuntimeEvent[];
+    stepCount: number;
+    error?: string;
+}
+declare class ChildRunInvoker {
+    private readonly modelResolver;
+    private readonly createLlmNode;
+    private readonly toolRuntime;
+    private readonly observationPreview;
+    private readonly eventToMessageConverter;
+    private readonly defaultJudgeToolName?;
+    private readonly telemetryPort;
+    private readonly auditPort;
+    constructor(dependencies: {
+        modelResolver: Pick<ModelResolverLike, 'resolveModelId'>;
+        createLlmNode: () => GraphNode;
+        toolRuntime: Pick<ToolRuntimePort, 'getToolDefinition' | 'executeTool'>;
+        observationPreview: ObservationPreviewPort;
+        eventToMessageConverter: (events: RuntimeEvent[]) => unknown[];
+        defaultJudgeToolName?: string;
+        telemetryPort?: TelemetryPort;
+        auditPort?: AuditPort;
+    });
+    invoke(config: ChildRunInvokeConfig): Promise<ChildRunInvokeResult>;
+}
+
+declare function pickChildRunSeedHistory(params: {
+    parentHistory: ReadonlyArray<RuntimeEvent>;
+    historyPolicy?: ChildRunHistoryPolicy;
+}): RuntimeEvent[];
+
+type index$7_ChildRunAgentConfig = ChildRunAgentConfig;
+type index$7_ChildRunInvokeConfig = ChildRunInvokeConfig;
+type index$7_ChildRunInvokeResult = ChildRunInvokeResult;
+type index$7_ChildRunInvoker = ChildRunInvoker;
+declare const index$7_ChildRunInvoker: typeof ChildRunInvoker;
+declare const index$7_ChildRunInvokerPort: typeof ChildRunInvokerPort;
+declare const index$7_ChildRunRequest: typeof ChildRunRequest;
+declare const index$7_ChildRunResult: typeof ChildRunResult;
+declare const index$7_pickChildRunSeedHistory: typeof pickChildRunSeedHistory;
+declare namespace index$7 {
+  export { type index$7_ChildRunAgentConfig as ChildRunAgentConfig, type index$7_ChildRunInvokeConfig as ChildRunInvokeConfig, type index$7_ChildRunInvokeResult as ChildRunInvokeResult, index$7_ChildRunInvoker as ChildRunInvoker, index$7_ChildRunInvokerPort as ChildRunInvokerPort, index$7_ChildRunRequest as ChildRunRequest, index$7_ChildRunResult as ChildRunResult, index$7_pickChildRunSeedHistory as pickChildRunSeedHistory };
+}
+
+interface EventBusSubRunTracePublisherOptions {
+    eventBus: EventBus;
+    sequencer: EventSequencer;
+    /** 父会话上下文：用于填充 RuntimeEvent 基础字段 */
+    conversationId: string;
+    turnId: string;
+    /** 绑定关系：用于 UI 精确归属与并发分桶 */
+    parentToolCallId: string;
+    subrunId: string;
+    subrunParentId?: string;
+    /**
+     * 事件来源（用于调试与过滤）
+     * 建议格式：`subrun:<tool_name>` 或 `tool:<tool_name>:subrun`
+     */
+    source?: string;
+    /**
+     * 透传到 RuntimeEvent.metadata 的扩展字段（可选）
+     * 注意：subrun_trace 默认不持久化，但 metadata 仍会随 SSE 推送给前端用于调试/归类。
+     */
+    metadata?: Record<string, unknown>;
+    /**
+     * 是否持久化 subrun_trace（用于历史回放）。
+     *
+     * 默认 false：
+     * - subrun_trace 为高频增量过程事件，写入事实事件表会造成体积膨胀；
+     * - 因此默认只走实时 SSE（ephemeral=true），不落库。
+     *
+     * 仅当业务明确需要“回放时可重建子过程”才应开启（例如 task 通用子 Agent）。
+     *
+     * ⚠️ 注意：
+     * - 即使开启持久化，该事件仍属于 UI-only 数据；
+     * - ContextManager 构建 LLM 上下文时必须过滤该类事件，避免污染父会话上下文。
+     */
+    persistForReplay?: boolean;
+}
+/**
+ * EventBusSubRunTracePublisher
+ *
+ * 说明：
+ * - 该发布器在构造时绑定 parent_tool_call_id 与 subrun_id；
+ * - 每次 publish 只需要提供“分片载荷”（kind/delta/...）即可。
+ */
+declare class EventBusSubRunTracePublisher implements SubRunTracePublisher {
+    private readonly eventBus;
+    private readonly sequencer;
+    private readonly conversationId;
+    private readonly turnId;
+    private readonly parentToolCallId;
+    private readonly subrunId;
+    private readonly subrunParentId?;
+    private readonly source;
+    private readonly metadata?;
+    private readonly persistForReplay;
+    constructor(options: EventBusSubRunTracePublisherOptions);
+    publish(envelope: SubRunTraceEnvelope): void;
+}
+
+type index$6_EventBusSubRunTracePublisher = EventBusSubRunTracePublisher;
+declare const index$6_EventBusSubRunTracePublisher: typeof EventBusSubRunTracePublisher;
+declare const index$6_SubRunTracePublisher: typeof SubRunTracePublisher;
+declare namespace index$6 {
+  export { index$6_EventBusSubRunTracePublisher as EventBusSubRunTracePublisher, index$6_SubRunTracePublisher as SubRunTracePublisher };
+}
+
+/**
+ * @file src/agent/runtime-kernel/enrichment/types.ts
+ * @description 请求增强器（Request Enricher）接口定义
+ *
+ * 核心目标：
+ * - 将业务特定的上下文组装逻辑（如 Review 的角色解析等）从主循环剥离
+ * - 提供统一的扩展点，主循环只负责调度，不感知具体业务
+ */
+
+interface EnrichmentContext {
+    /**
+     * 当前会话 ID
+     *
+     * 中文备注：
+     * - RequestEnricher 的目标是"把业务特定逻辑从主循环剥离"，但它仍然是"针对某个会话的增强"；
+     * - Deep Research / Review 等业务常需要读取/写入会话级状态（例如 conversations.metadata），
+     *   因此把 conversationId 纳入 enrichment 上下文是结构性必需条件；
+     * - 该字段是运行期上下文，不属于模型输入。
+     */
+    conversationId: string;
+    /** 原始请求（运行时为 AgentInvokeRequest，runtime 只依赖 AgentInvocationRequest 协议面） */
+    request: AgentInvocationRequest;
+    /** 当前运行上下文 */
+    runContext: RunContext;
+}
+interface EnrichmentResult {
+    /**
+     * 增强后的请求对象（例如：补全了 system_prompt / knowledge 变量）
+     * - 如果不需要修改，可返回原对象
+     */
+    request: AgentInvocationRequest;
+    /**
+     * 需要注入到 ToolContext 的额外数据
+     * - 例如：Review 场景下的 block_map (已废弃) 或 review_run_id 等元信息
+     * - 这些数据仅工具可见，模型不可见
+     */
+    toolContextPatch?: ToolContextPatch;
+    /**
+     * 对 RunContext 的更新（可选）
+     * - 例如：业务层解析出了更准确的 traceId 或 tags
+     */
+    runContextPatch?: Partial<RunContext>;
+}
+/**
+ * Registry 输出的最终增强结果
+ *
+ * 说明：
+ * - `RequestEnricher.enrich()` 返回 patch（增量）
+ * - Registry 会把所有 patch 串行合并，并返回最终的 `runContext`
+ */
+interface RegistryEnrichmentResult {
+    request: AgentInvocationRequest;
+    toolContextPatch?: ToolContextPatch;
+    runContext: RunContext;
+}
+/**
+ * 请求增强器接口
+ *
+ * 中文备注：
+ * - runtime 层只依赖 AgentInvocationRequest 协议面；
+ * - 产品层 enricher 实现中，运行时收到的实际值是 AgentInvokeRequest（结构上满足 AgentInvocationRequest）；
+ * - 需要访问产品级字段时，features 实现可在边界做安全窄化。
+ */
+interface RequestEnricher {
+    /** 增强器名称（用于调试/日志） */
+    name: string;
+    /**
+     * 判断该增强器是否适用于当前请求
+     * - 通常基于 promptKey 或 mode 判断
+     */
+    isApplicable(request: AgentInvocationRequest): boolean;
+    /**
+     * 执行增强逻辑
+     * - 可以包含异步操作（查库、调 RPC 等）
+     */
+    enrich(context: EnrichmentContext): Promise<EnrichmentResult>;
+}
+
+/**
+ * @file src/agent/runtime-kernel/enrichment/registry.ts
+ * @description 请求增强器注册表
+ */
+
+declare class RequestEnricherRegistry {
+    private enrichers;
+    /**
+     * 注册增强器
+     */
+    register(enricher: RequestEnricher): void;
+    /**
+     * 执行所有适用的增强器
+     * - 按注册顺序串行执行（后续增强器基于前序结果继续增强）
+     */
+    enrich(context: EnrichmentContext): Promise<RegistryEnrichmentResult>;
+}
+declare const requestEnricherRegistry: RequestEnricherRegistry;
+
+type index$5_EnrichmentContext = EnrichmentContext;
+type index$5_EnrichmentResult = EnrichmentResult;
+type index$5_RegistryEnrichmentResult = RegistryEnrichmentResult;
+type index$5_RequestEnricher = RequestEnricher;
+declare const index$5_requestEnricherRegistry: typeof requestEnricherRegistry;
+declare namespace index$5 {
+  export { type index$5_EnrichmentContext as EnrichmentContext, type index$5_EnrichmentResult as EnrichmentResult, type index$5_RegistryEnrichmentResult as RegistryEnrichmentResult, type index$5_RequestEnricher as RequestEnricher, index$5_requestEnricherRegistry as requestEnricherRegistry };
+}
+
+declare class NotImplementedError extends Error {
+    constructor(message: string);
+}
+declare class RunNotFoundError extends Error {
+    constructor(runId: string);
+}
+declare class RunAlreadyRegisteredError extends Error {
+    readonly runId: string;
+    constructor(runId: string);
+}
+
+declare const index$4_CancelOpts: typeof CancelOpts;
+declare const index$4_DefaultRunHandle: typeof DefaultRunHandle;
+declare const index$4_DefaultRunHandleOptions: typeof DefaultRunHandleOptions;
+declare const index$4_DefaultRunSupervisor: typeof DefaultRunSupervisor;
+declare const index$4_DefaultRunSupervisorOptions: typeof DefaultRunSupervisorOptions;
+declare const index$4_FindActiveByConversationOptions: typeof FindActiveByConversationOptions;
+declare const index$4_ListRunsFilter: typeof ListRunsFilter;
+declare const index$4_MemoryRunRegistryStore: typeof MemoryRunRegistryStore;
+type index$4_NotImplementedError = NotImplementedError;
+declare const index$4_NotImplementedError: typeof NotImplementedError;
+type index$4_RunAlreadyRegisteredError = RunAlreadyRegisteredError;
+declare const index$4_RunAlreadyRegisteredError: typeof RunAlreadyRegisteredError;
+declare const index$4_RunAwaitingUserPatch: typeof RunAwaitingUserPatch;
+declare const index$4_RunCost: typeof RunCost;
+declare const index$4_RunCostCollector: typeof RunCostCollector;
+declare const index$4_RunExecutionContext: typeof RunExecutionContext;
+declare const index$4_RunExecutorPort: typeof RunExecutorPort;
+declare const index$4_RunFailureInfo: typeof RunFailureInfo;
+declare const index$4_RunHandle: typeof RunHandle;
+declare const index$4_RunLifecyclePatch: typeof RunLifecyclePatch;
+declare const index$4_RunMeta: typeof RunMeta;
+type index$4_RunNotFoundError = RunNotFoundError;
+declare const index$4_RunNotFoundError: typeof RunNotFoundError;
+declare const index$4_RunObserveFilter: typeof RunObserveFilter;
+declare const index$4_RunOutcome: typeof RunOutcome;
+declare const index$4_RunRecord: typeof RunRecord;
+declare const index$4_RunRegistrationSpec: typeof RunRegistrationSpec;
+declare const index$4_RunRegistryStore: typeof RunRegistryStore;
+declare const index$4_RunRequestSnapshot: typeof RunRequestSnapshot;
+declare const index$4_RunSnapshot: typeof RunSnapshot;
+declare const index$4_RunStatus: typeof RunStatus;
+declare const index$4_RunSupervisor: typeof RunSupervisor;
+declare const index$4_RunTerminalError: typeof RunTerminalError;
+declare const index$4_RunTerminalEvent: typeof RunTerminalEvent;
+declare const index$4_RunTerminalStatus: typeof RunTerminalStatus;
+declare const index$4_RunWaitForTerminalOptions: typeof RunWaitForTerminalOptions;
+declare const index$4_runMetaFromRecord: typeof runMetaFromRecord;
+declare namespace index$4 {
+  export { index$4_CancelOpts as CancelOpts, index$4_DefaultRunHandle as DefaultRunHandle, index$4_DefaultRunHandleOptions as DefaultRunHandleOptions, index$4_DefaultRunSupervisor as DefaultRunSupervisor, index$4_DefaultRunSupervisorOptions as DefaultRunSupervisorOptions, index$4_FindActiveByConversationOptions as FindActiveByConversationOptions, index$4_ListRunsFilter as ListRunsFilter, index$4_MemoryRunRegistryStore as MemoryRunRegistryStore, index$4_NotImplementedError as NotImplementedError, index$4_RunAlreadyRegisteredError as RunAlreadyRegisteredError, index$4_RunAwaitingUserPatch as RunAwaitingUserPatch, index$4_RunCost as RunCost, index$4_RunCostCollector as RunCostCollector, index$4_RunExecutionContext as RunExecutionContext, index$4_RunExecutorPort as RunExecutorPort, index$4_RunFailureInfo as RunFailureInfo, index$4_RunHandle as RunHandle, index$4_RunLifecyclePatch as RunLifecyclePatch, index$4_RunMeta as RunMeta, index$4_RunNotFoundError as RunNotFoundError, index$4_RunObserveFilter as RunObserveFilter, index$4_RunOutcome as RunOutcome, index$4_RunRecord as RunRecord, index$4_RunRegistrationSpec as RunRegistrationSpec, index$4_RunRegistryStore as RunRegistryStore, index$4_RunRequestSnapshot as RunRequestSnapshot, index$4_RunSnapshot as RunSnapshot, index$4_RunStatus as RunStatus, index$4_RunSupervisor as RunSupervisor, index$4_RunTerminalError as RunTerminalError, index$4_RunTerminalEvent as RunTerminalEvent, index$4_RunTerminalStatus as RunTerminalStatus, index$4_RunWaitForTerminalOptions as RunWaitForTerminalOptions, index$4_runMetaFromRecord as runMetaFromRecord };
+}
+
+declare const noopTelemetry: TelemetryPort;
+
+declare const index$3_TELEMETRY_EVENT_KINDS: typeof TELEMETRY_EVENT_KINDS;
+declare const index$3_TelemetryEvent: typeof TelemetryEvent;
+declare const index$3_TelemetryPort: typeof TelemetryPort;
+declare const index$3_TelemetryScope: typeof TelemetryScope;
+declare const index$3_noopTelemetry: typeof noopTelemetry;
+declare namespace index$3 {
+  export { index$3_TELEMETRY_EVENT_KINDS as TELEMETRY_EVENT_KINDS, index$3_TelemetryEvent as TelemetryEvent, index$3_TelemetryPort as TelemetryPort, index$3_TelemetryScope as TelemetryScope, index$3_noopTelemetry as noopTelemetry };
+}
+
+interface ConsoleAuditOptions {
+    sink?: Pick<Console, 'info'>;
+}
+declare function createConsoleAudit(options?: ConsoleAuditOptions): AuditPort;
+declare const consoleAudit: AuditPort;
+
+interface CompositeAuditOptions {
+    ports: readonly AuditPort[];
+}
+/**
+ * 组合多个审计 sink。
+ *
+ * 中文备注：
+ * - 按顺序 await，确保 EventStore 这类主审计落点先完成；
+ * - 不吞异常，审计失败应该暴露给调用方，由 host 决定是否降级。
+ */
+declare class CompositeAuditPort implements AuditPort {
+    private readonly ports;
+    constructor(options: CompositeAuditOptions);
+    emit(envelope: AuditEnvelope): Promise<void>;
+    flush(): Promise<void>;
+}
+declare function createCompositeAudit(options: CompositeAuditOptions): AuditPort;
+
+interface EmitAuditEnvelopeParams {
+    runId?: string;
+    parentRunId?: string;
+    actor?: AuditActor;
+    action: string;
+    decision?: AuditDecision;
+    evidence?: AuditEvidence[];
+    costDelta?: AuditCostDelta;
+    scope: AuditScope;
+}
+/**
+ * 统一发出 AuditEnvelope。
+ *
+ * 中文备注：
+ * - 调用点只描述“谁做了什么决策”，这里统一补 envelopeId / ts / runId；
+ * - 不吞 emit 异常，审计链路异常应由上层测试或 host 策略显式处理。
+ */
+declare function emitAuditEnvelope(auditPort: AuditPort, params: EmitAuditEnvelopeParams): Promise<void>;
+declare function emitSandboxDecisionAudit(auditPort: AuditPort, params: {
+    scope: AuditScope;
+    allowed: boolean;
+    reason?: string;
+    policy?: string;
+    evidence?: AuditEvidence[];
+}): Promise<void>;
+
+interface EventStoreAuditOptions {
+    eventStore: EventStore;
+}
+declare class AuditEnvelopePersistenceError extends Error {
+    constructor(message: string);
+}
+/**
+ * 默认 EventStore 审计 sink。
+ *
+ * 中文备注：
+ * - 写入隐藏 RuntimeEvent：type=audit_envelope；
+ * - 事件不进 UI、不进 agent context，只作为追加只读审计事实保留；
+ * - conversationId 必须来自 envelope.scope，避免把跨会话审计混进同一条流。
+ */
+declare class EventStoreAuditPort implements AuditPort {
+    private readonly eventStore;
+    constructor(options: EventStoreAuditOptions);
+    emit(envelope: AuditEnvelope): Promise<void>;
+}
+declare function createEventStoreAudit(options: EventStoreAuditOptions): AuditPort;
+
+interface FileAuditOptions {
+    filePath: string;
+}
+/**
+ * JSONL 文件审计 sink。
+ *
+ * 中文备注：
+ * - 每个 envelope 一行，便于 tail / grep / 后续导入 SIEM；
+ * - 不做轮转与脱敏，轮转/脱敏属于 host 策略，后续由 G-4 RedactionPort 处理。
+ */
+declare class FileAuditPort implements AuditPort {
+    private readonly filePath;
+    constructor(options: FileAuditOptions);
+    emit(envelope: AuditEnvelope): Promise<void>;
+}
+declare function createFileAudit(options: FileAuditOptions): AuditPort;
+
+declare const noopAudit: AuditPort;
+
+type index$2_AuditEnvelopePersistenceError = AuditEnvelopePersistenceError;
+declare const index$2_AuditEnvelopePersistenceError: typeof AuditEnvelopePersistenceError;
+type index$2_CompositeAuditOptions = CompositeAuditOptions;
+type index$2_CompositeAuditPort = CompositeAuditPort;
+declare const index$2_CompositeAuditPort: typeof CompositeAuditPort;
+type index$2_ConsoleAuditOptions = ConsoleAuditOptions;
+type index$2_EmitAuditEnvelopeParams = EmitAuditEnvelopeParams;
+type index$2_EventStoreAuditOptions = EventStoreAuditOptions;
+type index$2_EventStoreAuditPort = EventStoreAuditPort;
+declare const index$2_EventStoreAuditPort: typeof EventStoreAuditPort;
+type index$2_FileAuditOptions = FileAuditOptions;
+type index$2_FileAuditPort = FileAuditPort;
+declare const index$2_FileAuditPort: typeof FileAuditPort;
+declare const index$2_consoleAudit: typeof consoleAudit;
+declare const index$2_createCompositeAudit: typeof createCompositeAudit;
+declare const index$2_createConsoleAudit: typeof createConsoleAudit;
+declare const index$2_createEventStoreAudit: typeof createEventStoreAudit;
+declare const index$2_createFileAudit: typeof createFileAudit;
+declare const index$2_emitAuditEnvelope: typeof emitAuditEnvelope;
+declare const index$2_emitSandboxDecisionAudit: typeof emitSandboxDecisionAudit;
+declare const index$2_noopAudit: typeof noopAudit;
+declare namespace index$2 {
+  export { index$2_AuditEnvelopePersistenceError as AuditEnvelopePersistenceError, type index$2_CompositeAuditOptions as CompositeAuditOptions, index$2_CompositeAuditPort as CompositeAuditPort, type index$2_ConsoleAuditOptions as ConsoleAuditOptions, type index$2_EmitAuditEnvelopeParams as EmitAuditEnvelopeParams, type index$2_EventStoreAuditOptions as EventStoreAuditOptions, index$2_EventStoreAuditPort as EventStoreAuditPort, type index$2_FileAuditOptions as FileAuditOptions, index$2_FileAuditPort as FileAuditPort, index$2_consoleAudit as consoleAudit, index$2_createCompositeAudit as createCompositeAudit, index$2_createConsoleAudit as createConsoleAudit, index$2_createEventStoreAudit as createEventStoreAudit, index$2_createFileAudit as createFileAudit, index$2_emitAuditEnvelope as emitAuditEnvelope, index$2_emitSandboxDecisionAudit as emitSandboxDecisionAudit, index$2_noopAudit as noopAudit };
+}
+
+/**
+ * @file src/agent/runtime-kernel/system-reminder/types.ts
+ * @description SystemReminder（系统提醒）类型定义
+ *
+ * 设计目标（必须遵守）：
+ * - ✅ 只对“当前 tick / 当前 request”生效：不写入 history，不转换成 RuntimeEvent，不进入持久化
+ * - ✅ 配置驱动：新增/调整提醒只改 rules 配置文件
+ * - ✅ 注入形态：追加到“最后一条将发给 LLM 的 message.content”末尾，包裹在 <system-reminder> 标签中
+ */
+
+interface SystemReminderContext {
+    request: AgentInvocationRequest;
+    history: ReadonlyArray<RuntimeEvent>;
+    /**
+     * 执行阶段信号（由 GraphExecutor 注入）
+     * - stepCount/maxSteps/remainingSteps/phase/finalStepPolicy...
+     */
+    executorLocal?: ExecutorLocalState;
+}
+interface SystemReminderRule {
+    /**
+     * 规则唯一 ID（用于本 tick 内去重与调试定位）
+     */
+    id: string;
+    /**
+     * 是否触发
+     */
+    when: (ctx: SystemReminderContext) => boolean;
+    /**
+     * 构建提醒正文（不包含外层 <system-reminder> 标签）
+     */
+    build: (ctx: SystemReminderContext) => string;
+}
+type SystemReminderTriggerEvaluator = (ctx: SystemReminderContext, trigger: AgentSpecSystemReminderTrigger) => boolean;
+type SystemReminderContentTemplate = (ctx: SystemReminderContext, args: Record<string, unknown> | undefined) => string;
+interface SystemReminderRuleDefinition extends AgentSpecSystemReminderExtraRule {
+}
+
+declare class SystemReminderRegistry {
+    private readonly triggers;
+    private readonly templates;
+    constructor(seed?: {
+        triggers?: Record<string, SystemReminderTriggerEvaluator>;
+        templates?: Record<string, SystemReminderContentTemplate>;
+    });
+    registerTriggerKind(kind: string, evaluator: SystemReminderTriggerEvaluator): void;
+    registerContentTemplate(name: string, template: SystemReminderContentTemplate): void;
+    buildRule(definition: SystemReminderRuleDefinition): SystemReminderRule | undefined;
+}
+declare function createDefaultSystemReminderRegistry(): SystemReminderRegistry;
+declare const defaultSystemReminderRegistry: SystemReminderRegistry;
+
+/**
+ * @file src/agent/runtime-kernel/system-reminder/apply.ts
+ * @description SystemReminder 注入引擎：把提醒追加到“最后一条将发送给 LLM 的 message.content”末尾
+ *
+ * 关键约束（根因级）：
+ * - 这里的注入只发生在“即将发给 LLM 的 messages”数组上
+ * - 不生成 RuntimeEvent，不写入 history，不进入数据库（下一次 request 不可回放）
+ * - 允许出现在 LLMRunAudit（after_context_manager）里：因为它属于“本次真实发给模型的输入”
+ */
+
+/**
+ * 将 system-reminder 追加到最后一条消息末尾（原地返回新数组，但不修改原数组引用）
+ */
+declare function applySystemReminders(params: {
+    llmMessages: unknown[];
+    ctx: SystemReminderContext;
+    rules?: ReadonlyArray<SystemReminderRule>;
+    policy?: AgentSpecSystemReminderPolicy;
+    registry?: SystemReminderRegistry;
+    /**
+     * 🔔 命中回调：仅当本次确实发生注入时触发
+     *
+     * 中文备注：
+     * - 用于“审计增强”：在 after_context_manager 覆盖写语义下，仍能保留命中时刻的快照；
+     * - 回调只传递最小信息（ruleIds），避免额外依赖和体积膨胀。
+     */
+    onInjected?: (info: {
+        ruleIds: string[];
+    }) => void;
+}): unknown[];
+
+declare function readNonEmptyStrings(value: unknown): string[];
+declare function toDisplayStep(nodeSwitches: number): number;
+declare function readContextCheckpointToolName(ctx: SystemReminderContext): string;
+/**
+ * 统计“本轮请求内”的工具调用次数（LLM 决策层）。
+ *
+ * 中文备注：只统计最后一个 user_input 之后的 tool_call_decision，避免旧事件或 ToolNode
+ * 复用 action 语义时把同一轮工具调用重复计数。
+ */
+declare function countToolCallsInCurrentRequest(history: ReadonlyArray<unknown>): number;
+
+/**
+ * @file src/agent/runtime-kernel/system-reminder/rules.ts
+ * @description SystemReminder 规则集合（注册式配置入口）
+ *
+ * 中文备注：
+ * - 内置规则也走 trigger + template，和 host extraRules 使用同一套解释链路；
+ * - spec 只引用 rule/template/trigger ID，不塞函数，保证可序列化、可回放、可审计。
+ */
+
+declare const SYSTEM_REMINDER_RULES: ReadonlyArray<SystemReminderRuleDefinition>;
+declare function createSystemReminderRules(params?: {
+    policy?: AgentSpecSystemReminderPolicy;
+    registry?: SystemReminderRegistry;
+}): ReadonlyArray<SystemReminderRule>;
+
+declare const maxStepsForceFinalAnswerTemplate: SystemReminderContentTemplate;
+declare const lastStepsHintTemplate: SystemReminderContentTemplate;
+declare const toolCallStreakTemplate: SystemReminderContentTemplate;
+declare const periodicTaskstateReflectionTemplate: SystemReminderContentTemplate;
+declare const contextBudgetWarningTemplate: SystemReminderContentTemplate;
+declare const BUILTIN_SYSTEM_REMINDER_TEMPLATES: Record<string, SystemReminderContentTemplate>;
+
+declare const phaseEqualsTrigger: SystemReminderTriggerEvaluator;
+declare const remainingStepsLeqTrigger: SystemReminderTriggerEvaluator;
+declare const stepCountModuloTrigger: SystemReminderTriggerEvaluator;
+declare const toolCallStreakTrigger: SystemReminderTriggerEvaluator;
+declare const budgetWarningTrigger: SystemReminderTriggerEvaluator;
+declare const agentHasToolTrigger: SystemReminderTriggerEvaluator;
+declare const BUILTIN_SYSTEM_REMINDER_TRIGGERS: Record<string, SystemReminderTriggerEvaluator>;
+
+declare const index$1_BUILTIN_SYSTEM_REMINDER_TEMPLATES: typeof BUILTIN_SYSTEM_REMINDER_TEMPLATES;
+declare const index$1_BUILTIN_SYSTEM_REMINDER_TRIGGERS: typeof BUILTIN_SYSTEM_REMINDER_TRIGGERS;
+declare const index$1_DEFAULT_CONTEXT_CHECKPOINT_TOOL_NAME: typeof DEFAULT_CONTEXT_CHECKPOINT_TOOL_NAME;
+declare const index$1_SYSTEM_REMINDER_RULES: typeof SYSTEM_REMINDER_RULES;
+type index$1_SystemReminderContentTemplate = SystemReminderContentTemplate;
+type index$1_SystemReminderContext = SystemReminderContext;
+type index$1_SystemReminderRegistry = SystemReminderRegistry;
+declare const index$1_SystemReminderRegistry: typeof SystemReminderRegistry;
+type index$1_SystemReminderRule = SystemReminderRule;
+type index$1_SystemReminderRuleDefinition = SystemReminderRuleDefinition;
+type index$1_SystemReminderTriggerEvaluator = SystemReminderTriggerEvaluator;
+declare const index$1_agentHasToolTrigger: typeof agentHasToolTrigger;
+declare const index$1_applySystemReminders: typeof applySystemReminders;
+declare const index$1_budgetWarningTrigger: typeof budgetWarningTrigger;
+declare const index$1_contextBudgetWarningTemplate: typeof contextBudgetWarningTemplate;
+declare const index$1_countToolCallsInCurrentRequest: typeof countToolCallsInCurrentRequest;
+declare const index$1_createDefaultSystemReminderRegistry: typeof createDefaultSystemReminderRegistry;
+declare const index$1_createSystemReminderRules: typeof createSystemReminderRules;
+declare const index$1_defaultSystemReminderRegistry: typeof defaultSystemReminderRegistry;
+declare const index$1_lastStepsHintTemplate: typeof lastStepsHintTemplate;
+declare const index$1_maxStepsForceFinalAnswerTemplate: typeof maxStepsForceFinalAnswerTemplate;
+declare const index$1_periodicTaskstateReflectionTemplate: typeof periodicTaskstateReflectionTemplate;
+declare const index$1_phaseEqualsTrigger: typeof phaseEqualsTrigger;
+declare const index$1_readContextCheckpointToolName: typeof readContextCheckpointToolName;
+declare const index$1_readNonEmptyStrings: typeof readNonEmptyStrings;
+declare const index$1_remainingStepsLeqTrigger: typeof remainingStepsLeqTrigger;
+declare const index$1_stepCountModuloTrigger: typeof stepCountModuloTrigger;
+declare const index$1_toDisplayStep: typeof toDisplayStep;
+declare const index$1_toolCallStreakTemplate: typeof toolCallStreakTemplate;
+declare const index$1_toolCallStreakTrigger: typeof toolCallStreakTrigger;
+declare namespace index$1 {
+  export { index$1_BUILTIN_SYSTEM_REMINDER_TEMPLATES as BUILTIN_SYSTEM_REMINDER_TEMPLATES, index$1_BUILTIN_SYSTEM_REMINDER_TRIGGERS as BUILTIN_SYSTEM_REMINDER_TRIGGERS, index$1_DEFAULT_CONTEXT_CHECKPOINT_TOOL_NAME as DEFAULT_CONTEXT_CHECKPOINT_TOOL_NAME, index$1_SYSTEM_REMINDER_RULES as SYSTEM_REMINDER_RULES, type index$1_SystemReminderContentTemplate as SystemReminderContentTemplate, type index$1_SystemReminderContext as SystemReminderContext, index$1_SystemReminderRegistry as SystemReminderRegistry, type index$1_SystemReminderRule as SystemReminderRule, type index$1_SystemReminderRuleDefinition as SystemReminderRuleDefinition, type index$1_SystemReminderTriggerEvaluator as SystemReminderTriggerEvaluator, index$1_agentHasToolTrigger as agentHasToolTrigger, index$1_applySystemReminders as applySystemReminders, index$1_budgetWarningTrigger as budgetWarningTrigger, index$1_contextBudgetWarningTemplate as contextBudgetWarningTemplate, index$1_countToolCallsInCurrentRequest as countToolCallsInCurrentRequest, index$1_createDefaultSystemReminderRegistry as createDefaultSystemReminderRegistry, index$1_createSystemReminderRules as createSystemReminderRules, index$1_defaultSystemReminderRegistry as defaultSystemReminderRegistry, index$1_lastStepsHintTemplate as lastStepsHintTemplate, index$1_maxStepsForceFinalAnswerTemplate as maxStepsForceFinalAnswerTemplate, index$1_periodicTaskstateReflectionTemplate as periodicTaskstateReflectionTemplate, index$1_phaseEqualsTrigger as phaseEqualsTrigger, index$1_readContextCheckpointToolName as readContextCheckpointToolName, index$1_readNonEmptyStrings as readNonEmptyStrings, index$1_remainingStepsLeqTrigger as remainingStepsLeqTrigger, index$1_stepCountModuloTrigger as stepCountModuloTrigger, index$1_toDisplayStep as toDisplayStep, index$1_toolCallStreakTemplate as toolCallStreakTemplate, index$1_toolCallStreakTrigger as toolCallStreakTrigger };
+}
+
+/**
+ * @file src/agent/shared/errorClassifier.ts
+ *
+ * @brief Agent runtime 自己拥有的错误分类器
+ *
+ * @description
+ * 错误分类与重试策略属于 Agent runtime 的执行协议，不应该继续由 app shared owner 持有。
+ */
+declare enum ErrorCategory {
+    RETRYABLE = "retryable",
+    NON_RETRYABLE = "non_retryable",
+    RATE_LIMIT = "rate_limit"
+}
+declare const ENGINE_ERROR_CODES: {
+    readonly LLM_RATE_LIMIT: "llm.rate_limit";
+    readonly LLM_INVALID_TOOL_ARGS: "llm.invalid_tool_args";
+    readonly LLM_PROVIDER_DOWN: "llm.provider_down";
+    readonly LLM_UNSUPPORTED_CAPABILITY: "llm.unsupported_capability";
+    readonly LLM_AUTH_FAILED: "llm.auth_failed";
+    readonly LLM_INVALID_REQUEST: "llm.invalid_request";
+    readonly LLM_RESOURCE_NOT_FOUND: "llm.resource_not_found";
+    readonly TOOL_TIMEOUT: "tool.timeout";
+    readonly TOOL_PROTOCOL_FUSE: "tool.protocol_fuse";
+    readonly ENGINE_DELEGATE_DEPTH: "engine.delegate_depth_exceeded";
+    readonly ENGINE_BUDGET_EXHAUSTED: "engine.budget_exhausted";
+    readonly USER_CANCELLED: "user.cancelled";
+    readonly ENGINE_UNKNOWN: "engine.unknown";
+};
+interface ErrorClassification {
+    category: ErrorCategory;
+    reason: string;
+    suggestedDelay: number | null;
+    errorCode: string;
+    recoverable: boolean;
+    retryAfterMs?: number;
+    hint?: string;
+    metadata?: Record<string, unknown>;
+}
+
+declare const index_AgentTool: typeof AgentTool;
+type index_AnswerNode = AnswerNode;
+declare const index_AnswerNode: typeof AnswerNode;
+type index_AuditEnvelopePersistenceError = AuditEnvelopePersistenceError;
+declare const index_AuditEnvelopePersistenceError: typeof AuditEnvelopePersistenceError;
+declare const index_BUILTIN_SYSTEM_REMINDER_TEMPLATES: typeof BUILTIN_SYSTEM_REMINDER_TEMPLATES;
+declare const index_BUILTIN_SYSTEM_REMINDER_TRIGGERS: typeof BUILTIN_SYSTEM_REMINDER_TRIGGERS;
+declare const index_BaseTool: typeof BaseTool;
+declare const index_CheckpointListFilter: typeof CheckpointListFilter;
+declare const index_CheckpointMeta: typeof CheckpointMeta;
+declare const index_CheckpointSummary: typeof CheckpointSummary;
+declare const index_Checkpointer: typeof Checkpointer;
+declare const index_CommonParameterTypes: typeof CommonParameterTypes;
+type index_CompositeAuditOptions = CompositeAuditOptions;
+type index_CompositeAuditPort = CompositeAuditPort;
+declare const index_CompositeAuditPort: typeof CompositeAuditPort;
+type index_ConsoleAuditOptions = ConsoleAuditOptions;
+type index_ContextCheckpointPayload = ContextCheckpointPayload;
+type index_ContextCheckpointPayloadExtension = ContextCheckpointPayloadExtension;
+type index_ContextCheckpointTool = ContextCheckpointTool;
+declare const index_ContextCheckpointTool: typeof ContextCheckpointTool;
+type index_ContextCheckpointToolArgs = ContextCheckpointToolArgs;
+type index_ContextCheckpointToolHookParams = ContextCheckpointToolHookParams;
+type index_ContextCheckpointToolOptions = ContextCheckpointToolOptions;
+declare const index_ConversationArtifactContext: typeof ConversationArtifactContext;
+declare const index_DEFAULT_CONTEXT_CHECKPOINT_TOOL_NAME: typeof DEFAULT_CONTEXT_CHECKPOINT_TOOL_NAME;
+declare const index_DefaultGraphExecutorOptions: typeof DefaultGraphExecutorOptions;
+type index_DefaultTokenizerPort = DefaultTokenizerPort;
+declare const index_DefaultTokenizerPort: typeof DefaultTokenizerPort;
+type index_DefaultTokenizerPortConfig = DefaultTokenizerPortConfig;
+declare const index_ENGINE_ERROR_CODES: typeof ENGINE_ERROR_CODES;
+declare const index_ENGINE_STATE_SCHEMA_VERSION: typeof ENGINE_STATE_SCHEMA_VERSION;
+type index_EmitAuditEnvelopeParams = EmitAuditEnvelopeParams;
+declare const index_EngineState: typeof EngineState;
+type index_EnrichmentContext = EnrichmentContext;
+type index_EnrichmentResult = EnrichmentResult;
+type index_ErrorClassification = ErrorClassification;
+type index_EventBusSubRunTracePublisher = EventBusSubRunTracePublisher;
+declare const index_EventBusSubRunTracePublisher: typeof EventBusSubRunTracePublisher;
+declare const index_EventRangeOptions: typeof EventRangeOptions;
+declare const index_EventStore: typeof EventStore;
+type index_EventStoreAuditOptions = EventStoreAuditOptions;
+type index_EventStoreAuditPort = EventStoreAuditPort;
+declare const index_EventStoreAuditPort: typeof EventStoreAuditPort;
+declare const index_ExecutorLocalState: typeof ExecutorLocalState;
+type index_FileAuditOptions = FileAuditOptions;
+type index_FileAuditPort = FileAuditPort;
+declare const index_FileAuditPort: typeof FileAuditPort;
+type index_GraphAgentExecutor = GraphAgentExecutor;
+declare const index_GraphAgentExecutor: typeof GraphAgentExecutor;
+type index_GraphAgentExecutorDependencies = GraphAgentExecutorDependencies;
+declare const index_GraphExecutor: typeof GraphExecutor;
+type index_GraphExecutorContextBuildInput = GraphExecutorContextBuildInput;
+type index_GraphExecutorContextBuildOutput = GraphExecutorContextBuildOutput;
+type index_GraphExecutorContextBuilder = GraphExecutorContextBuilder;
+declare const index_GraphLoopHarness: typeof GraphLoopHarness;
+declare const index_GraphLoopHarnessOptions: typeof GraphLoopHarnessOptions;
+declare const index_GraphLoopHarnessRunResult: typeof GraphLoopHarnessRunResult;
+declare const index_GraphLoopLlmNodeFactoryParams: typeof GraphLoopLlmNodeFactoryParams;
+declare const index_GraphNode: typeof GraphNode;
+declare const index_JsonObjectSchema: typeof JsonObjectSchema;
+declare const index_LLMPolicy: typeof LLMPolicy;
+type index_LLMPolicyEngine = LLMPolicyEngine;
+declare const index_LLMPolicyEngine: typeof LLMPolicyEngine;
+declare const index_LLMPolicyErrorDecision: typeof LLMPolicyErrorDecision;
+declare const index_LLMPolicyMatchContext: typeof LLMPolicyMatchContext;
+declare const index_LLMPolicyRequestContext: typeof LLMPolicyRequestContext;
+declare const index_LLMPolicyResponseContext: typeof LLMPolicyResponseContext;
+declare const index_LlmCallOptions: typeof LlmCallOptions;
+declare const index_LlmCaller: typeof LlmCaller;
+type index_LlmNode = LlmNode;
+declare const index_LlmNode: typeof LlmNode;
+declare const index_LlmRequestMessage: typeof LlmRequestMessage;
+declare const index_LlmResponseContent: typeof LlmResponseContent;
+declare const index_LlmRetryConfig: typeof LlmRetryConfig;
+type index_MemoryCheckpointer = MemoryCheckpointer;
+declare const index_MemoryCheckpointer: typeof MemoryCheckpointer;
+declare const index_MemoryEventStore: typeof MemoryEventStore;
+declare const index_ModelCatalogEntry: typeof ModelCatalogEntry;
+declare const index_ModelCatalogLike: typeof ModelCatalogLike;
+declare const index_ModelResolver: typeof ModelResolver;
+declare const index_ObservationPreviewContext: typeof ObservationPreviewContext;
+declare const index_ObservationPreviewMeta: typeof ObservationPreviewMeta;
+declare const index_ObservationPreviewPort: typeof ObservationPreviewPort;
+declare const index_ObservationPreviewResult: typeof ObservationPreviewResult;
+declare const index_OpenAIToolSchema: typeof OpenAIToolSchema;
+type index_PendingContextRuntimeEvent = PendingContextRuntimeEvent;
+declare const index_PersistedEvent: typeof PersistedEvent;
+declare const index_ProviderReasoningDetails: typeof ProviderReasoningDetails;
+type index_RegistryEnrichmentResult = RegistryEnrichmentResult;
+type index_RequestEnricher = RequestEnricher;
+declare const index_SYSTEM_REMINDER_RULES: typeof SYSTEM_REMINDER_RULES;
+declare const index_StructuredToolResult: typeof StructuredToolResult;
+declare const index_SubRunTracePublisher: typeof SubRunTracePublisher;
+type index_SystemReminderContentTemplate = SystemReminderContentTemplate;
+type index_SystemReminderContext = SystemReminderContext;
+type index_SystemReminderRegistry = SystemReminderRegistry;
+declare const index_SystemReminderRegistry: typeof SystemReminderRegistry;
+type index_SystemReminderRule = SystemReminderRule;
+type index_SystemReminderRuleDefinition = SystemReminderRuleDefinition;
+type index_SystemReminderTriggerEvaluator = SystemReminderTriggerEvaluator;
+declare const index_ToolArgs: typeof ToolArgs;
+declare const index_ToolCall: typeof ToolCall;
+declare const index_ToolCallChunk: typeof ToolCallChunk;
+declare const index_ToolCallExtraContent: typeof ToolCallExtraContent;
+declare const index_ToolCallResult: typeof ToolCallResult;
+declare const index_ToolCatalogPort: typeof ToolCatalogPort;
+declare const index_ToolContextCompatibilityFields: typeof ToolContextCompatibilityFields;
+declare const index_ToolContextConversationView: typeof ToolContextConversationView;
+declare const index_ToolContextPatch: typeof ToolContextPatch;
+declare const index_ToolControlInfo: typeof ToolControlInfo;
+declare const index_ToolDisplayOptions: typeof ToolDisplayOptions;
+declare const index_ToolExecutionContext: typeof ToolExecutionContext;
+declare const index_ToolExecutionPort: typeof ToolExecutionPort;
+declare const index_ToolExecutionResult: typeof ToolExecutionResult;
+declare const index_ToolLayoutOptions: typeof ToolLayoutOptions;
+type index_ToolNode = ToolNode;
+declare const index_ToolNode: typeof ToolNode;
+declare const index_ToolParameterProperty: typeof ToolParameterProperty;
+declare const index_ToolParameterSchema: typeof ToolParameterSchema;
+declare const index_ToolPresentationPort: typeof ToolPresentationPort;
+declare const index_ToolRegistryEntry: typeof ToolRegistryEntry;
+declare const index_ToolResult: typeof ToolResult;
+declare const index_ToolRuntimeDefinition: typeof ToolRuntimeDefinition;
+declare const index_ToolRuntimePort: typeof ToolRuntimePort;
+declare const index_ToolSchemaContext: typeof ToolSchemaContext;
+declare const index_UnifiedToolResult: typeof UnifiedToolResult;
+type index_UserNode = UserNode;
+declare const index_UserNode: typeof UserNode;
+type index_WaitUserNode = WaitUserNode;
+declare const index_WaitUserNode: typeof WaitUserNode;
+declare const index_agentHasToolTrigger: typeof agentHasToolTrigger;
+declare const index_applySystemReminders: typeof applySystemReminders;
+declare const index_budgetWarningTrigger: typeof budgetWarningTrigger;
+declare const index_computeToolIdempotencyKey: typeof computeToolIdempotencyKey;
+declare const index_consoleAudit: typeof consoleAudit;
+declare const index_contextBudgetWarningTemplate: typeof contextBudgetWarningTemplate;
+declare const index_countToolCallsInCurrentRequest: typeof countToolCallsInCurrentRequest;
+declare const index_createCompositeAudit: typeof createCompositeAudit;
+declare const index_createConsoleAudit: typeof createConsoleAudit;
+declare const index_createContextCheckpointTool: typeof createContextCheckpointTool;
+declare const index_createDefaultGraphExecutor: typeof createDefaultGraphExecutor;
+declare const index_createDefaultSystemReminderRegistry: typeof createDefaultSystemReminderRegistry;
+declare const index_createDefaultTokenizerPort: typeof createDefaultTokenizerPort;
+declare const index_createEventStoreAudit: typeof createEventStoreAudit;
+declare const index_createFileAudit: typeof createFileAudit;
+declare const index_createGraphLoopHarness: typeof createGraphLoopHarness;
+declare const index_createMonotonicEventIdFactory: typeof createMonotonicEventIdFactory;
+declare const index_createSystemReminderRules: typeof createSystemReminderRules;
+declare const index_defaultPolicyEngine: typeof defaultPolicyEngine;
+declare const index_defaultSystemReminderRegistry: typeof defaultSystemReminderRegistry;
+declare const index_emitAuditEnvelope: typeof emitAuditEnvelope;
+declare const index_emitSandboxDecisionAudit: typeof emitSandboxDecisionAudit;
+declare const index_ensureToolContextRuntimeCapability: typeof ensureToolContextRuntimeCapability;
+declare const index_findCachedToolOutputByIdempotencyKey: typeof findCachedToolOutputByIdempotencyKey;
+declare const index_getToolContextRuntimeBinding: typeof getToolContextRuntimeBinding;
+declare const index_lastStepsHintTemplate: typeof lastStepsHintTemplate;
+declare const index_maxStepsForceFinalAnswerTemplate: typeof maxStepsForceFinalAnswerTemplate;
+declare const index_noopAudit: typeof noopAudit;
+declare const index_normalizeToolArgs: typeof normalizeToolArgs;
+declare const index_periodicTaskstateReflectionTemplate: typeof periodicTaskstateReflectionTemplate;
+declare const index_phaseEqualsTrigger: typeof phaseEqualsTrigger;
+declare const index_readContextCheckpointToolName: typeof readContextCheckpointToolName;
+declare const index_readNonEmptyStrings: typeof readNonEmptyStrings;
+declare const index_readToolContextModelId: typeof readToolContextModelId;
+declare const index_readToolContextPersistedHistory: typeof readToolContextPersistedHistory;
+declare const index_readToolContextRunContext: typeof readToolContextRunContext;
+declare const index_readToolContextUserQuery: typeof readToolContextUserQuery;
+declare const index_readToolContextWorkingHistory: typeof readToolContextWorkingHistory;
+declare const index_remainingStepsLeqTrigger: typeof remainingStepsLeqTrigger;
+declare const index_requestEnricherRegistry: typeof requestEnricherRegistry;
+declare const index_stepCountModuloTrigger: typeof stepCountModuloTrigger;
+declare const index_stripRuntimeReservedToolContextPatch: typeof stripRuntimeReservedToolContextPatch;
+declare const index_summarizeCheckpoint: typeof summarizeCheckpoint;
+declare const index_toDisplayStep: typeof toDisplayStep;
+declare const index_toolCallStreakTemplate: typeof toolCallStreakTemplate;
+declare const index_toolCallStreakTrigger: typeof toolCallStreakTrigger;
+declare namespace index {
+  export { index_AgentTool as AgentTool, index_AnswerNode as AnswerNode, index_AuditEnvelopePersistenceError as AuditEnvelopePersistenceError, index_BUILTIN_SYSTEM_REMINDER_TEMPLATES as BUILTIN_SYSTEM_REMINDER_TEMPLATES, index_BUILTIN_SYSTEM_REMINDER_TRIGGERS as BUILTIN_SYSTEM_REMINDER_TRIGGERS, index_BaseTool as BaseTool, index_CheckpointListFilter as CheckpointListFilter, index_CheckpointMeta as CheckpointMeta, index_CheckpointSummary as CheckpointSummary, index_Checkpointer as Checkpointer, index_CommonParameterTypes as CommonParameterTypes, type index_CompositeAuditOptions as CompositeAuditOptions, index_CompositeAuditPort as CompositeAuditPort, type index_ConsoleAuditOptions as ConsoleAuditOptions, type index_ContextCheckpointPayload as ContextCheckpointPayload, type index_ContextCheckpointPayloadExtension as ContextCheckpointPayloadExtension, index_ContextCheckpointTool as ContextCheckpointTool, type index_ContextCheckpointToolArgs as ContextCheckpointToolArgs, type index_ContextCheckpointToolHookParams as ContextCheckpointToolHookParams, type index_ContextCheckpointToolOptions as ContextCheckpointToolOptions, index_ConversationArtifactContext as ConversationArtifactContext, index_DEFAULT_CONTEXT_CHECKPOINT_TOOL_NAME as DEFAULT_CONTEXT_CHECKPOINT_TOOL_NAME, index_DefaultGraphExecutorOptions as DefaultGraphExecutorOptions, index_DefaultTokenizerPort as DefaultTokenizerPort, type index_DefaultTokenizerPortConfig as DefaultTokenizerPortConfig, index_ENGINE_ERROR_CODES as ENGINE_ERROR_CODES, index_ENGINE_STATE_SCHEMA_VERSION as ENGINE_STATE_SCHEMA_VERSION, type index_EmitAuditEnvelopeParams as EmitAuditEnvelopeParams, index_EngineState as EngineState, type index_EnrichmentContext as EnrichmentContext, type index_EnrichmentResult as EnrichmentResult, type index_ErrorClassification as ErrorClassification, index_EventBusSubRunTracePublisher as EventBusSubRunTracePublisher, index_EventRangeOptions as EventRangeOptions, index_EventStore as EventStore, type index_EventStoreAuditOptions as EventStoreAuditOptions, index_EventStoreAuditPort as EventStoreAuditPort, index_ExecutorLocalState as ExecutorLocalState, type index_FileAuditOptions as FileAuditOptions, index_FileAuditPort as FileAuditPort, index_GraphAgentExecutor as GraphAgentExecutor, type index_GraphAgentExecutorDependencies as GraphAgentExecutorDependencies, index_GraphExecutor as GraphExecutor, type index_GraphExecutorContextBuildInput as GraphExecutorContextBuildInput, type index_GraphExecutorContextBuildOutput as GraphExecutorContextBuildOutput, type index_GraphExecutorContextBuilder as GraphExecutorContextBuilder, index_GraphLoopHarness as GraphLoopHarness, index_GraphLoopHarnessOptions as GraphLoopHarnessOptions, index_GraphLoopHarnessRunResult as GraphLoopHarnessRunResult, index_GraphLoopLlmNodeFactoryParams as GraphLoopLlmNodeFactoryParams, index_GraphNode as GraphNode, index_JsonObjectSchema as JsonObjectSchema, index_LLMPolicy as LLMPolicy, index_LLMPolicyEngine as LLMPolicyEngine, index_LLMPolicyErrorDecision as LLMPolicyErrorDecision, index_LLMPolicyMatchContext as LLMPolicyMatchContext, index_LLMPolicyRequestContext as LLMPolicyRequestContext, index_LLMPolicyResponseContext as LLMPolicyResponseContext, index_LlmCallOptions as LlmCallOptions, index_LlmCaller as LlmCaller, index_LlmNode as LlmNode, index_LlmRequestMessage as LlmRequestMessage, index_LlmResponseContent as LlmResponseContent, index_LlmRetryConfig as LlmRetryConfig, index_MemoryCheckpointer as MemoryCheckpointer, index_MemoryEventStore as MemoryEventStore, index_ModelCatalogEntry as ModelCatalogEntry, index_ModelCatalogLike as ModelCatalogLike, index_ModelResolver as ModelResolver, index_ObservationPreviewContext as ObservationPreviewContext, index_ObservationPreviewMeta as ObservationPreviewMeta, index_ObservationPreviewPort as ObservationPreviewPort, index_ObservationPreviewResult as ObservationPreviewResult, index_OpenAIToolSchema as OpenAIToolSchema, type index_PendingContextRuntimeEvent as PendingContextRuntimeEvent, index_PersistedEvent as PersistedEvent, index_ProviderReasoningDetails as ProviderReasoningDetails, type index_RegistryEnrichmentResult as RegistryEnrichmentResult, type index_RequestEnricher as RequestEnricher, index_SYSTEM_REMINDER_RULES as SYSTEM_REMINDER_RULES, index_StructuredToolResult as StructuredToolResult, index_SubRunTracePublisher as SubRunTracePublisher, type index_SystemReminderContentTemplate as SystemReminderContentTemplate, type index_SystemReminderContext as SystemReminderContext, index_SystemReminderRegistry as SystemReminderRegistry, type index_SystemReminderRule as SystemReminderRule, type index_SystemReminderRuleDefinition as SystemReminderRuleDefinition, type index_SystemReminderTriggerEvaluator as SystemReminderTriggerEvaluator, index_ToolArgs as ToolArgs, index_ToolCall as ToolCall, index_ToolCallChunk as ToolCallChunk, index_ToolCallExtraContent as ToolCallExtraContent, index_ToolCallResult as ToolCallResult, index_ToolCatalogPort as ToolCatalogPort, index_ToolContextCompatibilityFields as ToolContextCompatibilityFields, index_ToolContextConversationView as ToolContextConversationView, index_ToolContextPatch as ToolContextPatch, index_ToolControlInfo as ToolControlInfo, index_ToolDisplayOptions as ToolDisplayOptions, index_ToolExecutionContext as ToolExecutionContext, index_ToolExecutionPort as ToolExecutionPort, index_ToolExecutionResult as ToolExecutionResult, index_ToolLayoutOptions as ToolLayoutOptions, index_ToolNode as ToolNode, index_ToolParameterProperty as ToolParameterProperty, index_ToolParameterSchema as ToolParameterSchema, index_ToolPresentationPort as ToolPresentationPort, index_ToolRegistryEntry as ToolRegistryEntry, index_ToolResult as ToolResult, index_ToolRuntimeDefinition as ToolRuntimeDefinition, index_ToolRuntimePort as ToolRuntimePort, index_ToolSchemaContext as ToolSchemaContext, index_UnifiedToolResult as UnifiedToolResult, index_UserNode as UserNode, index_WaitUserNode as WaitUserNode, index_agentHasToolTrigger as agentHasToolTrigger, index_applySystemReminders as applySystemReminders, index$2 as audit, index_budgetWarningTrigger as budgetWarningTrigger, index$6 as childRunTrace, index$7 as childRuns, index_computeToolIdempotencyKey as computeToolIdempotencyKey, index_consoleAudit as consoleAudit, index_contextBudgetWarningTemplate as contextBudgetWarningTemplate, index_countToolCallsInCurrentRequest as countToolCallsInCurrentRequest, index_createCompositeAudit as createCompositeAudit, index_createConsoleAudit as createConsoleAudit, index_createContextCheckpointTool as createContextCheckpointTool, index_createDefaultGraphExecutor as createDefaultGraphExecutor, index_createDefaultSystemReminderRegistry as createDefaultSystemReminderRegistry, index_createDefaultTokenizerPort as createDefaultTokenizerPort, index_createEventStoreAudit as createEventStoreAudit, index_createFileAudit as createFileAudit, index_createGraphLoopHarness as createGraphLoopHarness, index_createMonotonicEventIdFactory as createMonotonicEventIdFactory, index_createSystemReminderRules as createSystemReminderRules, index_defaultPolicyEngine as defaultPolicyEngine, index_defaultSystemReminderRegistry as defaultSystemReminderRegistry, index_emitAuditEnvelope as emitAuditEnvelope, index_emitSandboxDecisionAudit as emitSandboxDecisionAudit, index$5 as enrichment, index_ensureToolContextRuntimeCapability as ensureToolContextRuntimeCapability, index$d as events, index$9 as execution, index_findCachedToolOutputByIdempotencyKey as findCachedToolOutputByIdempotencyKey, index_getToolContextRuntimeBinding as getToolContextRuntimeBinding, index$b as graph, index_lastStepsHintTemplate as lastStepsHintTemplate, index$c as llm, index_maxStepsForceFinalAnswerTemplate as maxStepsForceFinalAnswerTemplate, index_noopAudit as noopAudit, index_normalizeToolArgs as normalizeToolArgs, index_periodicTaskstateReflectionTemplate as periodicTaskstateReflectionTemplate, index_phaseEqualsTrigger as phaseEqualsTrigger, index_readContextCheckpointToolName as readContextCheckpointToolName, index_readNonEmptyStrings as readNonEmptyStrings, index_readToolContextModelId as readToolContextModelId, index_readToolContextPersistedHistory as readToolContextPersistedHistory, index_readToolContextRunContext as readToolContextRunContext, index_readToolContextUserQuery as readToolContextUserQuery, index_readToolContextWorkingHistory as readToolContextWorkingHistory, index_remainingStepsLeqTrigger as remainingStepsLeqTrigger, index_requestEnricherRegistry as requestEnricherRegistry, index$8 as runContext, index$4 as runSupervisor, index_stepCountModuloTrigger as stepCountModuloTrigger, index_stripRuntimeReservedToolContextPatch as stripRuntimeReservedToolContextPatch, index_summarizeCheckpoint as summarizeCheckpoint, index$1 as systemReminder, index$3 as telemetry, index_toDisplayStep as toDisplayStep, index_toolCallStreakTemplate as toolCallStreakTemplate, index_toolCallStreakTrigger as toolCallStreakTrigger, index$a as tools };
+}
+
+export { consoleAudit as $, AnswerNode as A, BUILTIN_SYSTEM_REMINDER_TEMPLATES as B, type CompositeAuditOptions as C, DefaultTokenizerPort as D, ENGINE_ERROR_CODES as E, type FileAuditOptions as F, GraphAgentExecutor as G, type SystemReminderContentTemplate as H, type SystemReminderContext as I, SystemReminderRegistry as J, type SystemReminderRule as K, LLMPolicyEngine as L, MemoryCheckpointer as M, type SystemReminderRuleDefinition as N, type SystemReminderTriggerEvaluator as O, type PendingContextRuntimeEvent as P, agentHasToolTrigger as Q, type RegistryEnrichmentResult as R, SYSTEM_REMINDER_RULES as S, ToolNode as T, UserNode as U, applySystemReminders as V, WaitUserNode as W, index$2 as X, budgetWarningTrigger as Y, index$6 as Z, index$7 as _, AuditEnvelopePersistenceError as a, contextBudgetWarningTemplate as a0, countToolCallsInCurrentRequest as a1, createCompositeAudit as a2, createConsoleAudit as a3, createContextCheckpointTool as a4, createDefaultSystemReminderRegistry as a5, createDefaultTokenizerPort as a6, createEventStoreAudit as a7, createFileAudit as a8, createSystemReminderRules as a9, index$1 as aA, index$3 as aB, toDisplayStep as aC, toolCallStreakTemplate as aD, toolCallStreakTrigger as aE, index$a as aF, defaultPolicyEngine as aa, defaultSystemReminderRegistry as ab, emitAuditEnvelope as ac, emitSandboxDecisionAudit as ad, index$5 as ae, ensureToolContextRuntimeCapability as af, index$9 as ag, getToolContextRuntimeBinding as ah, index$b as ai, lastStepsHintTemplate as aj, index$c as ak, maxStepsForceFinalAnswerTemplate as al, noopAudit as am, normalizeToolArgs as an, periodicTaskstateReflectionTemplate as ao, phaseEqualsTrigger as ap, readContextCheckpointToolName as aq, readNonEmptyStrings as ar, readToolContextPersistedHistory as as, readToolContextWorkingHistory as at, remainingStepsLeqTrigger as au, requestEnricherRegistry as av, index$8 as aw, index$4 as ax, stepCountModuloTrigger as ay, stripRuntimeReservedToolContextPatch as az, BUILTIN_SYSTEM_REMINDER_TRIGGERS as b, CompositeAuditPort as c, type ConsoleAuditOptions as d, type ContextCheckpointPayload as e, type ContextCheckpointPayloadExtension as f, ContextCheckpointTool as g, type ContextCheckpointToolArgs as h, index as i, type ContextCheckpointToolHookParams as j, type ContextCheckpointToolOptions as k, type DefaultTokenizerPortConfig as l, type EmitAuditEnvelopeParams as m, type EnrichmentContext as n, type EnrichmentResult as o, type ErrorClassification as p, EventBusSubRunTracePublisher as q, type EventStoreAuditOptions as r, EventStoreAuditPort as s, FileAuditPort as t, type GraphAgentExecutorDependencies as u, type GraphExecutorContextBuildInput as v, type GraphExecutorContextBuildOutput as w, type GraphExecutorContextBuilder as x, LlmNode as y, type RequestEnricher as z };