@yolk-sdk/vercel-workflows 0.1.0-canary.100

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yolk SDK contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,340 @@
+# @yolk-sdk/vercel-workflows
+
+Vercel Workflow agent-loop contracts, durable stream helpers, and an Effect-native Workflow client/layer.
+
+## Install
+
+```bash
+pnpm add @yolk-sdk/vercel-workflows@canary effect@4.0.0 workflow@^5.0.0-beta.42
+```
+
+Canary APIs are unstable. Keep all `@yolk-sdk/*` packages on the same version.
+Use the SDK's matching Effect version (`4.0.0`) in host code.
+Requires Node.js 22+ and a server runtime supported by Vercel Workflow.
+
+Requires `workflow@^5.0.0-beta.42`. The 5.x line region-pins Vercel runs so durable streams are
+served from the deployment's own region; the 4.x backend was `iad1`-only, which made deployed
+streaming from other regions arrive in multi-second bursts. Host apps must resolve a single
+`workflow` instance shared with this package.
+
+## Subpaths
+
+| Subpath                               | Purpose                                                 |
+| ------------------------------------- | ------------------------------------------------------- |
+| `@yolk-sdk/vercel-workflows`          | Workflow-safe agent loop orchestration APIs             |
+| `@yolk-sdk/vercel-workflows/workflow` | Explicit equivalent subpath                             |
+| `@yolk-sdk/vercel-workflows/effect`   | Effect-native wrapper around public `workflow/api` APIs |
+| `@yolk-sdk/vercel-workflows/testing`  | `TestWorkflowWorld` behavioral platform emulator        |
+
+## Imports
+
+Import Workflow APIs from the package root:
+
+```ts
+import {
+  commitThenWriteTerminalEvent,
+  makeDurableAgentEventSequencerState,
+  noWorkflowStepRetry,
+  runVercelAgentWorkflow,
+  VercelAgentWorkflowRunResult,
+  WorkflowStepResult,
+  writeDurableAgentEvent
+} from '@yolk-sdk/vercel-workflows'
+```
+
+The `./workflow` subpath is also exported for explicit imports.
+
+Use `./effect` at host boundaries that start, replay, resume, or cancel Workflow runs. This is a
+host-wiring sketch; `runAgentWorkflow`, `request`, and `context` are host-owned values:
+
+```ts
+import { Effect } from 'effect'
+import { VercelWorkflows } from '@yolk-sdk/vercel-workflows/effect'
+
+const program = Effect.gen(function* () {
+  const workflows = yield* VercelWorkflows
+  const run = yield* workflows.start(runAgentWorkflow, [{ request, context }])
+
+  return yield* run.getReadable<Uint8Array>()
+}).pipe(Effect.provide(VercelWorkflows.layer))
+```
+
+The API wrapper keeps Vercel's SDK underneath. It does not reimplement Vercel backend HTTP,
+queues, hooks, or stream storage.
+
+## Test Workflow behavior
+
+`@yolk-sdk/vercel-workflows/testing` provides `TestWorkflowWorld`, a behavioral emulator for host
+tests. It covers run lifecycle, append-only streams with close-once conflicts, step retries and
+attempt metadata, hooks/resume, cancellation, and the SDK seam used by
+`VercelWorkflows.layerFromSdk`. Ambient module mocks do not apply retry policy by themselves: wrap
+host step callbacks with `world.step(...)` or call `world.runStep(...)` explicitly when the test
+must exercise platform retry attempts and `getStepMetadata().attempt`.
+
+Mock the ambient `workflow` module so production orchestration runs against the active test world:
+
+```ts
+import { vi } from 'vitest'
+import { TestWorkflowWorld } from '@yolk-sdk/vercel-workflows/testing'
+
+vi.mock('workflow', async () => {
+  const { testWorkflowModule } = await import('@yolk-sdk/vercel-workflows/testing')
+  return testWorkflowModule
+})
+
+const world = new TestWorkflowWorld()
+```
+
+Tests whose import graph reaches `workflow` must use Vitest's Node environment, not jsdom, because
+Workflow 5 captures Node `URL` intrinsics at import time. Hosts should test their own `'use workflow'`
+and `'use step'` directive files with `@workflow/vitest` in addition to using the emulator.
+
+## Runtime model
+
+`runVercelAgentWorkflow` coordinates host-provided callbacks:
+
+- model step: produce model events/tool calls
+- no-tool continuation: when a model step returns `done: false` with no tool calls, continue
+  directly to the next model step without invoking the tool-batch callback
+- tool batch step: execute requested tools
+- tool batch result: return one ordered tool-result message per host call, including failed `isError` results
+- partial tool-step failure: return wire-safe `failure`, cumulative `usage`, and `eventSequence` when
+  completed sibling tools must remain observable
+- awaiting-input state: carry pending HITL hook data, wait through `awaitInput`, then rerun the
+  same tool batch with accumulated responses
+- close step: flush/close output stream after a successful final model step
+- terminal status: completed, step failure, await-input failure, close failure, or max turns exceeded
+
+`WorkflowStepResult` and `VercelAgentWorkflowRunResult` are `Data.taggedEnum` **values** (plain objects,
+`_tag` last), re-exported from the package root and `./workflow`. `settleWorkflowStep` returns
+`WorkflowStepResult.Success({ value })` / `.Failure({ error })`. Inspect run status with constructors
+or `VercelAgentWorkflowRunResult.$is('Completed')` rather than handwritten `{ _tag }` objects.
+
+Continuation state stays plain serializable data for Workflow persistence.
+
+## Minimal workflow wrapper
+
+Host apps keep concrete Workflow directives local and pass them into the package loop. The callback
+names below are host-owned `'use step'` functions:
+
+```ts
+import { createHook } from 'workflow'
+import { runVercelAgentWorkflow } from '@yolk-sdk/vercel-workflows'
+
+export async function runAgentWorkflow(input: { request: unknown; context: unknown }) {
+  'use workflow'
+
+  return await runVercelAgentWorkflow({
+    input,
+    runModelStep,
+    runToolBatchStep,
+    closeStream,
+    writeError,
+    awaitInput: async awaitingInput => {
+      using hook = createHook<unknown>({ token: awaitingInput.hookToken })
+
+      return await hook
+    }
+  })
+}
+```
+
+`runModelStep`, `closeStream`, and `writeError` are host-owned `'use step'` functions.
+`runToolBatchStep` may instead be Workflow orchestration calling concrete per-call steps. Keep provider calls, tools, persistence, telemetry, and Effect runtimes in
+those steps, not in the `'use workflow'` orchestration body.
+
+## Tool steps are at-least-once
+
+Vercel's queue delivers steps at least once. A tool-batch step can run again after a crash and,
+in practice, concurrently with a first execution that is still running, even with
+`noWorkflowStepRetry`. Retry policy cannot prevent duplicate writes; a durable tool ledger can.
+This package does not build tool sets or call `runToolBatch` (your step does), so wire the ledger
+where you resolve tools inside the step:
+
+```ts
+// Inside the host's tool-batch 'use step' function.
+const resolveStepTools = Effect.gen(function* () {
+  return yield* resolveTools(modules, context, {
+    ledger: { store: makeRunToolLedger(workflowRunId), deadline: () => stepDeadlineMs }
+  })
+})
+```
+
+`resolveTools` and `ToolLedgerStore` come from `@yolk-sdk/agent/tools` (install
+`@yolk-sdk/agent@canary` in the host; this package does not depend on it); `makeRunToolLedger` is
+your durable store (for example Postgres) scoped to the Workflow run. Ledgered calls (by default every
+non-`read` tool plus the built-in `subagent` tool, including code mode scripts and their nested
+writes) then return their recorded result, wait for the running execution, or report that an
+abandoned call may already have been applied; they never run twice under the same ledger key.
+Add custom delegation tools with `isLedgered`. Input and interaction tools are never ledgered (they
+rely on the host's `InteractionHost` receipts). Read calls still re-run, and after an in-flight
+timeout the model may retry under a new call id. An in-memory store does not protect steps.
+`deadline` bounds only waiting for a duplicate: recording a call's outcome can take up to about
+15 s after the call returns, so leave that time before the function budget ends, and keep store
+operations interruptible (the ledger's timeouts cannot cut uninterruptible store work).
+
+## Independent children
+
+`orchestrateWorkflowToolBatch` runs a full-batch `preflight` before any `execute` callback,
+limits local concurrency, and returns results in original call order. Both callbacks are host
+seams: perform IO in steps, not in the orchestration helper. The host commits exactly one tool
+result per call. Return a pause value from preflight when any HITL request is pending.
+If an execution rejects, the helper stops dispatching new calls, settles already-active siblings,
+and returns their ordered progress plus `failures`. Hosts must propagate those failures while
+retaining completed results and usage; do not treat a partial batch as successful.
+
+Start child workflows with Workflow 5 `start(childWorkflow, args)` **from orchestration**, not
+inside the parent tool step. A child wrapper runs its own model/tool steps and returns a typed
+application outcome; platform `completed` alone does not prove application success. Foreground
+hosts await that child outcome; background hosts return an accepted handle and continue.
+
+`awaitWorkflowChild({ read, sleep })` polls short durable read steps with a host-provided Workflow
+`sleep` between reads. Both callbacks receive the same zero-based attempt index, so hosts can
+apply capped backoff and end an observation after a bounded number of reads. At that ceiling,
+`read` should return `{ done: true, value: stillRunningObservation }`; this ends polling, not the
+child lifecycle. Preserve an owned handle for eventual result lookup. Existing zero-argument
+callbacks remain supported and the helper has no implicit budget. Hosts must explicitly bound
+long waits to avoid unbounded durable event accumulation. Do not hold a step open awaiting a long
+`run.returnValue` poll.
+
+Hosts own immutable logical reservations, admission/CAS, ownership checks, storage, bounded
+fanout, safe errors, credentials, and cancellation policy. Parent completion/failure must not
+implicitly cancel independent children. Explicit Stop should persist a durable tombstone before
+sweeping admitted child ids, reject late admission, and expose partial sweep failures for retry.
+Give each independent stream and parallel call its own deterministic event-id namespace.
+
+## Awaiting input
+
+When a tool batch needs HITL input, return `awaitingInput` from `runToolBatchStep`. The package
+loop will:
+
+1. pass that payload to `awaitInput`
+2. wait for the hook/webhook response
+3. rerun the same tool batch with the accumulated responses in a fresh `hitlResponses` array
+
+The loop owns its accumulator: host mutation of a supplied array cannot affect a later batch.
+Response order and element identity are preserved; response objects are not deep-cloned.
+
+The host owns `hookToken` construction, auth, resume routes, and response decoding. Use stable
+tokens that the resume side can reconstruct or store.
+
+## Retry policy
+
+Default retry policy is `noWorkflowStepRetry` (`maxAttempts: 1`). Retries are opt-in because
+streamed retries can duplicate chunks unless host/client de-dupe is ready.
+Finite `maxAttempts` values are floored and clamped to at least one; non-finite values normalize to
+one. Retries have no built-in backoff.
+
+One attempt does not stop queue redelivery: a step can still run again after a crash or
+concurrently. See [Tool steps are at-least-once](#tool-steps-are-at-least-once).
+
+`maxTurns` follows the same positive-integer boundary: finite values are floored and clamped to at
+least one. Omitted or non-finite values use `defaultMaxWorkflowTurns`.
+
+## Durable stream events
+
+Workflow streams can replay old chunks after retries or reconnects. Durable streams should emit an
+`eventId` on every JSON-serializable event, typically `AgentEvent`, including errors. Clients should
+track seen ids.
+
+Use `writeDurableAgentEvent` to assign deterministic ids and write NDJSON. The following is an
+`Effect.gen` fragment; `writer`, `event`, `runId`, `turn`, and `eventSequence` are host-owned:
+
+```ts
+const state = makeDurableAgentEventSequencerState(eventSequence)
+const sequenced =
+  yield *
+  writeDurableAgentEvent({
+    writer,
+    event,
+    streamId: `workflow:${runId}`,
+    turn,
+    state
+  })
+
+eventSequence = sequenced.nextEventSequence
+```
+
+The id format is `${streamId}:${turn}:${eventSequence}`. Scope `streamId` to one logical durable
+run (for example `workflow:${runId}`), not just one route or feature. Replay-safe clients de-dupe by
+`eventId`; reusing a stream id across independent runs can make a follow-up run's live deltas look
+like old replayed events. Keep `eventSequence` in Workflow state and reset it when starting a fresh
+logical stream. Resume route reads should use `startIndex` when available. Host apps still own
+active-run locking, stale-run guards, and cancellation behavior.
+
+## Terminal barriers
+
+For durable host streams, protocol terminal events are commit barriers. Emit live/progress events
+first, commit canonical host state, then write the event.
+
+“Terminal” in `isTerminalAgentEvent` means a logical client-consumption boundary, not necessarily a
+final Workflow state. Final callback ownership is:
+
+```txt
+AgentEnd: durable completion commit -> AgentEnd -> closeStream
+AgentError: failure commit/mapping -> AgentError -> writeError-owned close
+```
+
+`AgentAwaitingInput` is terminal for the current client consumption window but resumable for the
+Workflow run. Persist pending HITL state and write it without finalizing the durable stream solely
+because `isTerminalAgentEvent` returns true:
+
+```txt
+persist pending HITL -> AgentAwaitingInput -> release writer lock (do not close) -> await hook -> continue
+```
+
+This lets clients stop consuming at a protocol-terminal event and immediately revalidate or reconnect
+from durable state. Hosts that emit terminal events before persistence should not rely on
+`streamAgentEventStreamUntilTerminal()` as a durable-settled signal.
+
+Use `commitThenWriteTerminalEvent` when a step must commit host state before writing its terminal
+event. This is an `Effect.gen` fragment whose terminal, persistence, writer, and stream values come
+from the host:
+
+```ts
+const result =
+  yield *
+  commitThenWriteTerminalEvent({
+    terminal,
+    commit: persistState,
+    write: event => writeDurableAgentEvent({ writer, event, streamId, turn, state }),
+    writeCommitError: error =>
+      writeDurableAgentEvent({ writer, event: commitErrorEvent(error), streamId, turn, state })
+  })
+```
+
+The helper never writes the success terminal before `commit` succeeds. If `commit` fails, it writes
+the host-provided terminal error event instead. It can protect either a final event or an
+`AgentAwaitingInput` persistence barrier; it never decides closure from `_tag` and never closes
+writers.
+
+`writeCommitError` receives the existing `CommitError` generic from `commit`
+(`Effect.Effect<void, CommitError>`), via `Effect.matchEffect` `onFailure`. Typed failures—not
+defects or interruptions—are passed to that callback. Result `commitError` and `error` fields stay
+`unknown`.
+Existing `(error: unknown) => …` callbacks remain assignable.
+
+`runVercelAgentWorkflow` calls `closeStream` only after `runModelStep` returns `done: true`. On model,
+tool, await-input, or max-turn failure it calls `writeError` best-effort and returns without calling
+`closeStream`; `writeError` must write a safe run-final error and attempt to close that failure path.
+Never close on resumable `AgentAwaitingInput`.
+
+## Host responsibilities
+
+- Own Next/Vercel routes, auth, providers, tools, persistence, and telemetry.
+- Encode/decode app transcript/session state into serializable Workflow inputs.
+- Preserve tool result order and never advance the next model step with dangling host tool calls.
+- Decide cancellation/resume/conflict UX.
+- Own hook tokens and response validation for HITL resume.
+- Emit replay-safe event ids for durable streams; scope stream ids per independent run and de-dupe
+  by `eventId` client-side.
+- Write durable terminal events only after host persistence has settled.
+- Implement `closeStream` for successful final closure and `writeError` for safe final error write
+  plus failure closure. Release, but do not close, the writer after `AgentAwaitingInput`.
+- Test host-owned Workflow directive files with `@workflow/vitest`; use the `./testing` emulator for
+  platform behavior in host tests.
+
+## Boundaries
+
+- No Next routes, server actions, auth, app tools, DB, UI, or provider SDKs.
+- Effect may run inside host/package step callbacks; workflow orchestration keeps plain data contracts.

package/dist/effect.d.mts

@@ -0,0 +1,56 @@
+import { Context, Effect, Layer } from "effect";
+import { WorkflowReadableStream, WorkflowReadableStreamOptions, WorkflowRun } from "workflow/api";
+
+//#region src/effect.d.ts
+type VercelWorkflowsOperation = 'start' | 'getRun' | 'getReadable' | 'tailIndex' | 'resumeHook' | 'cancel' | 'status' | 'returnValue';
+declare const VercelWorkflowsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "VercelWorkflowsError";
+} & Readonly<A>;
+declare class VercelWorkflowsError extends VercelWorkflowsError_base<{
+  readonly operation: VercelWorkflowsOperation;
+  readonly message: string;
+  readonly cause: unknown;
+}> {}
+type VercelWorkflowFunction<TArgs extends unknown[], TResult> = (...args: TArgs) => Promise<TResult>;
+type VercelWorkflowReadableOptions = WorkflowReadableStreamOptions;
+type VercelWorkflowReadableStream<Chunk> = WorkflowReadableStream<Chunk>;
+type VercelWorkflowRunStatus = WorkflowRun['status'];
+type VercelWorkflowsSdkRun<TResult> = {
+  readonly runId: string;
+  readonly getReadable: <Chunk>(options?: VercelWorkflowReadableOptions) => VercelWorkflowReadableStream<Chunk>;
+  readonly cancel: () => Promise<void>;
+  readonly status: Promise<VercelWorkflowRunStatus>;
+  readonly returnValue: Promise<TResult>;
+};
+type VercelWorkflowsSdkClient = {
+  readonly start: <TArgs extends unknown[], TResult>(workflow: VercelWorkflowFunction<TArgs, TResult>, args: TArgs) => Promise<VercelWorkflowsSdkRun<TResult>>;
+  readonly getRun: <TResult>(runId: string) => VercelWorkflowsSdkRun<TResult>;
+  readonly resumeHook: (token: string, payload: unknown) => Promise<void>;
+};
+type VercelWorkflowRun<TResult> = {
+  readonly runId: string;
+  readonly getReadable: <Chunk>(options?: VercelWorkflowReadableOptions) => Effect.Effect<VercelWorkflowReadableStream<Chunk>, VercelWorkflowsError>;
+  readonly cancel: Effect.Effect<void, VercelWorkflowsError>;
+  readonly status: Effect.Effect<VercelWorkflowRunStatus, VercelWorkflowsError>;
+  readonly returnValue: Effect.Effect<TResult, VercelWorkflowsError>;
+};
+type VercelWorkflowsClient = {
+  readonly start: <TArgs extends unknown[], TResult>(workflow: VercelWorkflowFunction<TArgs, TResult>, args: TArgs) => Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError>;
+  readonly getRun: <TResult>(runId: string) => Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError>;
+  readonly getReadable: <Chunk>(runId: string, options?: VercelWorkflowReadableOptions) => Effect.Effect<VercelWorkflowReadableStream<Chunk>, VercelWorkflowsError>;
+  readonly tailIndex: (runId: string) => Effect.Effect<number, VercelWorkflowsError>;
+  readonly resumeHook: (token: string, payload: unknown) => Effect.Effect<void, VercelWorkflowsError>;
+  readonly cancel: (runId: string) => Effect.Effect<void, VercelWorkflowsError>;
+};
+declare const VercelWorkflowsSdk_base: Context.ServiceClass<VercelWorkflowsSdk, "@yolk-sdk/vercel-workflows/VercelWorkflowsSdk", VercelWorkflowsSdkClient>;
+declare class VercelWorkflowsSdk extends VercelWorkflowsSdk_base {}
+declare const VercelWorkflows_base: Context.ServiceClass<VercelWorkflows, "@yolk-sdk/vercel-workflows/VercelWorkflows", VercelWorkflowsClient> & {
+  readonly make: Effect.Effect<VercelWorkflowsClient, never, VercelWorkflowsSdk>;
+};
+declare class VercelWorkflows extends VercelWorkflows_base {
+  static layer: Layer.Layer<VercelWorkflows, never, never>;
+  static layerFromSdk: Layer.Layer<VercelWorkflows, never, VercelWorkflowsSdk>;
+}
+//#endregion
+export { VercelWorkflowFunction, VercelWorkflowReadableOptions, VercelWorkflowReadableStream, VercelWorkflowRun, VercelWorkflowRunStatus, VercelWorkflows, VercelWorkflowsClient, VercelWorkflowsError, VercelWorkflowsOperation, VercelWorkflowsSdk, VercelWorkflowsSdkClient, VercelWorkflowsSdkRun };
+//# sourceMappingURL=effect.d.mts.map

package/dist/effect.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.mts","names":[],"sources":["../src/effect.ts"],"mappings":";;;;KAUY,wBAAA;AAAA,cAQK,yBAAA;;;cAEJ,oBAAA,SAA6B,yBAAA;EAAA,SAC/B,SAAA,EAAW,wBAAA;EAAA,SACX,OAAA;EAAA,SACA,KAAA;AAAA;AAAA,KAGC,sBAAA,yCACP,IAAA,EAAM,KAAA,KACN,OAAA,CAAQ,OAAA;AAAA,KAED,6BAAA,GAAgC,6BAA6B;AAAA,KAE7D,4BAAA,UAAsC,sBAAsB,CAAC,KAAA;AAAA,KAE7D,uBAAA,GAA0B,WAAW;AAAA,KAErC,qBAAA;EAAA,SACD,KAAA;EAAA,SACA,WAAA,UACP,OAAA,GAAU,6BAAA,KACP,4BAAA,CAA6B,KAAA;EAAA,SACzB,MAAA,QAAc,OAAA;EAAA,SACd,MAAA,EAAQ,OAAA,CAAQ,uBAAA;EAAA,SAChB,WAAA,EAAa,OAAA,CAAQ,OAAA;AAAA;AAAA,KAGpB,wBAAA;EAAA,SACD,KAAA,qCACP,QAAA,EAAU,sBAAA,CAAuB,KAAA,EAAO,OAAA,GACxC,IAAA,EAAM,KAAA,KACH,OAAA,CAAQ,qBAAA,CAAsB,OAAA;EAAA,SAC1B,MAAA,YAAkB,KAAA,aAAkB,qBAAA,CAAsB,OAAA;EAAA,SAC1D,UAAA,GAAa,KAAA,UAAe,OAAA,cAAqB,OAAA;AAAA;AAAA,KAGhD,iBAAA;EAAA,SACD,KAAA;EAAA,SACA,WAAA,UACP,OAAA,GAAU,6BAAA,KACP,MAAA,CAAO,MAAA,CAAO,4BAAA,CAA6B,KAAA,GAAQ,oBAAA;EAAA,SAC/C,MAAA,EAAQ,MAAA,CAAO,MAAA,OAAa,oBAAA;EAAA,SAC5B,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,uBAAA,EAAyB,oBAAA;EAAA,SAC/C,WAAA,EAAa,MAAA,CAAO,MAAA,CAAO,OAAA,EAAS,oBAAA;AAAA;AAAA,KAGnC,qBAAA;EAAA,SACD,KAAA,qCACP,QAAA,EAAU,sBAAA,CAAuB,KAAA,EAAO,OAAA,GACxC,IAAA,EAAM,KAAA,KACH,MAAA,CAAO,MAAA,CAAO,iBAAA,CAAkB,OAAA,GAAU,oBAAA;EAAA,SACtC,MAAA,YACP,KAAA,aACG,MAAA,CAAO,MAAA,CAAO,iBAAA,CAAkB,OAAA,GAAU,oBAAA;EAAA,SACtC,WAAA,UACP,KAAA,UACA,OAAA,GAAU,6BAAA,KACP,MAAA,CAAO,MAAA,CAAO,4BAAA,CAA6B,KAAA,GAAQ,oBAAA;EAAA,SAC/C,SAAA,GAAY,KAAA,aAAkB,MAAA,CAAO,MAAA,SAAe,oBAAA;EAAA,SACpD,UAAA,GACP,KAAA,UACA,OAAA,cACG,MAAA,CAAO,MAAA,OAAa,oBAAA;EAAA,SAChB,MAAA,GAAS,KAAA,aAAkB,MAAA,CAAO,MAAA,OAAa,oBAAA;AAAA;AAAA,cACzD,uBAAA;cAEY,kBAAA,SAA2B,uBAGY;AAAA,cAAG,oBAAA;;;cAkE1C,eAAA,SAAwB,oBAAA;EAAA,OA2E5B,KAAA,EAAK,KAAA,CAAA,KAAA,CAAA,eAAA;EAAA,OACL,YAAA,EAAY,KAAA,CAAA,KAAA,CAAA,eAAA,SAAA,kBAAA;AAAA"}

package/dist/effect.mjs

@@ -0,0 +1,58 @@
+import { Context, Data, Effect, Layer } from "effect";
+import { getRun, resumeHook, start } from "workflow/api";
+//#region src/effect.ts
+var VercelWorkflowsError = class extends Data.TaggedError("VercelWorkflowsError") {};
+var VercelWorkflowsSdk = class extends Context.Service()("@yolk-sdk/vercel-workflows/VercelWorkflowsSdk") {};
+const workflowsError = (operation, cause) => new VercelWorkflowsError({
+	operation,
+	message: `Vercel Workflow ${operation} failed`,
+	cause
+});
+const spanAttributes = (runId) => ({ "workflow.run.id": runId });
+const trySdkPromise = (body) => Effect.tryPromise({
+	try: body,
+	catch: (error) => error
+});
+const mapSdkError = (operation) => (effect) => effect.pipe(Effect.mapError((cause) => workflowsError(operation, cause)));
+const makeWorkflowRun = (run) => ({
+	runId: run.runId,
+	getReadable: (options) => Effect.try({
+		try: () => run.getReadable(options),
+		catch: (cause) => workflowsError("getReadable", cause)
+	}).pipe(Effect.withSpan("VercelWorkflows.run.getReadable", { attributes: spanAttributes(run.runId) })),
+	cancel: trySdkPromise(() => run.cancel()).pipe(mapSdkError("cancel"), Effect.withSpan("VercelWorkflows.run.cancel", { attributes: spanAttributes(run.runId) })),
+	status: trySdkPromise(() => run.status).pipe(mapSdkError("status"), Effect.withSpan("VercelWorkflows.run.status", { attributes: spanAttributes(run.runId) })),
+	returnValue: trySdkPromise(() => run.returnValue).pipe(mapSdkError("returnValue"), Effect.withSpan("VercelWorkflows.run.returnValue", { attributes: spanAttributes(run.runId) }))
+});
+const VercelWorkflowsSdkLive = Layer.succeed(VercelWorkflowsSdk, {
+	start: (workflow, args) => start(workflow, args),
+	getRun: (runId) => getRun(runId),
+	resumeHook: async (token, payload) => {
+		await resumeHook(token, payload);
+	}
+});
+var VercelWorkflows = class extends Context.Service()("@yolk-sdk/vercel-workflows/VercelWorkflows", { make: Effect.gen(function* () {
+	const sdk = yield* VercelWorkflowsSdk;
+	const getRun = (runId) => Effect.try({
+		try: () => sdk.getRun(runId),
+		catch: (error) => error
+	}).pipe(mapSdkError("getRun"), Effect.map(makeWorkflowRun), Effect.withSpan("VercelWorkflows.getRun", { attributes: spanAttributes(runId) }));
+	return {
+		start: (workflow, args) => trySdkPromise(() => sdk.start(workflow, args)).pipe(mapSdkError("start"), Effect.map(makeWorkflowRun), Effect.withSpan("VercelWorkflows.start")),
+		getRun,
+		getReadable: (runId, options) => getRun(runId).pipe(Effect.flatMap((run) => run.getReadable(options)), Effect.withSpan("VercelWorkflows.getReadable", { attributes: spanAttributes(runId) })),
+		tailIndex: (runId) => getRun(runId).pipe(Effect.flatMap((run) => run.getReadable({ startIndex: -1 })), Effect.flatMap((readable) => Effect.tryPromise({
+			try: () => readable.getTailIndex(),
+			catch: (cause) => workflowsError("tailIndex", cause)
+		})), Effect.withSpan("VercelWorkflows.tailIndex", { attributes: spanAttributes(runId) })),
+		resumeHook: (token, payload) => trySdkPromise(() => sdk.resumeHook(token, payload)).pipe(mapSdkError("resumeHook"), Effect.withSpan("VercelWorkflows.resumeHook")),
+		cancel: (runId) => getRun(runId).pipe(Effect.flatMap((run) => run.cancel), Effect.withSpan("VercelWorkflows.cancel", { attributes: spanAttributes(runId) }))
+	};
+}) }) {
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide(VercelWorkflowsSdkLive));
+	static layerFromSdk = Layer.effect(this, this.make);
+};
+//#endregion
+export { VercelWorkflows, VercelWorkflowsError, VercelWorkflowsSdk };
+
+//# sourceMappingURL=effect.mjs.map

package/dist/effect.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.mjs","names":["workflowStart","workflowGetRun","workflowResumeHook"],"sources":["../src/effect.ts"],"sourcesContent":["import { Context, Data, Effect, Layer } from 'effect'\nimport {\n  getRun as workflowGetRun,\n  resumeHook as workflowResumeHook,\n  start as workflowStart,\n  type WorkflowReadableStream,\n  type WorkflowReadableStreamOptions,\n  type WorkflowRun\n} from 'workflow/api'\n\nexport type VercelWorkflowsOperation =\n  | 'start'\n  | 'getRun'\n  | 'getReadable'\n  | 'tailIndex'\n  | 'resumeHook'\n  | 'cancel'\n  | 'status'\n  | 'returnValue'\n\nexport class VercelWorkflowsError extends Data.TaggedError('VercelWorkflowsError')<{\n  readonly operation: VercelWorkflowsOperation\n  readonly message: string\n  readonly cause: unknown\n}> {}\n\nexport type VercelWorkflowFunction<TArgs extends unknown[], TResult> = (\n  ...args: TArgs\n) => Promise<TResult>\n\nexport type VercelWorkflowReadableOptions = WorkflowReadableStreamOptions\n\nexport type VercelWorkflowReadableStream<Chunk> = WorkflowReadableStream<Chunk>\n\nexport type VercelWorkflowRunStatus = WorkflowRun['status']\n\nexport type VercelWorkflowsSdkRun<TResult> = {\n  readonly runId: string\n  readonly getReadable: <Chunk>(\n    options?: VercelWorkflowReadableOptions\n  ) => VercelWorkflowReadableStream<Chunk>\n  readonly cancel: () => Promise<void>\n  readonly status: Promise<VercelWorkflowRunStatus>\n  readonly returnValue: Promise<TResult>\n}\n\nexport type VercelWorkflowsSdkClient = {\n  readonly start: <TArgs extends unknown[], TResult>(\n    workflow: VercelWorkflowFunction<TArgs, TResult>,\n    args: TArgs\n  ) => Promise<VercelWorkflowsSdkRun<TResult>>\n  readonly getRun: <TResult>(runId: string) => VercelWorkflowsSdkRun<TResult>\n  readonly resumeHook: (token: string, payload: unknown) => Promise<void>\n}\n\nexport type VercelWorkflowRun<TResult> = {\n  readonly runId: string\n  readonly getReadable: <Chunk>(\n    options?: VercelWorkflowReadableOptions\n  ) => Effect.Effect<VercelWorkflowReadableStream<Chunk>, VercelWorkflowsError>\n  readonly cancel: Effect.Effect<void, VercelWorkflowsError>\n  readonly status: Effect.Effect<VercelWorkflowRunStatus, VercelWorkflowsError>\n  readonly returnValue: Effect.Effect<TResult, VercelWorkflowsError>\n}\n\nexport type VercelWorkflowsClient = {\n  readonly start: <TArgs extends unknown[], TResult>(\n    workflow: VercelWorkflowFunction<TArgs, TResult>,\n    args: TArgs\n  ) => Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError>\n  readonly getRun: <TResult>(\n    runId: string\n  ) => Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError>\n  readonly getReadable: <Chunk>(\n    runId: string,\n    options?: VercelWorkflowReadableOptions\n  ) => Effect.Effect<VercelWorkflowReadableStream<Chunk>, VercelWorkflowsError>\n  readonly tailIndex: (runId: string) => Effect.Effect<number, VercelWorkflowsError>\n  readonly resumeHook: (\n    token: string,\n    payload: unknown\n  ) => Effect.Effect<void, VercelWorkflowsError>\n  readonly cancel: (runId: string) => Effect.Effect<void, VercelWorkflowsError>\n}\n\nexport class VercelWorkflowsSdk extends Context.Service<\n  VercelWorkflowsSdk,\n  VercelWorkflowsSdkClient\n>()('@yolk-sdk/vercel-workflows/VercelWorkflowsSdk') {}\n\nconst workflowsError = (operation: VercelWorkflowsOperation, cause: unknown) =>\n  new VercelWorkflowsError({\n    operation,\n    message: `Vercel Workflow ${operation} failed`,\n    cause\n  })\n\nconst spanAttributes = (runId: string) => ({ 'workflow.run.id': runId })\n\nconst trySdkPromise = <A>(body: () => Promise<A>) =>\n  Effect.tryPromise({\n    try: body,\n    catch: error => error\n  })\n\nconst mapSdkError =\n  (operation: VercelWorkflowsOperation) =>\n  <A>(effect: Effect.Effect<A, unknown>) =>\n    effect.pipe(Effect.mapError(cause => workflowsError(operation, cause)))\n\nconst makeWorkflowRun = <TResult>(\n  run: VercelWorkflowsSdkRun<TResult>\n): VercelWorkflowRun<TResult> => ({\n  runId: run.runId,\n  getReadable: <Chunk>(options?: VercelWorkflowReadableOptions) =>\n    Effect.try({\n      try: () => run.getReadable<Chunk>(options),\n      catch: cause => workflowsError('getReadable', cause)\n    }).pipe(\n      Effect.withSpan('VercelWorkflows.run.getReadable', {\n        attributes: spanAttributes(run.runId)\n      })\n    ),\n  cancel: trySdkPromise(() => run.cancel()).pipe(\n    mapSdkError('cancel'),\n    Effect.withSpan('VercelWorkflows.run.cancel', {\n      attributes: spanAttributes(run.runId)\n    })\n  ),\n  status: trySdkPromise(() => run.status).pipe(\n    mapSdkError('status'),\n    Effect.withSpan('VercelWorkflows.run.status', {\n      attributes: spanAttributes(run.runId)\n    })\n  ),\n  returnValue: trySdkPromise(() => run.returnValue).pipe(\n    mapSdkError('returnValue'),\n    Effect.withSpan('VercelWorkflows.run.returnValue', {\n      attributes: spanAttributes(run.runId)\n    })\n  )\n})\n\nconst VercelWorkflowsSdkLive = Layer.succeed(VercelWorkflowsSdk, {\n  start: <TArgs extends unknown[], TResult>(\n    workflow: VercelWorkflowFunction<TArgs, TResult>,\n    args: TArgs\n  ) => workflowStart(workflow, args),\n  getRun: <TResult>(runId: string) => workflowGetRun<TResult>(runId),\n  resumeHook: async (token: string, payload: unknown) => {\n    await workflowResumeHook<unknown>(token, payload)\n  }\n})\n\nexport class VercelWorkflows extends Context.Service<VercelWorkflows, VercelWorkflowsClient>()(\n  '@yolk-sdk/vercel-workflows/VercelWorkflows',\n  {\n    make: Effect.gen(function* () {\n      const sdk = yield* VercelWorkflowsSdk\n\n      const getRun = <TResult>(\n        runId: string\n      ): Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError> =>\n        Effect.try({\n          try: () => sdk.getRun<TResult>(runId),\n          catch: error => error\n        }).pipe(\n          mapSdkError('getRun'),\n          Effect.map(makeWorkflowRun),\n          Effect.withSpan('VercelWorkflows.getRun', {\n            attributes: spanAttributes(runId)\n          })\n        )\n\n      return {\n        start: <TArgs extends unknown[], TResult>(\n          workflow: VercelWorkflowFunction<TArgs, TResult>,\n          args: TArgs\n        ): Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError> =>\n          trySdkPromise(() => sdk.start(workflow, args)).pipe(\n            mapSdkError('start'),\n            Effect.map(makeWorkflowRun),\n            Effect.withSpan('VercelWorkflows.start')\n          ),\n\n        getRun,\n\n        getReadable: <Chunk>(\n          runId: string,\n          options?: VercelWorkflowReadableOptions\n        ): Effect.Effect<VercelWorkflowReadableStream<Chunk>, VercelWorkflowsError> =>\n          getRun<unknown>(runId).pipe(\n            Effect.flatMap(run => run.getReadable<Chunk>(options)),\n            Effect.withSpan('VercelWorkflows.getReadable', {\n              attributes: spanAttributes(runId)\n            })\n          ),\n\n        tailIndex: (runId: string): Effect.Effect<number, VercelWorkflowsError> =>\n          getRun<unknown>(runId).pipe(\n            Effect.flatMap(run => run.getReadable<unknown>({ startIndex: -1 })),\n            Effect.flatMap(readable =>\n              Effect.tryPromise({\n                try: () => readable.getTailIndex(),\n                catch: cause => workflowsError('tailIndex', cause)\n              })\n            ),\n            Effect.withSpan('VercelWorkflows.tailIndex', {\n              attributes: spanAttributes(runId)\n            })\n          ),\n\n        resumeHook: (token: string, payload: unknown): Effect.Effect<void, VercelWorkflowsError> =>\n          trySdkPromise(() => sdk.resumeHook(token, payload)).pipe(\n            mapSdkError('resumeHook'),\n            Effect.withSpan('VercelWorkflows.resumeHook')\n          ),\n\n        cancel: (runId: string): Effect.Effect<void, VercelWorkflowsError> =>\n          getRun<unknown>(runId).pipe(\n            Effect.flatMap(run => run.cancel),\n            Effect.withSpan('VercelWorkflows.cancel', {\n              attributes: spanAttributes(runId)\n            })\n          )\n      }\n    })\n  }\n) {\n  static layer = Layer.effect(this, this.make).pipe(Layer.provide(VercelWorkflowsSdkLive))\n  static layerFromSdk = Layer.effect(this, this.make)\n}\n"],"mappings":";;;AAoBA,IAAa,uBAAb,cAA0C,KAAK,YAAY,sBAAsB,EAI9E,CAAC;AA6DJ,IAAa,qBAAb,cAAwC,QAAQ,QAG9C,EAAE,+CAA+C,EAAE,CAAC;AAEtD,MAAM,kBAAkB,WAAqC,UAC3D,IAAI,qBAAqB;CACvB;CACA,SAAS,mBAAmB,UAAU;CACtC;AACF,CAAC;AAEH,MAAM,kBAAkB,WAAmB,EAAE,mBAAmB,MAAM;AAEtE,MAAM,iBAAoB,SACxB,OAAO,WAAW;CAChB,KAAK;CACL,QAAO,UAAS;AAClB,CAAC;AAEH,MAAM,eACH,eACG,WACF,OAAO,KAAK,OAAO,UAAS,UAAS,eAAe,WAAW,KAAK,CAAC,CAAC;AAE1E,MAAM,mBACJ,SACgC;CAChC,OAAO,IAAI;CACX,cAAqB,YACnB,OAAO,IAAI;EACT,WAAW,IAAI,YAAmB,OAAO;EACzC,QAAO,UAAS,eAAe,eAAe,KAAK;CACrD,CAAC,EAAE,KACD,OAAO,SAAS,mCAAmC,EACjD,YAAY,eAAe,IAAI,KAAK,EACtC,CAAC,CACH;CACF,QAAQ,oBAAoB,IAAI,OAAO,CAAC,EAAE,KACxC,YAAY,QAAQ,GACpB,OAAO,SAAS,8BAA8B,EAC5C,YAAY,eAAe,IAAI,KAAK,EACtC,CAAC,CACH;CACA,QAAQ,oBAAoB,IAAI,MAAM,EAAE,KACtC,YAAY,QAAQ,GACpB,OAAO,SAAS,8BAA8B,EAC5C,YAAY,eAAe,IAAI,KAAK,EACtC,CAAC,CACH;CACA,aAAa,oBAAoB,IAAI,WAAW,EAAE,KAChD,YAAY,aAAa,GACzB,OAAO,SAAS,mCAAmC,EACjD,YAAY,eAAe,IAAI,KAAK,EACtC,CAAC,CACH;AACF;AAEA,MAAM,yBAAyB,MAAM,QAAQ,oBAAoB;CAC/D,QACE,UACA,SACGA,MAAc,UAAU,IAAI;CACjC,SAAkB,UAAkBC,OAAwB,KAAK;CACjE,YAAY,OAAO,OAAe,YAAqB;EACrD,MAAMC,WAA4B,OAAO,OAAO;CAClD;AACF,CAAC;AAED,IAAa,kBAAb,cAAqC,QAAQ,QAAgD,EAC3F,8CACA,EACE,MAAM,OAAO,IAAI,aAAa;CAC5B,MAAM,MAAM,OAAO;CAEnB,MAAM,UACJ,UAEA,OAAO,IAAI;EACT,WAAW,IAAI,OAAgB,KAAK;EACpC,QAAO,UAAS;CAClB,CAAC,EAAE,KACD,YAAY,QAAQ,GACpB,OAAO,IAAI,eAAe,GAC1B,OAAO,SAAS,0BAA0B,EACxC,YAAY,eAAe,KAAK,EAClC,CAAC,CACH;CAEF,OAAO;EACL,QACE,UACA,SAEA,oBAAoB,IAAI,MAAM,UAAU,IAAI,CAAC,EAAE,KAC7C,YAAY,OAAO,GACnB,OAAO,IAAI,eAAe,GAC1B,OAAO,SAAS,uBAAuB,CACzC;EAEF;EAEA,cACE,OACA,YAEA,OAAgB,KAAK,EAAE,KACrB,OAAO,SAAQ,QAAO,IAAI,YAAmB,OAAO,CAAC,GACrD,OAAO,SAAS,+BAA+B,EAC7C,YAAY,eAAe,KAAK,EAClC,CAAC,CACH;EAEF,YAAY,UACV,OAAgB,KAAK,EAAE,KACrB,OAAO,SAAQ,QAAO,IAAI,YAAqB,EAAE,YAAY,GAAG,CAAC,CAAC,GAClE,OAAO,SAAQ,aACb,OAAO,WAAW;GAChB,WAAW,SAAS,aAAa;GACjC,QAAO,UAAS,eAAe,aAAa,KAAK;EACnD,CAAC,CACH,GACA,OAAO,SAAS,6BAA6B,EAC3C,YAAY,eAAe,KAAK,EAClC,CAAC,CACH;EAEF,aAAa,OAAe,YAC1B,oBAAoB,IAAI,WAAW,OAAO,OAAO,CAAC,EAAE,KAClD,YAAY,YAAY,GACxB,OAAO,SAAS,4BAA4B,CAC9C;EAEF,SAAS,UACP,OAAgB,KAAK,EAAE,KACrB,OAAO,SAAQ,QAAO,IAAI,MAAM,GAChC,OAAO,SAAS,0BAA0B,EACxC,YAAY,eAAe,KAAK,EAClC,CAAC,CACH;CACJ;AACF,CAAC,EACH,CACF,EAAE;CACA,OAAO,QAAQ,MAAM,OAAO,MAAM,KAAK,IAAI,EAAE,KAAK,MAAM,QAAQ,sBAAsB,CAAC;CACvF,OAAO,eAAe,MAAM,OAAO,MAAM,KAAK,IAAI;AACpD"}

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { SerializableWorkflowState, VercelAgentWorkflowAwaitingInput, VercelAgentWorkflowInput, VercelAgentWorkflowLoopConfig, VercelAgentWorkflowModelStepInput, VercelAgentWorkflowModelStepResult, VercelAgentWorkflowRunResult, VercelAgentWorkflowStepRetryPolicy, VercelAgentWorkflowToolBatchStepInput, VercelAgentWorkflowToolBatchStepResult, WorkflowStepResult, defaultMaxWorkflowTurns, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, settleWorkflowStep } from "./workflow-loop.mjs";
+import { CommitThenWriteTerminalEventInput, CommitThenWriteTerminalEventResult, DurableAgentEvent, DurableAgentEventIdInput, DurableAgentEventSequencerState, SequenceDurableAgentEventInput, SequencedDurableAgentEvent, WriteDurableAgentEventInput, commitThenWriteTerminalEvent, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent } from "./workflow-events.mjs";
+import { awaitWorkflowChild, orchestrateWorkflowToolBatch } from "./workflow-children.mjs";
+export { type CommitThenWriteTerminalEventInput, type CommitThenWriteTerminalEventResult, type DurableAgentEvent, type DurableAgentEventIdInput, type DurableAgentEventSequencerState, type SequenceDurableAgentEventInput, type SequencedDurableAgentEvent, type SerializableWorkflowState, type VercelAgentWorkflowAwaitingInput, type VercelAgentWorkflowInput, type VercelAgentWorkflowLoopConfig, type VercelAgentWorkflowModelStepInput, type VercelAgentWorkflowModelStepResult, VercelAgentWorkflowRunResult, type VercelAgentWorkflowStepRetryPolicy, type VercelAgentWorkflowToolBatchStepInput, type VercelAgentWorkflowToolBatchStepResult, WorkflowStepResult, type WriteDurableAgentEventInput, awaitWorkflowChild, commitThenWriteTerminalEvent, defaultMaxWorkflowTurns, durableAgentEventId, makeDurableAgentEventSequencerState, noWorkflowStepRetry, orchestrateWorkflowToolBatch, retryWorkflowStep, runVercelAgentWorkflow, sequenceDurableAgentEvent, settleWorkflowStep, writeDurableAgentEvent };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { VercelAgentWorkflowRunResult, WorkflowStepResult, defaultMaxWorkflowTurns, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, settleWorkflowStep } from "./workflow-loop.mjs";
+import { commitThenWriteTerminalEvent, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent } from "./workflow-events.mjs";
+import { awaitWorkflowChild, orchestrateWorkflowToolBatch } from "./workflow-children.mjs";
+export { VercelAgentWorkflowRunResult, WorkflowStepResult, awaitWorkflowChild, commitThenWriteTerminalEvent, defaultMaxWorkflowTurns, durableAgentEventId, makeDurableAgentEventSequencerState, noWorkflowStepRetry, orchestrateWorkflowToolBatch, retryWorkflowStep, runVercelAgentWorkflow, sequenceDurableAgentEvent, settleWorkflowStep, writeDurableAgentEvent };

package/dist/testing/index.d.mts

@@ -0,0 +1,97 @@
+import { VercelWorkflowReadableOptions, VercelWorkflowReadableStream, VercelWorkflowRunStatus, VercelWorkflowsSdkClient } from "../effect.mjs";
+
+//#region src/testing/index.d.ts
+type TestWorkflowRunStatus = VercelWorkflowRunStatus;
+declare class TestWorkflowStreamConflictError extends Error {
+  readonly name = "EntityConflictError";
+  readonly status = 409;
+  constructor(runId: string);
+}
+declare class TestWorkflowRunConflictError extends Error {
+  readonly name = "EntityConflictError";
+  readonly status = 409;
+  constructor(message: string);
+}
+declare class TestWorkflowHookNotFoundError extends Error {
+  readonly name = "HookNotFoundError";
+  constructor(token: string);
+}
+declare class TestWorkflowHookConflictError extends Error {
+  readonly name = "HookConflictError";
+  constructor(token: string);
+}
+declare class TestWorkflowRunNotFoundError extends Error {
+  readonly name = "WorkflowRunNotFoundError";
+  constructor(runId: string);
+}
+declare class TestWorkflowRunCancelledError extends Error {
+  readonly name = "WorkflowRunCancelledError";
+  constructor(runId: string);
+}
+type TestWorkflowMetadata = {
+  readonly workflowRunId: string;
+};
+type TestWorkflowStepMetadata = {
+  readonly attempt: number;
+  readonly stepId: string;
+  readonly stepName: string;
+};
+type TestWorkflowStepFunction<TArgs extends ReadonlyArray<unknown>, TResult> = ((...args: TArgs) => Promise<TResult>) & {
+  readonly maxRetries?: number;
+};
+declare const defaultTestWorkflowStepMaxRetries = 3;
+type TestWorkflowRunInspection = {
+  readonly runId: string;
+  readonly status: TestWorkflowRunStatus;
+  readonly chunks: ReadonlyArray<unknown>;
+  readonly streamClosed: boolean;
+  readonly streamCloseCount: number;
+  readonly writeAfterCloseAttempts: number;
+  readonly stepAttempts: ReadonlyMap<string, number>;
+  readonly runError: unknown;
+};
+type TestWorkflowHook<T> = Promise<T> & {
+  readonly [Symbol.dispose]: () => void;
+};
+type TestWorkflowWorldStartResult = {
+  readonly runId: string;
+};
+declare class TestWorkflowWorld {
+  private readonly runs;
+  private runSequence;
+  start<TArgs extends ReadonlyArray<unknown>, TResult>(workflowFn: (...args: TArgs) => Promise<TResult>, args: TArgs): TestWorkflowWorldStartResult;
+  settled(runId: string): Promise<void>;
+  inspect(runId: string): TestWorkflowRunInspection;
+  status(runId: string): TestWorkflowRunStatus;
+  cancel(runId: string): Promise<void>;
+  resumeHook(token: string, payload: unknown): Promise<void>;
+  hasResumedHook(token: string): boolean;
+  runStep<TArgs extends ReadonlyArray<unknown>, TResult>(stepFn: TestWorkflowStepFunction<TArgs, TResult>, args: TArgs, stepName?: string): Promise<TResult>;
+  step<TArgs extends ReadonlyArray<unknown>, TResult>(stepFn: TestWorkflowStepFunction<TArgs, TResult>, stepName?: string): (...args: TArgs) => Promise<TResult>;
+  static getWorkflowMetadata(): TestWorkflowMetadata;
+  static getStepMetadata(): TestWorkflowStepMetadata;
+  static getWritable<T>(): WritableStream<T>;
+  static createHook<T>(input: {
+    readonly token: string;
+  }): TestWorkflowHook<T>;
+  private makeWritable;
+  private makeHook;
+  getReadable<T>(runId: string, options?: VercelWorkflowReadableOptions): VercelWorkflowReadableStream<T>;
+  private streamEnded;
+  private notifyChange;
+  private nextChange;
+  private requireRun;
+  private sdkRun;
+  readonly sdk: VercelWorkflowsSdkClient;
+}
+declare const testWorkflowModule: {
+  getWorkflowMetadata: () => TestWorkflowMetadata;
+  getStepMetadata: () => TestWorkflowStepMetadata;
+  getWritable: <T>() => WritableStream<T>;
+  createHook: <T>(input: {
+    readonly token: string;
+  }) => TestWorkflowHook<T>;
+};
+//#endregion
+export { TestWorkflowHook, TestWorkflowHookConflictError, TestWorkflowHookNotFoundError, TestWorkflowMetadata, TestWorkflowRunCancelledError, TestWorkflowRunConflictError, TestWorkflowRunInspection, TestWorkflowRunNotFoundError, TestWorkflowRunStatus, TestWorkflowStepFunction, TestWorkflowStepMetadata, TestWorkflowStreamConflictError, TestWorkflowWorld, defaultTestWorkflowStepMaxRetries, testWorkflowModule };
+//# sourceMappingURL=index.d.mts.map

package/dist/testing/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/testing/index.ts"],"mappings":";;;KAsBY,qBAAA,GAAwB,uBAAuB;AAAA,cAK9C,+BAAA,SAAwC,KAAK;EAAA,SACtC,IAAA;EAAA,SACT,MAAA;cAEG,KAAA;AAAA;AAAA,cAKD,4BAAA,SAAqC,KAAK;EAAA,SACnC,IAAA;EAAA,SACT,MAAA;cAEG,OAAA;AAAA;AAAA,cAKD,6BAAA,SAAsC,KAAK;EAAA,SACpC,IAAA;cAEN,KAAA;AAAA;AAAA,cAKD,6BAAA,SAAsC,KAAK;EAAA,SACpC,IAAA;cAEN,KAAA;AAAA;AAAA,cAKD,4BAAA,SAAqC,KAAK;EAAA,SACnC,IAAA;cAEN,KAAA;AAAA;AAAA,cAKD,6BAAA,SAAsC,KAAK;EAAA,SACpC,IAAA;cAEN,KAAA;AAAA;AAAA,KAKF,oBAAA;EAAA,SAAkC,aAAa;AAAA;AAAA,KAE/C,wBAAA;EAAA,SACD,OAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA;AAAA;AAAA,KAGC,wBAAA,eAAuC,aAAA,2BAC9C,IAAA,EAAM,KAAA,KACN,OAAA,CAAQ,OAAA;EAAA,SAAuB,UAAA;AAAA;AAAA,cAGvB,iCAAA;AAAA,KA0CD,yBAAA;EAAA,SACD,KAAA;EAAA,SACA,MAAA,EAAQ,qBAAA;EAAA,SACR,MAAA,EAAQ,aAAA;EAAA,SACR,YAAA;EAAA,SACA,gBAAA;EAAA,SACA,uBAAA;EAAA,SACA,YAAA,EAAc,WAAA;EAAA,SACd,QAAA;AAAA;AAAA,KAGC,gBAAA,MAAsB,OAAA,CAAQ,CAAA;EAAA,UAAiB,MAAA,CAAO,OAAA;AAAA;AAAA,KAE7D,4BAAA;EAAA,SAA0C,KAAK;AAAA;AAAA,cAEvC,iBAAA;EAAA,iBACM,IAAA;EAAA,QACT,WAAA;EAER,KAAA,eAAoB,aAAA,mBAAA,CAClB,UAAA,MAAgB,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA,GACxC,IAAA,EAAM,KAAA,GACL,4BAAA;EAmDG,OAAA,CAAQ,KAAA,WAAgB,OAAA;EAI9B,OAAA,CAAQ,KAAA,WAAgB,yBAAA;EAexB,MAAA,CAAO,KAAA,WAAgB,qBAAA;EAIjB,MAAA,CAAO,KAAA,WAAgB,OAAA;EAmBvB,UAAA,CAAW,KAAA,UAAe,OAAA,YAAmB,OAAA;EAoBnD,cAAA,CAAe,KAAA;EAaT,OAAA,eAAsB,aAAA,mBAAA,CAC1B,MAAA,EAAQ,wBAAA,CAAyB,KAAA,EAAO,OAAA,GACxC,IAAA,EAAM,KAAA,EACN,QAAA,YACC,OAAA,CAAQ,OAAA;EA2BX,IAAA,eAAmB,aAAA,mBAAA,CACjB,MAAA,EAAQ,wBAAA,CAAyB,KAAA,EAAO,OAAA,GACxC,QAAA,gBACK,IAAA,EAAM,KAAA,KAAU,OAAA,CAAQ,OAAA;EAAA,OAMxB,mBAAA,CAAA,GAAuB,oBAAA;EAAA,OAIvB,eAAA,CAAA,GAAmB,wBAAA;EAAA,OAUnB,WAAA,GAAA,CAAA,GAAkB,cAAA,CAAe,CAAA;EAAA,OAMjC,UAAA,GAAA,CAAc,KAAA;IAAA,SAAkB,KAAA;EAAA,IAAkB,gBAAA,CAAiB,CAAA;EAAA,QAQlE,YAAA;EAAA,QAwBA,QAAA;EAqBR,WAAA,GAAA,CACE,KAAA,UACA,OAAA,GAAU,6BAAA,GACT,4BAAA,CAA6B,CAAA;EAAA,QAiCxB,WAAA;EAAA,QAIA,YAAA;EAAA,QAOA,UAAA;EAAA,QAMA,UAAA;EAAA,QAUA,MAAA;EAAA,SA2BC,GAAA,EAAK,wBAAA;AAAA;AAAA,cAcH,kBAAA;;;wBAGI,cAAA,CAAA,CAAA;kBACD,KAAA;IAAA,SAAoB,KAAA;EAAA,MAAe,gBAAA,CAAA,CAAA;AAAA"}