@fevex/core 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/index-lCCFokc6.d.mts

@@ -0,0 +1,617 @@
+import { o as ToolEmbeddingCache, t as ToolReranker, z as ExactDefinition } from "./index-DHcfIfh-.mjs";
+import { c as ReasoningEffort, i as ModelRef, l as ToolChoice, r as ModelMetadata, s as ModelUsage, t as ModelGateway, u as EmbeddingModel } from "./index-D7r0puBi.mjs";
+import { f as RunId, g as ToolSpec, i as AgentMessage, l as JsonValue, o as ExecutionContext, s as JsonObject, t as AgentEvent } from "./types-CckDlhYo.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/runtime/run-store.d.ts
+/** Stable identifier for conversation history shared across runs. */
+type SessionId = string;
+type RunStatus = 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+interface ApprovalRequest {
+  id: string;
+  toolCallId: string;
+  toolName: string;
+  toolLabel?: string;
+  input: JsonValue;
+  risk: 'read' | 'write' | 'sensitive' | 'destructive';
+  requestedAt: string;
+}
+type ElicitationMode = 'pause' | 'forbid';
+type ApprovalMode = 'pause' | 'deny';
+interface ElicitationRequest {
+  id: string;
+  toolCallId: string;
+  prompt: string;
+  responseSchema: JsonObject;
+  requestedAt: string;
+  expiresAt?: string;
+}
+type AgentRunPause = {
+  type: 'elicitation';
+  request: ElicitationRequest;
+} | {
+  type: 'approval';
+  approval: ApprovalRequest;
+} | {
+  type: 'tool_execution_unknown';
+  toolCallId: string;
+  toolName: string;
+  input: JsonValue;
+};
+type RunPause = AgentRunPause | {
+  type: 'workflow_child';
+  childRunId: RunId;
+  childPause: AgentRunPause;
+} | {
+  type: 'workflow_children';
+  children: Array<{
+    stepId: string;
+    childRunId: RunId;
+    childPause: AgentRunPause;
+  }>;
+} | {
+  type: 'workflow_timer';
+  stepId: string;
+  resumeAt: string;
+} | {
+  type: 'workflow_event';
+  stepId: string;
+  eventName: string;
+};
+interface ApprovalResolution {
+  type: 'approval';
+  approvalId: string;
+  decision: 'approve' | 'reject';
+  actor: {
+    id: string;
+    type?: string;
+  };
+}
+interface ElicitationResolution {
+  type: 'elicitation';
+  requestId: string;
+  value: JsonValue;
+  actor: {
+    id: string;
+    type?: string;
+  };
+}
+type ToolExecutionResolution = {
+  type: 'tool_execution';
+  toolCallId: string;
+  decision: 'use_output';
+  output: JsonValue;
+  actor: {
+    id: string;
+    type?: string;
+  };
+} | {
+  type: 'tool_execution';
+  toolCallId: string;
+  decision: 'retry';
+  actor: {
+    id: string;
+    type?: string;
+  };
+};
+type TimerResolution = {
+  type: 'timer';
+  actor?: {
+    id: string;
+    type?: string;
+  };
+};
+type EventResolution = {
+  type: 'event';
+  eventName: string;
+  payload?: JsonValue;
+  actor?: {
+    id: string;
+    type?: string;
+  };
+};
+type ResumeRunResolution = ElicitationResolution | ApprovalResolution | ToolExecutionResolution | TimerResolution | EventResolution;
+/** Correlation fields for runs created by a workflow or team coordinator. */
+interface RunCorrelation {
+  /** Run that created this one. */
+  parentRunId?: RunId;
+  /** Top-level run in the correlation tree. */
+  rootRunId?: RunId;
+}
+interface AgentRun<TOutput = JsonValue> extends RunCorrelation {
+  kind?: 'agent';
+  id: RunId;
+  sessionId: SessionId;
+  agentName: string;
+  /** Effective model identity retained after checkpoint cleanup. Absent on older runs. */
+  modelName?: string;
+  modelMetadata?: ModelMetadata;
+  status: RunStatus;
+  revision: number;
+  pause?: RunPause;
+  createdAt: string;
+  updatedAt: string;
+  /** Absolute deadline for the run, derived from `RunRequest.deadlineMs`. */
+  deadlineAt?: string;
+  output?: TOutput;
+  error?: string;
+  usage?: ModelUsage;
+}
+interface WorkflowRun<TOutput = JsonValue> extends RunCorrelation {
+  kind: 'workflow';
+  id: RunId;
+  sessionId: SessionId;
+  workflowName: string;
+  status: RunStatus;
+  revision: number;
+  pause?: RunPause;
+  createdAt: string;
+  updatedAt: string;
+  /** Absolute deadline for the run, derived from `RunRequest.deadlineMs`. */
+  deadlineAt?: string;
+  output?: TOutput;
+  error?: string;
+  usage?: ModelUsage;
+}
+interface TeamRun<TOutput = JsonValue> extends RunCorrelation {
+  kind: 'team';
+  id: RunId;
+  sessionId: SessionId;
+  teamName: string;
+  status: RunStatus;
+  revision: number;
+  pause?: RunPause;
+  createdAt: string;
+  updatedAt: string;
+  /** Absolute deadline for the run, derived from `RunRequest.deadlineMs`. */
+  deadlineAt?: string;
+  output?: TOutput;
+  error?: string;
+  usage?: ModelUsage;
+}
+type CoordinatorRun<TOutput = JsonValue> = WorkflowRun<TOutput> | TeamRun<TOutput>;
+type RunRecord<TOutput = unknown> = AgentRun<TOutput> | WorkflowRun<TOutput> | TeamRun<TOutput>;
+interface SessionCompaction {
+  /** Derived summary for the first `coveredMessages` history entries. */
+  summary: string;
+  coveredMessages: number;
+  updatedAt: string;
+}
+interface Session {
+  /** Optimistic history revision. Missing on legacy sessions means zero. Store-managed. */
+  revision?: number;
+  id: SessionId;
+  history: AgentMessage[];
+  /** Reusable summary; the original history remains the source of truth. */
+  compaction?: SessionCompaction;
+  createdAt: string;
+  updatedAt: string;
+}
+interface ListEventsOptions {
+  after?: AgentEvent['id'];
+  /** Maximum results; omitted preserves the complete result for existing consumers. */
+  limit?: number;
+  /** Sequence order. Use descending with limit: 1 for the latest event. */
+  order?: 'asc' | 'desc';
+}
+declare function validateListEventsOptions(options: ListEventsOptions): void;
+type RetainableRunStatus = 'completed' | 'failed' | 'cancelled';
+interface PurgeRunsOptions {
+  /** Delete runs created strictly before this ISO timestamp. */
+  before?: string;
+  /** Terminal statuses to delete. Defaults to completed, failed and cancelled. */
+  statuses?: RetainableRunStatus[];
+  /** Maximum runs to delete in one call. */
+  limit?: number;
+}
+interface PurgeRunsResult {
+  runs: number;
+  sessions: number;
+}
+/** Optional capability for stores that can delete terminal runs and empty sessions. */
+interface RetainableRunStore extends RunStore {
+  purgeRuns(options?: PurgeRunsOptions): Promise<PurgeRunsResult>;
+}
+declare function isRetainableRunStore(store: RunStore): store is RetainableRunStore;
+declare function validatePurgeRunsOptions(options?: PurgeRunsOptions): {
+  statuses: RetainableRunStatus[];
+  before?: string;
+  limit?: number;
+};
+interface RunStore {
+  getRun<TRun extends RunRecord<unknown> = AgentRun>(runId: RunId): Promise<TRun | undefined>;
+  saveRun(run: RunRecord): Promise<void>;
+  getSession(sessionId: SessionId): Promise<Session | undefined>;
+  /** Compare and advance revision; reject active/paused sessions and stale snapshots. */
+  saveSession(session: Session): Promise<void>;
+  appendEvent(event: AgentEvent): Promise<void>;
+  listEvents(runId: RunId, options?: ListEventsOptions): Promise<AgentEvent[]>;
+}
+interface CredentialStore {
+  resolve(input: {
+    name: string;
+    namespace?: string;
+    actor?: {
+      id: string;
+      type?: string;
+    };
+  }): Promise<string | undefined>;
+}
+interface PendingToolExecution {
+  call: {
+    id: string;
+    name: string;
+    input: JsonValue;
+  };
+  input: JsonValue;
+  idempotencyKey: string;
+  attempt: number;
+}
+interface RunCheckpoint {
+  version: 2;
+  kind?: 'agent';
+  runId: RunId;
+  modelName?: string;
+  reasoning?: ReasoningEffort;
+  definitionHash: string;
+  limits?: AgentLimits;
+  contextBudget?: ContextBudget;
+  toolSearch?: ToolSearchCheckpointOptions;
+  loadedTools?: string[];
+  messages: AgentMessage[];
+  inputContent: string;
+  context?: ExecutionContext;
+  usage?: ModelUsage;
+  providerState?: JsonValue;
+  step: number;
+  toolCallCount: number;
+  seenToolCallIds: string[];
+  pendingTools: PendingToolExecution[];
+  pendingIndex: number;
+  effectiveElicitationMode?: ElicitationMode;
+  effectiveApprovalMode?: ApprovalMode;
+  effectiveToolChoice?: ToolChoice;
+}
+type WorkflowStepRecord = {
+  type: 'agent';
+  status: 'running';
+  agentName: string;
+  childRunId: RunId;
+  metadata?: JsonObject;
+} | {
+  type: 'agent';
+  status: 'completed';
+  agentName: string;
+  childRunId: RunId;
+  result: RunResult<JsonValue>;
+  compensation?: WorkflowCompensationRecord;
+  metadata?: JsonObject;
+} | {
+  type: 'parallel';
+  status: 'running';
+  metadata?: JsonObject;
+} | {
+  type: 'parallel';
+  status: 'completed';
+  result: JsonObject;
+  compensation?: WorkflowCompensationRecord;
+  metadata?: JsonObject;
+} | {
+  type: 'wait';
+  status: 'running';
+  wait: WorkflowWaitRecord;
+} | {
+  type: 'wait';
+  status: 'completed';
+  wait: WorkflowWaitRecord;
+  payload?: JsonValue;
+  actor?: NonNullable<ExecutionContext['actor']>;
+  receivedAt?: string;
+};
+interface WorkflowCompensationRecord {
+  status: 'pending' | 'completed' | 'failed';
+  error?: string;
+}
+type WorkflowWaitRecord = {
+  type: 'timer';
+  resumeAt: string;
+} | {
+  type: 'event';
+  eventName: string;
+  requireActor: boolean;
+};
+interface WorkflowBudgetUsage {
+  usage?: ModelUsage;
+  steps: number;
+  toolCalls: number;
+}
+interface WorkflowCheckpoint {
+  version: 2;
+  kind: 'workflow';
+  runId: RunId;
+  workflowName: string;
+  model?: string;
+  reasoning?: ReasoningEffort;
+  definitionHash: string;
+  input: JsonValue;
+  context?: ExecutionContext;
+  steps: Record<string, WorkflowStepRecord>;
+  limits?: AgentLimits;
+  budget?: WorkflowBudgetUsage;
+}
+interface TeamCheckpoint extends Omit<WorkflowCheckpoint, 'kind' | 'workflowName'> {
+  kind: 'team';
+  teamName: string;
+}
+type CoordinatorCheckpoint = WorkflowCheckpoint | TeamCheckpoint;
+type StoredRunCheckpoint = RunCheckpoint | WorkflowCheckpoint | TeamCheckpoint;
+type ToolExecutionStatus = 'started' | 'completed' | 'failed' | 'unknown';
+interface ToolExecutionRecord {
+  runId: RunId;
+  toolCallId: string;
+  toolName: string;
+  input: JsonValue;
+  status: ToolExecutionStatus;
+  attempt: number;
+  idempotencyKey: string;
+  output?: JsonValue;
+  error?: string;
+  updatedAt: string;
+}
+/** Store assigns a new generation on creation/acquisition; callers must retain it. */
+interface RunLease {
+  generation: number;
+  runId: RunId;
+  ownerId: string;
+  expiresAt: string;
+}
+interface ExecutionCommit {
+  /** Current lease identity; ownership, generation and expiry are checked atomically. */
+  lease: Pick<RunLease, 'ownerId' | 'generation'>;
+  expectedRevision: number;
+  run: RunRecord;
+  checkpoint?: StoredRunCheckpoint | null;
+  session?: Session;
+  toolExecution?: ToolExecutionRecord;
+  events?: AgentEvent[];
+}
+/** Atomically reserve the session until this run is terminal, including across pause/crash. */
+interface ExecutionCreate {
+  run: RunRecord;
+  checkpoint: StoredRunCheckpoint;
+  /** Snapshot used to prepare the run; revision must match the stored history. */
+  session: Session;
+  lease: RunLease;
+  events: AgentEvent[];
+}
+interface DurableRunStore extends RunStore {
+  getCheckpoint<TCheckpoint extends StoredRunCheckpoint = RunCheckpoint>(runId: RunId): Promise<TCheckpoint | undefined>;
+  getToolExecution(runId: RunId, toolCallId: string): Promise<ToolExecutionRecord | undefined>;
+  /** On success, assigns run/session revisions and lease generation 1. */
+  createExecution(create: ExecutionCreate): Promise<boolean>;
+  commitExecution(commit: ExecutionCommit): Promise<boolean>;
+  /** Acquires only absent/expired leases and assigns a strictly newer generation. */
+  acquireLease(lease: RunLease): Promise<boolean>;
+  /** Requires matching owner/generation and an unexpired stored lease. */
+  renewLease(lease: RunLease): Promise<boolean>;
+  /** Expires a matching token while retaining its generation for future acquisitions. */
+  releaseLease(runId: RunId, ownerId: string, generation: number): Promise<void>;
+}
+declare function isDurableRunStore(store: RunStore): store is DurableRunStore;
+interface RunRequest<TInput = unknown, TOutput = unknown> {
+  input: TInput;
+  model?: string;
+  reasoning?: ReasoningEffort;
+  context?: ExecutionContext;
+  limits?: AgentLimits;
+  contextBudget?: ContextBudget;
+  toolSearch?: ToolSearchOptions;
+  elicitation?: ElicitationMode;
+  approvalMode?: ApprovalMode;
+  toolChoice?: ToolChoice;
+  sessionId?: SessionId;
+  signal?: AbortSignal;
+  /** Maximum wall-clock time for this run, including time spent paused. */
+  deadlineMs?: number;
+}
+interface RunResult<TOutput = unknown> {
+  runId: RunId;
+  sessionId: SessionId;
+  output: TOutput;
+  events?: AgentEvent[];
+  usage?: ModelUsage;
+}
+//#endregion
+//#region src/runtime/compaction.d.ts
+/** Estimates the input tokens of messages and tool definitions. */
+type ContextTokenEstimator = (input: {
+  messages: AgentMessage[];
+  tools?: ToolSpec[];
+}) => number;
+interface ContextCompactionInput {
+  agentName: string;
+  sessionId: SessionId;
+  /** Older turns and earlier tool batches; system prefix, current request and latest batch are preserved. */
+  messages: AgentMessage[];
+  tools?: ToolSpec[];
+  /** Estimated tokens of the whole prompt before compaction. */
+  estimatedTokens: number;
+  /** Soft budget for the messages returned by the compactor. */
+  targetTokens: number;
+  /** Hard model context window. */
+  contextWindow: number;
+  step: number;
+  context?: ExecutionContext;
+  signal?: AbortSignal;
+  /** Estimates messages with the runtime's configured estimator. */
+  estimateTokens(messages: AgentMessage[]): number;
+}
+/** Returns the replacement for the older conversation messages. */
+interface ContextCompactor {
+  compact(input: ContextCompactionInput): AgentMessage[] | Promise<AgentMessage[]>;
+}
+interface ContextCompactionOptions {
+  /** Defaults to a deterministic digest compactor. */
+  compactor?: ContextCompactor;
+  /** Defaults to a character-based estimate. */
+  estimateTokens?: ContextTokenEstimator;
+  /** Redacts the summary before it enters the context.compacted event. */
+  redactSummary?: (summary: string) => string;
+}
+/** Cumulative runtime counters for automatic context compaction. */
+interface ContextCompactionStats {
+  compactions: number;
+  removedMessages: number;
+  estimatedTokens: number;
+  compactedTokens: number;
+  savedTokens: number;
+}
+interface ResolvedContextBudget {
+  contextWindow: number;
+  reserveOutputTokens: number;
+  compactAt: number;
+  targetTokens: number;
+  safetyFactor: number;
+}
+/** Validates a context budget and fills in defaults. */
+declare function resolveContextBudget(budget: ContextBudget | undefined, label: string): ResolvedContextBudget | undefined;
+/**
+ * Rough provider-neutral estimate: about four characters per token plus
+ * message and tool framing. Hosts can inject a real tokenizer instead.
+ */
+declare function estimateContextTokens(input: {
+  messages: AgentMessage[];
+  tools?: ToolSpec[];
+}): number;
+interface ModelContextCompactorOptions {
+  /** Model used only to summarize older context. */
+  model: ModelGateway;
+  /** Overrides the built-in summarization instructions. */
+  systemPrompt?: string;
+  /** Maximum output tokens for the summary. Defaults to 1,024. */
+  maxOutputTokens?: number;
+  /** Maximum characters sent to one summarization call. Defaults to 120,000. */
+  maxInputChars?: number;
+}
+/**
+ * Creates a semantic compactor backed by a model. Use a cheap, fast model and
+ * keep it separate from the agent model when possible. Large transcripts are
+ * summarized in chunks and then merged.
+ */
+declare function createModelContextCompactor(options: ModelContextCompactorOptions): ContextCompactor;
+interface DigestContextCompactorOptions {
+  /** Maximum characters kept from one message. Defaults to 400. */
+  maxCharsPerMessage?: number;
+}
+/**
+ * Deterministic compactor used when the host does not inject one. It keeps
+ * role-aware excerpts of older messages and drops the oldest excerpts first.
+ * It never calls a model.
+ */
+declare function createDigestContextCompactor(options?: DigestContextCompactorOptions): ContextCompactor;
+//#endregion
+//#region src/runtime/in-memory-run-store.d.ts
+/**
+ * In-process durable store intended for development and tests.
+ *
+ * Values are cloned at the boundary so callers cannot mutate persisted state.
+ * Data is lost when the process exits.
+ */
+declare class InMemoryRunStore implements DurableRunStore {
+  #private;
+  getRun<TRun extends RunRecord<unknown> = AgentRun>(runId: RunId): Promise<TRun | undefined>;
+  saveRun(run: RunRecord): Promise<void>;
+  getSession(sessionId: SessionId): Promise<Session | undefined>;
+  saveSession(session: Session): Promise<void>;
+  appendEvent(event: AgentEvent): Promise<void>;
+  listEvents(runId: RunId, options?: ListEventsOptions): Promise<AgentEvent[]>;
+  getCheckpoint<TCheckpoint extends StoredRunCheckpoint = RunCheckpoint>(runId: RunId): Promise<TCheckpoint | undefined>;
+  getToolExecution(runId: RunId, toolCallId: string): Promise<ToolExecutionRecord | undefined>;
+  createExecution(create: ExecutionCreate): Promise<boolean>;
+  commitExecution(commit: ExecutionCommit): Promise<boolean>;
+  purgeRuns(options?: PurgeRunsOptions): Promise<PurgeRunsResult>;
+  acquireLease(lease: RunLease): Promise<boolean>;
+  renewLease(lease: RunLease): Promise<boolean>;
+  releaseLease(runId: RunId, ownerId: string, generation: number): Promise<void>;
+}
+//#endregion
+//#region src/agents/agent.d.ts
+/** Resource limits enforced by the runtime for a single agent run. */
+interface AgentLimits {
+  maxSteps?: number;
+  maxToolCalls?: number;
+  maxInputTokens?: number | false;
+  maxOutputTokens?: number | false;
+  /** Maximum serialized bytes for one tool result. Use `false` to disable the default cap. */
+  maxToolResultBytes?: number | false;
+}
+/**
+ * Per-request model context budget. It is separate from
+ * {@link AgentLimits.maxInputTokens}, which caps cumulative spend for a run.
+ */
+interface ContextBudget {
+  /** Model context window in tokens. */
+  contextWindow: number;
+  /** Tokens reserved for the next model output. Defaults to 0. */
+  reserveOutputTokens?: number;
+  /** Fraction of the usable window that triggers compaction. Defaults to 0.8. */
+  compactAt?: number;
+  /** Target tokens after compaction. Defaults below the compaction threshold. */
+  targetTokens?: number;
+  /** Multiplier applied to estimates to leave headroom. Defaults to 1.1. */
+  safetyFactor?: number;
+}
+interface ToolSearchSemanticOptions {
+  /** Embedding model used to index tools and queries. */
+  embeddings: EmbeddingModel;
+  /** Cache for tool vectors. Defaults to the runtime cache. */
+  cache?: ToolEmbeddingCache;
+  /** Vector candidates considered before fusion. Defaults to 20. */
+  topK?: number;
+  /** Minimum cosine score for vector candidates. Defaults to 0. */
+  minScore?: number;
+  /** Optional second-stage reranker over the fused candidates. */
+  reranker?: ToolReranker;
+}
+/** On-demand tool discovery for agents with large tool catalogs. */
+interface ToolSearchOptions {
+  /** `auto` enables search above the configured thresholds. Defaults to `auto`. */
+  mode?: 'auto' | 'on' | 'off';
+  /** Tool-count threshold for `auto`. Defaults to 30. */
+  threshold?: number;
+  /** Estimated tool-token threshold for `auto`. */
+  tokenThreshold?: number;
+  /** Maximum tools returned by one search. Defaults to 5. */
+  limit?: number;
+  /** Tool names exposed without a search. */
+  pinned?: string[];
+  /** Optional hybrid lexical + vector retrieval. */
+  semantic?: ToolSearchSemanticOptions;
+}
+/** Serializable tool-search options stored in a run checkpoint. */
+type ToolSearchCheckpointOptions = Omit<ToolSearchOptions, 'semantic'>;
+interface AgentDefinition<TInput = unknown, TOutput = unknown> {
+  name: string;
+  instructions: string;
+  model?: ModelRef;
+  tools?: string[];
+  context?: string[];
+  memory?: {
+    read?: boolean;
+    write?: boolean;
+    limit?: number;
+  };
+  skills?: string[];
+  reasoning?: ReasoningEffort;
+  modelOptions?: Record<string, unknown>;
+  toolChoice?: ToolChoice;
+  elicitation?: ElicitationMode;
+  approvalMode?: ApprovalMode;
+  inputSchema?: StandardSchemaV1<unknown, TInput>;
+  outputSchema?: StandardSchemaV1<unknown, TOutput>;
+  limits?: AgentLimits;
+  contextBudget?: ContextBudget;
+  toolSearch?: ToolSearchOptions;
+}
+declare function defineAgent<T extends AgentDefinition>(agent: ExactDefinition<T, AgentDefinition>): T;
+//#endregion
+export { SessionCompaction as $, ElicitationMode as A, ResumeRunResolution as B, ApprovalMode as C, CoordinatorRun as D, CoordinatorCheckpoint as E, ExecutionCreate as F, RunLease as G, RetainableRunStore as H, ListEventsOptions as I, RunRequest as J, RunPause as K, PendingToolExecution as L, ElicitationResolution as M, EventResolution as N, CredentialStore as O, ExecutionCommit as P, Session as Q, PurgeRunsOptions as R, AgentRunPause as S, ApprovalResolution as T, RunCheckpoint as U, RetainableRunStatus as V, RunCorrelation as W, RunStatus as X, RunResult as Y, RunStore as Z, createDigestContextCompactor as _, validatePurgeRunsOptions as _t, ToolSearchOptions as a, ToolExecutionRecord as at, resolveContextBudget as b, InMemoryRunStore as c, WorkflowBudgetUsage as ct, ContextCompactionStats as d, WorkflowRun as dt, SessionId as et, ContextCompactor as f, WorkflowStepRecord as ft, ResolvedContextBudget as g, validateListEventsOptions as gt, ModelContextCompactorOptions as h, isRetainableRunStore as ht, ToolSearchCheckpointOptions as i, TimerResolution as it, ElicitationRequest as j, DurableRunStore as k, ContextCompactionInput as l, WorkflowCheckpoint as lt, DigestContextCompactorOptions as m, isDurableRunStore as mt, AgentLimits as n, TeamCheckpoint as nt, ToolSearchSemanticOptions as o, ToolExecutionResolution as ot, ContextTokenEstimator as p, WorkflowWaitRecord as pt, RunRecord as q, ContextBudget as r, TeamRun as rt, defineAgent as s, ToolExecutionStatus as st, AgentDefinition as t, StoredRunCheckpoint as tt, ContextCompactionOptions as u, WorkflowCompensationRecord as ut, createModelContextCompactor as v, ApprovalRequest as w, AgentRun as x, estimateContextTokens as y, PurgeRunsResult as z };