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

package/dist/types-CckDlhYo.d.mts

@@ -0,0 +1,575 @@
+//#region src/artifacts/artifacts.d.ts
+/** Stable identifier for a stored artifact. */
+type ArtifactId = string;
+/**
+ * Small, JSON-serializable reference to a stored artifact.
+ *
+ * The bytes live in an `ArtifactStore`; runs, events and prompts only carry
+ * this descriptor.
+ */
+interface ArtifactDescriptor {
+  artifactId: ArtifactId;
+  /** Stable URI for host and protocol hand-offs, for example `artifact://<id>`. */
+  uri: string;
+  filename: string;
+  mimeType: string;
+  size: number;
+  sha256: string;
+  createdAt: string;
+  expiresAt?: string;
+  metadata?: JsonObject;
+}
+interface ArtifactWrite {
+  filename: string;
+  mimeType: string;
+  bytes: Uint8Array;
+  metadata?: JsonObject;
+  expiresAt?: string;
+}
+interface ArtifactContent {
+  descriptor: ArtifactDescriptor;
+  bytes: Uint8Array;
+}
+/** Scope supplied by the host when reading or writing an artifact. */
+interface ArtifactStoreContext {
+  tenantId?: string;
+  runId?: string;
+  sessionId?: string;
+  actor?: ExecutionContext['actor'];
+  signal?: AbortSignal;
+}
+/**
+ * Durable storage for large or binary outputs.
+ *
+ * Implementations must never return mutable internal state; callers may mutate
+ * the returned descriptor or bytes.
+ */
+interface ArtifactStore {
+  put(input: ArtifactWrite, context?: ArtifactStoreContext): Promise<ArtifactDescriptor>;
+  get(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactContent | null>;
+  head?(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactDescriptor | null>;
+  delete?(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<boolean>;
+}
+type ArtifactErrorCode = 'ARTIFACT_INVALID_INPUT' | 'ARTIFACT_TOO_LARGE' | 'ARTIFACT_MIME_UNSUPPORTED' | 'ARTIFACT_INVALID_ID' | 'ARTIFACT_INVALID_CONTEXT' | 'ARTIFACT_CONFLICT' | 'ARTIFACT_CORRUPT';
+declare class ArtifactError extends Error {
+  readonly code: ArtifactErrorCode;
+  constructor(code: ArtifactErrorCode, message: string);
+}
+/** Metadata record indexed by an `ArtifactCatalog`. */
+interface ArtifactRecord {
+  descriptor: ArtifactDescriptor;
+  tenantId: string;
+  runId?: string;
+  sessionId?: string;
+  actorId?: string;
+}
+interface ArtifactQuery {
+  runId?: string;
+  sessionId?: string;
+  actorId?: string;
+  mimeType?: string;
+  /** Include expired artifacts. Defaults to false. */
+  includeExpired?: boolean;
+  /** Maximum records to return. Defaults to 100 and is capped at 1000. */
+  limit?: number;
+}
+/**
+ * Queryable metadata index for artifacts.
+ *
+ * The bytes stay in an `ArtifactStore`; the catalog lets hosts list, authorize
+ * and delete by tenant, run, session or actor without scanning object storage.
+ */
+interface ArtifactCatalog {
+  save(record: ArtifactRecord, context?: ArtifactStoreContext): Promise<void>;
+  get(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactRecord | null>;
+  list(query?: ArtifactQuery, context?: ArtifactStoreContext): Promise<ArtifactRecord[]>;
+  delete(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<boolean>;
+  deleteByRun(runId: string, context?: ArtifactStoreContext): Promise<number>;
+}
+/** Resolves and validates the tenant scope used by stores and catalogs. */
+declare function artifactTenantId(context?: ArtifactStoreContext): string;
+/** Validates an artifact id before using it in a query or storage key. */
+declare function assertArtifactId(artifactId: string): void;
+//#endregion
+//#region src/artifacts/cataloged-artifact-store.d.ts
+interface CatalogedArtifactStoreOptions {
+  /** Byte store, for example `FileSystemArtifactStore` or `S3ArtifactStore`. */
+  store: ArtifactStore;
+  /** Metadata index, for example `SQLiteArtifactCatalog` or `PostgresArtifactCatalog`. */
+  catalog: ArtifactCatalog;
+}
+/**
+ * Composes a byte store with a queryable metadata catalog.
+ *
+ * `put` writes bytes first and then indexes metadata. If indexing fails, the
+ * bytes are deleted so the catalog never points at a half-written artifact.
+ */
+declare class CatalogedArtifactStore implements ArtifactStore {
+  #private;
+  constructor(options: CatalogedArtifactStoreOptions);
+  put(input: ArtifactWrite, context?: ArtifactStoreContext): Promise<ArtifactDescriptor>;
+  get(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactContent | null>;
+  head(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactDescriptor | null>;
+  delete(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<boolean>;
+  list(query?: ArtifactQuery, context?: ArtifactStoreContext): Promise<ArtifactRecord[]>;
+  deleteByRun(runId: string, context?: ArtifactStoreContext): Promise<number>;
+}
+//#endregion
+//#region src/artifacts/internal.d.ts
+interface ArtifactStoreLimits {
+  maxBytes?: number;
+  allowedMimeTypes?: readonly string[];
+  retentionMs?: number;
+}
+//#endregion
+//#region src/artifacts/file-system-artifact-store.d.ts
+interface FileSystemArtifactStoreOptions extends ArtifactStoreLimits {
+  /** Directory that owns artifact bytes and metadata. */
+  rootDir: string;
+}
+/**
+ * Local filesystem artifact store.
+ *
+ * Layout:
+ *   <rootDir>/tenants/<tenantId>/artifacts/<artifactId>
+ *   <rootDir>/tenants/<tenantId>/artifacts/<artifactId>.json
+ *
+ * Bytes are written before metadata, and both use an atomic rename. This is
+ * intended for local development and single-node deployments; use
+ * `S3ArtifactStore` for multi-instance production.
+ */
+declare class FileSystemArtifactStore implements ArtifactStore {
+  #private;
+  constructor(options: FileSystemArtifactStoreOptions);
+  put(input: ArtifactWrite, context?: ArtifactStoreContext): Promise<ArtifactDescriptor>;
+  get(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactContent | null>;
+  head(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactDescriptor | null>;
+  delete(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<boolean>;
+}
+//#endregion
+//#region src/artifacts/in-memory-artifact-catalog.d.ts
+/** Volatile artifact metadata catalog for tests and local development. */
+declare class InMemoryArtifactCatalog implements ArtifactCatalog {
+  #private;
+  save(record: ArtifactRecord, context?: ArtifactStoreContext): Promise<void>;
+  get(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactRecord | null>;
+  list(query?: ArtifactQuery, context?: ArtifactStoreContext): Promise<ArtifactRecord[]>;
+  delete(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<boolean>;
+  deleteByRun(runId: string, context?: ArtifactStoreContext): Promise<number>;
+}
+//#endregion
+//#region src/artifacts/in-memory-artifact-store.d.ts
+interface InMemoryArtifactStoreOptions extends ArtifactStoreLimits {}
+/** Volatile artifact store for tests and local development. */
+declare class InMemoryArtifactStore implements ArtifactStore {
+  #private;
+  constructor(options?: InMemoryArtifactStoreOptions);
+  put(input: ArtifactWrite, context?: ArtifactStoreContext): Promise<ArtifactDescriptor>;
+  get(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactContent | null>;
+  head(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactDescriptor | null>;
+  delete(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<boolean>;
+}
+//#endregion
+//#region src/artifacts/s3-artifact-store.d.ts
+/**
+ * Minimal S3-compatible object client.
+ *
+ * Wrap `@aws-sdk/client-s3`, a Cloudflare R2 client, MinIO or any other
+ * S3-compatible SDK with this interface. Fevex does not depend on an object
+ * storage SDK.
+ */
+interface S3ObjectClient {
+  putObject(input: {
+    key: string;
+    body: Uint8Array;
+    contentType: string;
+    metadata?: Record<string, string>;
+  }): Promise<void>;
+  getObject(input: {
+    key: string;
+  }): Promise<Uint8Array | null>;
+  deleteObject(input: {
+    key: string;
+  }): Promise<void>;
+}
+interface S3ArtifactStoreOptions extends ArtifactStoreLimits {
+  client: S3ObjectClient;
+  /** Key prefix. Defaults to `fevex`. */
+  prefix?: string;
+}
+/**
+ * Artifact store for S3-compatible object storage (S3, R2, MinIO, GCS via an
+ * S3 gateway, and similar).
+ *
+ * Bytes are stored at `<prefix>/<tenant>/artifacts/<artifactId>` and metadata
+ * in a `.json` sidecar next to them. The bucket should stay private; the host
+ * serves downloads through its authenticated API or short-lived signed URLs.
+ */
+declare class S3ArtifactStore implements ArtifactStore {
+  #private;
+  constructor(options: S3ArtifactStoreOptions);
+  put(input: ArtifactWrite, context?: ArtifactStoreContext): Promise<ArtifactDescriptor>;
+  get(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactContent | null>;
+  head(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<ArtifactDescriptor | null>;
+  delete(artifactId: ArtifactId, context?: ArtifactStoreContext): Promise<boolean>;
+}
+//#endregion
+//#region src/core/types.d.ts
+/** A value that can cross provider and persistence boundaries without conversion. */
+type JsonPrimitive = string | number | boolean | null;
+type JsonObject = {
+  [key: string]: JsonValue;
+};
+type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+type RunId = string;
+declare const SCHEMA_NOT_TRANSPORTABLE = "SCHEMA_NOT_TRANSPORTABLE";
+declare const PROVIDER_SCHEMA_UNSUPPORTED = "PROVIDER_SCHEMA_UNSUPPORTED";
+declare const PROVIDER_REASONING_UNSUPPORTED = "PROVIDER_REASONING_UNSUPPORTED";
+interface ExecutionContext {
+  namespace?: string;
+  actor?: {
+    id: string;
+    type?: string;
+  };
+  attributes?: JsonObject;
+  prompt?: JsonObject;
+}
+type AgentMessageRole = 'system' | 'user' | 'assistant' | 'tool';
+interface AgentMessage {
+  role: AgentMessageRole;
+  content: string;
+  name?: string;
+  toolCallId?: string;
+  toolCalls?: ToolCall[];
+}
+interface ToolSpec {
+  name: string;
+  description?: string;
+  inputSchema?: JsonObject;
+}
+interface ToolCall {
+  id: string;
+  name: string;
+  input: JsonValue;
+}
+interface ToolEventSource {
+  kind: 'connection';
+  provider: string;
+  connectionName: string;
+  remoteToolName: string;
+}
+type AgentEventType = 'run.started' | 'run.recovered' | 'run.paused' | 'run.resumed' | 'model.started' | 'model.output.delta' | 'model.completed' | 'context.compacted' | 'tool.started' | 'tool.completed' | 'tool.failed' | 'tool.retrying' | 'tool.execution_unknown' | 'artifact.created' | 'elicitation.requested' | 'elicitation.resolved' | 'approval.requested' | 'approval.resolved' | 'run.completed' | 'run.failed' | 'run.cancelled' | 'workflow.run.started' | 'workflow.run.recovered' | 'workflow.step.started' | 'workflow.step.completed' | 'workflow.step.failed' | 'workflow.compensation.started' | 'workflow.compensation.completed' | 'workflow.compensation.failed' | 'workflow.wait.started' | 'workflow.wait.completed' | 'workflow.run.paused' | 'workflow.run.resumed' | 'workflow.run.completed' | 'workflow.run.failed' | 'workflow.run.cancelled' | 'team.run.started' | 'team.run.recovered' | 'team.agent.assigned' | 'team.handoff.created' | 'team.task.completed' | 'team.task.failed' | 'team.merge.started' | 'team.merge.completed' | 'team.merge.failed' | 'team.run.paused' | 'team.run.resumed' | 'team.run.completed' | 'team.run.failed' | 'team.run.cancelled';
+interface AgentEventPayloads {
+  'run.started': undefined;
+  'run.recovered': {
+    actorId: string;
+  };
+  'run.paused': {
+    reason: 'elicitation' | 'approval' | 'tool_execution_unknown';
+    toolCallId: string;
+  };
+  'run.resumed': undefined;
+  'model.started': {
+    step: number;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'model.output.delta': {
+    step: number;
+    delta: string;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'model.completed': {
+    step: number;
+    usage?: JsonObject;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'context.compacted': {
+    step: number;
+    removedMessages: number;
+    estimatedTokens: number;
+    compactedTokens: number;
+    targetTokens: number;
+    contextWindow: number;
+    summary: string;
+    summaryTruncated?: boolean;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'tool.started': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    attempt?: number;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'tool.completed': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    attempt?: number;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'tool.failed': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    error: string;
+    errorCode?: string;
+    retryable?: boolean;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'tool.retrying': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    attempt: number;
+    delayMs: number;
+    error: string;
+    errorCode?: string;
+    retryable?: boolean;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'tool.execution_unknown': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'artifact.created': {
+    descriptor: ArtifactDescriptor;
+    toolCallId?: string;
+    toolName?: string;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'elicitation.requested': {
+    request: {
+      id: string;
+      toolCallId: string;
+      prompt: string;
+      responseSchema: JsonObject;
+      requestedAt: string;
+      expiresAt?: string;
+    };
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'elicitation.resolved': {
+    requestId: string;
+    toolCallId: string;
+    actorId: string;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'approval.requested': {
+    approvalId: string;
+    toolCallId: string;
+    toolName: string;
+    toolLabel?: string;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'approval.resolved': {
+    approvalId: string;
+    toolCallId: string;
+    decision: 'approve' | 'reject';
+    actorId: string;
+    toolLabel?: string;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'run.completed': {
+    output: JsonValue;
+    usage?: JsonObject;
+  };
+  'run.failed': {
+    error: string;
+    errorCode?: string;
+    retryable?: boolean;
+    source?: ToolEventSource;
+  };
+  'run.cancelled': {
+    reason: 'aborted' | 'timeout' | 'approval_rejected';
+  };
+  'workflow.run.started': undefined;
+  'workflow.run.recovered': {
+    actorId: string;
+  };
+  'workflow.step.started': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+    agentName?: string;
+    childRunId?: string;
+  };
+  'workflow.step.completed': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+  };
+  'workflow.step.failed': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+    error: string;
+  };
+  'workflow.compensation.started': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+  };
+  'workflow.compensation.completed': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+  };
+  'workflow.compensation.failed': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+    error: string;
+  };
+  'workflow.wait.started': {
+    stepId: string;
+    kind: 'timer' | 'event';
+    resumeAt?: string;
+    eventName?: string;
+  };
+  'workflow.wait.completed': {
+    stepId: string;
+    kind: 'timer' | 'event';
+    payload?: JsonValue;
+    actorId?: string;
+    receivedAt?: string;
+  };
+  'workflow.run.paused': {
+    stepId: string;
+    reason: 'child' | 'timer' | 'event';
+    childRunId?: string;
+  };
+  'workflow.run.resumed': undefined;
+  'workflow.run.completed': {
+    output: JsonValue;
+    usage?: JsonObject;
+  };
+  'workflow.run.failed': {
+    error: string;
+    errorCode?: string;
+    retryable?: boolean;
+    source?: ToolEventSource;
+  };
+  'workflow.run.cancelled': {
+    reason: 'aborted' | 'timeout' | 'approval_rejected';
+  };
+  'team.run.started': undefined;
+  'team.run.recovered': {
+    actorId: string;
+  };
+  'team.agent.assigned': {
+    delegationId: string;
+    agentName: string;
+    action: 'delegate' | 'handoff';
+    expectedOutput?: string;
+    constraints?: string[];
+    childRunId?: string;
+  };
+  'team.handoff.created': {
+    delegationId: string;
+    from: string;
+    to: string;
+    reason: string;
+  };
+  'team.task.completed': {
+    delegationId: string;
+    agentName: string;
+    usage?: JsonObject;
+  };
+  'team.task.failed': {
+    delegationId: string;
+    agentName?: string;
+    error: string;
+  };
+  'team.merge.started': {
+    stepId: string;
+    width: number;
+  };
+  'team.merge.completed': {
+    stepId: string;
+  };
+  'team.merge.failed': {
+    stepId: string;
+    error: string;
+  };
+  'team.run.paused': {
+    delegationId: string;
+    reason: 'child' | 'timer' | 'event';
+    childRunId?: string;
+  };
+  'team.run.resumed': undefined;
+  'team.run.completed': {
+    output: JsonValue;
+    usage?: JsonObject;
+  };
+  'team.run.failed': {
+    error: string;
+    errorCode?: string;
+    retryable?: boolean;
+    source?: ToolEventSource;
+  };
+  'team.run.cancelled': {
+    reason: 'aborted' | 'timeout' | 'approval_rejected';
+  };
+}
+interface AgentEventBase {
+  id: string;
+  sequence: number;
+  runId: RunId;
+  timestamp: string;
+}
+type AgentEvent<TType extends AgentEventType = AgentEventType> = { [TCurrent in TType]: AgentEventBase & {
+  type: TCurrent;
+} & (AgentEventPayloads[TCurrent] extends undefined ? {
+  payload?: never;
+} : {
+  payload: AgentEventPayloads[TCurrent];
+}); }[TType];
+//#endregion
+export { ArtifactError as A, FileSystemArtifactStore as C, ArtifactCatalog as D, CatalogedArtifactStoreOptions as E, ArtifactStore as F, ArtifactStoreContext as I, ArtifactWrite as L, ArtifactId as M, ArtifactQuery as N, ArtifactContent as O, ArtifactRecord as P, artifactTenantId as R, InMemoryArtifactCatalog as S, CatalogedArtifactStore as T, S3ArtifactStore as _, AgentMessageRole as a, InMemoryArtifactStore as b, JsonPrimitive as c, PROVIDER_SCHEMA_UNSUPPORTED as d, RunId as f, ToolSpec as g, ToolEventSource as h, AgentMessage as i, ArtifactErrorCode as j, ArtifactDescriptor as k, JsonValue as l, ToolCall as m, AgentEventPayloads as n, ExecutionContext as o, SCHEMA_NOT_TRANSPORTABLE as p, AgentEventType as r, JsonObject as s, AgentEvent as t, PROVIDER_REASONING_UNSUPPORTED as u, S3ArtifactStoreOptions as v, FileSystemArtifactStoreOptions as w, InMemoryArtifactStoreOptions as x, S3ObjectClient as y, assertArtifactId as z };

package/dist/workflows/index.d.mts

@@ -0,0 +1,2 @@
+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-Btth7rdL.mjs";
+export { WorkflowAgentResult, WorkflowDefinition, WorkflowEventDefinition, WorkflowEventResult, WorkflowStep, WorkflowStepContext, WorkflowStepOptions, defineWorkflow };

package/dist/workflows/index.mjs

@@ -0,0 +1,6 @@
+//#region src/workflows/workflow.ts
+function defineWorkflow(workflow) {
+	return workflow;
+}
+//#endregion
+export { defineWorkflow };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fevex/core",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.10",
   "description": "Agent Engineering Framework for code-first, provider-neutral AI agents.",
   "type": "module",
   "license": "Apache-2.0",
@@ -31,6 +31,22 @@
       "types": "./dist/agents/index.d.mts",
       "import": "./dist/agents/index.mjs"
     },
+    "./artifacts": {
+      "types": "./dist/artifacts/index.d.mts",
+      "import": "./dist/artifacts/index.mjs"
+    },
+    "./channels": {
+      "types": "./dist/channels/index.d.mts",
+      "import": "./dist/channels/index.mjs"
+    },
+    "./http": {
+      "types": "./dist/http/index.d.mts",
+      "import": "./dist/http/index.mjs"
+    },
+    "./knowledge": {
+      "types": "./dist/knowledge/index.d.mts",
+      "import": "./dist/knowledge/index.mjs"
+    },
     "./models": {
       "types": "./dist/models/index.d.mts",
       "import": "./dist/models/index.mjs"
@@ -39,10 +55,22 @@
       "types": "./dist/tools/index.d.mts",
       "import": "./dist/tools/index.mjs"
     },
+    "./workflows": {
+      "types": "./dist/workflows/index.d.mts",
+      "import": "./dist/workflows/index.mjs"
+    },
+    "./teams": {
+      "types": "./dist/teams/index.d.mts",
+      "import": "./dist/teams/index.mjs"
+    },
     "./runtime": {
       "types": "./dist/runtime/index.d.mts",
       "import": "./dist/runtime/index.mjs"
     },
+    "./sandbox": {
+      "types": "./dist/sandbox/index.d.mts",
+      "import": "./dist/sandbox/index.mjs"
+    },
     "./policies": {
       "types": "./dist/policies/index.d.mts",
       "import": "./dist/policies/index.mjs"
@@ -61,9 +89,9 @@
     }
   },
   "scripts": {
-    "build": "tsdown src/index.ts src/agents/index.ts src/models/index.ts src/tools/index.ts src/runtime/index.ts src/policies/index.ts src/observability/index.ts src/evals/index.ts src/testing/index.ts --format esm --dts --clean",
+    "build": "tsdown src/index.ts src/agents/index.ts src/artifacts/index.ts src/channels/index.ts src/http/index.ts src/knowledge/index.ts src/models/index.ts src/tools/index.ts src/workflows/index.ts src/teams/index.ts src/runtime/index.ts src/sandbox/index.ts src/policies/index.ts src/observability/index.ts src/evals/index.ts src/testing/index.ts --format esm --dts --clean",
     "prepack": "bun run build",
-    "test": "bun test src/index.test.ts src/internal/json.test.ts src/internal/model-stream.test.ts src/observability/index.test.ts src/evals/index.test.ts src/testing/index.test.ts",
+    "test": "bun test --cwd src",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "publishConfig": {

package/dist/exact-definition-NHBBFlFR.d.mts

@@ -1,4 +0,0 @@
-//#region src/internal/exact-definition.d.ts
-type ExactDefinition<TInput, TShape> = TInput & { readonly [TKey in Exclude<keyof TInput, keyof TShape>]: never; };
-//#endregion
-export { ExactDefinition as t };

package/dist/fevex-Dz6GBz9o.d.mts

@@ -1,32 +0,0 @@
-import { f as RunId, t as AgentEvent } from "./index-C_Zpr13f.mjs";
-import { ModelGateway } from "./models/index.mjs";
-import { t as AgentDefinition } from "./index-BzxHfyYV.mjs";
-import { _ as RunStore, c as ListEventsOptions, h as RunResult, i as CredentialStore, m as RunRequest, t as AgentRun, u as ResumeRunResolution, v as Session, y as SessionId } from "./index-DGWOGXzc.mjs";
-import { r as ObservabilityOptions } from "./index-ojCY3lwm.mjs";
-import { n as ToolDefinition } from "./index-CZGyhNIQ.mjs";
-import { r as PolicyDefinition } from "./index-QTkd6a7C.mjs";
-//#region src/fevex.d.ts
-interface FevexConfig {
-  models: Record<string, ModelGateway>;
-  agents: AgentDefinition[];
-  tools?: ToolDefinition[];
-  runStore?: RunStore;
-  credentialStore?: CredentialStore;
-  policies?: PolicyDefinition[];
-  onEvent?: (event: AgentEvent) => void;
-  observability?: ObservabilityOptions;
-}
-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>;
-  getRun<TOutput = unknown>(runId: RunId): Promise<AgentRun<TOutput> | undefined>;
-  listEvents(runId: RunId, options?: ListEventsOptions): Promise<AgentEvent[]>;
-  cancelRun(runId: RunId): Promise<boolean>;
-  resumeRun<TOutput = unknown>(runId: RunId, resolution: ResumeRunResolution): Promise<AgentRun<TOutput>>;
-  compactSession(sessionId: SessionId, summary: string): Promise<Session>;
-  flushObservability(): Promise<void>;
-}
-declare function createFevex(config: FevexConfig): Fevex;
-//#endregion
-export { FevexConfig as n, createFevex as r, Fevex as t };