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

package/README.md

@@ -33,6 +33,8 @@ For official model adapters:
 ```bash
 npm install @fevex/core @fevex/openai
 npm install @fevex/core @fevex/deepseek
+npm install @fevex/core @fevex/mcp
+npm install @fevex/core @fevex/openapi
 npm install @fevex/core @fevex/sqlite
 npm install @fevex/core @fevex/postgres
 npm install @fevex/core @fevex/opentelemetry @opentelemetry/api
@@ -106,6 +108,133 @@ console.log(result.output.answer);
 `fakeModel` returns its configured responses in order and records every input in
 `model.calls`.
 
+## Durable workflows
+
+Workflows require a `DurableRunStore`. Their definition owns the input, output,
+event and limit contracts:
+
+```ts
+const review = defineWorkflow({
+  name: 'review',
+  version: '2',
+  inputSchema: z.object({ draft: z.string() }),
+  outputSchema: z.string(),
+  events: {
+    'review.approved': {
+      payloadSchema: z.object({ approved: z.literal(true) }),
+      requireActor: true,
+    },
+  },
+  limits: { maxSteps: 8, maxToolCalls: 12 },
+  async run(step, input) {
+    const draft = await step.agent('draft', 'writer', { input });
+    const approval = await step.waitForEvent('approval', 'review.approved');
+    return `${draft.output} (${approval.actor?.id}, ${approval.receivedAt})`;
+  },
+});
+```
+
+Input is validated and transformed before the initial checkpoint is stored.
+Output is always validated with the definition schema, including after a pause
+or recovery. Effective workflow limits combine definition and request limits;
+agent steps additionally combine their own agent/request limits. These values
+are checkpointed so recovery cannot silently widen a budget.
+
+`stepId` is the durable identity of a step: keep it stable while its meaning is
+stable. Increment `version` when replay order, business rules or step meanings
+change. Completed agent steps are reused on replay and `step.agent` always
+returns `{ runId, sessionId, output, usage? }`, without a transient `events`
+field.
+
+Child execution context inherits the workflow context. Namespace, attributes
+and prompt values are merged; an authenticated parent actor cannot be replaced
+by a child. `parallel` waits for every declared task to settle, records durable
+child successes, reports multiple failures in declaration order and resolves
+multiple pauses one at a time. Arbitrary promises used in `parallel` must be
+pure or replay-safe; side effects belong in durable agent/tool steps.
+
+External events must be declared. `waitForEvent` returns
+`{ payload, actor, receivedAt }`; payload and required actor are checked before
+the checkpoint changes. Cancelling a workflow first cancels its running or
+paused children. Compensation runs in reverse completed-step order; if both the
+workflow and compensation fail, the terminal error is a stable
+`AggregateError`.
+
+Durable executions start with a checkpoint v2 and lease in the same atomic
+store operation. An external worker may recover an orphaned `running` run after
+its lease expires:
+
+```ts
+await app.recoverRun(runId, { actor: { id: 'recovery-worker', type: 'service' } });
+```
+
+Paused runs use `resumeRun`; terminal runs and older checkpoints are rejected.
+Fevex does not poll globally: deployments need an external orphan detector and
+a scheduler that calls `resumeRun` for elapsed timers. Exactly-once protection
+is limited to keyed/idempotent tools and durable steps.
+
+## Advanced teams
+
+Teams are an opt-in coordination layer on the durable workflow engine. They
+reuse registered agents and cannot widen an agent's model, tools, policies,
+sandbox or limits:
+
+```ts
+const model = fakeModel(
+  { output: 'plan' },
+  { output: 'research' },
+  { output: 'code' },
+  { output: 'approved' },
+);
+
+const softwareTeam = defineTeam({
+  name: 'software-team',
+  version: '1',
+  supervisor: 'planner',
+  members: [
+    { agent: 'researcher', role: 'research' },
+    { agent: 'coder', role: 'implementation' },
+    { agent: 'reviewer', role: 'review' },
+  ],
+  limits: { maxDelegations: 12, maxParallel: 2 },
+  async run(team, input) {
+    const plan = await team.delegate('plan', {
+      agent: 'planner',
+      task: input,
+      expectedOutput: 'Implementation plan',
+    });
+    const work = await team.parallel('work', {
+      research: () =>
+        team.delegate('research', { agent: 'researcher', task: plan.output }),
+      implementation: () =>
+        team.delegate('implementation', { agent: 'coder', task: plan.output }),
+    });
+    return (
+      await team.handoff('review', {
+        from: 'coder',
+        to: 'reviewer',
+        reason: 'Final review',
+        task: work,
+      })
+    ).output;
+  },
+});
+
+const app = createFevex({ models, agents, teams: [softwareTeam] });
+const result = await app.runTeam('software-team', { input: 'Implement the change.' });
+```
+
+Delegation and parallel step IDs are durable identities and must remain stable
+within a team version. Team runs emit `team.*` events and relay child events
+with `teamDelegationId` and `teamAgentName`. `startTeam`, `streamTeam`,
+`getTeamRun`, `resumeRun`, `recoverRun` and `cancelRun` use the same durable
+store as agents and workflows.
+
+This release intentionally omits automatic routers, network/graph modes,
+quorum, shared blackboards and nested teams. Coordination remains explicit
+TypeScript and shared context travels through task inputs, outputs and the
+existing memory contracts.
+
 ## Connect A Model
 
 Real providers connect through the small `ModelGateway` contract:
@@ -184,8 +313,26 @@ such as temperature, metadata and provider-only reasoning settings are kept.
 
 `createFevex` validates the complete composition before returning the app,
 including JavaScript values that bypass TypeScript. Invalid registrations throw
-`FevexConfigurationError` with a stable `code` such as `INVALID_TOOL`,
-`DUPLICATE_AGENT` or `MISSING_MODEL`, while preserving a readable message.
+`FevexConfigurationError` with a stable `code`, while preserving a readable
+message.
+
+Codes follow one rule: `INVALID_CONFIG` covers the shape of the root config
+object, and every registered entity gets its own code.
+
+| Entity | Invalid | Duplicated by name | Referenced but missing |
+|---|---|---|---|
+| Model | `INVALID_MODEL` | — | `MISSING_MODEL` |
+| Agent | `INVALID_AGENT` | `DUPLICATE_AGENT` | — |
+| Tool | `INVALID_TOOL` | `DUPLICATE_TOOL` | `MISSING_TOOL` |
+| Workflow | `INVALID_WORKFLOW` | `DUPLICATE_WORKFLOW` | — |
+| Team | `INVALID_TEAM` | `DUPLICATE_TEAM` | — |
+| Context provider | `INVALID_CONTEXT_PROVIDER` | `DUPLICATE_CONTEXT_PROVIDER` | — |
+| Connection | `INVALID_CONNECTION` | — | — |
+| Policy | `INVALID_POLICY` | — | — |
+
+Connections have no duplicate code of their own: two connections sharing a name
+produce colliding `<connection>__<tool>` entries and fail with
+`DUPLICATE_TOOL`.
 
 The app captures a shallow snapshot of registered definitions, tool lists,
 limits, model options and `onEvent`. Mutating those caller-owned containers
@@ -197,13 +344,15 @@ Fevex accepts
 [`StandardSchemaV1`](https://github.com/standard-schema/standard-schema)
 validators for:
 
+- agent, workflow and team input before it is persisted;
 - tool input before `execute`;
 - tool output before it is returned to the model;
-- final agent output before it is returned to the application.
+- final agent, workflow and team output before it is returned to the application;
+- declared workflow event payloads before a wait is resolved.
 
 Schemas may transform values. The transformed result must still be JSON-safe.
-The schema passed to `runAgent` takes precedence over the agent schema for that
-run. Plain JSON Schema objects are not executable validators and are not
+Schemas belong to agent, workflow or team definitions; requests cannot replace an output
+contract. Plain JSON Schema objects are not executable validators and are not
 accepted by these fields.
 
 When a model adapter needs schemas, Fevex converts authoring schemas that also
@@ -353,6 +502,72 @@ Unknown cursors fail instead of silently replaying events.
 it. The default survives only while the process lives, and one run at a time
 may update a session.
 
+The built-in durable stores reserve each session atomically when creating an
+agent, workflow or team run. A competing run receives `RUN_CONFLICT` before
+calling its model or tools. A paused or orphaned run keeps its reservation:
+resume, recover or cancel that run before starting another. Lease expiry permits
+recovery of the same run; it does not free its conversation for a new run.
+
+`Session.revision` is store-managed. Creation, history commits and compaction
+check the snapshot revision and advance it atomically. Compaction rejects active
+or paused sessions and stale snapshots. On conflict, reload the session and
+decide whether to retry; never automatically retry external effects.
+
+Custom durable adapters must implement these guarantees in `createExecution`,
+`commitExecution` and `saveSession`, and pass `testRunStore`.
+`ExecutionCreate.session` is now required for existing sessions as well as new
+ones. A legacy session without a revision is treated as revision zero.
+The low-level `saveRun` API is for trusted storage maintenance; it must not be
+used to bypass runtime reservation or overwrite active runs.
+
+Upgrade all workers and adapters together; old workers do not enforce session
+reservation. Every durable commit also validates the lease owner, generation and expiry in
+the same transaction as the run revision. Acquisition advances the generation,
+including when an owner ID is reused. Release expires the lease without deleting
+that counter; stale workers cannot commit, renew or release a newer generation.
+
+Custom adapters must accept `ExecutionCommit.lease` and the generation argument
+to `releaseLease`. Initialize `RunLease.generation` to zero for creation or
+acquisition and retain the generation assigned by the store on success.
+Renewal keeps the same generation and cannot revive an expired lease.
+
+Renewal errors surface as `FevexRunError` with code `RUN_CONFLICT` and the original
+error in `cause`. Local cleanup does not persist cancellation after ownership is lost.
+A lost, failed or blocked renewal aborts local execution; the runtime will not
+start further work or persist results under that token. The orphaned run remains
+available for recovery. External effects already in flight still need
+idempotency or fencing in the external system.
+
+Migrate storage before restarting workers. Legacy leases get generation zero
+and cannot commit or renew; recovery can acquire a new generation after they
+expire. Never run old and new workers together during this upgrade.
+
+## HTTP protocol
+
+`@fevex/core/http` exposes the runtime through versioned JSON and SSE using
+native Fetch types:
+
+```ts
+import { createFevexHttpHandler, createFevexHttpClient } from '@fevex/core/http';
+
+const handler = createFevexHttpHandler({ fevex: app });
+const client = createFevexHttpClient({ baseUrl: 'http://localhost:3001' });
+
+const run = await client.startRun('support', { input: 'Check account 42.' });
+for await (const event of client.observeRun(run.id)) {
+  console.log(event.type);
+}
+```
+
+Protocol v3 also exposes `client.startWorkflow(...)` and
+`client.startTeam(...)`; all run kinds share observation, resume, recovery and
+cancellation endpoints.
+
+Hosts pass authenticated `ExecutionContext` separately to `handler(request,
+{ context })`. Observation reconnects with `Last-Event-ID`; disconnecting an
+SSE response never cancels its run. Cancellation is explicit through
+`client.cancelRun(run.id)`.
+
 ## Approvals and durable runs
 
 Tools can declare risk, approval, idempotency, retries and credential names.
@@ -510,15 +725,166 @@ or `textReporter` with your own write callback, and `compareEvaluationReports`
 to fail CI when cases disappear, passing scores fail or scores drop beyond the
 configured tolerance.
 
+## Connections
+
+Connections turn remote tool providers into normal Fevex tools. Names are local
+and explicit: a connection named `docs` with remote tool `search` is exposed to
+agents as `docs__search`.
+
+```ts
+import { createFevex, defineAgent, defineConnection } from '@fevex/core';
+import { createMcpToolProvider } from '@fevex/mcp';
+
+const docs = defineConnection({
+  name: 'docs',
+  provider: createMcpToolProvider({ url: 'https://example.com/mcp' }),
+  allowlist: ['search'],
+  timeoutMs: 30_000,
+  tools: {
+    search: {
+      description: 'Search docs.',
+      inputSchema: { type: 'object', properties: { query: { type: 'string' } } },
+    },
+  },
+});
+
+createFevex({
+  models: {},
+  agents: [defineAgent({
+    name: 'assistant',
+    instructions: 'Help.',
+    tools: ['docs__search'],
+  })],
+  connections: [docs],
+});
+```
+
+Fevex owns allowlists, timeouts, approvals, policies and safe error messages.
+MCP metadata and annotations are treated as untrusted hints. The first MCP
+adapter supports Streamable HTTP only; `stdio`, resources, prompts and legacy
+HTTP+SSE stay out of scope.
+
+OpenAPI providers use the same connection contract:
+
+```ts
+import { createOpenApiToolProvider } from '@fevex/openapi';
+
+const billing = defineConnection({
+  name: 'billing',
+  provider: createOpenApiToolProvider({
+    document: openApiDocument,
+    operations: { allow: ['getInvoice'] },
+    headers: () => ({ Authorization: `Bearer ${process.env.BILLING_TOKEN}` }),
+  }),
+  allowlist: ['getInvoice'],
+});
+```
+
+`@fevex/openapi` accepts bundled JSON OpenAPI 3.1.x documents, local refs and
+JSON request/response bodies. It rejects unsupported JSON Schema keywords,
+remote refs, YAML, OpenAPI 3.0/3.2 and non-JSON payloads instead of silently
+dropping constraints.
+
+## Channels
+
+`@fevex/core/channels` provides a small adapter contract and `handleChannelInput`
+for hosting apps that receive messages from another surface:
+
+```ts
+import { handleChannelInput } from '@fevex/core/channels';
+
+const sessions = new Map<string, string>();
+
+const result = await handleChannelInput(
+  { id: 'm1', conversationId: 'c1', text: 'hello' },
+  {
+    fevex: app,
+    agentName: 'assistant',
+    adapter: {
+      name: 'memory',
+      async parse(input) {
+        return {
+          id: input.id,
+          deliveryId: input.id,
+          conversationId: input.conversationId,
+          content: input.text,
+        };
+      },
+      async deliver(output) {
+        return output;
+      },
+    },
+    resolveSessionId(message) {
+      return sessions.get(message.conversationId);
+    },
+  },
+);
+
+if (!result.ignored) sessions.set(result.message.conversationId, result.run.sessionId);
+```
+
+The helper emits local channel events around the run. Slack verification,
+acknowledgement, durable redelivery and deduplication remain outside this core
+helper and belong to the Slack adapter phase.
+
+## Knowledge and memory
+
+`@fevex/core/knowledge` keeps external context separate from sessions:
+
+```ts
+import {
+  InMemoryMemoryStore,
+  createFevex,
+  defineAgent,
+  defineContextProvider,
+  defineSkill,
+} from '@fevex/core';
+
+const app = createFevex({
+  models,
+  memoryStore: new InMemoryMemoryStore(),
+  contextProviders: [
+    defineSkill({
+      name: 'refunds',
+      instructions: 'Refunds are allowed for 30 days after purchase.',
+    }),
+    defineContextProvider({
+      name: 'account',
+      async read({ context }) {
+        return [{ id: 'tier', content: `Plan: ${context?.attributes?.plan ?? 'free'}` }];
+      },
+    }),
+  ],
+  agents: [
+    defineAgent({
+      name: 'support',
+      instructions: 'Answer with business context.',
+      skills: ['refunds'],
+      context: ['account'],
+      memory: { read: true, write: true },
+    }),
+  ],
+});
+```
+
+Context providers are lazy per run. Memory is a replaceable store; the built-in
+store is in-memory substring search, not embeddings, vector search or durable
+storage.
+
 ## Public Exports
 
 | Import | Purpose |
 | --- | --- |
 | `@fevex/core` | Common runtime, definitions and contracts |
 | `@fevex/core/agents` | Agent definitions |
+| `@fevex/core/channels` | Channel adapters and message handling |
+| `@fevex/core/knowledge` | Context providers, skills and memory contracts |
 | `@fevex/core/models` | Provider-neutral model contracts |
-| `@fevex/core/tools` | Tool definitions and execution context |
+| `@fevex/core/tools` | Tool, connection and provider contracts |
+| `@fevex/core/workflows` | Durable workflow definitions |
+| `@fevex/core/teams` | Multiagent team definitions |
 | `@fevex/core/runtime` | Runs, sessions and store contracts |
+| `@fevex/core/sandbox` | Sandbox contract and local development sandbox |
 | `@fevex/core/policies` | Authorization policy contracts |
 | `@fevex/core/observability` | Trace, redaction and cost contracts |
 | `@fevex/core/evals` | Datasets, scorers, reporters and regressions |
@@ -526,6 +892,25 @@ configured tolerance.
 
 All subpaths ship in the same `@fevex/core` package.
 
+## Source Layout
+
+Each public subpath is a folder under `src`. Its `index.ts` is intentionally a
+small export barrel; contracts and implementations live in files named after
+their responsibility. For example, `runtime/run-store.ts` owns persistence
+contracts while `runtime/in-memory-run-store.ts` owns the development
+implementation. Keep provider-neutral public contracts in their domain folder
+and orchestration details under `src/internal`.
+
+When adding a feature:
+
+- extend an existing responsibility before creating a new abstraction;
+- keep platform or provider-specific behavior outside `@fevex/core`;
+- export public API only through the domain barrel and preserve existing
+  subpath imports;
+- document lifecycle, persistence, security and replay semantics; avoid
+  comments that only restate the TypeScript signature;
+- add the smallest test that exercises the behavior at its public boundary.
+
 ## Current Scope
 
 The MVP intentionally supports:
@@ -543,3 +928,36 @@ human evaluation workflows.
 ## License
 
 Apache-2.0
+
+### Connection discovery isolation
+
+Connection tool metadata is discovered for each resolution using that caller's
+context. The core does not cache catalogs or rejected discovery promises across
+calls. A failed discovery can therefore recover on the next attempt without
+recreating the runtime. Providers must scope their own state to an identity;
+`@fevex/mcp` binds each instance to its first resolved header set and rejects
+changes. Use a separate MCP provider/connection per identity and recreate it when
+credentials rotate. This adds discovery requests in exchange for avoiding stale
+or cross-identity catalogs. Tool calls are not automatically replayed by MCP.
+
+### Paged event reads and SSE
+
+`listEvents(runId, { after, limit, order })` returns events whose sequence is
+strictly greater than the cursor's sequence. `order` is `asc` by default;
+`{ order: 'desc', limit: 1 }` retrieves the latest event. `limit` must be a positive
+safe integer. Omitting it preserves the existing complete-result behavior.
+Unknown cursors and cursors belonging to another run reject with
+`FevexRunError` code `INVALID_CURSOR` (HTTP 400).
+
+SQLite and PostgreSQL resolve the cursor by ID and filter, order and limit in
+SQL using the existing `(run_id, sequence)` index. Prior event payloads are not
+loaded to find the cursor. Custom run stores must implement these options and
+the cursor error contract before being used with the updated HTTP handler.
+
+The HTTP handler accepts `eventPageSize` (default 100, range 1–1000). It uses this
+limit for the initial SSE read and every subsequent read. Full pages drain
+without the polling delay; short pages wait for `pollIntervalMs`. Stream demand
+controls progress, so a slow consumer retains at most one page plus the stream's
+single queued frame, rather than buffering the run's entire history. Disconnecting
+cancels polling. This bounds event counts, not the byte size of an individual event;
+per-event payload limits and data retention remain host responsibilities.

package/dist/agents/index.d.mts

@@ -1,2 +1,2 @@
-import { n as AgentLimits, r as defineAgent, t as AgentDefinition } from "../index-BzxHfyYV.mjs";
+import { n as AgentLimits, r as defineAgent, t as AgentDefinition } from "../index-Dx_LotWZ.mjs";
 export { AgentDefinition, AgentLimits, defineAgent };

package/dist/agents/index.mjs

@@ -1,4 +1,4 @@
-//#region src/agents/index.ts
+//#region src/agents/agent.ts
 function defineAgent(agent) {
 	return agent;
 }

package/dist/channels/index.d.mts

@@ -0,0 +1,2 @@
+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";
+export { ChannelAdapter, ChannelContext, ChannelError, ChannelEvent, ChannelEventType, ChannelFailurePhase, ChannelMessage, ChannelOutput, ChannelRunEvent, ChannelRunOptions, ChannelRunResult, handleChannelInput };

package/dist/channels/index.mjs

@@ -0,0 +1,150 @@
+//#region src/channels/channel.ts
+var ChannelError = class extends Error {
+	code;
+	safeMessage;
+	name = "ChannelError";
+	constructor(code, safeMessage, options) {
+		super(safeMessage, options);
+		this.code = code;
+		this.safeMessage = safeMessage;
+	}
+};
+//#endregion
+//#region src/channels/handle-channel-input.ts
+/** Parses one channel input, runs the configured agent, and delivers its output. */
+async function handleChannelInput(input, options) {
+	const channelEvents = [];
+	const emit = (event) => {
+		channelEvents.push(event);
+		options.onEvent?.(event);
+	};
+	let parsed;
+	try {
+		parsed = await options.adapter.parse(input, { signal: options.signal });
+	} catch (cause) {
+		const error = channelError("CHANNEL_PARSE_FAILED", "Channel parse failed", cause);
+		emit(failed(options.adapter.name, "parse", error));
+		throw error;
+	}
+	if (parsed === null) return {
+		ignored: true,
+		events: []
+	};
+	const message = parsed;
+	emit(received(options.adapter.name, message));
+	let result;
+	try {
+		const sessionId = await options.resolveSessionId?.(message);
+		result = await options.fevex.runAgent(options.agentName, {
+			input: message.content,
+			...sessionId ? { sessionId } : {},
+			context: channelContext(options.adapter.name, message),
+			signal: options.signal
+		});
+	} catch (cause) {
+		const error = channelError("CHANNEL_RUN_FAILED", "Channel run failed", cause);
+		emit(failed(options.adapter.name, "run", error, message));
+		throw error;
+	}
+	const run = await options.fevex.getRun(result.runId);
+	if (!run || run.kind === "workflow" || run.kind === "team") {
+		const error = channelError("CHANNEL_RUN_FAILED", "Channel run was not found after completion");
+		emit(failed(options.adapter.name, "run", error, message));
+		throw error;
+	}
+	const output = {
+		deliveryId: message.deliveryId,
+		conversationId: message.conversationId,
+		...message.threadId ? { threadId: message.threadId } : {},
+		content: stringifyOutput(result.output),
+		metadata: {
+			runId: result.runId,
+			sessionId: result.sessionId
+		}
+	};
+	let delivery;
+	try {
+		delivery = await options.adapter.deliver(output, { signal: options.signal });
+	} catch (cause) {
+		const error = channelError("CHANNEL_DELIVERY_FAILED", "Channel delivery failed", cause);
+		emit(failed(options.adapter.name, "deliver", error, message));
+		throw error;
+	}
+	const deliveredEvent = delivered(options.adapter.name, message);
+	emit(deliveredEvent);
+	return {
+		ignored: false,
+		message,
+		run,
+		output,
+		delivery,
+		events: [
+			channelEvents[0],
+			...result.events ?? [],
+			deliveredEvent
+		]
+	};
+}
+function channelContext(adapter, message) {
+	return {
+		namespace: adapter,
+		...message.actor ? { actor: message.actor } : {},
+		attributes: {
+			...message.metadata ?? {},
+			channel: adapter,
+			messageId: message.id,
+			deliveryId: message.deliveryId,
+			conversationId: message.conversationId,
+			...message.threadId ? { threadId: message.threadId } : {}
+		}
+	};
+}
+function received(adapter, message) {
+	return {
+		type: "channel.received",
+		id: crypto.randomUUID(),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		adapter,
+		messageId: message.id,
+		deliveryId: message.deliveryId,
+		conversationId: message.conversationId,
+		...message.threadId ? { threadId: message.threadId } : {},
+		...message.actor ? { actor: message.actor } : {}
+	};
+}
+function delivered(adapter, message) {
+	return {
+		type: "channel.delivered",
+		id: crypto.randomUUID(),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		adapter,
+		messageId: message.id,
+		deliveryId: message.deliveryId,
+		conversationId: message.conversationId,
+		...message.threadId ? { threadId: message.threadId } : {}
+	};
+}
+function failed(adapter, phase, error, message) {
+	return {
+		type: "channel.failed",
+		id: crypto.randomUUID(),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		adapter,
+		phase,
+		error: error.safeMessage,
+		...message ? {
+			messageId: message.id,
+			deliveryId: message.deliveryId,
+			conversationId: message.conversationId,
+			...message.threadId ? { threadId: message.threadId } : {}
+		} : {}
+	};
+}
+function channelError(code, safeMessage, cause) {
+	return new ChannelError(code, safeMessage, cause === void 0 ? void 0 : { cause });
+}
+function stringifyOutput(value) {
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+//#endregion
+export { ChannelError, handleChannelInput };