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

package/dist/index-DGWOGXzc.d.mts

@@ -0,0 +1,181 @@
+import { f as RunId, i as AgentMessage, l as JsonValue, o as ExecutionContext, t as AgentEvent } from "./index-C_Zpr13f.mjs";
+import { ModelUsage } from "./models/index.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/runtime/index.d.ts
+type SessionId = string;
+type RunStatus = 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+interface ApprovalRequest {
+  id: string;
+  toolCallId: string;
+  toolName: string;
+  input: JsonValue;
+  risk: 'read' | 'write' | 'sensitive' | 'destructive';
+  requestedAt: string;
+}
+type RunPause = {
+  type: 'approval';
+  approval: ApprovalRequest;
+} | {
+  type: 'tool_execution_unknown';
+  toolCallId: string;
+  toolName: string;
+  input: JsonValue;
+};
+interface ApprovalResolution {
+  type: 'approval';
+  approvalId: string;
+  decision: 'approve' | 'reject';
+  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 ResumeRunResolution = ApprovalResolution | ToolExecutionResolution;
+interface AgentRun<TOutput = JsonValue> {
+  id: RunId;
+  sessionId: SessionId;
+  agentName: string;
+  status: RunStatus;
+  revision: number;
+  pause?: RunPause;
+  createdAt: string;
+  updatedAt: string;
+  output?: TOutput;
+  error?: string;
+  usage?: ModelUsage;
+}
+interface Session {
+  id: SessionId;
+  history: AgentMessage[];
+  createdAt: string;
+  updatedAt: string;
+}
+interface ListEventsOptions {
+  after?: AgentEvent['id'];
+}
+interface RunStore {
+  getRun(runId: RunId): Promise<AgentRun | undefined>;
+  saveRun(run: AgentRun): 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[]>;
+}
+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 {
+  runId: RunId;
+  definitionHash: string;
+  messages: AgentMessage[];
+  inputContent: string;
+  context?: ExecutionContext;
+  usage?: ModelUsage;
+  providerState?: JsonValue;
+  step: number;
+  toolCallCount: number;
+  seenToolCallIds: string[];
+  pendingTools: PendingToolExecution[];
+  pendingIndex: number;
+}
+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;
+}
+interface RunLease {
+  runId: RunId;
+  ownerId: string;
+  expiresAt: string;
+}
+interface ExecutionCommit {
+  expectedRevision: number;
+  run: AgentRun;
+  checkpoint?: RunCheckpoint | null;
+  session?: Session;
+  toolExecution?: ToolExecutionRecord;
+  events?: AgentEvent[];
+}
+interface DurableRunStore extends RunStore {
+  getCheckpoint(runId: RunId): Promise<RunCheckpoint | undefined>;
+  getToolExecution(runId: RunId, toolCallId: string): Promise<ToolExecutionRecord | undefined>;
+  commitExecution(commit: ExecutionCommit): Promise<boolean>;
+  acquireLease(lease: RunLease): Promise<boolean>;
+  renewLease(lease: RunLease): Promise<boolean>;
+  releaseLease(runId: RunId, ownerId: string): Promise<void>;
+}
+declare function isDurableRunStore(store: RunStore): store is DurableRunStore;
+declare class InMemoryRunStore implements DurableRunStore {
+  #private;
+  getRun(runId: RunId): Promise<AgentRun | undefined>;
+  saveRun(run: AgentRun): 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(runId: RunId): Promise<RunCheckpoint | undefined>;
+  getToolExecution(runId: RunId, toolCallId: string): Promise<ToolExecutionRecord | undefined>;
+  commitExecution(commit: ExecutionCommit): Promise<boolean>;
+  acquireLease(lease: RunLease): Promise<boolean>;
+  renewLease(lease: RunLease): Promise<boolean>;
+  releaseLease(runId: RunId, ownerId: string): Promise<void>;
+}
+interface RunRequest<TInput = unknown, TOutput = unknown> {
+  input: TInput;
+  context?: ExecutionContext;
+  outputSchema?: StandardSchemaV1<unknown, TOutput>;
+  sessionId?: SessionId;
+  signal?: AbortSignal;
+}
+interface RunResult<TOutput = unknown> {
+  runId: RunId;
+  sessionId: SessionId;
+  output: TOutput;
+  events?: AgentEvent[];
+  usage?: ModelUsage;
+}
+//#endregion
+export { isDurableRunStore as C, ToolExecutionStatus as S, RunStore as _, DurableRunStore as a, ToolExecutionRecord as b, ListEventsOptions as c, RunCheckpoint as d, RunLease as f, RunStatus as g, RunResult as h, CredentialStore as i, PendingToolExecution as l, RunRequest as m, ApprovalRequest as n, ExecutionCommit as o, RunPause as p, ApprovalResolution as r, InMemoryRunStore as s, AgentRun as t, ResumeRunResolution as u, Session as v, ToolExecutionResolution as x, SessionId as y };

package/dist/index-QTkd6a7C.d.mts

@@ -0,0 +1,20 @@
+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
+type PolicyDecision = 'allow' | 'deny' | 'require_approval';
+interface PolicyAuthorization {
+  runId: RunId;
+  agentName: string;
+  toolName: string;
+  risk: ToolRisk;
+  input: JsonValue;
+  action: 'tool.execute' | 'approval.resolve';
+  context?: ExecutionContext;
+}
+interface PolicyDefinition {
+  name: string;
+  authorize(input: PolicyAuthorization): PolicyDecision | Promise<PolicyDecision>;
+}
+declare function definePolicy<T extends PolicyDefinition>(policy: T): T;
+//#endregion
+export { definePolicy as i, PolicyDecision as n, PolicyDefinition as r, PolicyAuthorization as t };

package/dist/index-ojCY3lwm.d.mts

@@ -0,0 +1,79 @@
+import { f as RunId, l as JsonValue, s as JsonObject } from "./index-C_Zpr13f.mjs";
+import { ModelMetadata, ModelUsage } from "./models/index.mjs";
+import { y as SessionId } from "./index-DGWOGXzc.mjs";
+//#region src/observability/index.d.ts
+type TraceStatus = 'completed' | 'failed' | 'cancelled';
+type TraceSpanKind = 'model' | 'tool';
+type TraceContentKind = 'run.output' | 'model.output' | 'error.message';
+interface TraceCost {
+  amount: number;
+  currency: string;
+}
+interface TraceContent {
+  kind: TraceContentKind;
+  value: JsonValue;
+}
+interface TraceAnnotation {
+  name: string;
+  timestamp: string;
+  attributes?: JsonObject;
+}
+interface TraceSpan {
+  id: string;
+  parentId: string;
+  kind: TraceSpanKind;
+  name: string;
+  startedAt: string;
+  endedAt: string;
+  durationMs: number;
+  status: TraceStatus;
+  attributes: JsonObject;
+  annotations: TraceAnnotation[];
+  usage?: ModelUsage;
+  cost?: TraceCost;
+  content?: TraceContent[];
+}
+interface RunTrace {
+  schemaVersion: '1';
+  traceId: string;
+  runId: RunId;
+  sessionId: SessionId;
+  agentName: string;
+  modelRegistryName: string;
+  model?: ModelMetadata;
+  startedAt: string;
+  endedAt: string;
+  durationMs: number;
+  status: TraceStatus;
+  attributes: JsonObject;
+  annotations: TraceAnnotation[];
+  spans: TraceSpan[];
+  usage?: ModelUsage;
+  cost?: TraceCost;
+  content?: TraceContent[];
+}
+interface CostCalculatorInput {
+  modelRegistryName: string;
+  model?: ModelMetadata;
+  usage: ModelUsage;
+}
+type CostCalculator = (input: CostCalculatorInput) => TraceCost | undefined;
+interface TraceRedactorInput {
+  kind: TraceContentKind;
+  value: JsonValue;
+}
+type TraceRedactor = (input: TraceRedactorInput) => JsonValue | undefined;
+interface TraceContentPolicy {
+  include: readonly TraceContentKind[];
+  redact?: TraceRedactor;
+}
+interface TraceExporter {
+  export(trace: Readonly<RunTrace>): void | Promise<void>;
+}
+interface ObservabilityOptions {
+  exporters: readonly TraceExporter[];
+  calculateCost?: CostCalculator;
+  content?: TraceContentPolicy;
+}
+//#endregion
+export { TraceAnnotation as a, TraceContentPolicy as c, TraceRedactor as d, TraceRedactorInput as f, TraceStatus as h, RunTrace as i, TraceCost as l, TraceSpanKind as m, CostCalculatorInput as n, TraceContent as o, TraceSpan as p, ObservabilityOptions as r, TraceContentKind as s, CostCalculator as t, TraceExporter as u };

package/dist/index.d.mts

@@ -1,18 +1,30 @@
-import { a as ExecutionContext, c as JsonValue, d as ToolCall, f as ToolSpec, i as AgentMessageRole, l as RunId, n as AgentEventType, o as JsonObject, r as AgentMessage, s as JsonPrimitive, t as AgentEvent, u as SCHEMA_NOT_TRANSPORTABLE } from "./index-D_RBJmVt.mjs";
-import { ModelGateway, ModelGenerateInput, ModelGenerateResult, ModelRef, ModelUsage, ReasoningEffort } from "./models/index.mjs";
-import { AgentDefinition, AgentLimits, defineAgent } from "./agents/index.mjs";
-import { RunRequest, RunResult } from "./runtime/index.mjs";
-import { ToolDefinition, ToolExecutionContext, ToolResult, defineTool, toToolSpec } from "./tools/index.mjs";
-//#region src/index.d.ts
-interface FevexConfig {
-  models: Record<string, ModelGateway>;
-  agents: AgentDefinition[];
-  tools?: ToolDefinition[];
-  onEvent?: (event: AgentEvent) => void;
+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";
+//#region src/configuration-error.d.ts
+type FevexConfigurationErrorCode = 'INVALID_CONFIG' | 'INVALID_MODEL' | 'INVALID_AGENT' | 'INVALID_TOOL' | 'DUPLICATE_AGENT' | 'DUPLICATE_TOOL' | 'MISSING_MODEL' | 'MISSING_TOOL';
+declare class FevexConfigurationError extends Error {
+  readonly code: FevexConfigurationErrorCode;
+  constructor(code: FevexConfigurationErrorCode, message: string);
 }
-interface Fevex {
-  runAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<RunResult<TOutput>>;
+//#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';
+declare class FevexRunError extends Error {
+  readonly code: FevexRunErrorCode;
+  readonly runId?: RunId | undefined;
+  readonly name: string;
+  constructor(code: FevexRunErrorCode, message: string, runId?: RunId | undefined, options?: ErrorOptions);
+}
+declare class RunPausedError extends FevexRunError {
+  readonly runId: RunId;
+  readonly pause: RunPause;
+  readonly name: string;
+  constructor(runId: RunId, pause: RunPause);
 }
-declare function createFevex(config: FevexConfig): Fevex;
 //#endregion
-export { AgentDefinition, AgentEvent, AgentEventType, AgentLimits, AgentMessage, AgentMessageRole, ExecutionContext, Fevex, FevexConfig, JsonObject, JsonPrimitive, JsonValue, ModelGateway, ModelGenerateInput, ModelGenerateResult, ModelRef, ModelUsage, ReasoningEffort, RunId, RunRequest, RunResult, SCHEMA_NOT_TRANSPORTABLE, ToolCall, ToolDefinition, ToolExecutionContext, ToolResult, ToolSpec, createFevex, defineAgent, defineTool, toToolSpec };
+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 };