fascicle 0.10.3 → 0.11.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1 +0,0 @@
1
- {"version":3,"file":"core-DkuJqLwd.js","names":["is_step","is_step","next_id","is_step","next_id","next_id","next_id","next_id","is_step","next_id","next_id","next_id","next_id","next_id"],"sources":["../src/core/flow-schema.json","../src/core/cleanup.ts","../src/core/errors.ts","../src/core/streaming.ts","../src/core/runner.ts","../src/core/step.ts","../src/core/is_step.ts","../src/core/describe.ts","../src/core/sequence.ts","../src/core/parallel.ts","../src/core/branch.ts","../src/core/map.ts","../src/core/pipe.ts","../src/policy/backoff.ts","../src/core/retry.ts","../src/core/fallback.ts","../src/core/timeout.ts","../src/core/loop.ts","../src/core/compose.ts","../src/core/checkpoint.ts","../src/schema/validate.ts","../src/core/suspend.ts","../src/core/scope.ts","../src/core/step_kinds.ts","../src/core/trajectory.ts","../src/core/index.ts"],"sourcesContent":["","/**\n * Per-run cleanup registry.\n *\n * Handlers fire in LIFO (reverse registration) order on abort, on uncaught\n * error in the root, and on successful completion. Each handler has a\n * 5-second timeout; timeouts are recorded in the trajectory but do not block\n * other handlers. A handler that throws is recorded as `cleanup_error`;\n * subsequent handlers still execute.\n */\n\nimport type { CleanupFn, TrajectoryLogger } from './types.js'\n\nconst HANDLER_TIMEOUT_MS = 5_000\n\nexport type CleanupRegistry = {\n readonly register: (fn: CleanupFn) => void\n readonly run_all: () => Promise<void>\n}\n\n/**\n * Create the per-run cleanup registry.\n *\n * `register` collects handlers during the run; `run_all` fires them once in\n * LIFO order and is idempotent. A registration arriving after the flush is\n * not executed; it is recorded as `cleanup_registered_after_flush` so the\n * leak is visible in the trajectory instead of silently dropped.\n */\nexport function create_cleanup_registry(trajectory: TrajectoryLogger): CleanupRegistry {\n const handlers: CleanupFn[] = []\n let ran = false\n\n function register(fn: CleanupFn): void {\n if (ran) {\n trajectory.record({\n kind: 'cleanup_registered_after_flush',\n })\n return\n }\n handlers.push(fn)\n }\n\n async function run_all(): Promise<void> {\n if (ran) return\n ran = true\n for (let i = handlers.length - 1; i >= 0; i -= 1) {\n const fn = handlers[i]\n if (!fn) continue\n await run_one(fn, trajectory)\n }\n }\n\n return { register, run_all }\n}\n\n/**\n * Run a single cleanup handler, never letting it fail the run.\n *\n * Races the handler against a 5-second timer. Whichever loses the race only\n * results in a trajectory record (`cleanup_timeout` or `cleanup_error`); the\n * returned promise always resolves so the remaining handlers still execute.\n * A timed-out handler keeps running in the background; it is abandoned, not\n * killed.\n */\nasync function run_one(fn: CleanupFn, trajectory: TrajectoryLogger): Promise<void> {\n let timeout_id: ReturnType<typeof setTimeout> | null = null\n try {\n await new Promise<void>((resolve) => {\n timeout_id = setTimeout(() => {\n trajectory.record({ kind: 'cleanup_timeout', timeout_ms: HANDLER_TIMEOUT_MS })\n resolve()\n }, HANDLER_TIMEOUT_MS)\n \n Promise.resolve()\n .then(() => fn())\n .then(\n () => {\n if (timeout_id) clearTimeout(timeout_id)\n resolve()\n },\n (err: unknown) => {\n if (timeout_id) clearTimeout(timeout_id)\n trajectory.record({\n kind: 'cleanup_error',\n error: err instanceof Error ? err.message : String(err),\n })\n resolve()\n },\n )\n })\n } finally {\n if (timeout_id) clearTimeout(timeout_id)\n }\n}\n","/**\n * Typed errors for the composition layer.\n *\n * This is the only source file in the core layer that uses the `class`\n * keyword. `Error` is a built-in and `instanceof` branching is how composers\n * like `retry` and `fallback` distinguish failure modes.\n */\n\nimport type { SchemaIssue } from '#schema'\n\nexport class timeout_error extends Error {\n readonly kind = 'timeout_error' as const;\n readonly timeout_ms: number;\n constructor(message: string, timeout_ms: number) {\n super(message)\n this.name = 'timeout_error'\n this.timeout_ms = timeout_ms\n }\n}\n\nexport class suspended_error extends Error {\n readonly kind = 'suspended_error' as const;\n readonly suspend_id: string;\n readonly payload: unknown;\n constructor(suspend_id: string, payload: unknown, message?: string) {\n super(message ?? `suspended at ${suspend_id}`)\n this.name = 'suspended_error'\n this.suspend_id = suspend_id\n this.payload = payload\n }\n}\n\nexport class resume_validation_error extends Error {\n readonly kind = 'resume_validation_error' as const;\n readonly issues: ReadonlyArray<SchemaIssue>;\n constructor(message: string, issues: ReadonlyArray<SchemaIssue>) {\n super(message)\n this.name = 'resume_validation_error'\n this.issues = issues\n }\n}\n\nexport class describe_cycle_error extends Error {\n readonly kind = 'describe_cycle_error' as const;\n readonly step_id: string;\n constructor(step_id: string, message?: string) {\n super(message ?? `describe: cycle detected at step id: ${step_id}`)\n this.name = 'describe_cycle_error'\n this.step_id = step_id\n }\n}\n\nexport class aborted_error extends Error {\n readonly kind = 'aborted_error' as const;\n readonly reason?: unknown;\n readonly step_index: number;\n readonly tool_call_in_flight?: { id: string; name: string };\n constructor(\n message = 'aborted',\n metadata: {\n reason?: unknown\n step_index?: number\n tool_call_in_flight?: { id: string; name: string }\n } = {},\n ) {\n super(message)\n this.name = 'aborted_error'\n if (metadata.reason !== undefined) this.reason = metadata.reason\n this.step_index = metadata.step_index ?? 0\n if (metadata.tool_call_in_flight !== undefined) {\n this.tool_call_in_flight = metadata.tool_call_in_flight\n }\n }\n}\n\n/**\n * Control-flow signals are not application failures. `suspended_error` is a\n * human-approval gate pausing the run for later resume; `aborted_error` is\n * cancellation. Resilience composers (`retry`, `fallback`) must rethrow these\n * rather than retry past a suspend or run a backup under an aborted context.\n *\n * Kept internal to core: not re-exported by index.ts, so it does not\n * widen the public surface.\n */\nexport function is_control_flow_error(\n err: unknown,\n): err is suspended_error | aborted_error {\n return err instanceof suspended_error || err instanceof aborted_error\n}\n","/**\n * Streaming observation channel.\n *\n * `run.stream(flow, input)` is a secondary entry point returning\n * `{ events, result }`. Events are observed via an async iterable; the result\n * promise resolves once the flow completes. Streaming is purely\n * observational: composers do not know it exists, and `run` and `run.stream`\n * produce identical final results.\n *\n * The event buffer has a default high-water mark of 10,000. When the consumer\n * never iterates, emissions past the mark drop the oldest events and record a\n * single `events_dropped` marker. The `result` promise resolves regardless of\n * buffer pressure.\n */\n\nimport type { TrajectoryEvent, TrajectoryLogger } from './types.js'\n\nexport const STREAMING_HIGH_WATER_MARK = 10_000\n\nexport type StreamingChannel = {\n readonly logger: TrajectoryLogger\n readonly events: AsyncIterable<TrajectoryEvent>\n readonly close: () => void\n}\n\n/**\n * Build the logger/iterable pair backing `run.stream`.\n *\n * Wraps a base `TrajectoryLogger` so every recorded event is also enqueued\n * for the async iterable. A single pending `waiter` hands events straight to\n * a blocked consumer; otherwise events buffer up to `high_water_mark`, after\n * which the oldest are dropped and counted for the `events_dropped` marker\n * emitted at close.\n */\nexport function create_streaming_channel(\n base: TrajectoryLogger,\n high_water_mark = STREAMING_HIGH_WATER_MARK,\n): StreamingChannel {\n const buffer: TrajectoryEvent[] = []\n let dropped = 0\n let closed = false\n let marker_emitted = false\n let waiter: ((value: IteratorResult<TrajectoryEvent>) => void) | null = null\n\n function enqueue(event: TrajectoryEvent): void {\n if (closed) return\n if (waiter) {\n const resolve = waiter\n waiter = null\n resolve({ value: event, done: false })\n return\n }\n if (buffer.length >= high_water_mark) {\n buffer.shift()\n dropped += 1\n return\n }\n buffer.push(event)\n }\n\n function close(): void {\n if (closed) return\n closed = true\n if (dropped > 0 && !marker_emitted) {\n marker_emitted = true\n buffer.push({ kind: 'events_dropped', count: dropped })\n }\n if (waiter) {\n const resolve = waiter\n waiter = null\n resolve({ value: undefined, done: true })\n }\n }\n\n const logger: TrajectoryLogger = {\n record: (event) => {\n base.record(event)\n enqueue(event)\n },\n start_span: (name, meta) => {\n const id = base.start_span(name, meta)\n enqueue({ kind: 'span_start', span_id: id, name, ...meta })\n return id\n },\n end_span: (id, meta) => {\n base.end_span(id, meta)\n enqueue({ kind: 'span_end', span_id: id, ...meta })\n },\n }\n\n const events: AsyncIterable<TrajectoryEvent> = {\n [Symbol.asyncIterator]() {\n return {\n next(): Promise<IteratorResult<TrajectoryEvent>> {\n if (buffer.length > 0) {\n const next_event = buffer.shift()\n if (next_event !== undefined) {\n return Promise.resolve({ value: next_event, done: false })\n }\n }\n if (closed) {\n return Promise.resolve({ value: undefined, done: true })\n }\n return new Promise<IteratorResult<TrajectoryEvent>>((resolve) => {\n waiter = resolve\n })\n },\n return(): Promise<IteratorResult<TrajectoryEvent>> {\n close()\n return Promise.resolve({ value: undefined, done: true })\n },\n }\n },\n }\n\n return { logger, events, close }\n}\n","/**\n * Runner.\n *\n * Dispatches a step to its kind-specific handler. `runner.ts` contains no\n * composer-specific logic beyond a Map lookup on `step.kind`; each composer\n * file registers its handler at module load via `register_kind(...)`.\n *\n * `run(flow, input, options?)` constructs a fresh `RunContext` per top-level\n * call, installs process signal handlers (opt-out via options), forwards an\n * optional caller-supplied `AbortSignal` into the run, and guarantees cleanup\n * handlers execute in LIFO order on success, failure, or abort.\n *\n * `run.stream(flow, input, options?)` is a secondary entry point returning\n * `{ events, result }`. Streaming is purely observational; the step graph is\n * identical to `run(...)`.\n */\n\nimport { randomUUID } from 'node:crypto'\nimport { create_cleanup_registry } from './cleanup.js'\nimport { aborted_error } from './errors.js'\nimport { create_streaming_channel, STREAMING_HIGH_WATER_MARK } from './streaming.js'\nimport type {\n CheckpointStore,\n RunContext,\n Step,\n TrajectoryEvent,\n TrajectoryLogger,\n} from './types.js'\n\ntype Dispatcher = (\n flow: Step<unknown, unknown>,\n input: unknown,\n ctx: RunContext,\n) => Promise<unknown>\n\nconst dispatch = new Map<string, Dispatcher>()\n\n/**\n * Register the dispatch handler for a step kind.\n *\n * Composer files call this (directly or via `register_traced_kind`) at module\n * load, which is how the runner stays free of composer-specific logic.\n */\nexport function register_kind(kind: string, fn: Dispatcher): void {\n dispatch.set(kind, fn)\n}\n\n/**\n * Resolve the trajectory span label for a step. Prefers a non-empty\n * `display_name` from `flow.config`; otherwise falls back to the supplied\n * default (typically the step's `kind`).\n *\n * Dispatch handlers use this so that any composer carrying a user-supplied\n * `name` surfaces under that label in the trajectory, while unconfigured\n * composers retain their kind-based label.\n */\nexport function resolve_span_label(\n flow: Step<unknown, unknown>,\n fallback: string,\n): string {\n const display = flow.config?.['display_name']\n return typeof display === 'string' && display.length > 0 ? display : fallback\n}\n\n/**\n * Register the standard span-wrapping dispatch handler for a composer kind.\n *\n * Every composer wraps `flow.run` in a span identically; this centralizes that\n * boilerplate and threads span parentage: the span opens with the current\n * `ctx.parent_span_id` as its parent, and `flow.run` receives a child context\n * whose `parent_span_id` is this span. Children dispatched from within\n * (including concurrent ones under `parallel`/`map`, which spread the context)\n * therefore nest correctly instead of leaving `parent_span_id` unpopulated.\n */\nexport function register_traced_kind(kind: string): void {\n register_kind(kind, async (flow, input, ctx) => {\n const label = resolve_span_label(flow, kind)\n const span_meta: Record<string, unknown> = { id: flow.id }\n if (ctx.parent_span_id !== undefined) {\n span_meta['parent_span_id'] = ctx.parent_span_id\n }\n const span_id = ctx.trajectory.start_span(label, span_meta)\n const child_ctx: RunContext = { ...ctx, parent_span_id: span_id }\n try {\n const out = await flow.run(input, child_ctx)\n ctx.trajectory.end_span(span_id, { id: flow.id })\n return out\n } catch (err) {\n ctx.trajectory.end_span(span_id, {\n id: flow.id,\n error: err instanceof Error ? err.message : String(err),\n })\n throw err\n }\n })\n}\n\nexport type RunOptions = {\n readonly install_signal_handlers?: boolean\n readonly trajectory?: TrajectoryLogger\n readonly checkpoint_store?: CheckpointStore\n readonly resume_data?: Readonly<Record<string, unknown>>\n // A caller-owned cancellation source (HTTP request, queue shutdown, MCP\n // request, AbortSignal.timeout). When it fires the run aborts with its\n // reason, composing with the internal controller and the process signal\n // handlers rather than replacing them.\n readonly abort?: AbortSignal\n}\n\nexport type StreamingRunHandle<o> = {\n readonly events: AsyncIterable<TrajectoryEvent>\n readonly result: Promise<o>\n}\n\nconst active_runs = new Set<AbortController>()\nlet signal_handler_installed = false\nlet sigint_handler: (() => void) | null = null\nlet sigterm_handler: (() => void) | null = null\n\n/**\n * Install process-wide SIGINT/SIGTERM handlers once.\n *\n * The handlers abort every active run with an `aborted_error` naming the\n * signal, so a Ctrl-C tears down all in-flight flows through the normal\n * abort/cleanup path instead of killing the process mid-step.\n */\nfunction ensure_signal_handlers(): void {\n if (signal_handler_installed) return\n signal_handler_installed = true\n const abort_all = (signal_name: string) => () => {\n for (const controller of active_runs) {\n controller.abort(new aborted_error(`received ${signal_name}`, { reason: { signal: signal_name } }))\n }\n }\n sigint_handler = abort_all('SIGINT')\n sigterm_handler = abort_all('SIGTERM')\n process.on('SIGINT', sigint_handler)\n process.on('SIGTERM', sigterm_handler)\n}\n\n/**\n * Remove the process signal handlers once the last active run settles.\n *\n * Keeps a library embed from leaving stray `process.on` listeners behind\n * after all runs complete.\n */\nfunction release_signal_handlers(): void {\n if (!signal_handler_installed) return\n if (active_runs.size > 0) return\n signal_handler_installed = false\n if (sigint_handler) process.off('SIGINT', sigint_handler)\n if (sigterm_handler) process.off('SIGTERM', sigterm_handler)\n sigint_handler = null\n sigterm_handler = null\n}\n\nconst noop_logger: TrajectoryLogger = {\n record: () => {},\n start_span: (name) => `${name}:${randomUUID().slice(0, 8)}`,\n end_span: () => {},\n}\n\n/**\n * Wrap a logger so every emitted event automatically carries `run_id` and a\n * `ts` (epoch milliseconds) stamped at emission.\n *\n * Studios and other downstream consumers multiplex events across runs by\n * `run_id` and reconstruct real timing from `ts` instead of fabricating it at\n * ingest. Either field already present on an event or its meta is preserved;\n * we never overwrite a caller-supplied value.\n */\nfunction decorate_logger(inner: TrajectoryLogger, run_id: string): TrajectoryLogger {\n const stamp_meta = (\n meta: Record<string, unknown> | undefined,\n ): Record<string, unknown> => {\n const out: Record<string, unknown> = { ...meta }\n if (!('run_id' in out)) out['run_id'] = run_id\n if (!('ts' in out)) out['ts'] = Date.now()\n return out\n }\n return {\n record: (event) => {\n if ('run_id' in event && 'ts' in event) {\n inner.record(event)\n return\n }\n const extra: Record<string, unknown> = {}\n if (!('run_id' in event)) extra['run_id'] = run_id\n if (!('ts' in event)) extra['ts'] = Date.now()\n inner.record({ ...event, ...extra })\n },\n start_span: (name, meta) => inner.start_span(name, stamp_meta(meta)),\n end_span: (id, meta) => {\n inner.end_span(id, stamp_meta(meta))\n },\n }\n}\n\n/**\n * Route a step to its registered kind handler.\n *\n * This is the single entry point composers use to run children. On failure\n * the step's id is prepended to the error's `path`, so an error surfacing\n * from a deep tree carries the chain of step ids it crossed.\n */\nexport async function dispatch_step<i, o>(\n flow: Step<i, o>,\n input: i,\n ctx: RunContext,\n): Promise<o> {\n const handler = dispatch.get(flow.kind)\n if (!handler) {\n throw new Error(`unknown step kind: ${flow.kind} (step id: ${flow.id})`)\n }\n try {\n const result = await handler(flow, input, ctx)\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return result as o\n } catch (err) {\n prepend_path(err, flow.id)\n throw err\n }\n}\n\n/**\n * Prepend a step id to the `path` array carried on an error object.\n *\n * Mutates the error in place so the path accumulates as the error bubbles up\n * through nested dispatches. Non-object errors are left untouched.\n */\nexport function prepend_path(err: unknown, id: string): void {\n if (err === null || typeof err !== 'object') return\n const existing = Reflect.get(err, 'path')\n const next: string[] = Array.isArray(existing)\n ? [id, ...existing.filter((v): v is string => typeof v === 'string')]\n : [id]\n Reflect.set(err, 'path', next)\n}\n\n/**\n * Throw the abort reason if the context has been cancelled. Composers that\n * iterate over children (`sequence`, `scope`, `loop`) call this between steps\n * so a pending abort is honored before the next child starts, not only when a\n * downstream dispatch happens to observe it.\n */\nexport function throw_if_aborted(ctx: RunContext): void {\n if (!ctx.abort.aborted) return\n const reason = ctx.abort.reason\n throw reason instanceof Error ? reason : new aborted_error('aborted', { reason })\n}\n\n/**\n * Forward a caller-owned AbortSignal into the run's internal controller and\n * return an unlink function. The reason is preserved so the original\n * cancellation cause propagates out of `run`. The listener is `once` and the\n * returned unlink is called when the run settles, so a long-lived host (an MCP\n * server, an HTTP worker) firing many short runs against one external signal\n * does not accumulate listeners.\n */\nfunction link_external_abort(\n controller: AbortController,\n external: AbortSignal | undefined,\n): () => void {\n if (external === undefined) return () => {}\n if (external.aborted) {\n controller.abort(external.reason)\n return () => {}\n }\n const on_abort = (): void => {\n controller.abort(external.reason)\n }\n external.addEventListener('abort', on_abort, { once: true })\n return () => {\n external.removeEventListener('abort', on_abort)\n }\n}\n\ntype StartResult<o> = {\n readonly events: AsyncIterable<TrajectoryEvent>\n readonly result: Promise<o>\n}\n\n/**\n * Construct a run context and execute a flow to settlement.\n *\n * Shared engine behind `run` and `run.stream`; `high_water_mark` selects the\n * mode (null means no streaming channel). Owns the full run lifecycle:\n * abort wiring, logger decoration, cleanup registration, signal handlers,\n * and the settle-time teardown ordering (cleanup handlers first, then\n * unlinking and stream close).\n */\nfunction start_run<i, o>(\n flow: Step<i, o>,\n input: i,\n options: RunOptions,\n high_water_mark: number | null,\n): StartResult<o> {\n const install_signal_handlers = options.install_signal_handlers !== false\n const base_logger = options.trajectory ?? noop_logger\n const streaming = high_water_mark !== null\n\n const controller = new AbortController()\n const unlink_abort = link_external_abort(controller, options.abort)\n const run_id = randomUUID()\n\n let stream_events: AsyncIterable<TrajectoryEvent> = empty_async_iterable()\n let close_stream: (() => void) | null = null\n let inner: TrajectoryLogger = base_logger\n\n if (streaming) {\n // Decorate must wrap the streaming channel, not the reverse: the channel\n // enqueues a copy of each event for `run.stream` consumers, so it has to\n // see the events after `decorate_logger` has stamped `ts` and `run_id`.\n const channel = create_streaming_channel(base_logger, high_water_mark)\n inner = channel.logger\n stream_events = channel.events\n close_stream = channel.close\n }\n\n const logger: TrajectoryLogger = decorate_logger(inner, run_id)\n\n const cleanup = create_cleanup_registry(logger)\n\n const ctx: RunContext = {\n run_id,\n trajectory: logger,\n state: new Map(),\n abort: controller.signal,\n emit: (event) => {\n logger.record({ ...event, kind: 'emit' })\n },\n on_cleanup: (fn) => {\n cleanup.register(fn)\n },\n checkpoint_store: options.checkpoint_store,\n resume_data: options.resume_data,\n streaming,\n }\n\n active_runs.add(controller)\n if (install_signal_handlers) {\n ensure_signal_handlers()\n }\n\n const result = (async (): Promise<o> => {\n try {\n // Honor an external signal that was already aborted at call time, so the\n // run rejects without dispatching even when the flow is a single leaf\n // step that never reaches a cooperative abort check.\n throw_if_aborted(ctx)\n return await dispatch_step(flow, input, ctx)\n } catch (err) {\n if (controller.signal.aborted && !(err instanceof aborted_error)) {\n const reason = controller.signal.reason\n if (reason instanceof aborted_error) throw reason\n }\n throw err\n } finally {\n try {\n await cleanup.run_all()\n } finally {\n unlink_abort()\n active_runs.delete(controller)\n release_signal_handlers()\n if (close_stream) close_stream()\n }\n }\n })()\n\n return { events: stream_events, result }\n}\n\n/**\n * Build an async iterable that is immediately done.\n *\n * Non-streaming runs hand this to callers so the `events` field always has\n * the same shape regardless of mode.\n */\nfunction empty_async_iterable(): AsyncIterable<TrajectoryEvent> {\n return {\n [Symbol.asyncIterator]() {\n return {\n next: (): Promise<IteratorResult<TrajectoryEvent>> =>\n Promise.resolve({ value: undefined, done: true } as IteratorResult<TrajectoryEvent>),\n }\n },\n }\n}\n\n/**\n * Execute a flow and resolve with its final output.\n */\nasync function run_impl<i, o>(\n flow: Step<i, o>,\n input: i,\n options: RunOptions = {},\n): Promise<o> {\n const { result } = start_run(flow, input, options, null)\n return result\n}\n\n/**\n * Execute a flow while exposing its trajectory events as an async iterable.\n */\nfunction run_stream<i, o>(\n flow: Step<i, o>,\n input: i,\n options: RunOptions = {},\n): StreamingRunHandle<o> {\n const { events, result } = start_run(flow, input, options, STREAMING_HIGH_WATER_MARK)\n return { events, result }\n}\n\n/**\n * The public entry point for executing a flow.\n *\n * Callable as `run(flow, input, options?)` for a plain result, or\n * `run.stream(flow, input, options?)` for `{ events, result }`. Both share\n * one implementation, so a streamed run and a plain run of the same flow\n * produce identical output.\n */\nexport const run: typeof run_impl & { stream: typeof run_stream } = Object.assign(run_impl, {\n stream: run_stream,\n})\n","/**\n * step() factory.\n *\n * Three forms:\n * step(id, fn): named step. id is rendered in trajectory spans and describe().\n * step(id, fn, meta): named step with optional human-readable metadata for studio,\n * codegen, and similar consumers. `meta` is purely descriptive\n * and never affects runtime semantics.\n * step(fn): anonymous step. id is `anon_<counter>`; cannot be checkpointed.\n *\n * Anonymous steps carry an internal `anonymous: true` flag so checkpoint can\n * reject them synchronously at flow construction time.\n */\n\nimport { register_traced_kind } from './runner.js'\nimport type { Step, StepFn, StepMetadata } from './types.js'\n\nlet anon_counter = 0\n\n/**\n * Generate a unique id of the form `anon_<n>` for anonymous steps.\n */\nfunction next_anon_id(): string {\n anon_counter += 1\n return `anon_${anon_counter}`\n}\n\n/**\n * Wrap a plain function as a `Step`, named or anonymous.\n *\n * The named form takes an explicit id (and optional descriptive `meta`); the\n * anonymous form generates an `anon_<n>` id and marks the step so checkpoint\n * rejects it at construction time.\n */\nexport function step<i, o>(id: string, fn: StepFn<i, o>, meta?: StepMetadata): Step<i, o>\nexport function step<i, o>(fn: StepFn<i, o>): Step<i, o>\nexport function step<i, o>(\n id_or_fn: string | StepFn<i, o>,\n maybe_fn?: StepFn<i, o>,\n meta?: StepMetadata,\n): Step<i, o> {\n if (typeof id_or_fn === 'function') {\n return {\n id: next_anon_id(),\n kind: 'step',\n run: id_or_fn,\n anonymous: true,\n }\n }\n if (typeof maybe_fn !== 'function') {\n throw new TypeError('step(id, fn): fn must be a function')\n }\n if (meta) {\n return {\n id: id_or_fn,\n kind: 'step',\n run: maybe_fn,\n meta,\n }\n }\n return {\n id: id_or_fn,\n kind: 'step',\n run: maybe_fn,\n }\n}\n\nregister_traced_kind('step')\n","/**\n * is_step: structural Step check.\n *\n * Steps are plain objects with no brand symbol, so runtime detection is\n * structural: string `id`, string `kind`, callable `run`. Used by describe()\n * to render Step references and by combinators to validate arguments at\n * construction time.\n */\n\nimport type { Step } from './types.js'\n\n/**\n * Check whether a value is structurally a `Step`.\n *\n * True when the value has a string `id`, a string `kind`, and a callable\n * `run`.\n */\nexport function is_step(value: unknown): value is Step<unknown, unknown> {\n if (typeof value !== 'object' || value === null) return false\n if (!('id' in value) || !('kind' in value) || !('run' in value)) return false\n const { id, kind, run } = value\n return typeof id === 'string' && typeof kind === 'string' && typeof run === 'function'\n}\n","/**\n * describe(step) and describe.json(step): composition introspection.\n *\n * `describe(step)` is the text-tree renderer. Multi-line string with\n * hierarchical indentation. Function values render as `<fn>` (or\n * `<fn:name>` when the function has a non-empty `name`); zod schemas\n * render as `<schema>`.\n *\n * `describe.json(step)` returns a `FlowNode` tree (kind, id, config, children)\n * for tooling (Studio UI, Mermaid renderers, diff tools). Function values\n * serialize as `{ kind: '<fn>', name? }` and schemas as `{ kind: '<schema>' }`.\n *\n * Both forms detect cycles. Under the default (loose) mode, back-references\n * render as `<cycle>(id)` in text and `{ kind: '<cycle>', id }` in JSON. Under\n * `{ strict: true }`, cycles throw `describe_cycle_error`.\n */\n\nimport { describe_cycle_error } from './errors.js'\nimport { is_step } from './is_step.js'\nimport type { Step, StepMetadata } from './types.js'\n\nconst INDENT = ' '\n\nexport type FlowValue =\n | string\n | number\n | boolean\n | null\n | ReadonlyArray<FlowValue>\n | Readonly<{ [key: string]: FlowValue }>\n | { readonly kind: '<fn>'; readonly name?: string }\n | { readonly kind: '<schema>' }\n | { readonly kind: string; readonly id: string }\n\nexport type FlowNode = {\n readonly kind: string\n readonly id: string\n readonly config?: Readonly<{ [key: string]: FlowValue }>\n readonly children?: ReadonlyArray<FlowNode>\n readonly meta?: StepMetadata\n}\n\nexport type DescribeOptions = {\n readonly strict?: boolean\n}\n\ntype Path = Set<Step<unknown, unknown>>\n\n/**\n * Render a step tree as an indented multi-line string.\n */\nfunction describe_text<i, o>(root: Step<i, o>, options?: DescribeOptions): string {\n const lines: string[] = []\n const strict = Boolean(options?.strict)\n render_text(root, 0, lines, new Set(), strict)\n return lines.join('\\n')\n}\n\n/**\n * Render a step tree as a serializable `FlowNode` tree.\n */\nfunction describe_json<i, o>(root: Step<i, o>, options?: DescribeOptions): FlowNode {\n const strict = Boolean(options?.strict)\n return render_json(root, new Set(), strict)\n}\n\n/**\n * Public entry point: `describe(step)` for text, `describe.json(step)` for\n * the `FlowNode` tree.\n */\nexport const describe: {\n <i, o>(root: Step<i, o>, options?: DescribeOptions): string\n json: <i, o>(root: Step<i, o>, options?: DescribeOptions) => FlowNode\n} = Object.assign(describe_text, { json: describe_json })\n\n/**\n * Append one node (label line, config lines, then children) to `lines`.\n *\n * `path` holds the steps on the current root-to-node path for cycle\n * detection; membership is added before recursing and removed in a `finally`\n * so shared (diamond) references are not misreported as cycles.\n */\nfunction render_text(\n node: Step<unknown, unknown>,\n depth: number,\n lines: string[],\n path: Path,\n strict: boolean,\n): void {\n const prefix = INDENT.repeat(depth)\n if (path.has(node)) {\n if (strict) throw new describe_cycle_error(node.id)\n lines.push(`${prefix}<cycle>(${node.id})`)\n return\n }\n path.add(node)\n try {\n const display = node.config?.['display_name']\n const label = typeof display === 'string' && display.length > 0 ? display : node.kind\n lines.push(`${prefix}${label}(${node.id})`)\n if (node.config) {\n for (const [key, value] of Object.entries(node.config)) {\n if (key === 'display_name') continue\n lines.push(`${prefix}${INDENT}${key}: ${render_value_text(value, path, strict)}`)\n }\n }\n if (node.children && node.children.length > 0) {\n for (const child of node.children) {\n render_text(child, depth + 1, lines, path, strict)\n }\n }\n } finally {\n path.delete(node)\n }\n}\n\n/**\n * Render a single config value for the text tree.\n *\n * Functions become `<fn>` or `<fn:name>`, zod schemas `<schema>`, and Step\n * references `kind(id)`; arrays and plain objects recurse. Strings are\n * JSON-quoted so empty and whitespace values stay visible.\n */\nfunction render_value_text(value: unknown, path: Path, strict: boolean): string {\n if (typeof value === 'function') {\n const name = typeof value.name === 'string' && value.name.length > 0 ? value.name : ''\n return name ? `<fn:${name}>` : '<fn>'\n }\n if (value === null) return 'null'\n if (value === undefined) return 'undefined'\n if (is_zod_schema(value)) return '<schema>'\n if (is_step(value)) {\n if (path.has(value)) {\n if (strict) throw new describe_cycle_error(value.id)\n return `<cycle>(${value.id})`\n }\n return `${value.kind}(${value.id})`\n }\n if (Array.isArray(value)) {\n return `[${value.map((item: unknown) => render_value_text(item, path, strict)).join(', ')}]`\n }\n if (typeof value === 'object') {\n const entries = Object.entries({ ...value }).map(\n ([k, v]: [string, unknown]) => `${k}: ${render_value_text(v, path, strict)}`,\n )\n return `{ ${entries.join(', ')} }`\n }\n if (typeof value === 'string') return JSON.stringify(value)\n if (typeof value === 'bigint') return `${value.toString()}n`\n if (typeof value === 'symbol') return value.toString()\n if (typeof value === 'number' || typeof value === 'boolean') return String(value)\n return JSON.stringify(value)\n}\n\n/**\n * Convert one step node to a `FlowNode`, recursing into config and children.\n *\n * Uses the same path-based cycle detection as `render_text`: back-references\n * become `{ kind: '<cycle>', id }` in loose mode and throw in strict mode.\n */\nfunction render_json(\n node: Step<unknown, unknown>,\n path: Path,\n strict: boolean,\n): FlowNode {\n if (path.has(node)) {\n if (strict) throw new describe_cycle_error(node.id)\n return { kind: '<cycle>', id: node.id }\n }\n path.add(node)\n try {\n const result: {\n kind: string\n id: string\n config?: { [key: string]: FlowValue }\n children?: FlowNode[]\n meta?: StepMetadata\n } = { kind: node.kind, id: node.id }\n if (node.config) {\n const config: { [key: string]: FlowValue } = {}\n for (const [key, value] of Object.entries(node.config)) {\n config[key] = render_value_json(value, path, strict)\n }\n result.config = config\n }\n if (node.children && node.children.length > 0) {\n result.children = node.children.map((child) => render_json(child, path, strict))\n }\n if (node.meta) {\n result.meta = node.meta\n }\n return result\n } finally {\n path.delete(node)\n }\n}\n\n/**\n * Convert a single config value to a JSON-safe `FlowValue`.\n *\n * Functions serialize as `{ kind: '<fn>', name? }`, schemas as\n * `{ kind: '<schema>' }`, Step references as `{ kind, id }`. `undefined`\n * maps to `null` and bigints/symbols to strings so the result survives\n * `JSON.stringify` without loss.\n */\nfunction render_value_json(value: unknown, path: Path, strict: boolean): FlowValue {\n if (typeof value === 'function') {\n const name = typeof value.name === 'string' && value.name.length > 0 ? value.name : ''\n return name ? { kind: '<fn>', name } : { kind: '<fn>' }\n }\n if (value === null) return null\n if (value === undefined) return null\n if (is_zod_schema(value)) return { kind: '<schema>' }\n if (is_step(value)) {\n if (path.has(value)) {\n if (strict) throw new describe_cycle_error(value.id)\n return { kind: '<cycle>', id: value.id }\n }\n return { kind: value.kind, id: value.id }\n }\n if (Array.isArray(value)) {\n return value.map((item: unknown) => render_value_json(item, path, strict))\n }\n if (typeof value === 'object') {\n const out: { [key: string]: FlowValue } = {}\n for (const [k, v] of Object.entries({ ...value })) {\n out[k] = render_value_json(v, path, strict)\n }\n return out\n }\n if (typeof value === 'string') return value\n if (typeof value === 'number' || typeof value === 'boolean') return value\n if (typeof value === 'bigint') return `${value.toString()}n`\n if (typeof value === 'symbol') return value.toString()\n return JSON.stringify(value)\n}\n\n/**\n * Detect a zod schema by its internal marker properties (`_zod` in zod 4,\n * `_def` in zod 3) without importing zod.\n */\nfunction is_zod_schema(value: unknown): boolean {\n if (typeof value !== 'object' || value === null) return false\n return '_zod' in value || '_def' in value\n}\n","/**\n * sequence: chain child outputs.\n *\n * `sequence([a, b, c])` runs a, b, c in declared order. The input to sequence\n * is passed to the first child; each subsequent child receives the previous\n * child's output. The composer returns the last child's output.\n */\n\nimport { is_step } from './is_step.js'\nimport { dispatch_step, register_traced_kind, throw_if_aborted } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\ntype AnyStep = Step<unknown, unknown>\n\ntype FirstInput<children> = children extends readonly [Step<infer i, unknown>, ...unknown[]]\n ? i\n : unknown\n\ntype LastOutput<children> = children extends readonly [...unknown[], Step<unknown, infer o>]\n ? o\n : children extends readonly [Step<unknown, infer o>]\n ? o\n : unknown\n\nlet sequence_counter = 0\n\n/**\n * Generate a unique step id of the form `sequence_<n>`.\n */\nfunction next_id(): string {\n sequence_counter += 1\n return `sequence_${sequence_counter}`\n}\n\nexport type SequenceOptions = {\n readonly name?: string\n}\n\n/**\n * Build a step that chains children, each feeding the next.\n *\n * Validates every element up front so a non-Step (usually a bare function)\n * fails at construction with a pointed message rather than at run time.\n * Checks `ctx.abort` before each child so aborts land on step boundaries.\n */\nexport function sequence<const children extends readonly AnyStep[]>(\n children: children,\n options?: SequenceOptions,\n): Step<FirstInput<children>, LastOutput<children>> {\n if (!Array.isArray(children)) {\n throw new TypeError(\n `sequence(children): children must be an array of Steps, got ${typeof children} — sequence takes a single array, e.g. sequence([a, b, c])`,\n )\n }\n children.forEach((child, index) => {\n if (is_step(child)) return\n const hint =\n typeof child === 'function'\n ? ' — wrap plain functions with step(fn), or use pipe(inner, fn) to transform output'\n : ''\n throw new TypeError(\n `sequence(children): children[${index}] is not a Step, got ${typeof child}${hint}`,\n )\n })\n\n const id = next_id()\n const children_ref = children\n const run_fn = async (input: unknown, ctx: RunContext): Promise<unknown> => {\n let acc: unknown = input\n for (const child of children_ref) {\n throw_if_aborted(ctx)\n acc = await dispatch_step(child, acc, ctx)\n }\n return acc\n }\n\n const config_meta: Record<string, unknown> | undefined =\n options?.name === undefined ? undefined : { display_name: options.name }\n\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return {\n id,\n kind: 'sequence',\n children,\n ...(config_meta ? { config: config_meta } : {}),\n run: run_fn,\n } as Step<FirstInput<children>, LastOutput<children>>\n}\n\nregister_traced_kind('sequence')\n","/**\n * parallel: concurrent execution of named children.\n *\n * `parallel({ a, b })` runs a and b concurrently with the same input. Output\n * is an object keyed by the child name; all children must accept the same\n * input type.\n *\n * Cancellation: each child runs with a composed abort signal,\n * `AbortSignal.any([ctx.abort, child_local])`. On abort the composer awaits\n * all in-flight children (success, failure, or aborted) before rethrowing\n * `ctx.abort.reason`.\n *\n * When several children fail, a `suspended_error` is preferred over an\n * application error so a human-approval gate inside a branch stays resumable\n * rather than being masked by a sibling's failure. Otherwise the first error\n * in declared order propagates.\n */\n\nimport { aborted_error, suspended_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\ntype AnyStep = Step<unknown, unknown>\n\ntype OutputOf<s> = s extends Step<unknown, infer o> ? o : unknown\n\ntype ParallelOutputs<children extends Record<string, AnyStep>> = {\n [k in keyof children]: OutputOf<children[k]>\n}\n\nlet parallel_counter = 0\n\n/**\n * Generate a unique step id of the form `parallel_<n>`.\n */\nfunction next_id(): string {\n parallel_counter += 1\n return `parallel_${parallel_counter}`\n}\n\nexport type ParallelOptions = {\n readonly name?: string\n}\n\n/**\n * Build a step that runs named children concurrently on the same input.\n *\n * Returns an object keyed by child name. All children settle before any\n * error propagates; a `suspended_error` wins over application errors so a\n * human-approval gate stays resumable instead of being masked by a sibling's\n * failure.\n */\nexport function parallel<i, children extends Record<string, Step<i, unknown>>>(\n members: children,\n options?: ParallelOptions,\n): Step<i, ParallelOutputs<children>> {\n const id = next_id()\n const entries: ReadonlyArray<readonly [string, AnyStep]> = Object.entries(members)\n const child_list: ReadonlyArray<AnyStep> = entries.map(([, s]) => s)\n const keys: ReadonlyArray<string> = entries.map(([k]) => k)\n\n const run_fn = async (input: i, ctx: RunContext): Promise<ParallelOutputs<children>> => {\n const controllers = entries.map(() => new AbortController())\n const on_parent_abort = (): void => {\n for (const c of controllers) c.abort(ctx.abort.reason)\n }\n if (ctx.abort.aborted) {\n on_parent_abort()\n } else {\n ctx.abort.addEventListener('abort', on_parent_abort, { once: true })\n }\n \n try {\n const settled = await Promise.all(\n entries.map(async ([key, child], idx) => {\n const local = controllers[idx]\n if (!local) throw new Error('parallel: missing controller')\n const composed = AbortSignal.any([ctx.abort, local.signal])\n const child_ctx: RunContext = { ...ctx, abort: composed }\n try {\n const value = await dispatch_step(child, input, child_ctx)\n return { status: 'ok' as const, key, value }\n } catch (err) {\n return { status: 'err' as const, key, err }\n }\n }),\n )\n \n if (ctx.abort.aborted) {\n const reason = ctx.abort.reason\n throw reason instanceof Error ? reason : new aborted_error('aborted', { reason })\n }\n\n let first_err: unknown\n let has_err = false\n let suspended: unknown\n let has_suspended = false\n for (const s of settled) {\n if (s.status !== 'err') continue\n if (!has_err) {\n first_err = s.err\n has_err = true\n }\n if (!has_suspended && s.err instanceof suspended_error) {\n suspended = s.err\n has_suspended = true\n }\n }\n if (has_suspended) throw suspended\n if (has_err) throw first_err\n \n const out: Record<string, unknown> = {}\n for (const s of settled) {\n if (s.status === 'ok') out[s.key] = s.value\n }\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return out as ParallelOutputs<children>\n } finally {\n ctx.abort.removeEventListener('abort', on_parent_abort)\n }\n }\n\n const config_meta: Record<string, unknown> = { keys }\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'parallel',\n children: child_list,\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('parallel')\n","/**\n * branch: conditional routing.\n *\n * `branch({ when, then, otherwise })` evaluates `when(input)`; if truthy, runs\n * `then`, else runs `otherwise`. Both branches must return the same output\n * type.\n */\n\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type BranchConfig<i, o> = {\n readonly name?: string\n readonly when: (input: i) => boolean | Promise<boolean>\n readonly then: Step<i, o>\n readonly otherwise: Step<i, o>\n}\n\nlet branch_counter = 0\n\n/**\n * Generate a unique step id of the form `branch_<n>`.\n */\nfunction next_id(): string {\n branch_counter += 1\n return `branch_${branch_counter}`\n}\n\n/**\n * Build a conditional-routing step.\n *\n * Evaluates `when(input)` at run time and dispatches to `then` or `otherwise`.\n * Both branches appear as children so `describe()` renders the full tree even\n * though only one branch runs.\n */\nexport function branch<i, o>(config: BranchConfig<i, o>): Step<i, o> {\n const id = next_id()\n const { when, then: then_step, otherwise: otherwise_step, name } = config\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n const cond = await when(input)\n const next_step = cond ? then_step : otherwise_step\n return dispatch_step(next_step, input, ctx)\n }\n\n const config_meta: Record<string, unknown> = { when, then: then_step, otherwise: otherwise_step }\n if (name !== undefined) config_meta['display_name'] = name\n\n return {\n id,\n kind: 'branch',\n children: [then_step, otherwise_step],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('branch')\n","/**\n * map: per-item execution.\n *\n * `map({ items, do, concurrency? })` extracts an array via `items(input)`,\n * runs `do` once per element, returns an array in the same order as inputs.\n * `concurrency` caps simultaneous in-flight items; omitted means full\n * parallelism.\n *\n * Cancellation: each in-flight item runs with a composed abort signal via\n * `AbortSignal.any([ctx.abort, child_local])`.\n * On abort no new items start. The composer awaits all in-flight items before\n * rethrowing `ctx.abort.reason`.\n */\n\nimport { aborted_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type MapConfig<input, item, result> = {\n readonly name?: string\n readonly items: (input: input) => ReadonlyArray<item> | Promise<ReadonlyArray<item>>\n readonly do: Step<item, result>\n readonly concurrency?: number\n}\n\nlet map_counter = 0\n\n/**\n * Generate a unique step id of the form `map_<n>`.\n */\nfunction next_id(): string {\n map_counter += 1\n return `map_${map_counter}`\n}\n\n/**\n * Build a per-item execution step.\n *\n * Extracts an array via `items(input)`, runs `do` once per element through a\n * bounded worker pool, and returns results in input order. The first item\n * failure stops new work and propagates after in-flight items settle.\n */\nexport function map<input, item, result>(\n config: MapConfig<input, item, result>,\n): Step<input, result[]> {\n const id = next_id()\n const { items, do: per_item, concurrency, name } = config\n\n const run_fn = async (input: input, ctx: RunContext): Promise<result[]> => {\n const list = await items(input)\n if (list.length === 0) return []\n const results: result[] = Array.from({ length: list.length })\n \n const limit = concurrency === undefined ? list.length : Math.max(1, concurrency)\n const controllers: AbortController[] = []\n \n const on_parent_abort = (): void => {\n for (const c of controllers) c.abort(ctx.abort.reason)\n }\n if (ctx.abort.aborted) {\n on_parent_abort()\n } else {\n ctx.abort.addEventListener('abort', on_parent_abort, { once: true })\n }\n \n let cursor = 0\n let worker_error: unknown = undefined\n \n const run_one = async (idx: number): Promise<void> => {\n const local = new AbortController()\n controllers.push(local)\n const composed = AbortSignal.any([ctx.abort, local.signal])\n const child_ctx: RunContext = { ...ctx, abort: composed }\n const item_value = list[idx]\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n const value = await dispatch_step(per_item, item_value as item, child_ctx)\n results[idx] = value\n }\n \n const worker = async (): Promise<void> => {\n while (true) {\n if (ctx.abort.aborted || worker_error !== undefined) return\n const idx = cursor\n cursor += 1\n if (idx >= list.length) return\n try {\n await run_one(idx)\n } catch (err) {\n if (worker_error === undefined) worker_error = err\n return\n }\n }\n }\n \n try {\n const worker_count = Math.min(limit, list.length)\n const workers: Promise<void>[] = []\n for (let w = 0; w < worker_count; w += 1) {\n workers.push(worker())\n }\n await Promise.all(workers)\n \n if (ctx.abort.aborted) {\n const reason = ctx.abort.reason\n throw reason instanceof Error ? reason : new aborted_error('aborted', { reason })\n }\n if (worker_error !== undefined) throw worker_error\n \n return results\n } finally {\n ctx.abort.removeEventListener('abort', on_parent_abort)\n }\n }\n\n const config_meta: Record<string, unknown> = { items }\n if (concurrency !== undefined) config_meta['concurrency'] = concurrency\n if (name !== undefined) config_meta['display_name'] = name\n\n return {\n id,\n kind: 'map',\n children: [per_item],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('map')\n","/**\n * pipe: transform output.\n *\n * `pipe(inner, fn)` runs `inner`, passes its output to `fn`, returns `fn`'s\n * result. Use for shape adaptation when composing heterogeneous steps.\n */\n\nimport { is_step } from './is_step.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nlet pipe_counter = 0\n\n/**\n * Generate a unique step id of the form `pipe_<n>`.\n */\nfunction next_id(): string {\n pipe_counter += 1\n return `pipe_${pipe_counter}`\n}\n\nexport type PipeOptions = {\n readonly name?: string\n}\n\n/**\n * Build an output-transforming step around `inner`.\n *\n * The argument checks reject Steps passed where functions belong: `pipe` is\n * not variadic, and the early `TypeError`s point misuse at `step(fn)` or\n * `sequence([...])` instead of failing obscurely at run time.\n */\nexport function pipe<i, a, b>(\n inner: Step<i, a>,\n fn: (value: a) => b | Promise<b>,\n options?: PipeOptions,\n): Step<i, b> {\n if (!is_step(inner)) {\n const hint = typeof inner === 'function' ? ' — wrap plain functions with step(fn)' : ''\n throw new TypeError(`pipe(inner, fn): inner must be a Step, got ${typeof inner}${hint}`)\n }\n if (typeof fn !== 'function') {\n if (is_step(fn)) {\n throw new TypeError(\n 'pipe(inner, fn): fn must be a function, got a Step — pipe is not variadic; to chain Steps use sequence([...])',\n )\n }\n throw new TypeError(`pipe(inner, fn): fn must be a function, got ${typeof fn}`)\n }\n if (is_step(options)) {\n throw new TypeError(\n 'pipe(inner, fn, options): got a Step as the third argument — pipe is not variadic; to chain Steps use sequence([...])',\n )\n }\n\n const id = next_id()\n\n const run_fn = async (input: i, ctx: RunContext): Promise<b> => {\n const intermediate = await dispatch_step(inner, input, ctx)\n return fn(intermediate)\n }\n\n const config_meta: Record<string, unknown> = { fn }\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'pipe',\n children: [inner],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('pipe')\n","/**\n * The backoff algebra shared by the composition layer and the engine.\n *\n * Both retry layers schedule delays between attempts, and each used to carry\n * its own exponential arithmetic plus its own timer/abort-listener dance. The\n * two drifted: one jittered and capped, the other did neither. This module is\n * the single algebra both express their delays through.\n *\n * The zone sits at the bottom of the dependency DAG and imports nothing, which\n * is why `wait_with_abort` is handed the abort-error factory rather than\n * constructing one: the error taxonomy lives in core, and reaching for it from\n * here would close a cycle back through the callers.\n */\n\nexport type BackoffPolicy = {\n readonly initial_delay_ms: number\n readonly max_delay_ms: number\n readonly jitter: boolean\n}\n\n/**\n * Map an abort reason onto the error a wait rejects with.\n *\n * Each layer surfaces an abort as its own error, so the caller supplies the\n * mapping instead of this zone owning an error taxonomy it cannot import.\n */\nexport type AbortErrorFactory = (reason: unknown) => Error\n\n/**\n * Compute the delay before retry attempt `attempt`, counted from zero.\n *\n * Exponential (`initial_delay_ms * 2^attempt`) plus up to one\n * `initial_delay_ms` of random jitter when `policy.jitter` is set, clamped to\n * `max_delay_ms`. The jitter spreads retries from concurrent callers apart so\n * they don't stampede in lockstep; a `max_delay_ms` of `Infinity` is uncapped.\n */\nexport function compute_backoff(policy: BackoffPolicy, attempt: number): number {\n const base = policy.initial_delay_ms * 2 ** attempt\n const jitter = policy.jitter ? Math.random() * policy.initial_delay_ms : 0\n return Math.min(base + jitter, policy.max_delay_ms)\n}\n\n/**\n * Sleep `ms`, rejecting the moment `signal` fires instead of serving out the\n * delay, so a pending abort never waits out a backoff.\n *\n * A non-positive `ms` resolves without arming a timer or consulting `signal`,\n * matching what both retry layers did before. The rejection value is\n * `to_error` applied to `signal.reason`.\n */\nexport function wait_with_abort(\n ms: number,\n signal: AbortSignal,\n to_error: AbortErrorFactory,\n): Promise<void> {\n if (ms <= 0) return Promise.resolve()\n return new Promise<void>((resolve, reject) => {\n if (signal.aborted) {\n reject(to_error(signal.reason))\n return\n }\n const timer = setTimeout(() => {\n signal.removeEventListener('abort', on_abort)\n resolve()\n }, ms)\n const on_abort = (): void => {\n clearTimeout(timer)\n reject(to_error(signal.reason))\n }\n signal.addEventListener('abort', on_abort, { once: true })\n })\n}\n","/**\n * retry: re-run on failure.\n *\n * `retry(inner, { max_attempts, backoff_ms?, max_delay_ms?, jitter?, on_error? })`\n * runs `inner`. If it throws an application error, retries up to\n * `max_attempts - 1` more times with exponential backoff\n * (`backoff_ms * 2^(attempt-1)`), jittered by up to one `backoff_ms` and\n * clamped to `max_delay_ms` (default 30s) through the shared `#policy`\n * algebra. `jitter` defaults on: un-jittered concurrent retries stampede in\n * lockstep. `on_error` is called on every such failure. The last error is\n * rethrown if all attempts fail.\n *\n * Control-flow signals (`suspended_error`, `aborted_error`) are not failures:\n * they propagate immediately without consuming an attempt, firing `on_error`,\n * or scheduling a backoff. A suspend's `on()` side effect therefore runs once\n * per run, not once per attempt.\n *\n * Cancellation / cleanup: cleanup handlers registered by the inner step\n * accumulate across attempts. The parent `ctx.abort` is honored between\n * attempts; a pending abort short-circuits the backoff and propagates.\n */\n\nimport { aborted_error, is_control_flow_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\nimport { compute_backoff, wait_with_abort } from '#policy'\nimport type { BackoffPolicy } from '#policy'\n\nconst DEFAULT_BACKOFF_MS = 1_000\nconst DEFAULT_MAX_DELAY_MS = 30_000\n\nexport type RetryConfig = {\n readonly name?: string\n readonly max_attempts: number\n readonly backoff_ms?: number\n readonly max_delay_ms?: number\n readonly jitter?: boolean\n readonly on_error?: (err: unknown, attempt: number) => void\n}\n\nlet retry_counter = 0\n\n/**\n * Generate a unique step id of the form `retry_<n>`.\n */\nfunction next_id(): string {\n retry_counter += 1\n return `retry_${retry_counter}`\n}\n\n/**\n * Map an abort reason onto the error a retry rejects with, preserving an\n * `Error` reason verbatim rather than wrapping it in `aborted_error`.\n */\nfunction to_abort_error(reason: unknown): Error {\n return reason instanceof Error ? reason : new aborted_error('aborted', { reason })\n}\n\n/**\n * Build a retrying step around `inner`.\n *\n * Runs `inner` up to `max_attempts` times with exponential backoff between\n * failures. Application errors consume an attempt and fire `on_error`;\n * control-flow signals propagate untouched.\n */\nexport function retry<i, o>(inner: Step<i, o>, config: RetryConfig): Step<i, o> {\n const id = next_id()\n const max_attempts = Math.max(1, Math.floor(config.max_attempts))\n const backoff_ms = config.backoff_ms ?? DEFAULT_BACKOFF_MS\n const max_delay_ms = config.max_delay_ms ?? DEFAULT_MAX_DELAY_MS\n const jitter = config.jitter ?? true\n const on_error = config.on_error\n const backoff_policy: BackoffPolicy = { initial_delay_ms: backoff_ms, max_delay_ms, jitter }\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n let last_err: unknown = undefined\n for (let attempt = 1; attempt <= max_attempts; attempt += 1) {\n if (ctx.abort.aborted) {\n throw to_abort_error(ctx.abort.reason)\n }\n try {\n return await dispatch_step(inner, input, ctx)\n } catch (err) {\n if (is_control_flow_error(err)) throw err\n last_err = err\n if (on_error) on_error(err, attempt)\n if (attempt >= max_attempts) break\n const delay = compute_backoff(backoff_policy, attempt - 1)\n await wait_with_abort(delay, ctx.abort, to_abort_error)\n }\n }\n throw last_err\n }\n\n const config_meta: Record<string, unknown> = { max_attempts, backoff_ms, max_delay_ms, jitter }\n if (on_error) config_meta['on_error'] = on_error\n if (config.name !== undefined) config_meta['display_name'] = config.name\n\n return {\n id,\n kind: 'retry',\n children: [inner],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('retry')\n","/**\n * fallback: primary-or-backup.\n *\n * `fallback(primary, backup)` runs `primary`. If it throws an application\n * error, runs `backup` with the same input, or with `handoff(input, err)`\n * when the `handoff` option is set, so the backup can be told why it is\n * running. If `backup` also throws, the `backup` error propagates.\n * Control-flow signals (`suspended_error`, `aborted_error`) are not\n * failures: they propagate instead of triggering the backup, so a\n * human-approval gate is never silently bypassed and the backup never runs\n * under an aborted context. `handoff` is never called for them.\n */\n\nimport { is_control_flow_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nlet fallback_counter = 0\n\n/**\n * Generate a unique step id of the form `fallback_<n>`.\n */\nfunction next_id(): string {\n fallback_counter += 1\n return `fallback_${fallback_counter}`\n}\n\nexport type FallbackOptions<i = unknown> = {\n readonly name?: string\n readonly handoff?: (input: i, err: unknown) => i\n}\n\n/**\n * Build a primary-or-backup step.\n *\n * Runs `primary`; on an application error runs `backup` with the same input,\n * or with `handoff(input, err)` when the option is set. Control-flow signals\n * propagate without triggering the backup or the handoff.\n */\nexport function fallback<i, o>(\n primary: Step<i, o>,\n backup: Step<i, o>,\n options?: FallbackOptions<i>,\n): Step<i, o> {\n const id = next_id()\n const handoff = options?.handoff\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n try {\n return await dispatch_step(primary, input, ctx)\n } catch (err) {\n if (is_control_flow_error(err)) throw err\n const backup_input = handoff === undefined ? input : handoff(input, err)\n return dispatch_step(backup, backup_input, ctx)\n }\n }\n\n const config_meta: Record<string, unknown> | undefined =\n options?.name === undefined ? undefined : { display_name: options.name }\n\n return {\n id,\n kind: 'fallback',\n children: [primary, backup],\n ...(config_meta ? { config: config_meta } : {}),\n run: run_fn,\n }\n}\n\nregister_traced_kind('fallback')\n","/**\n * timeout: bound execution.\n *\n * `timeout(inner, ms)` runs `inner` with a composed `AbortSignal` that fires\n * at `ms` milliseconds. If the inner step does not complete in time, throws\n * `timeout_error`. The inner step is responsible for honoring `ctx.abort`;\n * a step that ignores the signal still triggers `timeout_error` on schedule\n * but continues running in the background.\n *\n * Cancellation: the inner step runs with\n * `AbortSignal.any([ctx.abort, timeout_local])`. On timer expiry, the local\n * controller aborts with a `timeout_error` as its reason; on parent abort\n * the parent reason flows through. The timer is always cleared in a finally\n * block so it does not leak across retries.\n */\n\nimport { aborted_error, timeout_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nlet timeout_counter = 0\n\n/**\n * Generate a unique step id of the form `timeout_<n>`.\n */\nfunction next_id(): string {\n timeout_counter += 1\n return `timeout_${timeout_counter}`\n}\n\nexport type TimeoutOptions = {\n readonly name?: string\n}\n\n/**\n * Build a deadline-bounded step around `inner`.\n *\n * Races the inner dispatch against a timer that aborts the composed signal\n * with `timeout_error`. The `timed_out` flag distinguishes timer expiry from\n * a parent abort so the right error propagates.\n */\nexport function timeout<i, o>(\n inner: Step<i, o>,\n ms: number,\n options?: TimeoutOptions,\n): Step<i, o> {\n const id = next_id()\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n const local = new AbortController()\n const composed = AbortSignal.any([ctx.abort, local.signal])\n const child_ctx: RunContext = { ...ctx, abort: composed }\n \n let timed_out = false\n const timer = setTimeout(() => {\n timed_out = true\n local.abort(new timeout_error(`timeout after ${ms}ms`, ms))\n }, ms)\n \n const deadline = new Promise<never>((_, reject) => {\n const on_local_abort = (): void => {\n if (timed_out) {\n reject(new timeout_error(`timeout after ${ms}ms`, ms))\n } else {\n const reason = ctx.abort.reason\n reject(reason instanceof Error ? reason : new aborted_error('aborted', { reason }))\n }\n }\n if (composed.aborted) {\n on_local_abort()\n return\n }\n composed.addEventListener('abort', on_local_abort, { once: true })\n })\n \n try {\n return await Promise.race([dispatch_step(inner, input, child_ctx), deadline])\n } finally {\n clearTimeout(timer)\n }\n }\n\n const config_meta: Record<string, unknown> = { ms }\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'timeout',\n children: [inner],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('timeout')\n","/**\n * loop: bounded iteration with carry-state.\n *\n * `loop({ init, body, guard?, finish, max_rounds, name? })` runs `body` up to\n * `max_rounds` times, threading `state` through each iteration. After every\n * `body` call, an optional `guard` step inspects (and may transform) the state\n * and decides whether to stop. When `guard.stop` is true, the loop exits\n * \"converged\"; otherwise it continues until `max_rounds`. `finish` projects\n * the final state to the loop's output value.\n *\n * Non-convergence is data, not error: when `max_rounds` is exhausted without\n * `guard` returning stop, the loop returns `{ value, converged: false, rounds }`,\n * the same convention `adversarial` and `consensus` use.\n *\n * Cancellation: between rounds the parent `ctx.abort` is honored; a pending\n * abort short-circuits and propagates `ctx.abort.reason`. The body and guard\n * receive the parent context unchanged; their own dispatch routes already\n * thread cancellation per the runner contract.\n */\n\nimport { dispatch_step, register_traced_kind, throw_if_aborted } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type LoopGuardResult<state> = {\n readonly stop: boolean\n readonly state: state\n}\n\nexport type LoopConfig<i, state, o> = {\n readonly name?: string\n readonly init: (input: i) => state\n readonly body: Step<state, state>\n readonly guard?: Step<state, LoopGuardResult<state>>\n readonly finish: (state: state, round: number) => o\n readonly max_rounds: number\n}\n\nexport type LoopResult<o> = {\n readonly value: o\n readonly converged: boolean\n readonly rounds: number\n}\n\nlet loop_counter = 0\n\n/**\n * Generate a unique step id, prefixed with the display name when one is set.\n */\nfunction next_id(name: string | undefined): string {\n loop_counter += 1\n return `${name ?? 'loop'}_${loop_counter}`\n}\n\n/**\n * Build a bounded iteration step with carry-state.\n *\n * Threads `state` through up to `max_rounds` runs of `body`, lets the\n * optional `guard` stop early, then projects the final state through\n * `finish`. Returns `{ value, converged, rounds }` so callers can tell a\n * converged run from an exhausted one.\n */\nexport function loop<i, state, o>(\n config: LoopConfig<i, state, o>,\n): Step<i, LoopResult<o>> {\n const { init, body, guard, finish, name } = config\n const rounds_limit = Math.max(1, Math.floor(config.max_rounds))\n const id = next_id(name)\n\n const run_fn = async (input: i, ctx: RunContext): Promise<LoopResult<o>> => {\n let state = init(input)\n let round = 0\n let converged = false\n \n while (round < rounds_limit) {\n throw_if_aborted(ctx)\n round += 1\n state = await dispatch_step(body, state, ctx)\n if (guard) {\n throw_if_aborted(ctx)\n const guard_out = await dispatch_step(guard, state, ctx)\n state = guard_out.state\n if (guard_out.stop) {\n converged = true\n break\n }\n }\n }\n \n const value = finish(state, round)\n return { value, converged, rounds: round }\n }\n\n const config_meta: Record<string, unknown> = { max_rounds: rounds_limit }\n if (name !== undefined) config_meta['display_name'] = name\n const children: ReadonlyArray<Step<unknown, unknown>> = guard\n ? [body, guard]\n : [body]\n\n return {\n id,\n kind: 'loop',\n children,\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('loop')\n","/**\n * compose: name a composite step.\n *\n * `compose(name, inner)` wraps any step and labels its trajectory span with\n * `name`. The inner step's own span (e.g. a `sequence`) appears as a child of\n * the compose span: the implementation tree is preserved while the user's\n * intent (\"this whole thing is an ensemble\") is surfaced in observability.\n *\n * Used by the composites package to make built-in patterns appear under\n * their familiar names, and available to library consumers who want their own\n * named composites to show up in logs as first-class components.\n *\n * The primitive's `kind` is always `'compose'`; the user-supplied label lives\n * in `config.display_name` and is the span name the dispatcher opens.\n */\n\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nlet compose_counter = 0\n\n/**\n * Generate a unique step id of the form `<name>_<n>`, using the user-supplied\n * label so compose ids read naturally in traces.\n */\nfunction next_id(name: string): string {\n compose_counter += 1\n return `${name}_${compose_counter}`\n}\n\n/**\n * Wrap `inner` in a named composite step.\n *\n * The step's `kind` is always `'compose'`; `name` becomes the\n * `display_name` used as the span label. Throws a `TypeError` when `name`\n * is not a non-empty string, catching the mistake at construction time.\n */\nexport function compose<i, o>(name: string, inner: Step<i, o>): Step<i, o> {\n if (typeof name !== 'string' || name.length === 0) {\n throw new TypeError('compose(name, inner): name must be a non-empty string')\n }\n const id = next_id(name)\n\n const run_fn = (input: i, ctx: RunContext): Promise<o> | o => dispatch_step(inner, input, ctx)\n\n return {\n id,\n kind: 'compose',\n children: [inner],\n config: { display_name: name },\n run: run_fn,\n }\n}\n\nregister_traced_kind('compose')\n","/**\n * checkpoint: persist and resume.\n *\n * `checkpoint(inner, { key })` checks a persistent store for a completed\n * result at `key` before running `inner`. On a hit, returns the stored\n * value. On a miss, runs `inner`, persists its result at `key`, and returns\n * it. Corrupted reads (store throws on `get`) are treated as a miss.\n *\n * Wrapping an anonymous inner step throws synchronously at construction time\n * with the message `checkpoint requires a named step; got anonymous`, because\n * a cached result must map back to a stable, identifiable step.\n */\n\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type CheckpointConfig<i> = {\n readonly name?: string\n readonly key: string | ((input: i) => string)\n}\n\nlet checkpoint_counter = 0\n\n/**\n * Generate a unique step id of the form `checkpoint_<n>`.\n */\nfunction next_id(): string {\n checkpoint_counter += 1\n return `checkpoint_${checkpoint_counter}`\n}\n\n/**\n * Wrap `inner` with persist-and-resume behavior keyed by `config.key`.\n *\n * `key` is a fixed string or a function of the input. Without a\n * `checkpoint_store` on the run context, the wrapper runs `inner` directly.\n * A stored `null` or `undefined` counts as a miss, so those values are\n * re-computed rather than replayed. Throws at construction time when `inner`\n * is anonymous.\n */\nexport function checkpoint<i, o>(inner: Step<i, o>, config: CheckpointConfig<i>): Step<i, o> {\n if (inner.anonymous === true) {\n throw new Error('checkpoint requires a named step; got anonymous')\n }\n\n const id = next_id()\n const key_spec = config.key\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n const key = typeof key_spec === 'function' ? key_spec(input) : key_spec\n const store = ctx.checkpoint_store\n \n if (store) {\n let cached: unknown = undefined\n let hit = false\n try {\n cached = await store.get(key)\n hit = cached !== null && cached !== undefined\n } catch {\n hit = false\n }\n if (hit) {\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return cached as o\n }\n }\n \n const result = await dispatch_step(inner, input, ctx)\n \n if (store) {\n await store.set(key, result)\n }\n \n return result\n }\n\n const config_meta: Record<string, unknown> = { key: key_spec }\n if (config.name !== undefined) config_meta['display_name'] = config.name\n\n return {\n id,\n kind: 'checkpoint',\n children: [inner],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('checkpoint')\n","/**\n * Validation against any Standard Schema implementation, and the one-line\n * rendering of its failures that repair prompts and error messages use.\n */\n\nimport type { StandardSchemaV1 } from '@standard-schema/spec'\nimport type { AnySchema, SchemaIssue, ValidateOutcome } from './types.js'\n\n/**\n * Validate `value` against `schema`, returning the typed value or the issues.\n *\n * Always async, even for a validator that answers synchronously: the spec\n * permits `validate` to return either a result or a promise of one, and\n * fascicle cannot know which a given vendor does. Awaiting a non-promise is\n * cheap; guessing wrong is a silent bug.\n */\nexport async function validate_schema<t>(\n schema: AnySchema<t>,\n value: unknown,\n): Promise<ValidateOutcome<t>> {\n const result = await schema['~standard'].validate(value)\n if (result.issues) return { ok: false, issues: result.issues.map(normalize_issue) }\n return { ok: true, value: result.value }\n}\n\n/**\n * Flatten one vendor issue into fascicle's shape.\n *\n * The spec allows a path segment to be a bare key or a `{ key }` wrapper, and\n * allows the path to be absent entirely. Normalizing here means no consumer has\n * to know which vendor produced the issue.\n */\nfunction normalize_issue(issue: StandardSchemaV1.Issue): SchemaIssue {\n if (issue.path === undefined) return { message: issue.message }\n const path = issue.path.map((segment) =>\n typeof segment === 'object' ? segment.key : segment,\n )\n return { message: issue.message, path }\n}\n\n/**\n * Render issues as the single line that goes into an error message or a repair\n * prompt fed back to the model.\n *\n * Paths are dotted (`address.city`, `items.0.name`) rather than bracketed for\n * indices: the model reads it as a hint about which field to fix, and one\n * consistent separator is easier to follow than two.\n */\nexport function format_schema_issues(issues: ReadonlyArray<SchemaIssue>): string {\n if (issues.length === 0) return 'unknown schema issue'\n return issues.map(format_issue).join('; ')\n}\n\n/**\n * Render one issue as `path: message`, or just the message when the vendor\n * reported no path (a failure about the value as a whole).\n */\nfunction format_issue(issue: SchemaIssue): string {\n const path = issue.path\n if (path === undefined || path.length === 0) return issue.message\n return `${path.map((segment) => String(segment)).join('.')}: ${issue.message}`\n}\n","/**\n * suspend: human-in-the-loop pause.\n *\n * `suspend({ id, on, resume_schema, combine })` pauses a flow waiting on\n * external input (a notification, an approval, an uploaded file). On first\n * encounter with no resume data, it calls `on(input, ctx)` (side effect) and\n * throws `suspended_error` carrying the run state. On resume (re-invocation\n * with `run_options.resume_data[id]` populated), the provided value is\n * validated against `resume_schema` and passed to `combine(input, resume,\n * ctx)`; the result is returned. Invalid resume data throws\n * `resume_validation_error` carrying the vendor-neutral issue list.\n */\n\nimport { validate_schema, type AnySchema } from '#schema'\nimport { resume_validation_error, suspended_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type SuspendConfig<i, o, resume> = {\n readonly id: string\n readonly name?: string\n readonly on: (input: i, ctx: RunContext) => Promise<void> | void\n readonly resume_schema: AnySchema<resume>\n readonly combine: (\n input: i,\n resume: resume,\n ctx: RunContext,\n ) => Promise<o> | o | Step<unknown, o>\n}\n\n/**\n * Structurally detect a `Step` returned from `combine`.\n *\n * `combine` may return either a plain value or a Step to dispatch; this local\n * check distinguishes the two without importing the shared helper.\n */\nfunction is_step(value: unknown): value is Step<unknown, unknown> {\n if (typeof value !== 'object' || value === null) return false\n if (!('id' in value) || !('kind' in value) || !('run' in value)) return false\n const { id, kind, run } = value\n return typeof id === 'string' && typeof kind === 'string' && typeof run === 'function'\n}\n\n/**\n * Build a human-in-the-loop pause step.\n *\n * First run fires the `on` side effect and throws `suspended_error`; a resume\n * run validates `resume_data[id]` against `resume_schema` and feeds it to\n * `combine`. The step's id is the user-supplied suspend id so resume data can\n * be addressed to it.\n */\nexport function suspend<i, o, resume>(config: SuspendConfig<i, o, resume>): Step<i, o> {\n const suspend_id = config.id\n const on_fn = config.on\n const resume_schema = config.resume_schema\n const combine_fn = config.combine\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n const resume_value = ctx.resume_data?.[suspend_id]\n \n if (resume_value === undefined) {\n await on_fn(input, ctx)\n throw new suspended_error(suspend_id, { input })\n }\n \n const parsed = await validate_schema(resume_schema, resume_value)\n if (!parsed.ok) {\n throw new resume_validation_error(\n `resume data for ${suspend_id} failed validation`,\n parsed.issues,\n )\n }\n\n const result = await combine_fn(input, parsed.value, ctx)\n if (is_step(result)) {\n return dispatch_step(result, input, ctx)\n }\n return result\n }\n\n const config_meta: Record<string, unknown> = { id: suspend_id }\n if (config.name !== undefined) config_meta['display_name'] = config.name\n\n return {\n id: suspend_id,\n kind: 'suspend',\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('suspend')\n","/**\n * scope / stash / use: named state.\n *\n * `scope([...children])` introduces a scope-local `Map<string, unknown>` and\n * runs its children in order, chaining outputs like `sequence`. `stash(key,\n * source)` runs `source`, writes its output to the scope's state at `key`,\n * and passes the value through. `use(keys, fn)` reads the named values from\n * state and runs `fn` with the projection. Inner scopes inherit outer state;\n * writes only affect the inner map.\n *\n * Using `stash` or `use` outside a `scope` is a runtime error with a clear\n * message.\n */\n\nimport { dispatch_step, register_traced_kind, throw_if_aborted } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\ntype AnyStep = Step<unknown, unknown>\n\ntype LastOutput<children> = children extends readonly [...unknown[], Step<unknown, infer o>]\n ? o\n : children extends readonly [Step<unknown, infer o>]\n ? o\n : unknown\n\nconst scope_states = new WeakSet<ReadonlyMap<string, unknown>>()\n\n/**\n * Check whether a state map was created by `scope`.\n *\n * The root `RunContext.state` map is not registered in `scope_states`, which\n * is how `stash`/`use` detect they are running outside any scope.\n */\nfunction is_scope_state(state: ReadonlyMap<string, unknown>): boolean {\n return scope_states.has(state)\n}\n\nlet scope_counter = 0\nlet stash_counter = 0\nlet use_counter = 0\n\n/**\n * Generate a unique step id of the form `scope_<n>`.\n */\nfunction next_scope_id(): string {\n scope_counter += 1\n return `scope_${scope_counter}`\n}\n\n/**\n * Generate a unique step id of the form `stash_<n>`.\n */\nfunction next_stash_id(): string {\n stash_counter += 1\n return `stash_${stash_counter}`\n}\n\n/**\n * Generate a unique step id of the form `use_<n>`.\n */\nfunction next_use_id(): string {\n use_counter += 1\n return `use_${use_counter}`\n}\n\nexport type ScopeOptions = {\n readonly name?: string\n}\n\nexport type StashOptions = {\n readonly name?: string\n}\n\nexport type UseOptions = {\n readonly name?: string\n}\n\n/**\n * Build a step that runs children in sequence under a fresh state map.\n *\n * The local map is seeded from the parent state (inner scopes read outer\n * values) and registered so `stash`/`use` inside recognize it; writes stay\n * local to this scope. Outputs chain like `sequence`.\n */\nexport function scope<const children extends readonly AnyStep[]>(\n children: children,\n options?: ScopeOptions,\n): Step<unknown, LastOutput<children>> {\n const id = next_scope_id()\n const children_ref = children\n\n const run_fn = async (input: unknown, ctx: RunContext): Promise<unknown> => {\n const local = new Map<string, unknown>(ctx.state)\n scope_states.add(local)\n const scope_ctx: RunContext = { ...ctx, state: local }\n \n let acc: unknown = input\n for (const child of children_ref) {\n throw_if_aborted(scope_ctx)\n acc = await dispatch_step(child, acc, scope_ctx)\n }\n return acc\n }\n\n const config_meta: Record<string, unknown> | undefined =\n options?.name === undefined ? undefined : { display_name: options.name }\n\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return {\n id,\n kind: 'scope',\n children,\n ...(config_meta ? { config: config_meta } : {}),\n run: run_fn,\n } as Step<unknown, LastOutput<children>>\n}\n\n/**\n * Build a step that stores its source's output in scope state at `key`.\n *\n * Passes the value through unchanged so it composes mid-chain. Throws when\n * run outside a `scope`.\n */\nexport function stash<i, v>(\n key: string,\n source: Step<i, v>,\n options?: StashOptions,\n): Step<i, v> {\n const id = next_stash_id()\n\n const run_fn = async (input: i, ctx: RunContext): Promise<v> => {\n if (!is_scope_state(ctx.state)) {\n throw new Error('stash() may only appear inside scope(); got: top-level')\n }\n const value = await dispatch_step(source, input, ctx)\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n const state = ctx.state as Map<string, unknown>\n state.set(key, value)\n return value\n }\n\n const config_meta: Record<string, unknown> = { key }\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'stash',\n children: [source],\n config: config_meta,\n run: run_fn,\n }\n}\n\n/**\n * Build a step that projects named scope values into a function call.\n *\n * Reads `keys` from scope state (missing keys project as `undefined`) and\n * invokes `fn(projection, input, ctx)`. Throws when run outside a `scope`.\n */\nexport function use<const keys extends readonly string[], i, o>(\n keys: keys,\n fn: (\n state: { [k in keys[number]]: unknown },\n input: i,\n ctx: RunContext,\n ) => Promise<o> | o,\n options?: UseOptions,\n): Step<i, o> {\n const id = next_use_id()\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n if (!is_scope_state(ctx.state)) {\n throw new Error('use() may only appear inside scope(); got: top-level')\n }\n const projection: Record<string, unknown> = {}\n for (const k of keys) {\n projection[k] = ctx.state.get(k)\n }\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return fn(projection as { [k in keys[number]]: unknown }, input, ctx)\n }\n\n const config_meta: Record<string, unknown> = { keys: [...keys] }\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'use',\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('scope')\n\nregister_traced_kind('stash')\n\nregister_traced_kind('use')\n","/**\n * Closed registry of every `Step.kind` produced by the composition layer.\n *\n * Studio (and any other consumer that needs to enumerate primitives: palette,\n * docs, code generation) can rely on this being the exhaustive set. New\n * primitives must add their kind here. The `step_kinds_cover_runner` contract\n * test in `step_kinds.test.ts` asserts every dispatch handler corresponds to a\n * kind listed here.\n */\n\nexport const STEP_KINDS = [\n 'step',\n 'sequence',\n 'parallel',\n 'branch',\n 'map',\n 'pipe',\n 'retry',\n 'fallback',\n 'timeout',\n 'loop',\n 'compose',\n 'adversarial',\n 'ensemble',\n 'tournament',\n 'consensus',\n 'checkpoint',\n 'suspend',\n 'scope',\n 'stash',\n 'use',\n] as const\n\nexport type StepKind = (typeof STEP_KINDS)[number]\n\n/**\n * Check whether a value is one of the registered `Step.kind` strings.\n */\nexport function is_step_kind(value: unknown): value is StepKind {\n return typeof value === 'string' && (STEP_KINDS as readonly string[]).includes(value)\n}\n","/**\n * Wire-format guards for trajectory events.\n *\n * `TrajectoryEvent` (in `types.ts`) is the loose internal type — any code that\n * calls `trajectory.record(event)` or `start_span(name, meta)` produces values\n * conforming to it. This file defines the *narrower* shapes that the studio\n * (and any other downstream consumer) can recognize in the wire stream:\n *\n * span_start — composer span open\n * span_end — composer span close\n * emit — user-emitted event from inside a step (ctx.emit)\n * <other> — anything else, recognized by `is_custom_trajectory_event`,\n * which only requires a string `kind`\n *\n * `parse_trajectory_event` is the wire gate, and it is deliberately permissive:\n * a value is a trajectory event iff it is a non-array object carrying a string\n * `kind`. The well-known guards layered on top are *recognizers*, not gates — a\n * `{ kind: 'span_start' }` line missing its `span_id` is still a valid event on\n * the wire, just not a `SpanStartEvent`. Anything stricter would have a viewer\n * drop lines a newer producer emits, which is the opposite of what a\n * forward-compatible wire format is for. `is_custom_trajectory_event` therefore\n * answers `true` for well-known kinds too: it is the fallback shape, not a\n * fifth disjoint case.\n *\n * Extra fields (`run_id`, `id`, provider-specific metadata) are neither\n * required nor stripped: a successful parse hands the value straight back, so a\n * parse / re-serialize round trip is lossless.\n */\n\nexport type SpanStartEvent = {\n readonly kind: 'span_start'\n readonly span_id: string\n readonly name: string\n} & { readonly [key: string]: unknown }\n\nexport type SpanEndEvent = {\n readonly kind: 'span_end'\n readonly span_id: string\n} & { readonly [key: string]: unknown }\n\nexport type EmitEvent = {\n readonly kind: 'emit'\n} & { readonly [key: string]: unknown }\n\nexport type CustomTrajectoryEvent = {\n readonly kind: string\n} & { readonly [key: string]: unknown }\n\nexport type ParsedTrajectoryEvent =\n | SpanStartEvent\n | SpanEndEvent\n | EmitEvent\n | CustomTrajectoryEvent\n\nexport type TrajectoryParseResult =\n | { readonly success: true; readonly data: ParsedTrajectoryEvent }\n | { readonly success: false; readonly error: Error }\n\n/**\n * The wire gate: a non-array object carrying a string `kind`.\n *\n * True for every well-known kind as well, since `custom` is the fallback shape\n * rather than a disjoint case.\n */\nexport function is_custom_trajectory_event(value: unknown): value is CustomTrajectoryEvent {\n if (typeof value !== 'object' || value === null) return false\n if (Array.isArray(value)) return false\n return typeof (value as { kind?: unknown }).kind === 'string'\n}\n\n/** A composer span open: both `span_id` and `name` must be present as strings. */\nexport function is_span_start_event(value: unknown): value is SpanStartEvent {\n if (!is_custom_trajectory_event(value)) return false\n if (value.kind !== 'span_start') return false\n return typeof value['span_id'] === 'string' && typeof value['name'] === 'string'\n}\n\n/** A composer span close: `span_id` must be present as a string, `name` need not be. */\nexport function is_span_end_event(value: unknown): value is SpanEndEvent {\n if (!is_custom_trajectory_event(value)) return false\n return value.kind === 'span_end' && typeof value['span_id'] === 'string'\n}\n\n/** A `ctx.emit` event: the kind alone identifies it, the payload is the caller's. */\nexport function is_emit_event(value: unknown): value is EmitEvent {\n return is_custom_trajectory_event(value) && value.kind === 'emit'\n}\n\n/**\n * Parse one wire value into a trajectory event, `safeParse`-shaped.\n *\n * On success `data` is the value itself, not a copy, so nothing on the line is\n * dropped or reordered on the way through.\n */\nexport function parse_trajectory_event(value: unknown): TrajectoryParseResult {\n if (!is_custom_trajectory_event(value)) {\n return {\n success: false,\n error: new Error(\"not a trajectory event: expected an object with a string 'kind'\"),\n }\n }\n return { success: true, data: value }\n}\n","/**\n * Public surface for core.\n *\n * Side-effect imports ensure every composer registers itself with the runner\n * at module load. Importing anything from `core` populates the\n * dispatch table with the core primitives. Built-in composites\n * (adversarial, ensemble, tournament, consensus) live in composites\n * and surface through the umbrella package.\n */\n\nimport flow_schema_data from './flow-schema.json' with { type: 'json' }\n\nexport { run } from './runner.js'\nexport { step } from './step.js'\nexport { describe } from './describe.js'\nexport type { DescribeOptions, FlowNode, FlowValue } from './describe.js'\nexport { sequence } from './sequence.js'\nexport { parallel } from './parallel.js'\nexport { branch } from './branch.js'\nexport { map } from './map.js'\nexport { pipe } from './pipe.js'\nexport { retry } from './retry.js'\nexport { fallback } from './fallback.js'\nexport { timeout } from './timeout.js'\nexport { loop } from './loop.js'\nexport type { LoopConfig, LoopGuardResult, LoopResult } from './loop.js'\nexport { compose } from './compose.js'\nexport { checkpoint } from './checkpoint.js'\nexport { suspend } from './suspend.js'\nexport { scope, stash, use } from './scope.js'\n\nexport {\n aborted_error,\n describe_cycle_error,\n resume_validation_error,\n suspended_error,\n timeout_error,\n} from './errors.js'\n\nexport type {\n CheckpointStore,\n RunContext,\n Step,\n StepMetadata,\n TrajectoryEvent,\n TrajectoryLogger,\n} from './types.js'\n\nexport { is_step_kind, STEP_KINDS } from './step_kinds.js'\nexport type { StepKind } from './step_kinds.js'\n\nexport {\n is_custom_trajectory_event,\n is_emit_event,\n is_span_end_event,\n is_span_start_event,\n parse_trajectory_event,\n} from './trajectory.js'\nexport type {\n CustomTrajectoryEvent,\n EmitEvent,\n ParsedTrajectoryEvent,\n SpanEndEvent,\n SpanStartEvent,\n TrajectoryParseResult,\n} from './trajectory.js'\n\nexport { flow_schema_data as flow_schema }\n"],"mappings":"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"}
@@ -1 +0,0 @@
1
- {"version":3,"file":"invoke-D9pxbZcu.js","names":["ai_tool"],"sources":["../src/engine/providers/ai_sdk/telemetry.ts","../src/engine/providers/ai_sdk/invoke.ts"],"sourcesContent":["/**\n * AI SDK telemetry wiring, confined to the ai_sdk transport.\n *\n * `@ai-sdk/otel` is adopted strictly below the turn seam: it instruments one\n * turn inside this module, never the loop. The peer is loaded lazily and only\n * when telemetry is explicitly enabled, so the disabled default (every call\n * that does not opt in) pulls in nothing.\n *\n * This is the ONLY place `@ai-sdk/otel` is referenced. generate.ts and\n * create_engine.ts thread a plain `AiSdkTelemetrySettings` value through the\n * seam and stay SDK-agnostic; loop-level, transport-neutral tracing is the\n * separate `fascicle/otel` bridge.\n */\n\nimport type { AiSdkTelemetrySettings } from '../../types.js'\nimport { load_optional_peer } from '../types.js'\n\ntype OpenTelemetryCtor = new (options?: { tracer?: unknown }) => unknown\n\ntype AiSdkOtelModule = {\n readonly OpenTelemetry: OpenTelemetryCtor\n}\n\n/**\n * The subset of the AI SDK's telemetry option shape this module produces, using\n * the SDK's own (camelCase) keys. Cast onto `experimental_telemetry` at the\n * call site.\n */\nexport type AiSdkTelemetryPassthrough = {\n isEnabled: true\n integrations: unknown[]\n functionId?: string\n recordInputs?: boolean\n recordOutputs?: boolean\n metadata?: Readonly<Record<string, string | number | boolean>>\n}\n\n/**\n * Build the AI SDK's `experimental_telemetry` option from engine settings,\n * loading the `@ai-sdk/otel` peer only when telemetry is enabled.\n */\nexport async function build_ai_sdk_telemetry(\n settings: AiSdkTelemetrySettings | undefined,\n): Promise<AiSdkTelemetryPassthrough | undefined> {\n if (!settings?.enabled) return undefined\n const mod = await load_optional_peer<AiSdkOtelModule>('@ai-sdk/otel')\n const integration = new mod.OpenTelemetry(\n settings.tracer !== undefined ? { tracer: settings.tracer } : {},\n )\n const out: AiSdkTelemetryPassthrough = { isEnabled: true, integrations: [integration] }\n if (settings.function_id !== undefined) out.functionId = settings.function_id\n if (settings.record_inputs !== undefined) out.recordInputs = settings.record_inputs\n if (settings.record_outputs !== undefined) out.recordOutputs = settings.record_outputs\n if (settings.metadata !== undefined) out.metadata = settings.metadata\n return out\n}\n","/**\n * The ai_sdk transport: the engine's only Vercel AI SDK call site.\n *\n * Only this module imports from `ai` or invokes generateText / streamText.\n * generate.ts drives this transport through create_ai_sdk_turn and stays\n * SDK-agnostic; run_tool_loop sees the same neutral TurnResult a native\n * adapter produces. Enforced by rules/no-ai-import-outside-ai-sdk-provider.yml.\n *\n * Retry stays out of this module on purpose: generate.ts wraps the turn\n * returned here in the engine-owned retry_turn, exactly as it wraps a native\n * adapter's invoke_turn. This module owns request/response mapping only.\n */\n\nimport {\n generateText,\n NoObjectGeneratedError,\n Output,\n isStepCount,\n streamText,\n tool as ai_tool,\n type LanguageModel,\n type ModelMessage,\n type TextStreamPart,\n type ToolSet,\n} from 'ai'\nimport type { ToolSchema } from '#schema'\nimport type {\n AiSdkTelemetrySettings,\n FinishReason,\n Message,\n StreamChunk,\n Tool,\n TurnResult,\n UsageTotals,\n} from '../../types.js'\nimport { aborted_error } from '../../errors.js'\nimport type { ChunkDispatcher } from '../../streaming.js'\nimport type { RawToolCall } from '../../tool_loop.js'\nimport {\n default_normalize_usage,\n type AiSdkProviderAdapter,\n type RawProviderUsage,\n} from '../types.js'\nimport { build_ai_sdk_telemetry, type AiSdkTelemetryPassthrough } from './telemetry.js'\n\n/**\n * Map the AI SDK's finish reason string to the engine's FinishReason.\n */\nexport function map_finish_reason(raw: string | undefined): FinishReason {\n switch (raw) {\n case 'stop':\n return 'stop'\n case 'length':\n return 'length'\n case 'content-filter':\n case 'content_filter':\n return 'content_filter'\n case 'tool-calls':\n case 'tool_calls':\n return 'tool_calls'\n default:\n return 'stop'\n }\n}\n\n/**\n * Extract the usage fields `default_normalize_usage` understands from an AI\n * SDK usage object, tolerating both the SDK's camelCase shape and the\n * flattened snake_case fields some provider mocks return directly.\n */\nexport function to_raw_provider_usage(usage: unknown): RawProviderUsage {\n if (usage === null || typeof usage !== 'object') return {}\n const raw: RawProviderUsage = {}\n const input_tokens = Reflect.get(usage, 'inputTokens')\n if (typeof input_tokens === 'number') raw.input_tokens = input_tokens\n const output_tokens = Reflect.get(usage, 'outputTokens')\n if (typeof output_tokens === 'number') raw.output_tokens = output_tokens\n const input_details = Reflect.get(usage, 'inputTokenDetails')\n if (input_details !== null && typeof input_details === 'object') {\n const cache_read = Reflect.get(input_details, 'cacheReadTokens')\n const cache_write = Reflect.get(input_details, 'cacheWriteTokens')\n raw.input_token_details = {}\n if (typeof cache_read === 'number') raw.input_token_details.cached_tokens = cache_read\n if (typeof cache_write === 'number') raw.input_token_details.cache_creation_input_tokens = cache_write\n }\n const output_details = Reflect.get(usage, 'outputTokenDetails')\n if (output_details !== null && typeof output_details === 'object') {\n const reasoning = Reflect.get(output_details, 'reasoningTokens')\n raw.output_token_details = {}\n if (typeof reasoning === 'number') raw.output_token_details.reasoning_tokens = reasoning\n }\n // Passthrough for mocks that provide flattened fields directly.\n const cached_flat = Reflect.get(usage, 'cached_input_tokens')\n if (typeof cached_flat === 'number') raw.cached_input_tokens = cached_flat\n const cache_write_flat = Reflect.get(usage, 'cache_write_tokens')\n if (typeof cache_write_flat === 'number') raw.cache_write_tokens = cache_write_flat\n const reasoning_flat = Reflect.get(usage, 'reasoning_tokens')\n if (typeof reasoning_flat === 'number') raw.reasoning_tokens = reasoning_flat\n const input_flat = Reflect.get(usage, 'input_tokens')\n if (raw.input_tokens === undefined && typeof input_flat === 'number') raw.input_tokens = input_flat\n const output_flat = Reflect.get(usage, 'output_tokens')\n if (raw.output_tokens === undefined && typeof output_flat === 'number') raw.output_tokens = output_flat\n return raw\n}\n\n/**\n * Normalize an AI SDK `providerMetadata` value into the neutral\n * TurnResult.provider_reported shape.\n *\n * The SDK's metadata is already keyed by provider name, which is the shape\n * provider_reported documents, so the keys ride through untranslated and every\n * ai_sdk provider is served by this one seam: bedrock's guardrail `trace`,\n * anthropic's cache detail, openai's own fields. The payloads stay opaque\n * (callers narrow them at the use site), so this copies the top level and\n * inspects nothing below it. An absent or empty map returns undefined, keeping\n * \"the provider reported nothing\" spelled one way.\n */\nexport function to_provider_reported(metadata: unknown): Record<string, unknown> | undefined {\n if (metadata === null || typeof metadata !== 'object') return undefined\n const keys = Object.keys(metadata)\n if (keys.length === 0) return undefined\n const reported: Record<string, unknown> = {}\n for (const key of keys) reported[key] = Reflect.get(metadata, key)\n return reported\n}\n\n/**\n * Map fascicle's Message[] to the AI SDK's ModelMessage[] shape.\n */\nexport function to_sdk_messages(messages: ReadonlyArray<Message>): ModelMessage[] {\n const out: ModelMessage[] = []\n for (const m of messages) {\n if (m.role === 'system') {\n out.push({ role: 'system', content: m.content })\n continue\n }\n if (m.role === 'user') {\n if (typeof m.content === 'string') {\n out.push({ role: 'user', content: m.content })\n } else {\n const parts: Array<\n | { type: 'text'; text: string }\n | { type: 'image'; image: string | Uint8Array; mediaType?: string }\n > = m.content.map((p) => {\n if (p.type === 'text') return { type: 'text', text: p.text }\n const image_part: { type: 'image'; image: string | Uint8Array; mediaType?: string } = {\n type: 'image',\n image: p.image,\n }\n if (p.media_type !== undefined) image_part.mediaType = p.media_type\n return image_part\n })\n out.push({ role: 'user', content: parts })\n }\n continue\n }\n if (m.role === 'tool') {\n out.push({\n role: 'tool',\n content: [\n {\n type: 'tool-result',\n toolCallId: m.tool_call_id,\n toolName: m.name,\n output: { type: 'text', value: m.content },\n },\n ],\n })\n continue\n }\n // assistant\n if (typeof m.content === 'string') {\n out.push({ role: 'assistant', content: m.content })\n continue\n }\n const parts = m.content.map((p) => {\n if (p.type === 'text') return { type: 'text' as const, text: p.text }\n return {\n type: 'tool-call' as const,\n toolCallId: p.id,\n toolName: p.name,\n input: p.input,\n }\n })\n out.push({ role: 'assistant', content: parts })\n }\n return out\n}\n\n/**\n * Hoist a leading run of system messages out of the SDK message list into the\n * AI SDK's top-level `system` option.\n *\n * Passing a `role: 'system'` entry inside `messages` makes the AI SDK treat it\n * as potentially attacker-controlled: it warns on every call (and newer `ai`\n * versions throw unless `allowSystemInMessages` is set). fascicle's system\n * content is the developer's own prompt, and the SDK's own recommendation is to\n * deliver it through the top-level `instructions` option (v7's rename of the\n * former `system` option), which removes the warning at its source rather than\n * suppressing it.\n *\n * Only the *leading* run is hoisted (fascicle's only shape: one or more system\n * messages, then the conversation). A system message that appears after a\n * non-system message keeps its position rather than being silently reordered to\n * the top, and the original list is returned untouched when hoisting would leave\n * `messages` empty, since the SDK rejects an empty messages array.\n */\nexport function split_leading_system(messages: ReadonlyArray<ModelMessage>): {\n system?: string\n messages: ModelMessage[]\n} {\n let run_end = 0\n const system_parts: string[] = []\n while (run_end < messages.length) {\n const m = messages[run_end]\n if (m?.role !== 'system') break\n system_parts.push(m.content)\n run_end += 1\n }\n const rest = messages.slice(run_end)\n if (system_parts.length === 0 || rest.length === 0) {\n return { messages: [...messages] }\n }\n return { system: system_parts.join('\\n\\n'), messages: rest }\n}\n\n/**\n * Map fascicle's Tool[] to the AI SDK's ToolSet.\n *\n * Returns undefined for an empty tool list so the caller can omit `tools`\n * from the call params entirely instead of passing an empty object.\n */\nexport function to_sdk_tools(tools: ReadonlyArray<Tool>): ToolSet | undefined {\n if (tools.length === 0) return undefined\n const entries: ToolSet = {}\n for (const t of tools) {\n entries[t.name] = ai_tool({\n description: t.description,\n inputSchema: t.input_schema,\n })\n }\n return entries\n}\n\n/**\n * Map one AI SDK stream part to the engine's StreamChunk shape, or undefined\n * for a part kind the engine does not model.\n */\nexport function map_stream_part_to_chunk(\n part: TextStreamPart<ToolSet>,\n step_index: number,\n): StreamChunk | undefined {\n switch (part.type) {\n case 'text-delta':\n return { kind: 'text', text: part.text, step_index }\n case 'reasoning-delta':\n return { kind: 'reasoning', text: part.text, step_index }\n case 'tool-input-start':\n return {\n kind: 'tool_call_start',\n id: part.id,\n name: part.toolName,\n step_index,\n }\n case 'tool-input-delta':\n return {\n kind: 'tool_call_input_delta',\n id: part.id,\n delta: part.delta,\n step_index,\n }\n case 'tool-call':\n return {\n kind: 'tool_call_end',\n id: part.toolCallId,\n input: part.input,\n step_index,\n }\n case 'finish-step':\n return {\n kind: 'step_finish',\n step_index,\n finish_reason: map_finish_reason(part.finishReason),\n usage: default_usage_from_sdk(part.usage),\n }\n default:\n // v7 parts with no engine StreamChunk kind (file, reasoning-file,\n // source, block framing) drop here on purpose: the engine models\n // text, reasoning, and tool traffic, not generated files.\n return undefined\n }\n}\n\n/**\n * Normalize a raw AI SDK usage object into UsageTotals for a streamed\n * step_finish chunk.\n */\nexport function default_usage_from_sdk(usage: unknown): UsageTotals {\n // Streamed step_finish chunks must carry the same cache/reasoning\n // granularity the step record gets via adapter.normalize_usage; every\n // built-in adapter routes through default_normalize_usage, so this keeps\n // the chunk surface consistent with the non-streamed result.\n return default_normalize_usage(to_raw_provider_usage(usage))\n}\n\n/**\n * Run one streamText call, dispatching StreamChunks as parts arrive and\n * accumulating them into a TurnResult once the stream completes.\n */\nasync function collect_stream(\n params: Parameters<typeof streamText>[0],\n step_index: number,\n dispatcher: ChunkDispatcher,\n on_first_chunk: () => void,\n internal_controller: AbortController,\n adapter: AiSdkProviderAdapter,\n): Promise<TurnResult> {\n const stream_result = streamText(params)\n let text = ''\n const tool_calls: RawToolCall[] = []\n let finish_reason: FinishReason = 'stop'\n let raw_usage: RawProviderUsage = {}\n let provider_reported: Record<string, unknown> | undefined\n let first = true\n\n for await (const part of stream_result.stream) {\n if (first) {\n first = false\n on_first_chunk()\n }\n if (part.type === 'text-delta') {\n text += part.text\n }\n if (part.type === 'tool-call') {\n tool_calls.push({\n id: part.toolCallId,\n name: part.toolName,\n input: part.input,\n })\n }\n if (part.type === 'finish-step') {\n finish_reason = map_finish_reason(part.finishReason)\n raw_usage = to_raw_provider_usage(part.usage)\n // The streamed finish-step carries the same providerMetadata generateText\n // returns on its result, which is what keeps a streamed run's\n // provider_reported identical to a plain run's.\n provider_reported = to_provider_reported(part.providerMetadata)\n }\n if (part.type === 'error') {\n throw part.error\n }\n if (part.type === 'abort') {\n throw new aborted_error('aborted', { step_index })\n }\n const chunk = map_stream_part_to_chunk(part, step_index)\n if (chunk === undefined) continue\n try {\n await dispatcher.dispatch(chunk)\n } catch (err: unknown) {\n internal_controller.abort()\n throw err\n }\n }\n\n return {\n text,\n tool_calls,\n finish_reason,\n usage: adapter.normalize_usage(raw_usage),\n // Stryker disable next-line ConditionalExpression: an always-true spread only adds an explicit `provider_reported: undefined` key, which every reader of TurnResult treats identically to the absent key.\n ...(provider_reported !== undefined ? { provider_reported } : {}),\n }\n}\n\n/**\n * Run one generateText call and map its result into a TurnResult, recovering\n * a schema-validation failure from the SDK via recover_no_object_generated\n * instead of letting it throw.\n */\nasync function collect_non_stream(\n params: Parameters<typeof generateText>[0],\n adapter: AiSdkProviderAdapter,\n): Promise<TurnResult> {\n let result: Awaited<ReturnType<typeof generateText>>\n try {\n result = await generateText(params)\n } catch (err: unknown) {\n const recovered = recover_no_object_generated(err, adapter)\n if (recovered !== undefined) return recovered\n throw err\n }\n const tool_calls: RawToolCall[] = []\n for (const tc of result.toolCalls) {\n tool_calls.push({\n id: tc.toolCallId,\n name: tc.toolName,\n input: tc.input,\n })\n }\n const raw_usage = to_raw_provider_usage(result.usage)\n // result.providerMetadata rather than result.finalStep.providerMetadata: the\n // two are the same value under stopWhen isStepCount(1), and the flat field\n // exists across the whole `ai` ^7 peer range this package declares.\n const provider_reported = to_provider_reported(result.providerMetadata)\n return {\n text: result.text,\n tool_calls,\n finish_reason: map_finish_reason(result.finishReason),\n usage: adapter.normalize_usage(raw_usage),\n // Stryker disable next-line ConditionalExpression: see collect_stream; the always-true spread is unobservable through every TurnResult reader.\n ...(provider_reported !== undefined ? { provider_reported } : {}),\n }\n}\n\n/**\n * When `output` (structured output) is in play, `generateText` eagerly parses the\n * model's text against the schema and throws `NoObjectGeneratedError` if it\n * does not conform. That parse is the SDK's, not fascicle's: turning it into a\n * thrown error would skip the engine's own schema-parse + repair loop (and the\n * error is not a retryable transient, so it would surface raw). Instead we\n * recover the model's raw text from the error and hand it back as a normal\n * turn result, so `parse_with_schema` re-validates it and the repair loop\n * engages exactly as it does for the prompt-based path. Returns undefined for\n * any other error so the caller rethrows.\n *\n * The recovered turn carries no provider_reported: the SDK's error exposes\n * text, usage, finishReason and response metadata, but not providerMetadata,\n * so there is nothing to read. The repair turn that follows reports normally.\n */\nfunction recover_no_object_generated(\n err: unknown,\n adapter: AiSdkProviderAdapter,\n): TurnResult | undefined {\n if (!NoObjectGeneratedError.isInstance(err)) return undefined\n const text_field = Reflect.get(err, 'text')\n const finish_field = Reflect.get(err, 'finishReason')\n const raw_usage = to_raw_provider_usage(Reflect.get(err, 'usage'))\n return {\n text: typeof text_field === 'string' ? text_field : '',\n tool_calls: [],\n finish_reason: map_finish_reason(typeof finish_field === 'string' ? finish_field : undefined),\n usage: adapter.normalize_usage(raw_usage),\n }\n}\n\ntype AiSdkCallParams = Parameters<typeof streamText>[0] & Parameters<typeof generateText>[0]\n\nexport type AiSdkTurnConfig = {\n readonly adapter: AiSdkProviderAdapter\n readonly model_id: string\n readonly dispatcher: ChunkDispatcher\n readonly tools: ReadonlyArray<Tool>\n readonly schema: ToolSchema | undefined\n readonly provider_options: Readonly<Record<string, Readonly<Record<string, unknown>>>> | undefined\n readonly temperature: number | undefined\n readonly max_tokens: number | undefined\n readonly top_p: number | undefined\n readonly telemetry: AiSdkTelemetrySettings | undefined\n}\n\nexport type AiSdkTurnArgs = {\n readonly step_index: number\n readonly messages: ReadonlyArray<Message>\n readonly abort: AbortSignal\n readonly stream: boolean\n readonly on_first_chunk: () => void\n}\n\nexport type AiSdkTurn = (args: AiSdkTurnArgs) => Promise<TurnResult>\n\n/**\n * Build the single-attempt SDK turn for one generate call: the\n * generateText/streamText call body behind the same neutral seam a native\n * adapter's invoke_turn implements. The built model is memoized across steps\n * of one generate call. No retry here: generate.ts wraps the returned turn in\n * the engine-owned retry_turn.\n */\nexport function create_ai_sdk_turn(cfg: AiSdkTurnConfig): AiSdkTurn {\n let model_instance: LanguageModel | undefined\n const get_model = async (): Promise<LanguageModel> => {\n if (model_instance === undefined) {\n const built = await cfg.adapter.build_model(cfg.model_id)\n // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n model_instance = built as LanguageModel\n }\n return model_instance\n }\n\n // Telemetry is resolved once per generate call and memoized across its steps,\n // mirroring get_model. build_ai_sdk_telemetry returns undefined immediately\n // (no peer load) unless telemetry is explicitly enabled, so the disabled\n // default costs nothing.\n let telemetry_options: AiSdkTelemetryPassthrough | undefined\n let telemetry_resolved = false\n const get_telemetry = async (): Promise<AiSdkTelemetryPassthrough | undefined> => {\n if (!telemetry_resolved) {\n telemetry_options = await build_ai_sdk_telemetry(cfg.telemetry)\n telemetry_resolved = true\n }\n return telemetry_options\n }\n\n const sdk_tools = to_sdk_tools(cfg.tools)\n\n // Native structured output: when a schema is requested and the provider\n // constrains decoding to it (the 'structured_output' capability), route\n // through the AI SDK's Output.object seam so the schema becomes the\n // provider's responseFormat (e.g. Ollama's `format`) instead of a\n // prompt-for-JSON-then-scrape. Gated on no tools: forcing a JSON\n // responseFormat alongside tool calls breaks tool dispatch on most\n // providers, so tool runs keep the prompt-based schema path. The engine's\n // schema parse + repair loop still owns validation either way. This seam\n // is ai_sdk-only: a native adapter that constrains decoding honors\n // TurnRequest.schema inside its own invoke_turn.\n let output_spec: NonNullable<AiSdkCallParams['output']> | undefined\n if (\n cfg.schema !== undefined &&\n cfg.tools.length === 0 &&\n cfg.adapter.supports('structured_output')\n ) {\n // Output.object<T> is not structurally assignable to the SDK's default\n // Output<string, string> param slot, but the runtime shape is exactly\n // what generateText/streamText consume to set responseFormat.\n // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n output_spec = Output.object({ schema: cfg.schema }) as NonNullable<\n AiSdkCallParams['output']\n >\n }\n\n // provider_options is Record<string, Record<string, unknown>>; the SDK\n // expects SharedV3ProviderOptions (Record<string, JSONObject>) which is\n // structurally compatible for our usage.\n // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n const provider_options = cfg.provider_options as AiSdkCallParams['providerOptions']\n\n return async (args: AiSdkTurnArgs): Promise<TurnResult> => {\n const model = await get_model()\n const telemetry = await get_telemetry()\n const internal_controller = new AbortController()\n const cancel_on_user_abort = (): void => {\n internal_controller.abort(args.abort.reason)\n }\n if (args.abort.aborted) {\n internal_controller.abort(args.abort.reason)\n } else {\n args.abort.addEventListener('abort', cancel_on_user_abort, { once: true })\n }\n const { system: hoisted_system, messages: sdk_messages } = split_leading_system(\n to_sdk_messages(args.messages),\n )\n const base_params: AiSdkCallParams = {\n model,\n messages: sdk_messages,\n abortSignal: internal_controller.signal,\n stopWhen: isStepCount(1),\n // The engine owns retry via retry_turn in generate.ts; disable the AI\n // SDK's own retry (default 2) so it does not nest inside each of our\n // attempts and inflate provider round-trips / distort backoff.\n maxRetries: 0,\n }\n if (hoisted_system !== undefined) base_params.instructions = hoisted_system\n if (sdk_tools !== undefined) base_params.tools = sdk_tools\n if (output_spec !== undefined) base_params.output = output_spec\n if (provider_options !== undefined) base_params.providerOptions = provider_options\n if (cfg.temperature !== undefined) base_params.temperature = cfg.temperature\n if (cfg.max_tokens !== undefined) base_params.maxOutputTokens = cfg.max_tokens\n if (cfg.top_p !== undefined) base_params.topP = cfg.top_p\n if (telemetry !== undefined) {\n // AiSdkTelemetryPassthrough uses the SDK's own telemetry keys; the slot's\n // generic (RUNTIME_CONTEXT/TOOLS) is erased for our usage.\n // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n base_params.experimental_telemetry = telemetry as NonNullable<\n AiSdkCallParams['experimental_telemetry']\n >\n }\n\n try {\n if (args.stream) {\n return await collect_stream(\n base_params,\n args.step_index,\n cfg.dispatcher,\n args.on_first_chunk,\n internal_controller,\n cfg.adapter,\n )\n }\n return await collect_non_stream(base_params, cfg.adapter)\n } finally {\n args.abort.removeEventListener('abort', cancel_on_user_abort)\n }\n }\n}\n"],"mappings":"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"}
@@ -1 +0,0 @@
1
- {"version":3,"file":"types-kO1JoGNZ.js","names":[],"sources":["../src/engine/errors.ts","../src/engine/providers/types.ts"],"sourcesContent":["/**\n * Typed errors for the AI engine layer.\n *\n * This is the only source file in the engine module permitted to use the\n * `class` keyword. `Error` is a built-in and `instanceof` branching is how\n * the retry helper and composition-layer composers distinguish failure modes.\n * Every other engine file stays class-free.\n *\n * `aborted_error` is defined in the core module and re-exported here so that\n * `instanceof aborted_error` is true regardless of which layer surfaced it.\n * This is the one value-level import from core permitted in engine source;\n * see the ignores in `rules/no-core-value-import-in-engine.yml`.\n */\n\nimport type { SchemaIssue } from '#schema'\nimport type { FinishReason } from './types.js'\n\nexport { aborted_error } from '#core'\n\nexport class rate_limit_error extends Error {\n readonly kind = 'rate_limit_error' as const;\n readonly retry_after_ms: number | undefined;\n readonly attempts: number;\n readonly status: number | undefined;\n constructor(\n message: string,\n metadata: { retry_after_ms?: number; attempts?: number; status?: number } = {},\n ) {\n super(message)\n this.name = 'rate_limit_error'\n this.retry_after_ms = metadata.retry_after_ms\n this.attempts = metadata.attempts ?? 0\n this.status = metadata.status\n }\n}\n\nexport class provider_error extends Error {\n readonly kind = 'provider_error' as const;\n readonly status: number | undefined;\n readonly body: string | undefined;\n readonly cause_kind: 'provider_5xx' | 'network' | 'unknown' | undefined;\n constructor(\n message: string,\n metadata: {\n status?: number\n body?: string\n cause_kind?: 'provider_5xx' | 'network' | 'unknown'\n } = {},\n ) {\n super(message)\n this.name = 'provider_error'\n this.status = metadata.status\n this.body = metadata.body\n this.cause_kind = metadata.cause_kind\n }\n}\n\n/**\n * Turn-timeout expiry. Thrown by the engine-owned retry_turn wrapper when a\n * single invoke_turn exceeds `turn_timeout_ms` before any chunk streamed.\n * Its `kind` is the RetryFailureKind wire value `'timeout'` (not the class\n * name) on purpose: that is the discriminant classify_retryable /\n * classify_provider_error already key on, so the shared classifier treats an\n * expiry as retryable without any timeout-specific branch. A mid-stream\n * expiry never reaches here; retry_turn converts it to a non-retryable\n * stream interruption first.\n */\nexport class turn_timeout_error extends Error {\n // classify_retryable reads this off an `unknown` via read_string(err, 'kind'),\n // a dynamic access no static analysis can resolve back to this field.\n // fallow-ignore-next-line unused-class-member\n readonly kind = 'timeout' as const;\n readonly timeout_ms: number;\n readonly step_index: number | undefined;\n constructor(timeout_ms: number, step_index?: number) {\n super(`turn exceeded turn_timeout_ms budget of ${timeout_ms}ms`)\n this.name = 'turn_timeout_error'\n this.timeout_ms = timeout_ms\n this.step_index = step_index\n }\n}\n\nexport class schema_validation_error extends Error {\n // Part of the published discriminant surface: consumers switch on `kind`\n // outside this repo, so the field has no in-repo production reader.\n // fallow-ignore-next-line unused-class-member\n readonly kind = 'schema_validation_error' as const;\n readonly schema_issues: ReadonlyArray<SchemaIssue>;\n readonly raw_text: string;\n constructor(message: string, schema_issues: ReadonlyArray<SchemaIssue>, raw_text: string) {\n super(message)\n this.name = 'schema_validation_error'\n this.schema_issues = schema_issues\n this.raw_text = raw_text\n }\n}\n\nexport class tool_error extends Error {\n readonly kind = 'tool_error' as const;\n readonly tool_name: string;\n readonly tool_call_id: string;\n override readonly cause: unknown;\n constructor(\n message: string,\n metadata: { tool_name: string; tool_call_id: string; cause: unknown },\n ) {\n super(message)\n this.name = 'tool_error'\n this.tool_name = metadata.tool_name\n this.tool_call_id = metadata.tool_call_id\n this.cause = metadata.cause\n }\n}\n\nexport class tool_approval_denied_error extends Error {\n readonly kind = 'tool_approval_denied_error' as const;\n readonly tool_name: string;\n readonly step_index: number;\n readonly tool_call_id: string;\n constructor(\n message: string,\n metadata: { tool_name: string; step_index: number; tool_call_id: string },\n ) {\n super(message)\n this.name = 'tool_approval_denied_error'\n this.tool_name = metadata.tool_name\n this.step_index = metadata.step_index\n this.tool_call_id = metadata.tool_call_id\n }\n}\n\nexport class model_required_error extends Error {\n readonly kind = 'model_required_error' as const;\n constructor(\n message = 'no model specified: pass `model` to generate() or set `defaults.model` on the engine',\n ) {\n super(message)\n this.name = 'model_required_error'\n }\n}\n\nexport class provider_not_configured_error extends Error {\n readonly kind = 'provider_not_configured_error' as const;\n readonly provider: string;\n constructor(provider: string) {\n super(`provider '${provider}' is not configured on this engine`)\n this.name = 'provider_not_configured_error'\n this.provider = provider\n }\n}\n\nexport class engine_config_error extends Error {\n readonly kind = 'engine_config_error' as const;\n readonly provider: string | undefined;\n constructor(message: string, provider?: string) {\n super(message)\n this.name = 'engine_config_error'\n this.provider = provider\n }\n}\n\nexport class on_chunk_error extends Error {\n readonly kind = 'on_chunk_error' as const;\n override readonly cause: unknown;\n constructor(message: string, cause: unknown) {\n super(message)\n this.name = 'on_chunk_error'\n this.cause = cause\n }\n}\n\nexport class provider_capability_error extends Error {\n readonly kind = 'provider_capability_error' as const;\n readonly provider: string;\n readonly capability: string;\n constructor(provider: string, capability: string, detail?: string) {\n const suffix = detail !== undefined ? `: ${detail}` : ''\n super(`provider '${provider}' does not support '${capability}'${suffix}`)\n this.name = 'provider_capability_error'\n this.provider = provider\n this.capability = capability\n }\n}\n\nexport class engine_disposed_error extends Error {\n readonly kind = 'engine_disposed_error' as const;\n constructor(message = 'engine has been disposed; further calls are not permitted') {\n super(message)\n this.name = 'engine_disposed_error'\n }\n}\n\nexport type ClaudeCliErrorReason =\n | 'binary_not_found'\n | 'auth_missing'\n | 'auth_expired'\n | 'api_key_missing'\n | 'startup_timeout'\n | 'stall_timeout'\n | 'no_result_event'\n | 'result_error'\n | 'subprocess_exit'\n | 'sandbox_unavailable'\n | 'engine_disposed'\n | 'parse_error'\n\nexport class claude_cli_error extends Error {\n readonly kind = 'claude_cli_error' as const;\n readonly reason: ClaudeCliErrorReason;\n readonly status: number | undefined;\n readonly stderr_snippet: string | undefined;\n constructor(\n reason: ClaudeCliErrorReason,\n message: string,\n metadata: { status?: number; stderr_snippet?: string } = {},\n ) {\n super(message)\n this.name = 'claude_cli_error'\n this.reason = reason\n this.status = metadata.status\n this.stderr_snippet = metadata.stderr_snippet\n }\n}\n\nexport class provider_auth_error extends Error {\n readonly kind = 'provider_auth_error' as const;\n readonly provider: string;\n readonly refresh_command: string | undefined;\n constructor(\n provider: string,\n message: string,\n metadata: { refresh_command?: string } = {},\n ) {\n super(message)\n this.name = 'provider_auth_error'\n this.provider = provider\n this.refresh_command = metadata.refresh_command\n }\n}\n\n/**\n * A generate call that set a schema finished for a reason other than 'stop'\n * (content_filter, length, max_steps, tool_calls), so no schema-validated\n * value exists and validation was never attempted. Carries the raw model text\n * and the last provider-reported payload, so a guardrail trace or other\n * block detail stays reachable from the catch. Distinct from\n * schema_validation_error, which covers a response that completed normally\n * and then failed validation after its repair attempts ran out.\n */\nexport class incomplete_generation_error extends Error {\n readonly kind = 'incomplete_generation_error' as const;\n readonly finish_reason: FinishReason;\n readonly raw_text: string;\n readonly provider_reported: Record<string, unknown> | undefined;\n constructor(\n finish_reason: FinishReason,\n raw_text: string,\n provider_reported?: Record<string, unknown>,\n ) {\n super(\n `generation finished with '${finish_reason}' before a schema-validated response was produced`,\n )\n this.name = 'incomplete_generation_error'\n this.finish_reason = finish_reason\n this.raw_text = raw_text\n this.provider_reported = provider_reported\n }\n}\n","/**\n * Shared provider-adapter shape.\n *\n * Each file under src/engine/providers/ exports a factory that accepts a\n * ProviderInit shape and returns a ProviderAdapter. Factories are\n * synchronous; build_model is async so SDK loading is deferred until a model\n * is actually needed. Missing peer dependencies surface as engine_config_error\n * on first build_model call with a clear message naming the missing peer.\n *\n * Only the ai_sdk transport module (providers/ai_sdk/invoke.ts) may import\n * from `ai` or invoke generateText/streamText. ai_sdk adapters build the\n * provider model and translate parameters; they do not orchestrate the call.\n */\n\nimport type {\n ResolvedModel,\n EffortLevel,\n GenerateOptions,\n GenerateResult,\n ProviderInit,\n TurnRequest,\n TurnResult,\n UsageTotals,\n} from '../types.js'\nimport { engine_config_error } from '../errors.js'\n\n/**\n * Which backend a provider factory returns: 'ai_sdk' wraps the Vercel AI SDK\n * provider package, 'native' talks to the provider's HTTP API directly. The\n * provider name stays the same across transports so pricing keys and usage\n * fields carry over; only the wire implementation changes.\n */\nexport type ProviderTransport = 'ai_sdk' | 'native'\n\n/**\n * Read the `transport` selector off a provider init. Defaults to 'ai_sdk';\n * anything but the two known backends throws at construction so a typo\n * fails loud instead of silently running the default.\n */\nexport function resolve_transport(\n init: ProviderInit,\n provider: string,\n): ProviderTransport {\n const raw = init['transport']\n if (raw === undefined || raw === 'ai_sdk') return 'ai_sdk'\n if (raw === 'native') return 'native'\n throw new engine_config_error(\n `${provider} provider: transport must be 'ai_sdk' or 'native', got ${JSON.stringify(raw)}`,\n provider,\n )\n}\n\nexport type EffortTranslation = {\n // Outer keys are provider names, inner records hold per-provider settings,\n // matching the two-level shape merge_provider_options expects.\n provider_options: Record<string, Record<string, unknown>>\n effort_ignored: boolean\n}\n\nexport type ProviderCapability =\n | 'text'\n | 'tools'\n | 'schema'\n | 'streaming'\n | 'image_input'\n | 'reasoning'\n // Provider performs native constrained decoding (the AI SDK responseFormat /\n // Output.object path), as opposed to the prompt-for-JSON-then-extract path.\n // Distinct from 'schema': every provider can satisfy a schema via repair, but\n // only some constrain the decode to it.\n | 'structured_output'\n\nexport type RawProviderUsage = {\n input_tokens?: number\n output_tokens?: number\n reasoning_tokens?: number\n cached_input_tokens?: number\n cache_write_tokens?: number\n // Vercel AI SDK v6 also surfaces details via *Details containers; adapters\n // accept the flattened shape above for testability.\n input_token_details?: {\n cached_tokens?: number\n cache_creation_input_tokens?: number\n }\n output_token_details?: {\n reasoning_tokens?: number\n }\n [k: string]: unknown\n}\n\nexport type AiSdkProviderAdapter = {\n readonly kind: 'ai_sdk'\n readonly name: string\n readonly build_model: (model_id: string) => Promise<unknown>\n readonly translate_effort: (effort: EffortLevel) => EffortTranslation\n readonly normalize_usage: (raw: RawProviderUsage | undefined) => UsageTotals\n readonly supports: (capability: ProviderCapability) => boolean\n}\n\n/**\n * Raw-HTTP transport: implements a single turn against a provider's own\n * API with zero `ai` / `@ai-sdk/*` in its module graph. generate.ts wraps\n * invoke_turn in retry + classification + abort, so a native adapter owns only\n * request/response mapping (and streaming via TurnRequest.dispatch_chunk); it\n * MUST NOT implement its own retry. classify_error optionally overrides the\n * shared classifier; dispose is optional (keep-alive agents, connection pools).\n */\nexport type NativeProviderAdapter = {\n readonly kind: 'native'\n readonly name: string\n readonly invoke_turn: (req: TurnRequest) => Promise<TurnResult>\n readonly supports: (capability: ProviderCapability) => boolean\n readonly dispose?: () => Promise<void>\n readonly classify_error?: (err: unknown) => unknown\n}\n\nexport type ExternalAgentAdapter = {\n readonly kind: 'external'\n readonly name: string\n readonly generate: <t>(\n opts: GenerateOptions<t>,\n resolved: ResolvedModel,\n ) => Promise<GenerateResult<t>>\n readonly dispose: () => Promise<void>\n readonly supports: (capability: ProviderCapability) => boolean\n}\n\nexport type ProviderAdapter =\n | AiSdkProviderAdapter\n | NativeProviderAdapter\n | ExternalAgentAdapter\n\nexport type ProviderFactory = (init: ProviderInit) => ProviderAdapter\n\n/**\n * Map raw provider usage to UsageTotals, the mapper most adapters share.\n *\n * Missing usage zeroes the totals. Optional fields (reasoning and cache\n * tokens) are set only when the raw payload carries them, reading the\n * flattened field first and the AI SDK's *_details container second.\n */\nexport function default_normalize_usage(\n raw: RawProviderUsage | undefined,\n): UsageTotals {\n if (raw === undefined) return { input_tokens: 0, output_tokens: 0 }\n const input_tokens = typeof raw.input_tokens === 'number' ? raw.input_tokens : 0\n const output_tokens = typeof raw.output_tokens === 'number' ? raw.output_tokens : 0\n const totals: UsageTotals = { input_tokens, output_tokens }\n if (typeof raw.reasoning_tokens === 'number') totals.reasoning_tokens = raw.reasoning_tokens\n else if (typeof raw.output_token_details?.reasoning_tokens === 'number') {\n totals.reasoning_tokens = raw.output_token_details.reasoning_tokens\n }\n if (typeof raw.cached_input_tokens === 'number') totals.cached_input_tokens = raw.cached_input_tokens\n else if (typeof raw.input_token_details?.cached_tokens === 'number') {\n totals.cached_input_tokens = raw.input_token_details.cached_tokens\n }\n if (typeof raw.cache_write_tokens === 'number') totals.cache_write_tokens = raw.cache_write_tokens\n else if (typeof raw.input_token_details?.cache_creation_input_tokens === 'number') {\n totals.cache_write_tokens = raw.input_token_details.cache_creation_input_tokens\n }\n return totals\n}\n\n/**\n * Build the standard missing-peer error: names the package and the install\n * command so a missing peer is diagnosable from the message alone. Shared so\n * every optional-peer failure reads identically, whether the failing\n * `import()` names the peer directly (load_optional_peer below) or a local\n * module that reaches the peer through its own static import (the ai_sdk\n * turn seam in generate.ts, whose dynamic import must stay written in\n * generate.ts for its relative specifier to resolve correctly).\n */\nexport function missing_peer_error(peer_name: string, cause: unknown): Error {\n const detail = cause instanceof Error ? cause.message : JSON.stringify(cause)\n const message =\n `missing peer dependency '${peer_name}'. Install it with: pnpm add ${peer_name}. Cause: ${detail}`\n return new Error(message, { cause })\n}\n\n/**\n * Dynamically import an optional peer dependency, rethrowing an import\n * failure via missing_peer_error so a missing peer is diagnosable from the\n * message alone.\n */\nexport async function load_optional_peer<t>(\n specifier: string,\n): Promise<t> {\n let mod: unknown\n try {\n mod = await import(specifier)\n } catch (err: unknown) {\n throw missing_peer_error(specifier, err)\n }\n // eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion\n return mod as t\n}\n"],"mappings":"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"}