@fevex/core 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/index-Dx_LotWZ.d.mts

@@ -0,0 +1,425 @@
+import { t as ExactDefinition } from "./exact-definition-NHBBFlFR.mjs";
+import { f as RunId, i as AgentMessage, l as JsonValue, o as ExecutionContext, s as JsonObject, t as AgentEvent } from "./types-CuoRx12Q.mjs";
+import { c as ReasoningEffort, i as ModelRef, l as ToolChoice, s as ModelUsage } from "./index-CTIwrVf9.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;
+interface AgentRun<TOutput = JsonValue> {
+  kind?: 'agent';
+  id: RunId;
+  sessionId: SessionId;
+  agentName: string;
+  status: RunStatus;
+  revision: number;
+  pause?: RunPause;
+  createdAt: string;
+  updatedAt: string;
+  output?: TOutput;
+  error?: string;
+  usage?: ModelUsage;
+}
+interface WorkflowRun<TOutput = JsonValue> {
+  kind: 'workflow';
+  id: RunId;
+  sessionId: SessionId;
+  workflowName: string;
+  status: RunStatus;
+  revision: number;
+  pause?: RunPause;
+  createdAt: string;
+  updatedAt: string;
+  output?: TOutput;
+  error?: string;
+  usage?: ModelUsage;
+}
+interface TeamRun<TOutput = JsonValue> {
+  kind: 'team';
+  id: RunId;
+  sessionId: SessionId;
+  teamName: string;
+  status: RunStatus;
+  revision: number;
+  pause?: RunPause;
+  createdAt: string;
+  updatedAt: 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 Session {
+  /** Optimistic history revision. Missing on legacy sessions means zero. Store-managed. */
+  revision?: number;
+  id: SessionId;
+  history: AgentMessage[];
+  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;
+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;
+  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;
+  elicitation?: ElicitationMode;
+  approvalMode?: ApprovalMode;
+  toolChoice?: ToolChoice;
+  sessionId?: SessionId;
+  signal?: AbortSignal;
+}
+interface RunResult<TOutput = unknown> {
+  runId: RunId;
+  sessionId: SessionId;
+  output: TOutput;
+  events?: AgentEvent[];
+  usage?: ModelUsage;
+}
+//#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>;
+  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;
+}
+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;
+}
+declare function defineAgent<T extends AgentDefinition>(agent: ExactDefinition<T, AgentDefinition>): T;
+//#endregion
+export { RunStore as A, WorkflowBudgetUsage as B, RunCheckpoint as C, RunRequest as D, RunRecord as E, TeamRun as F, WorkflowWaitRecord as G, WorkflowCompensationRecord as H, TimerResolution as I, isDurableRunStore as K, ToolExecutionRecord as L, SessionId as M, StoredRunCheckpoint as N, RunResult as O, TeamCheckpoint as P, ToolExecutionResolution as R, ResumeRunResolution as S, RunPause as T, WorkflowRun as U, WorkflowCheckpoint as V, WorkflowStepRecord as W, EventResolution as _, AgentRun as a, ListEventsOptions as b, ApprovalRequest as c, CoordinatorRun as d, CredentialStore as f, ElicitationResolution as g, ElicitationRequest as h, InMemoryRunStore as i, Session as j, RunStatus as k, ApprovalResolution as l, ElicitationMode as m, AgentLimits as n, AgentRunPause as o, DurableRunStore as p, validateListEventsOptions as q, defineAgent as r, ApprovalMode as s, AgentDefinition as t, CoordinatorCheckpoint as u, ExecutionCommit as v, RunLease as w, PendingToolExecution as x, ExecutionCreate as y, ToolExecutionStatus as z };

package/dist/{index-QTkd6a7C.d.mts → index-dkFyTNh4.d.mts}

@@ -1,6 +1,7 @@
-import { f as RunId, l as JsonValue, o as ExecutionContext } from "./index-C_Zpr13f.mjs";
-import { s as ToolRisk } from "./index-CZGyhNIQ.mjs";
-//#region src/policies/index.d.ts
+import { f as RunId, l as JsonValue, o as ExecutionContext } from "./types-CuoRx12Q.mjs";
+import { x as ToolRisk } from "./index-CqOjvtQ9.mjs";
+//#region src/policies/policy.d.ts
+/** Authorization outcome returned by a policy. */
 type PolicyDecision = 'allow' | 'deny' | 'require_approval';
 interface PolicyAuthorization {
   runId: RunId;

package/dist/index.d.mts

@@ -1,19 +1,31 @@
-import { a as AgentMessageRole, c as JsonPrimitive, d as PROVIDER_SCHEMA_UNSUPPORTED, f as RunId, h as ToolSpec, i as AgentMessage, l as JsonValue, m as ToolCall, n as AgentEventPayloads, o as ExecutionContext, p as SCHEMA_NOT_TRANSPORTABLE, r as AgentEventType, s as JsonObject, t as AgentEvent, u as PROVIDER_REASONING_UNSUPPORTED } from "./index-C_Zpr13f.mjs";
-import { ModelGateway, ModelInput, ModelMetadata, ModelRef, ModelResult, ModelStreamEvent, ModelUsage, ReasoningEffort } from "./models/index.mjs";
-import { n as AgentLimits, r as defineAgent, t as AgentDefinition } from "./index-BzxHfyYV.mjs";
-import { C as isDurableRunStore, S as ToolExecutionStatus, _ as RunStore, a as DurableRunStore, b as ToolExecutionRecord, c as ListEventsOptions, d as RunCheckpoint, f as RunLease, g as RunStatus, h as RunResult, i as CredentialStore, l as PendingToolExecution, m as RunRequest, n as ApprovalRequest, o as ExecutionCommit, p as RunPause, r as ApprovalResolution, s as InMemoryRunStore, t as AgentRun, u as ResumeRunResolution, v as Session, x as ToolExecutionResolution, y as SessionId } from "./index-DGWOGXzc.mjs";
-import { a as ToolResult, c as defineTool, i as ToolIdempotency, l as toToolSpec, n as ToolDefinition, o as ToolRetryPolicy, r as ToolExecutionContext, s as ToolRisk, t as ToolApproval } from "./index-CZGyhNIQ.mjs";
-import { i as definePolicy, n as PolicyDecision, r as PolicyDefinition, t as PolicyAuthorization } from "./index-QTkd6a7C.mjs";
-import { n as FevexConfig, r as createFevex, t as Fevex } from "./fevex-Dz6GBz9o.mjs";
+import { a as AgentMessageRole, c as JsonPrimitive, d as PROVIDER_SCHEMA_UNSUPPORTED, f as RunId, g as ToolSpec, h as ToolEventSource, i as AgentMessage, l as JsonValue, m as ToolCall, n as AgentEventPayloads, o as ExecutionContext, p as SCHEMA_NOT_TRANSPORTABLE, r as AgentEventType, s as JsonObject, t as AgentEvent, u as PROVIDER_REASONING_UNSUPPORTED } from "./types-CuoRx12Q.mjs";
+import { a as ModelResult, c as ReasoningEffort, i as ModelRef, l as ToolChoice, n as ModelInput, o as ModelStreamEvent, r as ModelMetadata, s as ModelUsage, t as ModelGateway } from "./index-CTIwrVf9.mjs";
+import { A as RunStore, B as WorkflowBudgetUsage, C as RunCheckpoint, D as RunRequest, E as RunRecord, F as TeamRun, G as WorkflowWaitRecord, H as WorkflowCompensationRecord, I as TimerResolution, K as isDurableRunStore, L as ToolExecutionRecord, M as SessionId, N as StoredRunCheckpoint, O as RunResult, P as TeamCheckpoint, R as ToolExecutionResolution, S as ResumeRunResolution, T as RunPause, U as WorkflowRun, V as WorkflowCheckpoint, W as WorkflowStepRecord, _ as EventResolution, a as AgentRun, b as ListEventsOptions, c as ApprovalRequest, d as CoordinatorRun, f as CredentialStore, g as ElicitationResolution, h as ElicitationRequest, i as InMemoryRunStore, j as Session, k as RunStatus, l as ApprovalResolution, m as ElicitationMode, n as AgentLimits, o as AgentRunPause, p as DurableRunStore, q as validateListEventsOptions, r as defineAgent, s as ApprovalMode, t as AgentDefinition, u as CoordinatorCheckpoint, v as ExecutionCommit, w as RunLease, x as PendingToolExecution, y as ExecutionCreate, z as ToolExecutionStatus } from "./index-Dx_LotWZ.mjs";
+import { a as MemoryQuery, c as MemoryWrite, d as defineContextProvider, f as defineSkill, i as KnowledgeContext, l as SkillDefinition, n as ContextBlock, o as MemoryRecord, r as ContextProvider, s as MemoryStore, t as InMemoryMemoryStore, u as createMemoryContextProvider } from "./index-DeXUtyd9.mjs";
+import { a as SandboxError, c as sandboxResultToJson, i as SandboxCapabilities, n as createLocalSandbox, o as SandboxRunRequest, r as Sandbox, s as SandboxRunResult, t as LocalSandboxOptions } from "./index-CrOId2px.mjs";
+import { C as toToolSpec, S as defineTool, _ as ToolExecutionContext, a as compileFevexJsonSchema, b as ToolRetryPolicy, c as ConnectionToolPolicy, d as ToolProvider, f as ToolProviderContext, g as ToolDefinition, h as ToolApproval, i as FevexJsonSchemaValidator, l as IntegrationError, m as defineConnection, n as FevexJsonSchemaProfileLimits, o as validateFevexJsonSchemaProfile, p as ToolProviderTool, r as FevexJsonSchemaProfileOptions, s as ConnectionDefinition, t as FEVEX_JSON_SCHEMA_PROFILE_VERSION, u as IntegrationErrorCategory, v as ToolIdempotency, x as ToolRisk, y as ToolResult } from "./index-CqOjvtQ9.mjs";
+import { i as definePolicy, n as PolicyDecision, r as PolicyDefinition, t as PolicyAuthorization } from "./index-dkFyTNh4.mjs";
+import { a as WorkflowStep, c as defineWorkflow, i as WorkflowEventResult, n as WorkflowDefinition, o as WorkflowStepContext, r as WorkflowEventDefinition, s as WorkflowStepOptions, t as WorkflowAgentResult } from "./index-DviHtsLo.mjs";
+import { a as TeamMember, c as defineTeam, i as TeamLimits, n as TeamDelegation, o as TeamStep, r as TeamHandoff, s as TeamTaskResult, t as TeamDefinition } from "./index-Bg9rr8Qe.mjs";
+import { n as FevexConfig, r as createFevex, t as Fevex } from "./fevex-Ddyi6z6L.mjs";
+import { a as ChannelEvent, c as ChannelMessage, d as ChannelRunOptions, f as ChannelRunResult, i as ChannelError, l as ChannelOutput, n as ChannelAdapter, o as ChannelEventType, r as ChannelContext, s as ChannelFailurePhase, t as handleChannelInput, u as ChannelRunEvent } from "./index-Bgcxgy66.mjs";
 //#region src/configuration-error.d.ts
-type FevexConfigurationErrorCode = 'INVALID_CONFIG' | 'INVALID_MODEL' | 'INVALID_AGENT' | 'INVALID_TOOL' | 'DUPLICATE_AGENT' | 'DUPLICATE_TOOL' | 'MISSING_MODEL' | 'MISSING_TOOL';
+/**
+ * Composition error codes.
+ *
+ * `INVALID_CONFIG` is reserved for the shape of the root config object. Every
+ * registered entity has its own `INVALID_*` code, plus `DUPLICATE_*` when it is
+ * registered by name and `MISSING_*` when an agent references something that
+ * was never registered.
+ */
+type FevexConfigurationErrorCode = 'INVALID_CONFIG' | 'INVALID_MODEL' | 'INVALID_AGENT' | 'INVALID_TOOL' | 'INVALID_WORKFLOW' | 'INVALID_TEAM' | 'INVALID_CONNECTION' | 'INVALID_CONTEXT_PROVIDER' | 'INVALID_POLICY' | 'DUPLICATE_AGENT' | 'DUPLICATE_TOOL' | 'DUPLICATE_WORKFLOW' | 'DUPLICATE_TEAM' | 'DUPLICATE_CONTEXT_PROVIDER' | 'MISSING_MODEL' | 'MISSING_TOOL';
 declare class FevexConfigurationError extends Error {
   readonly code: FevexConfigurationErrorCode;
   constructor(code: FevexConfigurationErrorCode, message: string);
 }
 //#endregion
 //#region src/run-error.d.ts
-type FevexRunErrorCode = 'DURABLE_STORE_REQUIRED' | 'RUN_CONFLICT' | 'RUN_NOT_RESUMABLE' | 'RUN_DEFINITION_CHANGED' | 'POLICY_DENIED' | 'CREDENTIAL_NOT_FOUND' | 'APPROVAL_INVALID' | 'RUN_PAUSED' | 'TOOL_EXECUTION_UNKNOWN';
+type FevexRunErrorCode = 'INVALID_CURSOR' | 'AGENT_NOT_FOUND' | 'WORKFLOW_NOT_FOUND' | 'TEAM_NOT_FOUND' | 'MODEL_NOT_FOUND' | 'SESSION_NOT_FOUND' | 'DURABLE_STORE_REQUIRED' | 'RUN_CONFLICT' | 'RUN_NOT_RESUMABLE' | 'RUN_NOT_RECOVERABLE' | 'CHECKPOINT_UNSUPPORTED' | 'RUN_DEFINITION_CHANGED' | 'POLICY_DENIED' | 'CREDENTIAL_NOT_FOUND' | 'SANDBOX_REQUIRED' | 'ELICITATION_INVALID' | 'APPROVAL_INVALID' | 'RUN_PAUSED' | 'TOOL_EXECUTION_UNKNOWN';
 declare class FevexRunError extends Error {
   readonly code: FevexRunErrorCode;
   readonly runId?: RunId | undefined;
@@ -27,4 +39,4 @@ declare class RunPausedError extends FevexRunError {
   constructor(runId: RunId, pause: RunPause);
 }
 //#endregion
-export { AgentDefinition, AgentEvent, AgentEventPayloads, AgentEventType, AgentLimits, AgentMessage, AgentMessageRole, AgentRun, ApprovalRequest, ApprovalResolution, CredentialStore, DurableRunStore, ExecutionCommit, ExecutionContext, Fevex, FevexConfig, FevexConfigurationError, FevexConfigurationErrorCode, FevexRunError, FevexRunErrorCode, InMemoryRunStore, JsonObject, JsonPrimitive, JsonValue, ListEventsOptions, ModelGateway, ModelInput, ModelMetadata, ModelRef, ModelResult, ModelStreamEvent, ModelUsage, PROVIDER_REASONING_UNSUPPORTED, PROVIDER_SCHEMA_UNSUPPORTED, PendingToolExecution, PolicyAuthorization, PolicyDecision, PolicyDefinition, ReasoningEffort, ResumeRunResolution, RunCheckpoint, RunId, RunLease, RunPause, RunPausedError, RunRequest, RunResult, RunStatus, RunStore, SCHEMA_NOT_TRANSPORTABLE, Session, SessionId, ToolApproval, ToolCall, ToolDefinition, ToolExecutionContext, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, ToolIdempotency, ToolResult, ToolRetryPolicy, ToolRisk, ToolSpec, createFevex, defineAgent, definePolicy, defineTool, isDurableRunStore, toToolSpec };
+export { AgentDefinition, AgentEvent, AgentEventPayloads, AgentEventType, AgentLimits, AgentMessage, AgentMessageRole, AgentRun, AgentRunPause, ApprovalMode, ApprovalRequest, ApprovalResolution, ChannelAdapter, ChannelContext, ChannelError, ChannelEvent, ChannelEventType, ChannelFailurePhase, ChannelMessage, ChannelOutput, ChannelRunEvent, ChannelRunOptions, ChannelRunResult, ConnectionDefinition, ConnectionToolPolicy, ContextBlock, ContextProvider, CoordinatorCheckpoint, CoordinatorRun, CredentialStore, DurableRunStore, ElicitationMode, ElicitationRequest, ElicitationResolution, EventResolution, ExecutionCommit, ExecutionContext, ExecutionCreate, FEVEX_JSON_SCHEMA_PROFILE_VERSION, Fevex, FevexConfig, FevexConfigurationError, FevexConfigurationErrorCode, FevexJsonSchemaProfileLimits, FevexJsonSchemaProfileOptions, FevexJsonSchemaValidator, FevexRunError, FevexRunErrorCode, InMemoryMemoryStore, InMemoryRunStore, IntegrationError, IntegrationErrorCategory, JsonObject, JsonPrimitive, JsonValue, KnowledgeContext, ListEventsOptions, LocalSandboxOptions, MemoryQuery, MemoryRecord, MemoryStore, MemoryWrite, ModelGateway, ModelInput, ModelMetadata, ModelRef, ModelResult, ModelStreamEvent, ModelUsage, PROVIDER_REASONING_UNSUPPORTED, PROVIDER_SCHEMA_UNSUPPORTED, PendingToolExecution, PolicyAuthorization, PolicyDecision, PolicyDefinition, ReasoningEffort, ResumeRunResolution, RunCheckpoint, RunId, RunLease, RunPause, RunPausedError, RunRecord, RunRequest, RunResult, RunStatus, RunStore, SCHEMA_NOT_TRANSPORTABLE, Sandbox, SandboxCapabilities, SandboxError, SandboxRunRequest, SandboxRunResult, Session, SessionId, SkillDefinition, StoredRunCheckpoint, TeamCheckpoint, type TeamDefinition, type TeamDelegation, type TeamHandoff, type TeamLimits, type TeamMember, TeamRun, type TeamStep, type TeamTaskResult, TimerResolution, ToolApproval, ToolCall, ToolChoice, ToolDefinition, ToolEventSource, ToolExecutionContext, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, ToolIdempotency, ToolProvider, ToolProviderContext, ToolProviderTool, ToolResult, ToolRetryPolicy, ToolRisk, ToolSpec, WorkflowAgentResult, WorkflowBudgetUsage, WorkflowCheckpoint, WorkflowCompensationRecord, WorkflowDefinition, WorkflowEventDefinition, WorkflowEventResult, WorkflowRun, WorkflowStep, WorkflowStepContext, WorkflowStepOptions, WorkflowStepRecord, WorkflowWaitRecord, compileFevexJsonSchema, createFevex, createLocalSandbox, createMemoryContextProvider, defineAgent, defineConnection, defineContextProvider, definePolicy, defineSkill, defineTeam, defineTool, defineWorkflow, handleChannelInput, isDurableRunStore, sandboxResultToJson, toToolSpec, validateFevexJsonSchemaProfile, validateListEventsOptions };