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

package/dist/fevex-_KOsOsB8.d.mts

@@ -0,0 +1,129 @@
+import { S as ConnectionDefinition, j as ToolDefinition, o as ToolEmbeddingCache } from "./index-DHcfIfh-.mjs";
+import { t as ModelGateway } from "./index-D7r0puBi.mjs";
+import { F as ArtifactStore, f as RunId, o as ExecutionContext, t as AgentEvent } from "./types-CckDlhYo.mjs";
+import { r as Sandbox } from "./index-DUhNa7IR.mjs";
+import { B as ResumeRunResolution, I as ListEventsOptions, J as RunRequest, O as CredentialStore, Q as Session, R as PurgeRunsOptions, Y as RunResult, Z as RunStore, a as ToolSearchOptions, d as ContextCompactionStats, dt as WorkflowRun, et as SessionId, q as RunRecord, r as ContextBudget, rt as TeamRun, t as AgentDefinition, u as ContextCompactionOptions, x as AgentRun, z as PurgeRunsResult } from "./index-lCCFokc6.mjs";
+import { c as ContextProvider, f as MemoryStore } from "./index-CIHWc5V1.mjs";
+import { i as ObservabilityStats, r as ObservabilityOptions } from "./index-BEqYWean.mjs";
+import { r as PolicyDefinition } from "./index-CFzrvDQ0.mjs";
+import { n as WorkflowDefinition } from "./index-Btth7rdL.mjs";
+import { t as TeamDefinition } from "./index-26ilbzAs.mjs";
+//#region src/fevex.d.ts
+interface FevexAdmissionRequest {
+  kind: 'agent' | 'workflow' | 'team';
+  name: string;
+  request: RunRequest;
+  activeRuns: number;
+  activeTenantRuns: number;
+}
+/** Optional host-level admission controls applied before a top-level run starts. */
+interface FevexAdmission {
+  /** Maximum concurrent top-level runs in this runtime. */
+  maxActiveRuns?: number;
+  /** Maximum concurrent top-level runs for one tenant. */
+  maxActiveRunsPerTenant?: number;
+  /** Defaults to a non-empty `context.attributes.tenantId` string. */
+  tenantKey?: (context?: ExecutionContext) => string | undefined;
+  /** Custom admission check, called after the built-in limits. */
+  authorize?: (request: FevexAdmissionRequest) => boolean | Promise<boolean>;
+}
+interface FevexShutdownOptions {
+  /**
+   * Maximum time to wait for active runs before cancelling them. Defaults to
+   * 30 seconds. Use `0` to cancel immediately. If the deadline expires,
+   * shutdown allows up to 5 additional seconds for forced cancellation and the
+   * final trace flush.
+   */
+  timeoutMs?: number;
+}
+interface FevexShutdownResult {
+  /** Runs that were still active when the grace period expired. */
+  cancelledRunIds: RunId[];
+  /** True when the grace deadline expired before all active runs finished. */
+  timedOut: boolean;
+  /** Error surfaced while flushing pending traces, if any. */
+  exportError?: unknown;
+  /** Observability counters after the shutdown flush. */
+  observability: ObservabilityStats;
+}
+interface FevexLimits {
+  /**
+   * Maximum non-control events persisted for one run. Control events such as
+   * pause, resume, approval and terminal transitions are always persisted.
+   */
+  maxEventsPerRun?: number;
+}
+/** Provider-neutral definitions and adapters used to create one Fevex runtime. */
+interface FevexConfig {
+  models: Record<string, ModelGateway>;
+  agents: AgentDefinition[];
+  workflows?: WorkflowDefinition[];
+  teams?: TeamDefinition[];
+  tools?: ToolDefinition[];
+  connections?: ConnectionDefinition[];
+  contextProviders?: ContextProvider[];
+  /** Default context budget for agents that do not declare one. */
+  contextBudget?: ContextBudget;
+  /** Optional context compactor and token estimator. */
+  compaction?: ContextCompactionOptions;
+  /** Default on-demand tool search for agents that do not declare one. */
+  toolSearch?: ToolSearchOptions;
+  /** Optional durable cache for semantic tool embeddings. */
+  toolSearchCache?: ToolEmbeddingCache;
+  memoryStore?: MemoryStore;
+  runStore?: RunStore;
+  credentialStore?: CredentialStore;
+  sandbox?: Sandbox;
+  /** Optional artifact store exposed to tools as `context.artifacts`. */
+  artifacts?: ArtifactStore;
+  policies?: PolicyDefinition[];
+  onEvent?: (event: AgentEvent) => void;
+  observability?: ObservabilityOptions;
+  admission?: FevexAdmission;
+  limits?: FevexLimits;
+}
+interface Fevex {
+  startAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<AgentRun<TOutput>>;
+  runAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<RunResult<TOutput>>;
+  streamAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): AsyncIterable<AgentEvent>;
+  startWorkflow<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<WorkflowRun<TOutput>>;
+  runWorkflow<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<RunResult<TOutput>>;
+  startTeam<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<TeamRun<TOutput>>;
+  runTeam<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<RunResult<TOutput>>;
+  streamTeam<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): AsyncIterable<AgentEvent>;
+  getTeamRun<TOutput = unknown>(runId: RunId): Promise<TeamRun<TOutput> | undefined>;
+  getRun<TOutput = unknown>(runId: RunId): Promise<RunRecord<TOutput> | undefined>;
+  listEvents(runId: RunId, options?: ListEventsOptions): Promise<AgentEvent[]>;
+  cancelRun(runId: RunId): Promise<boolean>;
+  resumeRun<TOutput = unknown>(runId: RunId, resolution: ResumeRunResolution): Promise<RunRecord<TOutput>>;
+  recoverRun<TOutput = unknown>(runId: RunId, options: {
+    actor: {
+      id: string;
+      type?: string;
+    };
+  }): Promise<RunRecord<TOutput>>;
+  purgeRuns(options?: PurgeRunsOptions): Promise<PurgeRunsResult>;
+  compactSession(sessionId: SessionId, summary: string): Promise<Session>;
+  /** Waits for queued exports and rejects with failures accumulated since the previous flush. */
+  flushObservability(options?: {
+    timeoutMs?: number;
+  }): Promise<void>;
+  /** Cumulative trace export counters for this runtime. */
+  getObservabilityStats(): ObservabilityStats;
+  /** Cumulative context compaction counters for this runtime. */
+  getCompactionStats(): ContextCompactionStats;
+  /**
+   * Stops admitting new work, drains or cancels active runs, and flushes trace
+   * exports. The host still owns closing its stores and external adapters.
+   */
+  shutdown(options?: FevexShutdownOptions): Promise<FevexShutdownResult>;
+}
+/**
+ * Validates a configuration snapshot and creates an isolated runtime.
+ *
+ * The runtime does not own external adapters; callers remain responsible for
+ * closing model, connection, store, and exporter resources they provide.
+ */
+declare function createFevex(config: FevexConfig): Fevex;
+//#endregion
+export { FevexLimits as a, createFevex as c, FevexConfig as i, FevexAdmission as n, FevexShutdownOptions as o, FevexAdmissionRequest as r, FevexShutdownResult as s, Fevex as t };

package/dist/http/index.d.mts

@@ -0,0 +1,150 @@
+import { c as ReasoningEffort } from "../index-D7r0puBi.mjs";
+import { D as ArtifactCatalog, F as ArtifactStore, f as RunId, k as ArtifactDescriptor, l as JsonValue, o as ExecutionContext, t as AgentEvent } from "../types-CckDlhYo.mjs";
+import { dt as WorkflowRun, et as SessionId, q as RunRecord, rt as TeamRun, x as AgentRun } from "../index-lCCFokc6.mjs";
+import { t as Fevex } from "../fevex-_KOsOsB8.mjs";
+//#region src/http/protocol.d.ts
+declare const FEVEX_HTTP_PROTOCOL_VERSION = "3";
+declare const FEVEX_HTTP_PROTOCOL_VERSION_HEADER = "Fevex-Protocol-Version";
+interface StartRunHttpRequest<TInput extends JsonValue = JsonValue> {
+  input: TInput;
+  model?: string;
+  reasoning?: ReasoningEffort;
+  sessionId?: SessionId;
+  /** Maximum wall-clock time for the run, including time spent paused. */
+  deadlineMs?: number;
+}
+type ResumeRunHttpRequest = {
+  type: 'elicitation';
+  requestId: string;
+  value: JsonValue;
+} | {
+  type: 'approval';
+  approvalId: string;
+  decision: 'approve' | 'reject';
+} | {
+  type: 'tool_execution';
+  toolCallId: string;
+  decision: 'use_output';
+  output: JsonValue;
+} | {
+  type: 'tool_execution';
+  toolCallId: string;
+  decision: 'retry';
+} | {
+  type: 'timer';
+} | {
+  type: 'event';
+  eventName: string;
+  payload?: JsonValue;
+};
+/** RFC 9457-compatible problem returned by the Fevex HTTP protocol. */
+interface FevexProblemDetails {
+  type: string;
+  title: string;
+  status: number;
+  code: string;
+  detail?: string;
+  instance?: string;
+}
+interface FevexHttpHandlerContext {
+  context?: ExecutionContext;
+}
+/** Host-facing resource access check. */
+type FevexHttpAccess = {
+  action: 'start';
+  kind: 'agent' | 'workflow' | 'team';
+  name: string;
+  sessionId?: SessionId;
+  context?: ExecutionContext;
+} | {
+  action: 'read' | 'observe' | 'cancel' | 'resume' | 'recover';
+  runId: RunId;
+  context?: ExecutionContext;
+};
+/** Host-facing artifact access check. */
+type FevexArtifactAccess = {
+  action: 'read' | 'delete';
+  kind: 'artifact';
+  artifactId: string;
+  context?: ExecutionContext;
+} | {
+  action: 'read';
+  kind: 'artifacts';
+  runId: RunId;
+  context?: ExecutionContext;
+};
+interface FevexHttpHandlerOptions {
+  fevex: Fevex;
+  pollIntervalMs?: number;
+  /** Events per SSE read (default 100, maximum 1000). */
+  eventPageSize?: number;
+  /** Maximum concurrent SSE streams (default unlimited). */
+  maxConnections?: number;
+  /**
+   * Authorizes a resource operation before the handler reads or mutates a run,
+   * or starts a run (new or existing session). Return false for a 403 response.
+   * Omit to preserve the host's existing trusted-network behavior.
+   */
+  authorize?: (access: FevexHttpAccess) => boolean | Promise<boolean>;
+  /**
+   * Byte store used by the artifact routes. When omitted, artifact routes
+   * return 501.
+   */
+  artifacts?: ArtifactStore;
+  /**
+   * Metadata catalog used to list artifacts for a run. When omitted, the
+   * run-artifact listing route returns 501.
+   */
+  artifactCatalog?: ArtifactCatalog;
+  /**
+   * Authorizes artifact reads, listings and deletions. Omit to preserve the
+   * host's existing trusted-network behavior.
+   */
+  authorizeArtifact?: (access: FevexArtifactAccess) => boolean | Promise<boolean>;
+  /**
+   * Called after a run starts so the host can persist run and session ownership.
+   * If it throws, the handler cancels the new run and returns 500. A process
+   * crash between start and this callback leaves the run unowned; hosts must
+   * treat unowned runs as inaccessible. Runs created outside the HTTP handler
+   * are not reported.
+   */
+  onRunStarted?: (run: RunRecord, context?: ExecutionContext) => void | Promise<void>;
+  onError?: (error: unknown, problem: FevexProblemDetails) => void;
+}
+type FevexHttpHandler = (request: Request, context?: FevexHttpHandlerContext) => Promise<Response>;
+interface FevexHttpClientOptions {
+  baseUrl: string;
+  fetch?: FevexHttpFetch;
+}
+type FevexHttpFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+interface ObserveRunOptions {
+  after?: AgentEvent['id'];
+  signal?: AbortSignal;
+}
+interface FevexHttpClient {
+  startRun<TInput extends JsonValue = JsonValue, TOutput = JsonValue>(agentName: string, request: StartRunHttpRequest<TInput>): Promise<AgentRun<TOutput>>;
+  startWorkflow<TInput extends JsonValue = JsonValue, TOutput = JsonValue>(workflowName: string, request: StartRunHttpRequest<TInput>): Promise<WorkflowRun<TOutput>>;
+  startTeam<TInput extends JsonValue = JsonValue, TOutput = JsonValue>(teamName: string, request: StartRunHttpRequest<TInput>): Promise<TeamRun<TOutput>>;
+  getRun<TOutput = JsonValue>(runId: string): Promise<RunRecord<TOutput>>;
+  observeRun(runId: string, options?: ObserveRunOptions): AsyncIterable<AgentEvent>;
+  resumeRun<TOutput = JsonValue>(runId: string, request: ResumeRunHttpRequest): Promise<RunRecord<TOutput>>;
+  recoverRun<TOutput = JsonValue>(runId: string): Promise<RunRecord<TOutput>>;
+  cancelRun(runId: string): Promise<void>;
+  getArtifact(artifactId: string): Promise<Response>;
+  listArtifacts(runId: string): Promise<ArtifactDescriptor[]>;
+  deleteArtifact(artifactId: string): Promise<void>;
+}
+//#endregion
+//#region src/http/transport.d.ts
+/** Exposes a Fevex instance through the versioned HTTP protocol. */
+declare function createFevexHttpHandler(options: FevexHttpHandlerOptions): FevexHttpHandler;
+declare class FevexHttpError extends Error {
+  readonly problem: FevexProblemDetails;
+  readonly name = "FevexHttpError";
+  constructor(problem: FevexProblemDetails);
+  get status(): number;
+  get code(): string;
+}
+declare function createFevexHttpClient(options: FevexHttpClientOptions): FevexHttpClient;
+//#endregion
+export { FEVEX_HTTP_PROTOCOL_VERSION, FEVEX_HTTP_PROTOCOL_VERSION_HEADER, FevexArtifactAccess, FevexHttpAccess, FevexHttpClient, FevexHttpClientOptions, FevexHttpError, FevexHttpFetch, FevexHttpHandler, FevexHttpHandlerContext, FevexHttpHandlerOptions, FevexProblemDetails, ObserveRunOptions, ResumeRunHttpRequest, StartRunHttpRequest, createFevexHttpClient, createFevexHttpHandler };