@yolk-sdk/vercel-workflows 0.1.0-canary.39 → 0.1.0-canary.41

package/README.md

@@ -25,12 +25,10 @@ Import Workflow APIs from the package root:
 ```ts
 import {
   commitThenWriteTerminalEvent,
-  commitThenWriteTerminalEventEffect,
   makeDurableAgentEventSequencerState,
   noWorkflowStepRetry,
   runVercelAgentWorkflow,
-  writeDurableAgentEvent,
-  writeDurableAgentEventEffect
+  writeDurableAgentEvent
 } from '@yolk-sdk/vercel-workflows'
 ```
 
@@ -73,23 +71,30 @@ Host apps keep concrete Workflow directives local and pass them into the package
 
 ```ts
 import { createHook } from 'workflow'
+import { Effect } from 'effect'
 import { runVercelAgentWorkflow } from '@yolk-sdk/vercel-workflows'
 
+const workflowStep = <A>(body: () => Promise<A>) =>
+  Effect.tryPromise({ try: body, catch: error => error })
+
 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
-    }
-  })
+  return await Effect.runPromise(
+    runVercelAgentWorkflow({
+      input,
+      runModelStep: input => workflowStep(() => runModelStep(input)),
+      runToolBatchStep: input => workflowStep(() => runToolBatchStep(input)),
+      closeStream: workflowStep(closeStream),
+      writeError: error => workflowStep(() => writeError(error)),
+      awaitInput: awaitingInput =>
+        workflowStep(async () => {
+          using hook = createHook<unknown>({ token: awaitingInput.hookToken })
+
+          return await hook
+        })
+    })
+  )
 }
 ```
 
@@ -124,7 +129,7 @@ Use `writeDurableAgentEvent` to assign deterministic ids and write NDJSON:
 
 ```ts
 const state = makeDurableAgentEventSequencerState(eventSequence)
-const sequenced = await writeDurableAgentEvent({
+const sequenced = yield* writeDurableAgentEvent({
   writer,
   event,
   streamId: `workflow:${runId}`,
@@ -142,15 +147,14 @@ like old replayed events. Keep `eventSequence` in Workflow state and reset it wh
 logical stream. Resume route reads should use `startIndex` when available. Host apps still own
 active-run locking, stale-run guards, and cancellation behavior.
 
-Use `writeDurableAgentEventEffect` when the writer path is already Effect-native.
-
 ## Terminal barriers
 
 For durable host streams, terminal events are commit barriers. Emit live/progress events first,
-commit canonical host state, then write the terminal event, then close the writer:
+commit canonical host state, then write the terminal event. The surrounding workflow loop owns the
+single final stream close:
 
 ```txt
-live events -> host durable commit -> terminal event -> close
+live events -> host durable commit -> terminal event -> workflow-owned close
 ```
 
 This lets clients stop consuming at a protocol-terminal event and immediately revalidate or reconnect
@@ -161,21 +165,18 @@ Use `commitThenWriteTerminalEvent` when a step must commit host state before wri
 event:
 
 ```ts
-const result = await commitThenWriteTerminalEvent({
+const result = yield* commitThenWriteTerminalEvent({
   terminal,
-  commit: () => persistState(),
+  commit: persistState,
   write: event => writeDurableAgentEvent({ writer, event, streamId, turn, state }),
   writeCommitError: error =>
-    writeDurableAgentEvent({ writer, event: commitErrorEvent(error), streamId, turn, state }),
-  close: () => writer.close()
+    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. Terminal write failures still attempt `close`; close
-failures are returned separately and do not turn a successful durable commit into a failed commit.
-
-Use `commitThenWriteTerminalEventEffect` for the same barrier with Effect callbacks.
+the host-provided terminal error event instead. The helper does not close writers; close once in the
+surrounding workflow loop or stream owner after terminal handling settles.
 
 ## Host responsibilities
 

package/dist/effect.d.mts

@@ -25,7 +25,7 @@ type VercelWorkflowsSdkRun<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<unknown>;
+  readonly resumeHook: (token: string, payload: unknown) => Promise<void>;
 };
 type VercelWorkflowRun<TResult> = {
   readonly runId: string;

package/dist/effect.d.mts.map

@@ -1 +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,KAC7D,4BAAA,UAAsC,sBAAsB,CAAC,KAAA;AAAA,KAC7D,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;;;cA2D1C,eAAA,SAAwB,oBAAA;EAAA,OAwE5B,KAAA,EAAK,KAAA,CAAA,KAAA,CAAA,eAAA;EAAA,OACL,YAAA,EAAY,KAAA,CAAA,KAAA,CAAA,eAAA,SAAA,kBAAA;AAAA"}
+{"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,KAC7D,4BAAA,UAAsC,sBAAsB,CAAC,KAAA;AAAA,KAC7D,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;;;cAiE1C,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

@@ -9,51 +9,43 @@ const workflowsError = (operation, cause) => new VercelWorkflowsError({
 	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: Effect.tryPromise({
-		try: () => run.cancel(),
-		catch: (cause) => workflowsError("cancel", cause)
-	}).pipe(Effect.withSpan("VercelWorkflows.run.cancel", { attributes: spanAttributes(run.runId) })),
-	status: Effect.tryPromise({
-		try: () => run.status,
-		catch: (cause) => workflowsError("status", cause)
-	}).pipe(Effect.withSpan("VercelWorkflows.run.status", { attributes: spanAttributes(run.runId) })),
-	returnValue: Effect.tryPromise({
-		try: () => run.returnValue,
-		catch: (cause) => workflowsError("returnValue", cause)
-	}).pipe(Effect.withSpan("VercelWorkflows.run.returnValue", { 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: (token, payload) => resumeHook(token, payload)
+	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: () => makeWorkflowRun(sdk.getRun(runId)),
-		catch: (cause) => workflowsError("getRun", cause)
-	}).pipe(Effect.withSpan("VercelWorkflows.getRun", { attributes: spanAttributes(runId) }));
+		try: () => sdk.getRun(runId),
+		catch: (error) => error
+	}).pipe(mapSdkError("getRun"), Effect.map(makeWorkflowRun), Effect.withSpan("VercelWorkflows.getRun", { attributes: spanAttributes(runId) }));
 	return {
-		start: (workflow, args) => Effect.tryPromise({
-			try: () => sdk.start(workflow, args),
-			catch: (cause) => workflowsError("start", cause)
-		}).pipe(Effect.map(makeWorkflowRun), Effect.withSpan("VercelWorkflows.start")),
+		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) => Effect.tryPromise({
-			try: () => sdk.resumeHook(token, payload).then(() => void 0),
-			catch: (cause) => workflowsError("resumeHook", cause)
-		}).pipe(Effect.withSpan("VercelWorkflows.resumeHook")),
+		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) }))
 	};
 }) }) {

package/dist/effect.mjs.map

@@ -1 +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\nexport type VercelWorkflowReadableStream<Chunk> = WorkflowReadableStream<Chunk>\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<unknown>\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 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: Effect.tryPromise({\n    try: () => run.cancel(),\n    catch: cause => workflowsError('cancel', cause)\n  }).pipe(\n    Effect.withSpan('VercelWorkflows.run.cancel', {\n      attributes: spanAttributes(run.runId)\n    })\n  ),\n  status: Effect.tryPromise({\n    try: () => run.status,\n    catch: cause => workflowsError('status', cause)\n  }).pipe(\n    Effect.withSpan('VercelWorkflows.run.status', {\n      attributes: spanAttributes(run.runId)\n    })\n  ),\n  returnValue: Effect.tryPromise({\n    try: () => run.returnValue,\n    catch: cause => workflowsError('returnValue', cause)\n  }).pipe(\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: (token: string, payload: unknown) => workflowResumeHook<unknown>(token, payload)\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: () => makeWorkflowRun(sdk.getRun<TResult>(runId)),\n          catch: cause => workflowsError('getRun', cause)\n        }).pipe(\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          Effect.tryPromise({\n            try: () => sdk.start(workflow, args),\n            catch: cause => workflowsError('start', cause)\n          }).pipe(Effect.map(makeWorkflowRun), Effect.withSpan('VercelWorkflows.start')),\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          Effect.tryPromise({\n            try: () => sdk.resumeHook(token, payload).then(() => undefined),\n            catch: cause => workflowsError('resumeHook', cause)\n          }).pipe(Effect.withSpan('VercelWorkflows.resumeHook')),\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":"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"}
+{"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\nexport type VercelWorkflowReadableStream<Chunk> = WorkflowReadableStream<Chunk>\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 = (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":"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"}

package/dist/index.d.mts

@@ -1,3 +1,3 @@
 import { SerializableWorkflowState, VercelAgentWorkflowAwaitingInput, VercelAgentWorkflowInput, VercelAgentWorkflowLoopConfig, VercelAgentWorkflowModelStepInput, VercelAgentWorkflowModelStepResult, VercelAgentWorkflowRunResult, VercelAgentWorkflowStepRetryPolicy, VercelAgentWorkflowToolBatchStepInput, VercelAgentWorkflowToolBatchStepResult, WorkflowStepResult, defaultMaxWorkflowTurns, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, settleWorkflowStep } from "./workflow-loop.mjs";
-import { CommitThenWriteTerminalEventEffectInput, CommitThenWriteTerminalEventInput, CommitThenWriteTerminalEventResult, DurableAgentEvent, DurableAgentEventIdInput, DurableAgentEventSequencerState, SequenceDurableAgentEventInput, SequencedDurableAgentEvent, TerminalEventCloseResult, WriteDurableAgentEventInput, commitThenWriteTerminalEvent, commitThenWriteTerminalEventEffect, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent, writeDurableAgentEventEffect } from "./workflow-events.mjs";
-export { type CommitThenWriteTerminalEventEffectInput, type CommitThenWriteTerminalEventInput, type CommitThenWriteTerminalEventResult, type DurableAgentEvent, type DurableAgentEventIdInput, type DurableAgentEventSequencerState, type SequenceDurableAgentEventInput, type SequencedDurableAgentEvent, type SerializableWorkflowState, type TerminalEventCloseResult, type VercelAgentWorkflowAwaitingInput, type VercelAgentWorkflowInput, type VercelAgentWorkflowLoopConfig, type VercelAgentWorkflowModelStepInput, type VercelAgentWorkflowModelStepResult, type VercelAgentWorkflowRunResult, type VercelAgentWorkflowStepRetryPolicy, type VercelAgentWorkflowToolBatchStepInput, type VercelAgentWorkflowToolBatchStepResult, type WorkflowStepResult, type WriteDurableAgentEventInput, commitThenWriteTerminalEvent, commitThenWriteTerminalEventEffect, defaultMaxWorkflowTurns, durableAgentEventId, makeDurableAgentEventSequencerState, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, sequenceDurableAgentEvent, settleWorkflowStep, writeDurableAgentEvent, writeDurableAgentEventEffect };
+import { CommitThenWriteTerminalEventInput, CommitThenWriteTerminalEventResult, DurableAgentEvent, DurableAgentEventIdInput, DurableAgentEventSequencerState, SequenceDurableAgentEventInput, SequencedDurableAgentEvent, WriteDurableAgentEventInput, commitThenWriteTerminalEvent, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent } from "./workflow-events.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, type VercelAgentWorkflowRunResult, type VercelAgentWorkflowStepRetryPolicy, type VercelAgentWorkflowToolBatchStepInput, type VercelAgentWorkflowToolBatchStepResult, type WorkflowStepResult, type WriteDurableAgentEventInput, commitThenWriteTerminalEvent, defaultMaxWorkflowTurns, durableAgentEventId, makeDurableAgentEventSequencerState, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, sequenceDurableAgentEvent, settleWorkflowStep, writeDurableAgentEvent };

package/dist/index.mjs

@@ -1,3 +1,3 @@
 import { defaultMaxWorkflowTurns, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, settleWorkflowStep } from "./workflow-loop.mjs";
-import { commitThenWriteTerminalEvent, commitThenWriteTerminalEventEffect, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent, writeDurableAgentEventEffect } from "./workflow-events.mjs";
-export { commitThenWriteTerminalEvent, commitThenWriteTerminalEventEffect, defaultMaxWorkflowTurns, durableAgentEventId, makeDurableAgentEventSequencerState, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, sequenceDurableAgentEvent, settleWorkflowStep, writeDurableAgentEvent, writeDurableAgentEventEffect };
+import { commitThenWriteTerminalEvent, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent } from "./workflow-events.mjs";
+export { commitThenWriteTerminalEvent, defaultMaxWorkflowTurns, durableAgentEventId, makeDurableAgentEventSequencerState, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, sequenceDurableAgentEvent, settleWorkflowStep, writeDurableAgentEvent };

package/dist/workflow-events.d.mts

@@ -36,52 +36,32 @@ type SequencedDurableAgentEvent<Event extends object = object> = {
 type WriteDurableAgentEventInput<Event extends object = object> = SequenceDurableAgentEventInput<Event> & {
   readonly writer: WritableStreamDefaultWriter<Uint8Array>;
 };
-type TerminalEventCloseResult = {
-  readonly _tag: 'Closed';
-} | {
-  readonly _tag: 'CloseFailed';
-  readonly error: unknown;
-};
-type CommitThenWriteTerminalEventInput<TerminalEvent extends object, TerminalWriteResult, CommitErrorWriteResult> = {
-  readonly commit: () => Promise<void>;
-  readonly terminal: TerminalEvent;
-  readonly write: (event: TerminalEvent) => Promise<TerminalWriteResult>;
-  readonly writeCommitError: (error: unknown) => Promise<CommitErrorWriteResult>;
-  readonly close: () => Promise<void>;
-};
-type CommitThenWriteTerminalEventEffectInput<TerminalEvent extends object, TerminalWriteResult, CommitErrorWriteResult, CommitError, TerminalWriteError, CommitErrorWriteError, CloseError> = {
+type CommitThenWriteTerminalEventInput<TerminalEvent extends object, TerminalWriteResult, CommitErrorWriteResult, CommitError, TerminalWriteError, CommitErrorWriteError> = {
   readonly commit: Effect.Effect<void, CommitError>;
   readonly terminal: TerminalEvent;
   readonly write: (event: TerminalEvent) => Effect.Effect<TerminalWriteResult, TerminalWriteError>;
   readonly writeCommitError: (error: unknown) => Effect.Effect<CommitErrorWriteResult, CommitErrorWriteError>;
-  readonly close: Effect.Effect<void, CloseError>;
 };
 type CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> = {
   readonly _tag: 'Committed';
   readonly writeResult: TerminalWriteResult;
-  readonly closeResult: TerminalEventCloseResult;
 } | {
   readonly _tag: 'CommitFailed';
   readonly commitError: unknown;
   readonly writeResult: CommitErrorWriteResult;
-  readonly closeResult: TerminalEventCloseResult;
 } | {
   readonly _tag: 'TerminalWriteFailed';
   readonly error: unknown;
-  readonly closeResult: TerminalEventCloseResult;
 } | {
   readonly _tag: 'CommitErrorWriteFailed';
   readonly commitError: unknown;
   readonly error: unknown;
-  readonly closeResult: TerminalEventCloseResult;
 };
 declare const makeDurableAgentEventSequencerState: (eventSequence?: number) => DurableAgentEventSequencerState;
 declare const durableAgentEventId: (input: DurableAgentEventIdInput) => string;
 declare const sequenceDurableAgentEvent: <Event extends object>(input: SequenceDurableAgentEventInput<Event>) => SequencedDurableAgentEvent<Event>;
-declare const writeDurableAgentEventEffect: <Event extends object>(input: WriteDurableAgentEventInput<Event>) => Effect.Effect<SequencedDurableAgentEvent<Event>, unknown>;
-declare const writeDurableAgentEvent: <Event extends object>(input: WriteDurableAgentEventInput<Event>) => Promise<SequencedDurableAgentEvent<Event>>;
-declare const commitThenWriteTerminalEventEffect: <TerminalEvent extends object, TerminalWriteResult, CommitErrorWriteResult, CommitError, TerminalWriteError, CommitErrorWriteError, CloseError>(input: CommitThenWriteTerminalEventEffectInput<TerminalEvent, TerminalWriteResult, CommitErrorWriteResult, CommitError, TerminalWriteError, CommitErrorWriteError, CloseError>) => Effect.Effect<CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult>, never>;
-declare const commitThenWriteTerminalEvent: <TerminalEvent extends object, TerminalWriteResult, CommitErrorWriteResult>(input: CommitThenWriteTerminalEventInput<TerminalEvent, TerminalWriteResult, CommitErrorWriteResult>) => Promise<CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult>>;
+declare const writeDurableAgentEvent: <Event extends object>(input: WriteDurableAgentEventInput<Event>) => Effect.Effect<SequencedDurableAgentEvent<Event>, unknown>;
+declare const commitThenWriteTerminalEvent: <TerminalEvent extends object, TerminalWriteResult, CommitErrorWriteResult, CommitError, TerminalWriteError, CommitErrorWriteError>(input: CommitThenWriteTerminalEventInput<TerminalEvent, TerminalWriteResult, CommitErrorWriteResult, CommitError, TerminalWriteError, CommitErrorWriteError>) => Effect.Effect<CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult>, never>;
 //#endregion
-export { CommitThenWriteTerminalEventEffectInput, CommitThenWriteTerminalEventInput, CommitThenWriteTerminalEventResult, DurableAgentEvent, DurableAgentEventIdInput, DurableAgentEventSequencerState, SequenceDurableAgentEventInput, SequencedDurableAgentEvent, TerminalEventCloseResult, WriteDurableAgentEventInput, commitThenWriteTerminalEvent, commitThenWriteTerminalEventEffect, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent, writeDurableAgentEventEffect };
+export { CommitThenWriteTerminalEventInput, CommitThenWriteTerminalEventResult, DurableAgentEvent, DurableAgentEventIdInput, DurableAgentEventSequencerState, SequenceDurableAgentEventInput, SequencedDurableAgentEvent, WriteDurableAgentEventInput, commitThenWriteTerminalEvent, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent };
 //# sourceMappingURL=workflow-events.d.mts.map

package/dist/workflow-events.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-events.d.mts","names":[],"sources":["../src/workflow-events.ts"],"mappings":";;;KAEY,+BAAA;EAAA,SACD,aAAa;AAAA;AAAA,KAGZ,iBAAA,kCAAmD,KAAK;EAAA,SACzD,OAAA;EAAA,SACA,WAAA;AAAA;AAAA,KAGC,wBAAA;EAAA,SACD,QAAA;EAAA,SACA,IAAA;EAAA,SACA,aAAA;AAAA;AAAA,KAGC,8BAAA;EAAA,SACD,KAAA,EAAO,+BAAA;EAVP;;AAAW;AAGtB;;;;EAHW,SAkBA,QAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA,EAAO,KAAK;EAAA,SACZ,WAAA;AAAA;AAAA,KAGC,0BAAA;EAAA,SACD,KAAA,EAAO,iBAAA,CAAkB,KAAA;EAAA,SACzB,aAAA;EAAA,SACA,iBAAA;EAAA,SACA,SAAA,EAAW,+BAAA;AAAA;AAAA,KAGV,2BAAA,kCACV,8BAAA,CAA+B,KAAA;EAAA,SACpB,MAAA,EAAQ,2BAAA,CAA4B,UAAA;AAAA;AAAA,KAGrC,wBAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAA8B,KAAA;AAAA;AAAA,KAEjC,iCAAA;EAAA,SAKD,MAAA,QAAc,OAAA;EAAA,SACd,QAAA,EAAU,aAAA;EAAA,SACV,KAAA,GAAQ,KAAA,EAAO,aAAA,KAAkB,OAAA,CAAQ,mBAAA;EAAA,SACzC,gBAAA,GAAmB,KAAA,cAAmB,OAAA,CAAQ,sBAAA;EAAA,SAC9C,KAAA,QAAa,OAAA;AAAA;AAAA,KAGZ,uCAAA;EAAA,SASD,MAAA,EAAQ,MAAA,CAAO,MAAA,OAAa,WAAA;EAAA,SAC5B,QAAA,EAAU,aAAA;EAAA,SACV,KAAA,GAAQ,KAAA,EAAO,aAAA,KAAkB,MAAA,CAAO,MAAA,CAAO,mBAAA,EAAqB,kBAAA;EAAA,SACpE,gBAAA,GACP,KAAA,cACG,MAAA,CAAO,MAAA,CAAO,sBAAA,EAAwB,qBAAA;EAAA,SAClC,KAAA,EAAO,MAAA,CAAO,MAAA,OAAa,UAAA;AAAA;AAAA,KAG1B,kCAAA;EAAA,SAEG,IAAA;EAAA,SACA,WAAA,EAAa,mBAAA;EAAA,SACb,WAAA,EAAa,wBAAA;AAAA;EAAA,SAGb,IAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA,EAAa,sBAAA;EAAA,SACb,WAAA,EAAa,wBAAA;AAAA;EAAA,SAGb,IAAA;EAAA,SACA,KAAA;EAAA,SACA,WAAA,EAAa,wBAAA;AAAA;EAAA,SAGb,IAAA;EAAA,SACA,WAAA;EAAA,SACA,KAAA;EAAA,SACA,WAAA,EAAa,wBAAA;AAAA;AAAA,cAKf,mCAAA,GACX,aAAA,cACC,+BAAsD;AAAA,cAE5C,mBAAA,GAAuB,KAA+B,EAAxB,wBAAwB;AAAA,cAGtD,yBAAA,yBACX,KAAA,EAAO,8BAAA,CAA+B,KAAA,MACrC,0BAAA,CAA2B,KAAA;AAAA,cAwBjB,4BAAA,yBACX,KAAA,EAAO,2BAAA,CAA4B,KAAA,MAClC,MAAA,CAAO,MAAA,CAAO,0BAAA,CAA2B,KAAA;AAAA,cAW/B,sBAAA,yBACX,KAAA,EAAO,2BAAA,CAA4B,KAAA,MAClC,OAAA,CAAQ,0BAAA,CAA2B,KAAA;AAAA,cA4DzB,kCAAA,kJASX,KAAA,EAAO,uCAAA,CACL,aAAA,EACA,mBAAA,EACA,sBAAA,EACA,WAAA,EACA,kBAAA,EACA,qBAAA,EACA,UAAA,MAED,MAAA,CAAO,MAAA,CACR,kCAAA,CAAmC,mBAAA,EAAqB,sBAAA;AAAA,cAwD7C,4BAAA,8EAKX,KAAA,EAAO,iCAAA,CACL,aAAA,EACA,mBAAA,EACA,sBAAA,MAED,OAAA,CAAQ,kCAAA,CAAmC,mBAAA,EAAqB,sBAAA"}
+{"version":3,"file":"workflow-events.d.mts","names":[],"sources":["../src/workflow-events.ts"],"mappings":";;;KAEY,+BAAA;EAAA,SACD,aAAa;AAAA;AAAA,KAGZ,iBAAA,kCAAmD,KAAK;EAAA,SACzD,OAAA;EAAA,SACA,WAAA;AAAA;AAAA,KAGC,wBAAA;EAAA,SACD,QAAA;EAAA,SACA,IAAA;EAAA,SACA,aAAA;AAAA;AAAA,KAGC,8BAAA;EAAA,SACD,KAAA,EAAO,+BAAA;EAVP;;AAAW;AAGtB;;;;EAHW,SAkBA,QAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA,EAAO,KAAK;EAAA,SACZ,WAAA;AAAA;AAAA,KAGC,0BAAA;EAAA,SACD,KAAA,EAAO,iBAAA,CAAkB,KAAA;EAAA,SACzB,aAAA;EAAA,SACA,iBAAA;EAAA,SACA,SAAA,EAAW,+BAAA;AAAA;AAAA,KAGV,2BAAA,kCACV,8BAAA,CAA+B,KAAA;EAAA,SACpB,MAAA,EAAQ,2BAAA,CAA4B,UAAA;AAAA;AAAA,KAGrC,iCAAA;EAAA,SAQD,MAAA,EAAQ,MAAA,CAAO,MAAA,OAAa,WAAA;EAAA,SAC5B,QAAA,EAAU,aAAA;EAAA,SACV,KAAA,GAAQ,KAAA,EAAO,aAAA,KAAkB,MAAA,CAAO,MAAA,CAAO,mBAAA,EAAqB,kBAAA;EAAA,SACpE,gBAAA,GACP,KAAA,cACG,MAAA,CAAO,MAAA,CAAO,sBAAA,EAAwB,qBAAA;AAAA;AAAA,KAGjC,kCAAA;EAAA,SAEG,IAAA;EAAA,SACA,WAAA,EAAa,mBAAA;AAAA;EAAA,SAGb,IAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA,EAAa,sBAAsB;AAAA;EAAA,SAGnC,IAAA;EAAA,SACA,KAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,WAAA;EAAA,SACA,KAAA;AAAA;AAAA,cAKF,mCAAA,GACX,aAAA,cACC,+BAAsD;AAAA,cAE5C,mBAAA,GAAuB,KAA+B,EAAxB,wBAAwB;AAAA,cAGtD,yBAAA,yBACX,KAAA,EAAO,8BAAA,CAA+B,KAAA,MACrC,0BAAA,CAA2B,KAAA;AAAA,cAwBjB,sBAAA,yBACX,KAAA,EAAO,2BAAA,CAA4B,KAAA,MAClC,MAAA,CAAO,MAAA,CAAO,0BAAA,CAA2B,KAAA;AAAA,cA2C/B,4BAAA,sIAQX,KAAA,EAAO,iCAAA,CACL,aAAA,EACA,mBAAA,EACA,sBAAA,EACA,WAAA,EACA,kBAAA,EACA,qBAAA,MAED,MAAA,CAAO,MAAA,CACR,kCAAA,CAAmC,mBAAA,EAAqB,sBAAA"}

package/dist/workflow-events.mjs

@@ -22,7 +22,7 @@ const sequenceDurableAgentEvent = (input) => {
 	};
 };
 const encodeDurableAgentEventNdjson = (event) => textEncoder.encode(`${JSON.stringify(event)}\n`);
-const writeDurableAgentEventEffect = (input) => Effect.gen(function* () {
+const writeDurableAgentEvent = (input) => Effect.gen(function* () {
 	const sequenced = sequenceDurableAgentEvent(input);
 	yield* Effect.tryPromise({
 		try: () => input.writer.write(encodeDurableAgentEventNdjson(sequenced.event)),
@@ -30,68 +30,35 @@ const writeDurableAgentEventEffect = (input) => Effect.gen(function* () {
 	});
 	return sequenced;
 });
-const writeDurableAgentEvent = async (input) => Effect.runPromise(writeDurableAgentEventEffect(input));
-const closedTerminalEventWriterResult = () => ({ _tag: "Closed" });
-const closeFailedTerminalEventWriterResult = (error) => ({
-	_tag: "CloseFailed",
-	error
-});
-const committedTerminalResult = (writeResult, closeResult) => ({
+const committedTerminalResult = (writeResult) => ({
 	_tag: "Committed",
-	writeResult,
-	closeResult
+	writeResult
 });
-const commitFailedTerminalResult = (commitError, writeResult, closeResult) => ({
+const commitFailedTerminalResult = (commitError, writeResult) => ({
 	_tag: "CommitFailed",
 	commitError,
-	writeResult,
-	closeResult
+	writeResult
 });
-const terminalWriteFailedResult = (error, closeResult) => ({
+const terminalWriteFailedResult = (error) => ({
 	_tag: "TerminalWriteFailed",
-	error,
-	closeResult
+	error
 });
-const commitErrorWriteFailedResult = (commitError, error, closeResult) => ({
+const commitErrorWriteFailedResult = (commitError, error) => ({
 	_tag: "CommitErrorWriteFailed",
 	commitError,
-	error,
-	closeResult
+	error
 });
-const closeTerminalEventWriterEffect = (close) => close.pipe(Effect.match({
-	onFailure: closeFailedTerminalEventWriterResult,
-	onSuccess: () => closedTerminalEventWriterResult()
-}));
-const commitThenWriteTerminalEventEffect = (input) => input.commit.pipe(Effect.matchEffect({
-	onFailure: (commitError) => input.writeCommitError(commitError).pipe(Effect.matchEffect({
-		onFailure: (error) => closeTerminalEventWriterEffect(input.close).pipe(Effect.map((closeResult) => commitErrorWriteFailedResult(commitError, error, closeResult))),
-		onSuccess: (writeResult) => closeTerminalEventWriterEffect(input.close).pipe(Effect.map((closeResult) => commitFailedTerminalResult(commitError, writeResult, closeResult)))
+const commitThenWriteTerminalEvent = (input) => input.commit.pipe(Effect.matchEffect({
+	onFailure: (commitError) => input.writeCommitError(commitError).pipe(Effect.match({
+		onFailure: (error) => commitErrorWriteFailedResult(commitError, error),
+		onSuccess: (writeResult) => commitFailedTerminalResult(commitError, writeResult)
 	})),
-	onSuccess: () => input.write(input.terminal).pipe(Effect.matchEffect({
-		onFailure: (error) => closeTerminalEventWriterEffect(input.close).pipe(Effect.map((closeResult) => terminalWriteFailedResult(error, closeResult))),
-		onSuccess: (writeResult) => closeTerminalEventWriterEffect(input.close).pipe(Effect.map((closeResult) => committedTerminalResult(writeResult, closeResult)))
+	onSuccess: () => input.write(input.terminal).pipe(Effect.match({
+		onFailure: (error) => terminalWriteFailedResult(error),
+		onSuccess: (writeResult) => committedTerminalResult(writeResult)
 	}))
 }));
-const commitThenWriteTerminalEvent = async (input) => Effect.runPromise(commitThenWriteTerminalEventEffect({
-	terminal: input.terminal,
-	commit: Effect.tryPromise({
-		try: input.commit,
-		catch: (cause) => cause
-	}),
-	write: (event) => Effect.tryPromise({
-		try: () => input.write(event),
-		catch: (cause) => cause
-	}),
-	writeCommitError: (error) => Effect.tryPromise({
-		try: () => input.writeCommitError(error),
-		catch: (cause) => cause
-	}),
-	close: Effect.tryPromise({
-		try: input.close,
-		catch: (cause) => cause
-	})
-}));
 //#endregion
-export { commitThenWriteTerminalEvent, commitThenWriteTerminalEventEffect, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent, writeDurableAgentEventEffect };
+export { commitThenWriteTerminalEvent, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent };
 
 //# sourceMappingURL=workflow-events.mjs.map

package/dist/workflow-events.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-events.mjs","names":[],"sources":["../src/workflow-events.ts"],"sourcesContent":["import { Effect } from 'effect'\n\nexport type DurableAgentEventSequencerState = {\n  readonly eventSequence: number\n}\n\nexport type DurableAgentEvent<Event extends object = object> = Event & {\n  readonly eventId: string\n  readonly createdAtMs?: number\n}\n\nexport type DurableAgentEventIdInput = {\n  readonly streamId: string\n  readonly turn: number\n  readonly eventSequence: number\n}\n\nexport type SequenceDurableAgentEventInput<Event extends object = object> = {\n  readonly state: DurableAgentEventSequencerState\n  /**\n   * Stable id namespace for one independent durable stream.\n   *\n   * Include the workflow/session/run id when multiple logical runs can be\n   * projected in the same client. Replay-safe clients de-dupe by `eventId`, so\n   * reusing a stream id across runs can drop legitimate follow-up events.\n   */\n  readonly streamId: string\n  readonly turn: number\n  readonly event: Event\n  readonly createdAtMs?: number\n}\n\nexport type SequencedDurableAgentEvent<Event extends object = object> = {\n  readonly event: DurableAgentEvent<Event>\n  readonly eventSequence: number\n  readonly nextEventSequence: number\n  readonly nextState: DurableAgentEventSequencerState\n}\n\nexport type WriteDurableAgentEventInput<Event extends object = object> =\n  SequenceDurableAgentEventInput<Event> & {\n    readonly writer: WritableStreamDefaultWriter<Uint8Array>\n  }\n\nexport type TerminalEventCloseResult =\n  | { readonly _tag: 'Closed' }\n  | { readonly _tag: 'CloseFailed'; readonly error: unknown }\n\nexport type CommitThenWriteTerminalEventInput<\n  TerminalEvent extends object,\n  TerminalWriteResult,\n  CommitErrorWriteResult\n> = {\n  readonly commit: () => Promise<void>\n  readonly terminal: TerminalEvent\n  readonly write: (event: TerminalEvent) => Promise<TerminalWriteResult>\n  readonly writeCommitError: (error: unknown) => Promise<CommitErrorWriteResult>\n  readonly close: () => Promise<void>\n}\n\nexport type CommitThenWriteTerminalEventEffectInput<\n  TerminalEvent extends object,\n  TerminalWriteResult,\n  CommitErrorWriteResult,\n  CommitError,\n  TerminalWriteError,\n  CommitErrorWriteError,\n  CloseError\n> = {\n  readonly commit: Effect.Effect<void, CommitError>\n  readonly terminal: TerminalEvent\n  readonly write: (event: TerminalEvent) => Effect.Effect<TerminalWriteResult, TerminalWriteError>\n  readonly writeCommitError: (\n    error: unknown\n  ) => Effect.Effect<CommitErrorWriteResult, CommitErrorWriteError>\n  readonly close: Effect.Effect<void, CloseError>\n}\n\nexport type CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> =\n  | {\n      readonly _tag: 'Committed'\n      readonly writeResult: TerminalWriteResult\n      readonly closeResult: TerminalEventCloseResult\n    }\n  | {\n      readonly _tag: 'CommitFailed'\n      readonly commitError: unknown\n      readonly writeResult: CommitErrorWriteResult\n      readonly closeResult: TerminalEventCloseResult\n    }\n  | {\n      readonly _tag: 'TerminalWriteFailed'\n      readonly error: unknown\n      readonly closeResult: TerminalEventCloseResult\n    }\n  | {\n      readonly _tag: 'CommitErrorWriteFailed'\n      readonly commitError: unknown\n      readonly error: unknown\n      readonly closeResult: TerminalEventCloseResult\n    }\n\nconst textEncoder = new TextEncoder()\n\nexport const makeDurableAgentEventSequencerState = (\n  eventSequence = 0\n): DurableAgentEventSequencerState => ({ eventSequence })\n\nexport const durableAgentEventId = (input: DurableAgentEventIdInput) =>\n  `${input.streamId}:${input.turn}:${input.eventSequence}`\n\nexport const sequenceDurableAgentEvent = <Event extends object>(\n  input: SequenceDurableAgentEventInput<Event>\n): SequencedDurableAgentEvent<Event> => {\n  const eventSequence = input.state.eventSequence\n  const nextEventSequence = eventSequence + 1\n  const event = {\n    ...input.event,\n    eventId: durableAgentEventId({\n      streamId: input.streamId,\n      turn: input.turn,\n      eventSequence\n    }),\n    ...(input.createdAtMs === undefined ? {} : { createdAtMs: input.createdAtMs })\n  }\n\n  return {\n    event,\n    eventSequence,\n    nextEventSequence,\n    nextState: makeDurableAgentEventSequencerState(nextEventSequence)\n  }\n}\n\nconst encodeDurableAgentEventNdjson = <Event extends object>(event: DurableAgentEvent<Event>) =>\n  textEncoder.encode(`${JSON.stringify(event)}\\n`)\n\nexport const writeDurableAgentEventEffect = <Event extends object>(\n  input: WriteDurableAgentEventInput<Event>\n): Effect.Effect<SequencedDurableAgentEvent<Event>, unknown> =>\n  Effect.gen(function* () {\n    const sequenced = sequenceDurableAgentEvent(input)\n    yield* Effect.tryPromise({\n      try: () => input.writer.write(encodeDurableAgentEventNdjson(sequenced.event)),\n      catch: cause => cause\n    })\n\n    return sequenced\n  })\n\nexport const writeDurableAgentEvent = async <Event extends object>(\n  input: WriteDurableAgentEventInput<Event>\n): Promise<SequencedDurableAgentEvent<Event>> =>\n  Effect.runPromise(writeDurableAgentEventEffect(input))\n\nconst closedTerminalEventWriterResult = (): TerminalEventCloseResult => ({ _tag: 'Closed' })\n\nconst closeFailedTerminalEventWriterResult = (error: unknown): TerminalEventCloseResult => ({\n  _tag: 'CloseFailed',\n  error\n})\n\nconst committedTerminalResult = <TerminalWriteResult, CommitErrorWriteResult>(\n  writeResult: TerminalWriteResult,\n  closeResult: TerminalEventCloseResult\n): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({\n  _tag: 'Committed',\n  writeResult,\n  closeResult\n})\n\nconst commitFailedTerminalResult = <TerminalWriteResult, CommitErrorWriteResult>(\n  commitError: unknown,\n  writeResult: CommitErrorWriteResult,\n  closeResult: TerminalEventCloseResult\n): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({\n  _tag: 'CommitFailed',\n  commitError,\n  writeResult,\n  closeResult\n})\n\nconst terminalWriteFailedResult = <TerminalWriteResult, CommitErrorWriteResult>(\n  error: unknown,\n  closeResult: TerminalEventCloseResult\n): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({\n  _tag: 'TerminalWriteFailed',\n  error,\n  closeResult\n})\n\nconst commitErrorWriteFailedResult = <TerminalWriteResult, CommitErrorWriteResult>(\n  commitError: unknown,\n  error: unknown,\n  closeResult: TerminalEventCloseResult\n): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({\n  _tag: 'CommitErrorWriteFailed',\n  commitError,\n  error,\n  closeResult\n})\n\nconst closeTerminalEventWriterEffect = <CloseError>(\n  close: Effect.Effect<void, CloseError>\n): Effect.Effect<TerminalEventCloseResult, never> =>\n  close.pipe(\n    Effect.match({\n      onFailure: closeFailedTerminalEventWriterResult,\n      onSuccess: () => closedTerminalEventWriterResult()\n    })\n  )\n\nexport const commitThenWriteTerminalEventEffect = <\n  TerminalEvent extends object,\n  TerminalWriteResult,\n  CommitErrorWriteResult,\n  CommitError,\n  TerminalWriteError,\n  CommitErrorWriteError,\n  CloseError\n>(\n  input: CommitThenWriteTerminalEventEffectInput<\n    TerminalEvent,\n    TerminalWriteResult,\n    CommitErrorWriteResult,\n    CommitError,\n    TerminalWriteError,\n    CommitErrorWriteError,\n    CloseError\n  >\n): Effect.Effect<\n  CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult>,\n  never\n> =>\n  input.commit.pipe(\n    Effect.matchEffect({\n      onFailure: commitError =>\n        input.writeCommitError(commitError).pipe(\n          Effect.matchEffect({\n            onFailure: error =>\n              closeTerminalEventWriterEffect(input.close).pipe(\n                Effect.map(closeResult =>\n                  commitErrorWriteFailedResult<TerminalWriteResult, CommitErrorWriteResult>(\n                    commitError,\n                    error,\n                    closeResult\n                  )\n                )\n              ),\n            onSuccess: writeResult =>\n              closeTerminalEventWriterEffect(input.close).pipe(\n                Effect.map(closeResult =>\n                  commitFailedTerminalResult<TerminalWriteResult, CommitErrorWriteResult>(\n                    commitError,\n                    writeResult,\n                    closeResult\n                  )\n                )\n              )\n          })\n        ),\n      onSuccess: () =>\n        input.write(input.terminal).pipe(\n          Effect.matchEffect({\n            onFailure: error =>\n              closeTerminalEventWriterEffect(input.close).pipe(\n                Effect.map(closeResult =>\n                  terminalWriteFailedResult<TerminalWriteResult, CommitErrorWriteResult>(\n                    error,\n                    closeResult\n                  )\n                )\n              ),\n            onSuccess: writeResult =>\n              closeTerminalEventWriterEffect(input.close).pipe(\n                Effect.map(closeResult =>\n                  committedTerminalResult<TerminalWriteResult, CommitErrorWriteResult>(\n                    writeResult,\n                    closeResult\n                  )\n                )\n              )\n          })\n        )\n    })\n  )\n\nexport const commitThenWriteTerminalEvent = async <\n  TerminalEvent extends object,\n  TerminalWriteResult,\n  CommitErrorWriteResult\n>(\n  input: CommitThenWriteTerminalEventInput<\n    TerminalEvent,\n    TerminalWriteResult,\n    CommitErrorWriteResult\n  >\n): Promise<CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult>> =>\n  Effect.runPromise(\n    commitThenWriteTerminalEventEffect({\n      terminal: input.terminal,\n      commit: Effect.tryPromise({\n        try: input.commit,\n        catch: cause => cause\n      }),\n      write: event =>\n        Effect.tryPromise({\n          try: () => input.write(event),\n          catch: cause => cause\n        }),\n      writeCommitError: error =>\n        Effect.tryPromise({\n          try: () => input.writeCommitError(error),\n          catch: cause => cause\n        }),\n      close: Effect.tryPromise({\n        try: input.close,\n        catch: cause => cause\n      })\n    })\n  )\n"],"mappings":"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"}
+{"version":3,"file":"workflow-events.mjs","names":[],"sources":["../src/workflow-events.ts"],"sourcesContent":["import { Effect } from 'effect'\n\nexport type DurableAgentEventSequencerState = {\n  readonly eventSequence: number\n}\n\nexport type DurableAgentEvent<Event extends object = object> = Event & {\n  readonly eventId: string\n  readonly createdAtMs?: number\n}\n\nexport type DurableAgentEventIdInput = {\n  readonly streamId: string\n  readonly turn: number\n  readonly eventSequence: number\n}\n\nexport type SequenceDurableAgentEventInput<Event extends object = object> = {\n  readonly state: DurableAgentEventSequencerState\n  /**\n   * Stable id namespace for one independent durable stream.\n   *\n   * Include the workflow/session/run id when multiple logical runs can be\n   * projected in the same client. Replay-safe clients de-dupe by `eventId`, so\n   * reusing a stream id across runs can drop legitimate follow-up events.\n   */\n  readonly streamId: string\n  readonly turn: number\n  readonly event: Event\n  readonly createdAtMs?: number\n}\n\nexport type SequencedDurableAgentEvent<Event extends object = object> = {\n  readonly event: DurableAgentEvent<Event>\n  readonly eventSequence: number\n  readonly nextEventSequence: number\n  readonly nextState: DurableAgentEventSequencerState\n}\n\nexport type WriteDurableAgentEventInput<Event extends object = object> =\n  SequenceDurableAgentEventInput<Event> & {\n    readonly writer: WritableStreamDefaultWriter<Uint8Array>\n  }\n\nexport type CommitThenWriteTerminalEventInput<\n  TerminalEvent extends object,\n  TerminalWriteResult,\n  CommitErrorWriteResult,\n  CommitError,\n  TerminalWriteError,\n  CommitErrorWriteError\n> = {\n  readonly commit: Effect.Effect<void, CommitError>\n  readonly terminal: TerminalEvent\n  readonly write: (event: TerminalEvent) => Effect.Effect<TerminalWriteResult, TerminalWriteError>\n  readonly writeCommitError: (\n    error: unknown\n  ) => Effect.Effect<CommitErrorWriteResult, CommitErrorWriteError>\n}\n\nexport type CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> =\n  | {\n      readonly _tag: 'Committed'\n      readonly writeResult: TerminalWriteResult\n    }\n  | {\n      readonly _tag: 'CommitFailed'\n      readonly commitError: unknown\n      readonly writeResult: CommitErrorWriteResult\n    }\n  | {\n      readonly _tag: 'TerminalWriteFailed'\n      readonly error: unknown\n    }\n  | {\n      readonly _tag: 'CommitErrorWriteFailed'\n      readonly commitError: unknown\n      readonly error: unknown\n    }\n\nconst textEncoder = new TextEncoder()\n\nexport const makeDurableAgentEventSequencerState = (\n  eventSequence = 0\n): DurableAgentEventSequencerState => ({ eventSequence })\n\nexport const durableAgentEventId = (input: DurableAgentEventIdInput) =>\n  `${input.streamId}:${input.turn}:${input.eventSequence}`\n\nexport const sequenceDurableAgentEvent = <Event extends object>(\n  input: SequenceDurableAgentEventInput<Event>\n): SequencedDurableAgentEvent<Event> => {\n  const eventSequence = input.state.eventSequence\n  const nextEventSequence = eventSequence + 1\n  const event = {\n    ...input.event,\n    eventId: durableAgentEventId({\n      streamId: input.streamId,\n      turn: input.turn,\n      eventSequence\n    }),\n    ...(input.createdAtMs === undefined ? {} : { createdAtMs: input.createdAtMs })\n  }\n\n  return {\n    event,\n    eventSequence,\n    nextEventSequence,\n    nextState: makeDurableAgentEventSequencerState(nextEventSequence)\n  }\n}\n\nconst encodeDurableAgentEventNdjson = <Event extends object>(event: DurableAgentEvent<Event>) =>\n  textEncoder.encode(`${JSON.stringify(event)}\\n`)\n\nexport const writeDurableAgentEvent = <Event extends object>(\n  input: WriteDurableAgentEventInput<Event>\n): Effect.Effect<SequencedDurableAgentEvent<Event>, unknown> =>\n  Effect.gen(function* () {\n    const sequenced = sequenceDurableAgentEvent(input)\n    yield* Effect.tryPromise({\n      try: () => input.writer.write(encodeDurableAgentEventNdjson(sequenced.event)),\n      catch: cause => cause\n    })\n\n    return sequenced\n  })\n\nconst committedTerminalResult = <TerminalWriteResult, CommitErrorWriteResult>(\n  writeResult: TerminalWriteResult\n): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({\n  _tag: 'Committed',\n  writeResult\n})\n\nconst commitFailedTerminalResult = <TerminalWriteResult, CommitErrorWriteResult>(\n  commitError: unknown,\n  writeResult: CommitErrorWriteResult\n): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({\n  _tag: 'CommitFailed',\n  commitError,\n  writeResult\n})\n\nconst terminalWriteFailedResult = <TerminalWriteResult, CommitErrorWriteResult>(\n  error: unknown\n): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({\n  _tag: 'TerminalWriteFailed',\n  error\n})\n\nconst commitErrorWriteFailedResult = <TerminalWriteResult, CommitErrorWriteResult>(\n  commitError: unknown,\n  error: unknown\n): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({\n  _tag: 'CommitErrorWriteFailed',\n  commitError,\n  error\n})\n\nexport const commitThenWriteTerminalEvent = <\n  TerminalEvent extends object,\n  TerminalWriteResult,\n  CommitErrorWriteResult,\n  CommitError,\n  TerminalWriteError,\n  CommitErrorWriteError\n>(\n  input: CommitThenWriteTerminalEventInput<\n    TerminalEvent,\n    TerminalWriteResult,\n    CommitErrorWriteResult,\n    CommitError,\n    TerminalWriteError,\n    CommitErrorWriteError\n  >\n): Effect.Effect<\n  CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult>,\n  never\n> =>\n  input.commit.pipe(\n    Effect.matchEffect({\n      onFailure: commitError =>\n        input.writeCommitError(commitError).pipe(\n          Effect.match({\n            onFailure: error =>\n              commitErrorWriteFailedResult<TerminalWriteResult, CommitErrorWriteResult>(\n                commitError,\n                error\n              ),\n            onSuccess: writeResult =>\n              commitFailedTerminalResult<TerminalWriteResult, CommitErrorWriteResult>(\n                commitError,\n                writeResult\n              )\n          })\n        ),\n      onSuccess: () =>\n        input.write(input.terminal).pipe(\n          Effect.match({\n            onFailure: error =>\n              terminalWriteFailedResult<TerminalWriteResult, CommitErrorWriteResult>(error),\n            onSuccess: writeResult =>\n              committedTerminalResult<TerminalWriteResult, CommitErrorWriteResult>(writeResult)\n          })\n        )\n    })\n  )\n"],"mappings":";;AAgFA,MAAM,cAAc,IAAI,YAAY;AAEpC,MAAa,uCACX,gBAAgB,OACqB,EAAE,cAAc;AAEvD,MAAa,uBAAuB,UAClC,GAAG,MAAM,SAAS,GAAG,MAAM,KAAK,GAAG,MAAM;AAE3C,MAAa,6BACX,UACsC;CACtC,MAAM,gBAAgB,MAAM,MAAM;CAClC,MAAM,oBAAoB,gBAAgB;CAW1C,OAAO;EACL,OAAA;GAVA,GAAG,MAAM;GACT,SAAS,oBAAoB;IAC3B,UAAU,MAAM;IAChB,MAAM,MAAM;IACZ;GACF,CAAC;GACD,GAAI,MAAM,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,aAAa,MAAM,YAAY;EAIxE;EACJ;EACA;EACA,WAAW,oCAAoC,iBAAiB;CAClE;AACF;AAEA,MAAM,iCAAuD,UAC3D,YAAY,OAAO,GAAG,KAAK,UAAU,KAAK,EAAE,GAAG;AAEjD,MAAa,0BACX,UAEA,OAAO,IAAI,aAAa;CACtB,MAAM,YAAY,0BAA0B,KAAK;CACjD,OAAO,OAAO,WAAW;EACvB,WAAW,MAAM,OAAO,MAAM,8BAA8B,UAAU,KAAK,CAAC;EAC5E,QAAO,UAAS;CAClB,CAAC;CAED,OAAO;AACT,CAAC;AAEH,MAAM,2BACJ,iBACqF;CACrF,MAAM;CACN;AACF;AAEA,MAAM,8BACJ,aACA,iBACqF;CACrF,MAAM;CACN;CACA;AACF;AAEA,MAAM,6BACJ,WACqF;CACrF,MAAM;CACN;AACF;AAEA,MAAM,gCACJ,aACA,WACqF;CACrF,MAAM;CACN;CACA;AACF;AAEA,MAAa,gCAQX,UAYA,MAAM,OAAO,KACX,OAAO,YAAY;CACjB,YAAW,gBACT,MAAM,iBAAiB,WAAW,EAAE,KAClC,OAAO,MAAM;EACX,YAAW,UACT,6BACE,aACA,KACF;EACF,YAAW,gBACT,2BACE,aACA,WACF;CACJ,CAAC,CACH;CACF,iBACE,MAAM,MAAM,MAAM,QAAQ,EAAE,KAC1B,OAAO,MAAM;EACX,YAAW,UACT,0BAAuE,KAAK;EAC9E,YAAW,gBACT,wBAAqE,WAAW;CACpF,CAAC,CACH;AACJ,CAAC,CACH"}

package/dist/workflow-loop.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-loop.d.mts","names":[],"sources":["../src/workflow-loop.ts"],"mappings":"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"}
+{"version":3,"file":"workflow-loop.d.mts","names":[],"sources":["../src/workflow-loop.ts"],"mappings":"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"}

package/dist/workflow-loop.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-loop.mjs","names":[],"sources":["../src/workflow-loop.ts"],"sourcesContent":["export type VercelAgentWorkflowInput = {\n  readonly request: unknown\n  readonly context: unknown\n}\n\nexport type SerializableWorkflowState = {\n  readonly request: unknown\n  readonly messages?: ReadonlyArray<unknown>\n  readonly createdMessages: ReadonlyArray<unknown>\n  readonly usage?: unknown\n  readonly turn: number\n  readonly eventSequence?: number\n}\n\nexport type VercelAgentWorkflowModelStepInput = {\n  readonly context: unknown\n  readonly state: SerializableWorkflowState\n}\n\nexport type VercelAgentWorkflowModelStepResult = {\n  readonly done: boolean\n  readonly messages: ReadonlyArray<unknown>\n  readonly createdMessages: ReadonlyArray<unknown>\n  readonly toolCalls: ReadonlyArray<unknown>\n  readonly usage: unknown\n  readonly turn: number\n  readonly eventSequence?: number\n}\n\nexport type VercelAgentWorkflowToolBatchStepInput = {\n  readonly context: unknown\n  readonly request: unknown\n  readonly calls: ReadonlyArray<unknown>\n  readonly createdMessages: ReadonlyArray<unknown>\n  readonly hitlResponses?: ReadonlyArray<unknown>\n  readonly usage?: unknown\n  readonly turn?: number\n  readonly eventSequence?: number\n}\n\nexport type VercelAgentWorkflowAwaitingInput = {\n  readonly hookToken: string\n  readonly requests: ReadonlyArray<unknown>\n  readonly messages: ReadonlyArray<unknown>\n  readonly usage: unknown\n  readonly turns: number\n  readonly eventSequence?: number\n}\n\nexport type VercelAgentWorkflowToolBatchStepResult = {\n  readonly messages: ReadonlyArray<unknown>\n  readonly createdMessages: ReadonlyArray<unknown>\n  readonly awaitingInput?: VercelAgentWorkflowAwaitingInput\n  readonly eventSequence?: number\n}\n\nexport type WorkflowStepResult<A> =\n  | {\n      readonly _tag: 'Success'\n      readonly value: A\n    }\n  | {\n      readonly _tag: 'Failure'\n      readonly error: unknown\n    }\n\nexport type VercelAgentWorkflowStepRetryPolicy = {\n  readonly maxAttempts: number\n}\n\nexport type VercelAgentWorkflowRunResult =\n  | {\n      readonly _tag: 'Completed'\n      readonly turns: number\n      readonly state: SerializableWorkflowState\n    }\n  | {\n      readonly _tag: 'ModelStepFailed'\n      readonly turn: number\n      readonly error: unknown\n      readonly state: SerializableWorkflowState\n    }\n  | {\n      readonly _tag: 'ToolBatchStepFailed'\n      readonly turn: number\n      readonly error: unknown\n      readonly state: SerializableWorkflowState\n    }\n  | {\n      readonly _tag: 'AwaitInputFailed'\n      readonly turn: number\n      readonly error: unknown\n      readonly awaitingInput: VercelAgentWorkflowAwaitingInput\n      readonly state: SerializableWorkflowState\n    }\n  | {\n      readonly _tag: 'CloseStreamFailed'\n      readonly turns: number\n      readonly error: unknown\n      readonly state: SerializableWorkflowState\n    }\n  | {\n      readonly _tag: 'MaxTurnsExceeded'\n      readonly maxTurns: number\n      readonly error: Error\n      readonly state: SerializableWorkflowState\n    }\n\nexport type VercelAgentWorkflowLoopConfig = {\n  readonly input: VercelAgentWorkflowInput\n  readonly maxTurns?: number\n  readonly runModelStep: (\n    input: VercelAgentWorkflowModelStepInput\n  ) => Promise<VercelAgentWorkflowModelStepResult>\n  readonly runToolBatchStep: (\n    input: VercelAgentWorkflowToolBatchStepInput\n  ) => Promise<VercelAgentWorkflowToolBatchStepResult>\n  readonly closeStream: () => Promise<void>\n  readonly writeError: (error: unknown) => Promise<void>\n  readonly awaitInput?: (input: VercelAgentWorkflowAwaitingInput) => Promise<unknown>\n  readonly modelStepRetry?: VercelAgentWorkflowStepRetryPolicy\n  readonly toolBatchStepRetry?: VercelAgentWorkflowStepRetryPolicy\n  readonly awaitInputRetry?: VercelAgentWorkflowStepRetryPolicy\n  readonly closeStreamRetry?: VercelAgentWorkflowStepRetryPolicy\n}\n\nexport const defaultMaxWorkflowTurns = 500\nexport const noWorkflowStepRetry: VercelAgentWorkflowStepRetryPolicy = { maxAttempts: 1 }\n\nexport const settleWorkflowStep = <A>(promise: Promise<A>): Promise<WorkflowStepResult<A>> =>\n  promise.then(\n    value => ({ _tag: 'Success', value }),\n    error => ({ _tag: 'Failure', error })\n  )\n\nconst workflowMaxTurnsError = (maxTurns: number) =>\n  new Error(`Vercel agent workflow exceeded max turns: ${maxTurns}`)\n\nconst writeErrorSafely = (writeError: (error: unknown) => Promise<void>, error: unknown) =>\n  writeError(error).catch(() => undefined)\n\nconst missingAwaitInputHandlerError = () =>\n  new Error(\n    'Vercel agent workflow awaiting input requested but no awaitInput handler is configured'\n  )\n\nconst maxRetryAttempts = (policy: VercelAgentWorkflowStepRetryPolicy | undefined) =>\n  Math.max(1, Math.floor(policy?.maxAttempts ?? noWorkflowStepRetry.maxAttempts))\n\nexport async function retryWorkflowStep<A>(\n  runStep: () => Promise<A>,\n  policy?: VercelAgentWorkflowStepRetryPolicy\n): Promise<A> {\n  const maxAttempts = maxRetryAttempts(policy)\n  let attempt = 1\n\n  for (;;) {\n    try {\n      return await runStep()\n    } catch (error) {\n      if (attempt >= maxAttempts) {\n        throw error\n      }\n\n      attempt += 1\n    }\n  }\n}\n\nexport async function runVercelAgentWorkflow(\n  config: VercelAgentWorkflowLoopConfig\n): Promise<VercelAgentWorkflowRunResult> {\n  const {\n    input,\n    maxTurns: configuredMaxTurns,\n    runModelStep,\n    runToolBatchStep,\n    closeStream,\n    writeError,\n    awaitInput,\n    modelStepRetry,\n    toolBatchStepRetry,\n    awaitInputRetry,\n    closeStreamRetry\n  } = config\n  let state: SerializableWorkflowState = {\n    request: input.request,\n    createdMessages: [],\n    turn: 1,\n    eventSequence: 0\n  }\n  const maxTurns = configuredMaxTurns ?? defaultMaxWorkflowTurns\n\n  for (let step = 0; step < maxTurns; step++) {\n    const modelResult = await settleWorkflowStep(\n      retryWorkflowStep(() => runModelStep({ context: input.context, state }), modelStepRetry)\n    )\n\n    if (modelResult._tag === 'Failure') {\n      await writeErrorSafely(writeError, modelResult.error)\n      return {\n        _tag: 'ModelStepFailed',\n        turn: state.turn,\n        error: modelResult.error,\n        state\n      }\n    }\n\n    if (modelResult.value.done) {\n      const closeResult = await settleWorkflowStep(retryWorkflowStep(closeStream, closeStreamRetry))\n\n      if (closeResult._tag === 'Failure') {\n        await writeErrorSafely(writeError, closeResult.error)\n\n        return {\n          _tag: 'CloseStreamFailed',\n          turns: modelResult.value.turn,\n          error: closeResult.error,\n          state\n        }\n      }\n\n      return {\n        _tag: 'Completed',\n        turns: modelResult.value.turn,\n        state\n      }\n    }\n\n    let completedToolsResult: VercelAgentWorkflowToolBatchStepResult | undefined\n    let toolHitlResponses: ReadonlyArray<unknown> = []\n    let toolEventSequence = modelResult.value.eventSequence ?? state.eventSequence\n\n    for (;;) {\n      const toolsResult = await settleWorkflowStep(\n        retryWorkflowStep(\n          () =>\n            runToolBatchStep({\n              context: input.context,\n              request: input.request,\n              calls: modelResult.value.toolCalls,\n              createdMessages: modelResult.value.createdMessages,\n              hitlResponses: toolHitlResponses,\n              usage: modelResult.value.usage,\n              turn: modelResult.value.turn,\n              eventSequence: toolEventSequence\n            }),\n          toolBatchStepRetry\n        )\n      )\n\n      if (toolsResult._tag === 'Failure') {\n        await writeErrorSafely(writeError, toolsResult.error)\n\n        return {\n          _tag: 'ToolBatchStepFailed',\n          turn: modelResult.value.turn,\n          error: toolsResult.error,\n          state\n        }\n      }\n\n      if (toolsResult.value.awaitingInput === undefined) {\n        completedToolsResult = toolsResult.value\n        break\n      }\n\n      const awaitingInput = toolsResult.value.awaitingInput\n      toolEventSequence =\n        awaitingInput.eventSequence ?? toolsResult.value.eventSequence ?? toolEventSequence\n\n      const hitlResponse = await settleWorkflowStep(\n        retryWorkflowStep(() => {\n          if (awaitInput === undefined) {\n            return Promise.reject(missingAwaitInputHandlerError())\n          }\n\n          return awaitInput(awaitingInput)\n        }, awaitInputRetry)\n      )\n\n      if (hitlResponse._tag === 'Failure') {\n        await writeErrorSafely(writeError, hitlResponse.error)\n\n        return {\n          _tag: 'AwaitInputFailed',\n          turn: modelResult.value.turn,\n          error: hitlResponse.error,\n          awaitingInput,\n          state\n        }\n      }\n\n      toolHitlResponses = [...toolHitlResponses, hitlResponse.value]\n    }\n\n    if (completedToolsResult === undefined) {\n      const error = new Error('Vercel agent workflow tool batch did not complete')\n      await writeErrorSafely(writeError, error)\n\n      return {\n        _tag: 'ToolBatchStepFailed',\n        turn: modelResult.value.turn,\n        error,\n        state\n      }\n    }\n\n    state = {\n      request: input.request,\n      messages: [...modelResult.value.messages, ...completedToolsResult.messages],\n      createdMessages: completedToolsResult.createdMessages,\n      usage: modelResult.value.usage,\n      turn: modelResult.value.turn + 1,\n      eventSequence: completedToolsResult.eventSequence ?? toolEventSequence\n    }\n  }\n\n  const error = workflowMaxTurnsError(maxTurns)\n  await writeErrorSafely(writeError, error)\n\n  return {\n    _tag: 'MaxTurnsExceeded',\n    maxTurns,\n    error,\n    state\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"workflow-loop.mjs","names":[],"sources":["../src/workflow-loop.ts"],"sourcesContent":["export type VercelAgentWorkflowInput = {\n  readonly request: unknown\n  readonly context: unknown\n}\n\nexport type SerializableWorkflowState = {\n  readonly request: unknown\n  readonly messages?: ReadonlyArray<unknown>\n  readonly createdMessages: ReadonlyArray<unknown>\n  readonly usage?: unknown\n  readonly turn: number\n  readonly eventSequence?: number\n}\n\nexport type VercelAgentWorkflowModelStepInput = {\n  readonly context: unknown\n  readonly state: SerializableWorkflowState\n}\n\nexport type VercelAgentWorkflowModelStepResult = {\n  readonly done: boolean\n  readonly messages: ReadonlyArray<unknown>\n  readonly createdMessages: ReadonlyArray<unknown>\n  readonly toolCalls: ReadonlyArray<unknown>\n  readonly usage: unknown\n  readonly turn: number\n  readonly eventSequence?: number\n}\n\nexport type VercelAgentWorkflowToolBatchStepInput = {\n  readonly context: unknown\n  readonly request: unknown\n  readonly calls: ReadonlyArray<unknown>\n  readonly createdMessages: ReadonlyArray<unknown>\n  readonly hitlResponses?: ReadonlyArray<unknown>\n  readonly usage?: unknown\n  readonly turn?: number\n  readonly eventSequence?: number\n}\n\nexport type VercelAgentWorkflowAwaitingInput = {\n  readonly hookToken: string\n  readonly requests: ReadonlyArray<unknown>\n  readonly messages: ReadonlyArray<unknown>\n  readonly usage: unknown\n  readonly turns: number\n  readonly eventSequence?: number\n}\n\nexport type VercelAgentWorkflowToolBatchStepResult = {\n  readonly messages: ReadonlyArray<unknown>\n  readonly createdMessages: ReadonlyArray<unknown>\n  readonly awaitingInput?: VercelAgentWorkflowAwaitingInput\n  readonly eventSequence?: number\n}\n\nexport type WorkflowStepResult<A> =\n  | {\n      readonly _tag: 'Success'\n      readonly value: A\n    }\n  | {\n      readonly _tag: 'Failure'\n      readonly error: unknown\n    }\n\nexport type VercelAgentWorkflowStepRetryPolicy = {\n  readonly maxAttempts: number\n}\n\nexport type VercelAgentWorkflowRunResult =\n  | {\n      readonly _tag: 'Completed'\n      readonly turns: number\n      readonly state: SerializableWorkflowState\n    }\n  | {\n      readonly _tag: 'ModelStepFailed'\n      readonly turn: number\n      readonly error: unknown\n      readonly state: SerializableWorkflowState\n    }\n  | {\n      readonly _tag: 'ToolBatchStepFailed'\n      readonly turn: number\n      readonly error: unknown\n      readonly state: SerializableWorkflowState\n    }\n  | {\n      readonly _tag: 'AwaitInputFailed'\n      readonly turn: number\n      readonly error: unknown\n      readonly awaitingInput: VercelAgentWorkflowAwaitingInput\n      readonly state: SerializableWorkflowState\n    }\n  | {\n      readonly _tag: 'CloseStreamFailed'\n      readonly turns: number\n      readonly error: unknown\n      readonly state: SerializableWorkflowState\n    }\n  | {\n      readonly _tag: 'MaxTurnsExceeded'\n      readonly maxTurns: number\n      readonly error: Error\n      readonly state: SerializableWorkflowState\n    }\n\nexport type VercelAgentWorkflowLoopConfig = {\n  readonly input: VercelAgentWorkflowInput\n  readonly maxTurns?: number\n  readonly runModelStep: (\n    input: VercelAgentWorkflowModelStepInput\n  ) => Promise<VercelAgentWorkflowModelStepResult>\n  readonly runToolBatchStep: (\n    input: VercelAgentWorkflowToolBatchStepInput\n  ) => Promise<VercelAgentWorkflowToolBatchStepResult>\n  readonly closeStream: () => Promise<void>\n  readonly writeError: (error: unknown) => Promise<void>\n  readonly awaitInput?: (input: VercelAgentWorkflowAwaitingInput) => Promise<unknown>\n  readonly modelStepRetry?: VercelAgentWorkflowStepRetryPolicy\n  readonly toolBatchStepRetry?: VercelAgentWorkflowStepRetryPolicy\n  readonly awaitInputRetry?: VercelAgentWorkflowStepRetryPolicy\n  readonly closeStreamRetry?: VercelAgentWorkflowStepRetryPolicy\n}\n\nexport const defaultMaxWorkflowTurns = 500\nexport const noWorkflowStepRetry: VercelAgentWorkflowStepRetryPolicy = { maxAttempts: 1 }\n\nexport const settleWorkflowStep = <A>(promise: Promise<A>): Promise<WorkflowStepResult<A>> =>\n  promise.then(\n    value => ({ _tag: 'Success', value }),\n    error => ({ _tag: 'Failure', error })\n  )\n\nconst workflowMaxTurnsError = (maxTurns: number) =>\n  new Error(`Vercel agent workflow exceeded max turns: ${maxTurns}`)\n\nconst writeErrorSafely = (writeError: (error: unknown) => Promise<void>, error: unknown) =>\n  writeError(error).catch(() => undefined)\n\nconst missingAwaitInputHandlerError = () =>\n  new Error(\n    'Vercel agent workflow awaiting input requested but no awaitInput handler is configured'\n  )\n\nconst maxRetryAttempts = (policy: VercelAgentWorkflowStepRetryPolicy | undefined) =>\n  Math.max(1, Math.floor(policy?.maxAttempts ?? noWorkflowStepRetry.maxAttempts))\n\nexport async function retryWorkflowStep<A>(\n  runStep: () => Promise<A>,\n  policy?: VercelAgentWorkflowStepRetryPolicy\n): Promise<A> {\n  const maxAttempts = maxRetryAttempts(policy)\n\n  let attempt = 1\n\n  for (;;) {\n    try {\n      return await runStep()\n    } catch (error) {\n      if (attempt >= maxAttempts) {\n        throw error\n      }\n\n      attempt += 1\n    }\n  }\n}\n\nexport async function runVercelAgentWorkflow(\n  config: VercelAgentWorkflowLoopConfig\n): Promise<VercelAgentWorkflowRunResult> {\n  const {\n    input,\n    maxTurns: configuredMaxTurns,\n    runModelStep,\n    runToolBatchStep,\n    closeStream,\n    writeError,\n    awaitInput,\n    modelStepRetry,\n    toolBatchStepRetry,\n    awaitInputRetry,\n    closeStreamRetry\n  } = config\n  let state: SerializableWorkflowState = {\n    request: input.request,\n    createdMessages: [],\n    turn: 1,\n    eventSequence: 0\n  }\n  const maxTurns = configuredMaxTurns ?? defaultMaxWorkflowTurns\n\n  for (let step = 0; step < maxTurns; step++) {\n    const modelResult = await settleWorkflowStep(\n      retryWorkflowStep(() => runModelStep({ context: input.context, state }), modelStepRetry)\n    )\n\n    if (modelResult._tag === 'Failure') {\n      await writeErrorSafely(writeError, modelResult.error)\n      return {\n        _tag: 'ModelStepFailed',\n        turn: state.turn,\n        error: modelResult.error,\n        state\n      }\n    }\n\n    if (modelResult.value.done) {\n      const closeResult = await settleWorkflowStep(retryWorkflowStep(closeStream, closeStreamRetry))\n\n      if (closeResult._tag === 'Failure') {\n        await writeErrorSafely(writeError, closeResult.error)\n\n        return {\n          _tag: 'CloseStreamFailed',\n          turns: modelResult.value.turn,\n          error: closeResult.error,\n          state\n        }\n      }\n\n      return {\n        _tag: 'Completed',\n        turns: modelResult.value.turn,\n        state\n      }\n    }\n\n    let completedToolsResult: VercelAgentWorkflowToolBatchStepResult | undefined\n    let toolHitlResponses: ReadonlyArray<unknown> = []\n    let toolEventSequence = modelResult.value.eventSequence ?? state.eventSequence\n\n    for (;;) {\n      const toolsResult = await settleWorkflowStep(\n        retryWorkflowStep(\n          () =>\n            runToolBatchStep({\n              context: input.context,\n              request: input.request,\n              calls: modelResult.value.toolCalls,\n              createdMessages: modelResult.value.createdMessages,\n              hitlResponses: toolHitlResponses,\n              usage: modelResult.value.usage,\n              turn: modelResult.value.turn,\n              eventSequence: toolEventSequence\n            }),\n          toolBatchStepRetry\n        )\n      )\n\n      if (toolsResult._tag === 'Failure') {\n        await writeErrorSafely(writeError, toolsResult.error)\n\n        return {\n          _tag: 'ToolBatchStepFailed',\n          turn: modelResult.value.turn,\n          error: toolsResult.error,\n          state\n        }\n      }\n\n      if (toolsResult.value.awaitingInput === undefined) {\n        completedToolsResult = toolsResult.value\n        break\n      }\n\n      const awaitingInput = toolsResult.value.awaitingInput\n      toolEventSequence =\n        awaitingInput.eventSequence ?? toolsResult.value.eventSequence ?? toolEventSequence\n\n      const hitlResponse = await settleWorkflowStep(\n        retryWorkflowStep(() => {\n          if (awaitInput === undefined) {\n            return Promise.reject(missingAwaitInputHandlerError())\n          }\n\n          return awaitInput(awaitingInput)\n        }, awaitInputRetry)\n      )\n\n      if (hitlResponse._tag === 'Failure') {\n        await writeErrorSafely(writeError, hitlResponse.error)\n\n        return {\n          _tag: 'AwaitInputFailed',\n          turn: modelResult.value.turn,\n          error: hitlResponse.error,\n          awaitingInput,\n          state\n        }\n      }\n\n      toolHitlResponses = [...toolHitlResponses, hitlResponse.value]\n    }\n\n    if (completedToolsResult === undefined) {\n      const error = new Error('Vercel agent workflow tool batch did not complete')\n      await writeErrorSafely(writeError, error)\n\n      return {\n        _tag: 'ToolBatchStepFailed',\n        turn: modelResult.value.turn,\n        error,\n        state\n      }\n    }\n\n    state = {\n      request: input.request,\n      messages: [...modelResult.value.messages, ...completedToolsResult.messages],\n      createdMessages: completedToolsResult.createdMessages,\n      usage: modelResult.value.usage,\n      turn: modelResult.value.turn + 1,\n      eventSequence: completedToolsResult.eventSequence ?? toolEventSequence\n    }\n  }\n\n  const error = workflowMaxTurnsError(maxTurns)\n  await writeErrorSafely(writeError, error)\n\n  return {\n    _tag: 'MaxTurnsExceeded',\n    maxTurns,\n    error,\n    state\n  }\n}\n"],"mappings":"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"}

package/dist/workflow.d.mts

@@ -1,3 +1,3 @@
 import { SerializableWorkflowState, VercelAgentWorkflowAwaitingInput, VercelAgentWorkflowInput, VercelAgentWorkflowLoopConfig, VercelAgentWorkflowModelStepInput, VercelAgentWorkflowModelStepResult, VercelAgentWorkflowRunResult, VercelAgentWorkflowStepRetryPolicy, VercelAgentWorkflowToolBatchStepInput, VercelAgentWorkflowToolBatchStepResult, WorkflowStepResult, defaultMaxWorkflowTurns, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, settleWorkflowStep } from "./workflow-loop.mjs";
-import { CommitThenWriteTerminalEventEffectInput, CommitThenWriteTerminalEventInput, CommitThenWriteTerminalEventResult, DurableAgentEvent, DurableAgentEventIdInput, DurableAgentEventSequencerState, SequenceDurableAgentEventInput, SequencedDurableAgentEvent, TerminalEventCloseResult, WriteDurableAgentEventInput, commitThenWriteTerminalEvent, commitThenWriteTerminalEventEffect, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent, writeDurableAgentEventEffect } from "./workflow-events.mjs";
-export { type CommitThenWriteTerminalEventEffectInput, type CommitThenWriteTerminalEventInput, type CommitThenWriteTerminalEventResult, type DurableAgentEvent, type DurableAgentEventIdInput, type DurableAgentEventSequencerState, type SequenceDurableAgentEventInput, type SequencedDurableAgentEvent, type SerializableWorkflowState, type TerminalEventCloseResult, type VercelAgentWorkflowAwaitingInput, type VercelAgentWorkflowInput, type VercelAgentWorkflowLoopConfig, type VercelAgentWorkflowModelStepInput, type VercelAgentWorkflowModelStepResult, type VercelAgentWorkflowRunResult, type VercelAgentWorkflowStepRetryPolicy, type VercelAgentWorkflowToolBatchStepInput, type VercelAgentWorkflowToolBatchStepResult, type WorkflowStepResult, type WriteDurableAgentEventInput, commitThenWriteTerminalEvent, commitThenWriteTerminalEventEffect, defaultMaxWorkflowTurns, durableAgentEventId, makeDurableAgentEventSequencerState, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, sequenceDurableAgentEvent, settleWorkflowStep, writeDurableAgentEvent, writeDurableAgentEventEffect };
+import { CommitThenWriteTerminalEventInput, CommitThenWriteTerminalEventResult, DurableAgentEvent, DurableAgentEventIdInput, DurableAgentEventSequencerState, SequenceDurableAgentEventInput, SequencedDurableAgentEvent, WriteDurableAgentEventInput, commitThenWriteTerminalEvent, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent } from "./workflow-events.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, type VercelAgentWorkflowRunResult, type VercelAgentWorkflowStepRetryPolicy, type VercelAgentWorkflowToolBatchStepInput, type VercelAgentWorkflowToolBatchStepResult, type WorkflowStepResult, type WriteDurableAgentEventInput, commitThenWriteTerminalEvent, defaultMaxWorkflowTurns, durableAgentEventId, makeDurableAgentEventSequencerState, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, sequenceDurableAgentEvent, settleWorkflowStep, writeDurableAgentEvent };

package/dist/workflow.mjs

@@ -1,3 +1,3 @@
 import { defaultMaxWorkflowTurns, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, settleWorkflowStep } from "./workflow-loop.mjs";
-import { commitThenWriteTerminalEvent, commitThenWriteTerminalEventEffect, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent, writeDurableAgentEventEffect } from "./workflow-events.mjs";
-export { commitThenWriteTerminalEvent, commitThenWriteTerminalEventEffect, defaultMaxWorkflowTurns, durableAgentEventId, makeDurableAgentEventSequencerState, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, sequenceDurableAgentEvent, settleWorkflowStep, writeDurableAgentEvent, writeDurableAgentEventEffect };
+import { commitThenWriteTerminalEvent, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent } from "./workflow-events.mjs";
+export { commitThenWriteTerminalEvent, defaultMaxWorkflowTurns, durableAgentEventId, makeDurableAgentEventSequencerState, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, sequenceDurableAgentEvent, settleWorkflowStep, writeDurableAgentEvent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolk-sdk/vercel-workflows",
-  "version": "0.1.0-canary.39",
+  "version": "0.1.0-canary.41",
   "description": "Vercel Workflow orchestration primitives for Yolk agent loops.",
   "license": "MIT",
   "type": "module",

package/src/effect.ts

@@ -48,7 +48,7 @@ export type VercelWorkflowsSdkClient = {
     args: TArgs
   ) => Promise<VercelWorkflowsSdkRun<TResult>>
   readonly getRun: <TResult>(runId: string) => VercelWorkflowsSdkRun<TResult>
-  readonly resumeHook: (token: string, payload: unknown) => Promise<unknown>
+  readonly resumeHook: (token: string, payload: unknown) => Promise<void>
 }
 
 export type VercelWorkflowRun<TResult> = {
@@ -95,6 +95,16 @@ const workflowsError = (operation: VercelWorkflowsOperation, cause: unknown) =>
 
 const spanAttributes = (runId: string) => ({ 'workflow.run.id': runId })
 
+const trySdkPromise = <A>(body: () => Promise<A>) =>
+  Effect.tryPromise({
+    try: body,
+    catch: error => error
+  })
+
+const mapSdkError = (operation: VercelWorkflowsOperation) =>
+  <A>(effect: Effect.Effect<A, unknown>) =>
+    effect.pipe(Effect.mapError(cause => workflowsError(operation, cause)))
+
 const makeWorkflowRun = <TResult>(
   run: VercelWorkflowsSdkRun<TResult>
 ): VercelWorkflowRun<TResult> => ({
@@ -108,26 +118,20 @@ const makeWorkflowRun = <TResult>(
         attributes: spanAttributes(run.runId)
       })
     ),
-  cancel: Effect.tryPromise({
-    try: () => run.cancel(),
-    catch: cause => workflowsError('cancel', cause)
-  }).pipe(
+  cancel: trySdkPromise(() => run.cancel()).pipe(
+    mapSdkError('cancel'),
     Effect.withSpan('VercelWorkflows.run.cancel', {
       attributes: spanAttributes(run.runId)
     })
   ),
-  status: Effect.tryPromise({
-    try: () => run.status,
-    catch: cause => workflowsError('status', cause)
-  }).pipe(
+  status: trySdkPromise(() => run.status).pipe(
+    mapSdkError('status'),
     Effect.withSpan('VercelWorkflows.run.status', {
       attributes: spanAttributes(run.runId)
     })
   ),
-  returnValue: Effect.tryPromise({
-    try: () => run.returnValue,
-    catch: cause => workflowsError('returnValue', cause)
-  }).pipe(
+  returnValue: trySdkPromise(() => run.returnValue).pipe(
+    mapSdkError('returnValue'),
     Effect.withSpan('VercelWorkflows.run.returnValue', {
       attributes: spanAttributes(run.runId)
     })
@@ -140,7 +144,9 @@ const VercelWorkflowsSdkLive = Layer.succeed(VercelWorkflowsSdk, {
     args: TArgs
   ) => workflowStart(workflow, args),
   getRun: <TResult>(runId: string) => workflowGetRun<TResult>(runId),
-  resumeHook: (token: string, payload: unknown) => workflowResumeHook<unknown>(token, payload)
+  resumeHook: async (token: string, payload: unknown) => {
+    await workflowResumeHook<unknown>(token, payload)
+  }
 })
 
 export class VercelWorkflows extends Context.Service<VercelWorkflows, VercelWorkflowsClient>()(
@@ -153,9 +159,11 @@ export class VercelWorkflows extends Context.Service<VercelWorkflows, VercelWork
         runId: string
       ): Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError> =>
         Effect.try({
-          try: () => makeWorkflowRun(sdk.getRun<TResult>(runId)),
-          catch: cause => workflowsError('getRun', cause)
+          try: () => sdk.getRun<TResult>(runId),
+          catch: error => error
         }).pipe(
+          mapSdkError('getRun'),
+          Effect.map(makeWorkflowRun),
           Effect.withSpan('VercelWorkflows.getRun', {
             attributes: spanAttributes(runId)
           })
@@ -166,10 +174,11 @@ export class VercelWorkflows extends Context.Service<VercelWorkflows, VercelWork
           workflow: VercelWorkflowFunction<TArgs, TResult>,
           args: TArgs
         ): Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError> =>
-          Effect.tryPromise({
-            try: () => sdk.start(workflow, args),
-            catch: cause => workflowsError('start', cause)
-          }).pipe(Effect.map(makeWorkflowRun), Effect.withSpan('VercelWorkflows.start')),
+          trySdkPromise(() => sdk.start(workflow, args)).pipe(
+            mapSdkError('start'),
+            Effect.map(makeWorkflowRun),
+            Effect.withSpan('VercelWorkflows.start')
+          ),
 
         getRun,
 
@@ -199,10 +208,10 @@ export class VercelWorkflows extends Context.Service<VercelWorkflows, VercelWork
           ),
 
         resumeHook: (token: string, payload: unknown): Effect.Effect<void, VercelWorkflowsError> =>
-          Effect.tryPromise({
-            try: () => sdk.resumeHook(token, payload).then(() => undefined),
-            catch: cause => workflowsError('resumeHook', cause)
-          }).pipe(Effect.withSpan('VercelWorkflows.resumeHook')),
+          trySdkPromise(() => sdk.resumeHook(token, payload)).pipe(
+            mapSdkError('resumeHook'),
+            Effect.withSpan('VercelWorkflows.resumeHook')
+          ),
 
         cancel: (runId: string): Effect.Effect<void, VercelWorkflowsError> =>
           getRun<unknown>(runId).pipe(

package/src/index.ts

@@ -1,6 +1,5 @@
 export {
   commitThenWriteTerminalEvent,
-  commitThenWriteTerminalEventEffect,
   durableAgentEventId,
   defaultMaxWorkflowTurns,
   makeDurableAgentEventSequencerState,
@@ -9,11 +8,9 @@ export {
   runVercelAgentWorkflow,
   sequenceDurableAgentEvent,
   settleWorkflowStep,
-  writeDurableAgentEvent,
-  writeDurableAgentEventEffect
+  writeDurableAgentEvent
 } from './workflow.ts'
 export type {
-  CommitThenWriteTerminalEventEffectInput,
   CommitThenWriteTerminalEventInput,
   CommitThenWriteTerminalEventResult,
   DurableAgentEvent,
@@ -31,7 +28,6 @@ export type {
   VercelAgentWorkflowStepRetryPolicy,
   VercelAgentWorkflowToolBatchStepInput,
   VercelAgentWorkflowToolBatchStepResult,
-  TerminalEventCloseResult,
   WorkflowStepResult,
   WriteDurableAgentEventInput
 } from './workflow.ts'

package/src/workflow-events.ts

@@ -42,30 +42,13 @@ export type WriteDurableAgentEventInput<Event extends object = object> =
     readonly writer: WritableStreamDefaultWriter<Uint8Array>
   }
 
-export type TerminalEventCloseResult =
-  | { readonly _tag: 'Closed' }
-  | { readonly _tag: 'CloseFailed'; readonly error: unknown }
-
 export type CommitThenWriteTerminalEventInput<
-  TerminalEvent extends object,
-  TerminalWriteResult,
-  CommitErrorWriteResult
-> = {
-  readonly commit: () => Promise<void>
-  readonly terminal: TerminalEvent
-  readonly write: (event: TerminalEvent) => Promise<TerminalWriteResult>
-  readonly writeCommitError: (error: unknown) => Promise<CommitErrorWriteResult>
-  readonly close: () => Promise<void>
-}
-
-export type CommitThenWriteTerminalEventEffectInput<
   TerminalEvent extends object,
   TerminalWriteResult,
   CommitErrorWriteResult,
   CommitError,
   TerminalWriteError,
-  CommitErrorWriteError,
-  CloseError
+  CommitErrorWriteError
 > = {
   readonly commit: Effect.Effect<void, CommitError>
   readonly terminal: TerminalEvent
@@ -73,31 +56,26 @@ export type CommitThenWriteTerminalEventEffectInput<
   readonly writeCommitError: (
     error: unknown
   ) => Effect.Effect<CommitErrorWriteResult, CommitErrorWriteError>
-  readonly close: Effect.Effect<void, CloseError>
 }
 
 export type CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> =
   | {
       readonly _tag: 'Committed'
       readonly writeResult: TerminalWriteResult
-      readonly closeResult: TerminalEventCloseResult
     }
   | {
       readonly _tag: 'CommitFailed'
       readonly commitError: unknown
       readonly writeResult: CommitErrorWriteResult
-      readonly closeResult: TerminalEventCloseResult
     }
   | {
       readonly _tag: 'TerminalWriteFailed'
       readonly error: unknown
-      readonly closeResult: TerminalEventCloseResult
     }
   | {
       readonly _tag: 'CommitErrorWriteFailed'
       readonly commitError: unknown
       readonly error: unknown
-      readonly closeResult: TerminalEventCloseResult
     }
 
 const textEncoder = new TextEncoder()
@@ -135,7 +113,7 @@ export const sequenceDurableAgentEvent = <Event extends object>(
 const encodeDurableAgentEventNdjson = <Event extends object>(event: DurableAgentEvent<Event>) =>
   textEncoder.encode(`${JSON.stringify(event)}\n`)
 
-export const writeDurableAgentEventEffect = <Event extends object>(
+export const writeDurableAgentEvent = <Event extends object>(
   input: WriteDurableAgentEventInput<Event>
 ): Effect.Effect<SequencedDurableAgentEvent<Event>, unknown> =>
   Effect.gen(function* () {
@@ -148,85 +126,53 @@ export const writeDurableAgentEventEffect = <Event extends object>(
     return sequenced
   })
 
-export const writeDurableAgentEvent = async <Event extends object>(
-  input: WriteDurableAgentEventInput<Event>
-): Promise<SequencedDurableAgentEvent<Event>> =>
-  Effect.runPromise(writeDurableAgentEventEffect(input))
-
-const closedTerminalEventWriterResult = (): TerminalEventCloseResult => ({ _tag: 'Closed' })
-
-const closeFailedTerminalEventWriterResult = (error: unknown): TerminalEventCloseResult => ({
-  _tag: 'CloseFailed',
-  error
-})
-
 const committedTerminalResult = <TerminalWriteResult, CommitErrorWriteResult>(
-  writeResult: TerminalWriteResult,
-  closeResult: TerminalEventCloseResult
+  writeResult: TerminalWriteResult
 ): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({
   _tag: 'Committed',
-  writeResult,
-  closeResult
+  writeResult
 })
 
 const commitFailedTerminalResult = <TerminalWriteResult, CommitErrorWriteResult>(
   commitError: unknown,
-  writeResult: CommitErrorWriteResult,
-  closeResult: TerminalEventCloseResult
+  writeResult: CommitErrorWriteResult
 ): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({
   _tag: 'CommitFailed',
   commitError,
-  writeResult,
-  closeResult
+  writeResult
 })
 
 const terminalWriteFailedResult = <TerminalWriteResult, CommitErrorWriteResult>(
-  error: unknown,
-  closeResult: TerminalEventCloseResult
+  error: unknown
 ): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({
   _tag: 'TerminalWriteFailed',
-  error,
-  closeResult
+  error
 })
 
 const commitErrorWriteFailedResult = <TerminalWriteResult, CommitErrorWriteResult>(
   commitError: unknown,
-  error: unknown,
-  closeResult: TerminalEventCloseResult
+  error: unknown
 ): CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> => ({
   _tag: 'CommitErrorWriteFailed',
   commitError,
-  error,
-  closeResult
+  error
 })
 
-const closeTerminalEventWriterEffect = <CloseError>(
-  close: Effect.Effect<void, CloseError>
-): Effect.Effect<TerminalEventCloseResult, never> =>
-  close.pipe(
-    Effect.match({
-      onFailure: closeFailedTerminalEventWriterResult,
-      onSuccess: () => closedTerminalEventWriterResult()
-    })
-  )
-
-export const commitThenWriteTerminalEventEffect = <
+export const commitThenWriteTerminalEvent = <
   TerminalEvent extends object,
   TerminalWriteResult,
   CommitErrorWriteResult,
   CommitError,
   TerminalWriteError,
-  CommitErrorWriteError,
-  CloseError
+  CommitErrorWriteError
 >(
-  input: CommitThenWriteTerminalEventEffectInput<
+  input: CommitThenWriteTerminalEventInput<
     TerminalEvent,
     TerminalWriteResult,
     CommitErrorWriteResult,
     CommitError,
     TerminalWriteError,
-    CommitErrorWriteError,
-    CloseError
+    CommitErrorWriteError
   >
 ): Effect.Effect<
   CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult>,
@@ -236,86 +182,27 @@ export const commitThenWriteTerminalEventEffect = <
     Effect.matchEffect({
       onFailure: commitError =>
         input.writeCommitError(commitError).pipe(
-          Effect.matchEffect({
+          Effect.match({
             onFailure: error =>
-              closeTerminalEventWriterEffect(input.close).pipe(
-                Effect.map(closeResult =>
-                  commitErrorWriteFailedResult<TerminalWriteResult, CommitErrorWriteResult>(
-                    commitError,
-                    error,
-                    closeResult
-                  )
-                )
+              commitErrorWriteFailedResult<TerminalWriteResult, CommitErrorWriteResult>(
+                commitError,
+                error
               ),
             onSuccess: writeResult =>
-              closeTerminalEventWriterEffect(input.close).pipe(
-                Effect.map(closeResult =>
-                  commitFailedTerminalResult<TerminalWriteResult, CommitErrorWriteResult>(
-                    commitError,
-                    writeResult,
-                    closeResult
-                  )
-                )
+              commitFailedTerminalResult<TerminalWriteResult, CommitErrorWriteResult>(
+                commitError,
+                writeResult
               )
           })
         ),
       onSuccess: () =>
         input.write(input.terminal).pipe(
-          Effect.matchEffect({
+          Effect.match({
             onFailure: error =>
-              closeTerminalEventWriterEffect(input.close).pipe(
-                Effect.map(closeResult =>
-                  terminalWriteFailedResult<TerminalWriteResult, CommitErrorWriteResult>(
-                    error,
-                    closeResult
-                  )
-                )
-              ),
+              terminalWriteFailedResult<TerminalWriteResult, CommitErrorWriteResult>(error),
             onSuccess: writeResult =>
-              closeTerminalEventWriterEffect(input.close).pipe(
-                Effect.map(closeResult =>
-                  committedTerminalResult<TerminalWriteResult, CommitErrorWriteResult>(
-                    writeResult,
-                    closeResult
-                  )
-                )
-              )
+              committedTerminalResult<TerminalWriteResult, CommitErrorWriteResult>(writeResult)
           })
         )
     })
   )
-
-export const commitThenWriteTerminalEvent = async <
-  TerminalEvent extends object,
-  TerminalWriteResult,
-  CommitErrorWriteResult
->(
-  input: CommitThenWriteTerminalEventInput<
-    TerminalEvent,
-    TerminalWriteResult,
-    CommitErrorWriteResult
-  >
-): Promise<CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult>> =>
-  Effect.runPromise(
-    commitThenWriteTerminalEventEffect({
-      terminal: input.terminal,
-      commit: Effect.tryPromise({
-        try: input.commit,
-        catch: cause => cause
-      }),
-      write: event =>
-        Effect.tryPromise({
-          try: () => input.write(event),
-          catch: cause => cause
-        }),
-      writeCommitError: error =>
-        Effect.tryPromise({
-          try: () => input.writeCommitError(error),
-          catch: cause => cause
-        }),
-      close: Effect.tryPromise({
-        try: input.close,
-        catch: cause => cause
-      })
-    })
-  )

package/src/workflow-loop.ts

@@ -152,6 +152,7 @@ export async function retryWorkflowStep<A>(
   policy?: VercelAgentWorkflowStepRetryPolicy
 ): Promise<A> {
   const maxAttempts = maxRetryAttempts(policy)
+
   let attempt = 1
 
   for (;;) {

package/src/workflow.ts

@@ -7,12 +7,10 @@ export {
 } from './workflow-loop.ts'
 export {
   commitThenWriteTerminalEvent,
-  commitThenWriteTerminalEventEffect,
   durableAgentEventId,
   makeDurableAgentEventSequencerState,
   sequenceDurableAgentEvent,
-  writeDurableAgentEvent,
-  writeDurableAgentEventEffect
+  writeDurableAgentEvent
 } from './workflow-events.ts'
 export type {
   SerializableWorkflowState,
@@ -31,11 +29,9 @@ export type {
   DurableAgentEvent,
   DurableAgentEventIdInput,
   DurableAgentEventSequencerState,
-  CommitThenWriteTerminalEventEffectInput,
   CommitThenWriteTerminalEventInput,
   CommitThenWriteTerminalEventResult,
   SequenceDurableAgentEventInput,
   SequencedDurableAgentEvent,
-  TerminalEventCloseResult,
   WriteDurableAgentEventInput
 } from './workflow-events.ts'