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

package/dist/testing/index.mjs

@@ -1,5 +1,6 @@
+import { isRetainableRunStore } from "../runtime/index.mjs";
 import { IntegrationError } from "../tools/index.mjs";
-import { t as readModelStream } from "../model-stream-u2xMsEaf.mjs";
+import { t as readModelStream } from "../model-stream-JQdHDDcj.mjs";
 //#region src/testing/contracts.ts
 const contractOutputSchema = {
 	type: "object",
@@ -126,6 +127,10 @@ async function testChannelAdapter(adapter, contract) {
 	if (contract.output.threadId !== void 0) assert(contract.output.threadId.trim(), "ChannelOutput threadId cannot be empty");
 	if (contract.output.metadata !== void 0) JSON.stringify(contract.output.metadata);
 	assert(JSON.stringify(await adapter.deliver(contract.output, {})) === JSON.stringify(contract.delivered), "ChannelAdapter returned an unexpected delivery");
+	if (contract.elicitation) {
+		assert(adapter.deliverElicitation, "ChannelAdapter must support elicitation delivery");
+		for (let attempt = 0; attempt < 2; attempt += 1) assert(JSON.stringify(await adapter.deliverElicitation(structuredClone(contract.elicitation.request), { ...contract.elicitation.context })) === JSON.stringify(contract.elicitation.delivered), "ChannelAdapter returned an unexpected elicitation delivery or retry receipt");
+	}
 }
 async function testModelGateway(model, contract = {}) {
 	const output = contract.output ?? { answer: "ok" };
@@ -595,6 +600,97 @@ async function testRunStore(store) {
 	}), "The current generation must be able to commit");
 	await store.releaseLease(runId, takeoverLease.ownerId, takeoverLease.generation);
 }
+async function testRetentionStore(store) {
+	assert(isRetainableRunStore(store), "RunStore must implement purgeRuns");
+	const suffix = crypto.randomUUID();
+	const now = Date.now();
+	const old = (/* @__PURE__ */ new Date(now - 2 * 864e5)).toISOString();
+	const before = (/* @__PURE__ */ new Date(now - 864e5)).toISOString();
+	const recent = new Date(now).toISOString();
+	const entries = [
+		{
+			id: `retention-old-completed-${suffix}`,
+			status: "completed",
+			createdAt: old
+		},
+		{
+			id: `retention-old-failed-${suffix}`,
+			status: "failed",
+			createdAt: old
+		},
+		{
+			id: `retention-recent-completed-${suffix}`,
+			status: "completed",
+			createdAt: recent
+		},
+		{
+			id: `retention-old-running-${suffix}`,
+			status: "running",
+			createdAt: old
+		}
+	];
+	for (const entry of entries) {
+		const sessionId = `retention-session-${entry.id}`;
+		await store.saveSession({
+			id: sessionId,
+			history: [],
+			createdAt: entry.createdAt,
+			updatedAt: entry.createdAt
+		});
+		await store.saveRun({
+			id: entry.id,
+			sessionId,
+			agentName: "retention-agent",
+			status: entry.status,
+			revision: 1,
+			createdAt: entry.createdAt,
+			updatedAt: entry.createdAt
+		});
+		await store.appendEvent({
+			id: `retention-event-${entry.id}`,
+			sequence: 1,
+			type: "run.started",
+			runId: entry.id,
+			timestamp: entry.createdAt
+		});
+	}
+	const purged = await store.purgeRuns({ before });
+	assert(purged.runs === 2, "Retention must delete only old terminal runs");
+	assert(purged.sessions === 2, "Retention must delete sessions left without runs");
+	assert(!await store.getRun(entries[0].id), "Retention must delete the completed run");
+	assert(!await store.getRun(entries[1].id), "Retention must delete the failed run");
+	assert(await store.getRun(entries[2].id), "Retention must keep recent terminal runs");
+	assert(await store.getRun(entries[3].id), "Retention must keep active runs");
+	assert(!await store.getSession(`retention-session-${entries[0].id}`), "Retention must delete empty sessions");
+	assert(await store.getSession(`retention-session-${entries[2].id}`), "Retention must keep sessions with runs");
+	assert((await store.purgeRuns({ limit: 1 })).runs === 1, "Retention must honor the limit");
+	await store.purgeRuns({ before: new Date(Date.now() + 864e5).toISOString() });
+	assert(!await store.getRun(entries[2].id), "Retention must purge remaining terminal runs");
+	assert(await store.getRun(entries[3].id), "Retention must keep active runs after a full purge");
+	const boundaryId = `retention-boundary-${suffix}`;
+	const boundarySessionId = `retention-boundary-session-${suffix}`;
+	const boundaryCreatedAt = "2020-01-01T00:00:00.100Z";
+	await store.saveSession({
+		id: boundarySessionId,
+		history: [],
+		createdAt: boundaryCreatedAt,
+		updatedAt: boundaryCreatedAt
+	});
+	await store.saveRun({
+		id: boundaryId,
+		sessionId: boundarySessionId,
+		agentName: "retention-agent",
+		status: "completed",
+		revision: 1,
+		createdAt: boundaryCreatedAt,
+		updatedAt: boundaryCreatedAt
+	});
+	assert((await store.purgeRuns({
+		before: "2020-01-01T00:00:00.500Z",
+		statuses: ["completed"]
+	})).runs === 1, "Retention must compare subsecond timestamps");
+	assert(!await store.getRun(boundaryId), "Retention must delete the boundary run");
+}
 //#endregion
 //#region src/testing/fake-model.ts
 /** Creates a deterministic model gateway for unit tests. */
@@ -622,4 +718,4 @@ function fakeModel(...responses) {
 	};
 }
 //#endregion
-export { fakeModel, testChannelAdapter, testMemoryStore, testModelGateway, testRunStore, testToolProvider };
+export { fakeModel, testChannelAdapter, testMemoryStore, testModelGateway, testRetentionStore, testRunStore, testToolProvider };

package/dist/tools/index.d.mts

@@ -1,3 +1,3 @@
-import { g as ToolSpec, m as ToolCall } from "../types-CuoRx12Q.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 { g as ToolSpec, m as ToolCall } from "../types-BDVUoAU6.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-CKQCNvJz.mjs";
 export { ConnectionDefinition, ConnectionToolPolicy, FEVEX_JSON_SCHEMA_PROFILE_VERSION, FevexJsonSchemaProfileLimits, FevexJsonSchemaProfileOptions, FevexJsonSchemaValidator, IntegrationError, IntegrationErrorCategory, ToolApproval, type ToolCall, ToolDefinition, ToolExecutionContext, ToolIdempotency, ToolProvider, ToolProviderContext, ToolProviderTool, ToolResult, ToolRetryPolicy, ToolRisk, type ToolSpec, compileFevexJsonSchema, defineConnection, defineTool, toToolSpec, validateFevexJsonSchemaProfile };

package/dist/types-BDVUoAU6.d.mts

@@ -0,0 +1,559 @@
+//#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' | '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;
+  };
+  '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;
+  };
+  '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[];
+  };
+  '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

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