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

package/README.md

@@ -150,10 +150,11 @@ active-run locking, stale-run guards, and cancellation behavior.
 ## 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
@@ -169,14 +170,13 @@ const result = yield* commitThenWriteTerminalEvent({
   commit: persistState,
   write: event => writeDurableAgentEvent({ writer, event, streamId, turn, state }),
   writeCommitError: error =>
-    writeDurableAgentEvent({ writer, event: commitErrorEvent(error), streamId, turn, state }),
-  close: Effect.tryPromise({ try: () => writer.close(), catch: error => error })
+    writeDurableAgentEvent({ writer, event: commitErrorEvent(error), streamId, turn, state })
 })
 ```
 
 The helper never writes the success terminal before `commit` succeeds. If `commit` fails, it writes
-the host-provided terminal error event instead. Terminal write failures still attempt `close`; close
-failures are returned separately and do not turn a successful durable commit into a failed commit.
+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/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 { CommitThenWriteTerminalEventInput, CommitThenWriteTerminalEventResult, DurableAgentEvent, DurableAgentEventIdInput, DurableAgentEventSequencerState, SequenceDurableAgentEventInput, SequencedDurableAgentEvent, TerminalEventCloseResult, 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 TerminalEventCloseResult, 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 };
+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-events.d.mts

@@ -36,43 +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, 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 writeDurableAgentEvent: <Event extends object>(input: WriteDurableAgentEventInput<Event>) => Effect.Effect<SequencedDurableAgentEvent<Event>, unknown>;
-declare const commitThenWriteTerminalEvent: <TerminalEvent extends object, TerminalWriteResult, CommitErrorWriteResult, CommitError, TerminalWriteError, CommitErrorWriteError, CloseError>(input: CommitThenWriteTerminalEventInput<TerminalEvent, TerminalWriteResult, CommitErrorWriteResult, CommitError, TerminalWriteError, CommitErrorWriteError, CloseError>) => Effect.Effect<CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult>, never>;
+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 { CommitThenWriteTerminalEventInput, CommitThenWriteTerminalEventResult, DurableAgentEvent, DurableAgentEventIdInput, DurableAgentEventSequencerState, SequenceDurableAgentEventInput, SequencedDurableAgentEvent, TerminalEventCloseResult, WriteDurableAgentEventInput, commitThenWriteTerminalEvent, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent };
+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,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,sBAAA,yBACX,KAAA,EAAO,2BAAA,CAA4B,KAAA,MAClC,MAAA,CAAO,MAAA,CAAO,0BAAA,CAA2B,KAAA;AAAA,cAoE/B,4BAAA,kJASX,KAAA,EAAO,iCAAA,CACL,aAAA,EACA,mBAAA,EACA,sBAAA,EACA,WAAA,EACA,kBAAA,EACA,qBAAA,EACA,UAAA,MAED,MAAA,CAAO,MAAA,CACR,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

@@ -30,45 +30,32 @@ const writeDurableAgentEvent = (input) => Effect.gen(function* () {
 	});
 	return sequenced;
 });
-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 commitThenWriteTerminalEvent = (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)))
+	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)
 	}))
 }));
 //#endregion

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  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 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 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 commitThenWriteTerminalEvent = <\n  TerminalEvent extends object,\n  TerminalWriteResult,\n  CommitErrorWriteResult,\n  CommitError,\n  TerminalWriteError,\n  CommitErrorWriteError,\n  CloseError\n>(\n  input: CommitThenWriteTerminalEventInput<\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"],"mappings":";;AA0FA,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,yCAAmE,EAAE,MAAM,SAAS;AAE1F,MAAM,wCAAwC,WAA8C;CAC1F,MAAM;CACN;AACF;AAEA,MAAM,2BACJ,aACA,iBACqF;CACrF,MAAM;CACN;CACA;AACF;AAEA,MAAM,8BACJ,aACA,aACA,iBACqF;CACrF,MAAM;CACN;CACA;CACA;AACF;AAEA,MAAM,6BACJ,OACA,iBACqF;CACrF,MAAM;CACN;CACA;AACF;AAEA,MAAM,gCACJ,aACA,OACA,iBACqF;CACrF,MAAM;CACN;CACA;CACA;AACF;AAEA,MAAM,kCACJ,UAEA,MAAM,KACJ,OAAO,MAAM;CACX,WAAW;CACX,iBAAiB,gCAAgC;AACnD,CAAC,CACH;AAEF,MAAa,gCASX,UAaA,MAAM,OAAO,KACX,OAAO,YAAY;CACjB,YAAW,gBACT,MAAM,iBAAiB,WAAW,EAAE,KAClC,OAAO,YAAY;EACjB,YAAW,UACT,+BAA+B,MAAM,KAAK,EAAE,KAC1C,OAAO,KAAI,gBACT,6BACE,aACA,OACA,WACF,CACF,CACF;EACF,YAAW,gBACT,+BAA+B,MAAM,KAAK,EAAE,KAC1C,OAAO,KAAI,gBACT,2BACE,aACA,aACA,WACF,CACF,CACF;CACJ,CAAC,CACH;CACF,iBACE,MAAM,MAAM,MAAM,QAAQ,EAAE,KAC1B,OAAO,YAAY;EACjB,YAAW,UACT,+BAA+B,MAAM,KAAK,EAAE,KAC1C,OAAO,KAAI,gBACT,0BACE,OACA,WACF,CACF,CACF;EACF,YAAW,gBACT,+BAA+B,MAAM,KAAK,EAAE,KAC1C,OAAO,KAAI,gBACT,wBACE,aACA,WACF,CACF,CACF;CACJ,CAAC,CACH;AACJ,CAAC,CACH"}
+{"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.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 { CommitThenWriteTerminalEventInput, CommitThenWriteTerminalEventResult, DurableAgentEvent, DurableAgentEventIdInput, DurableAgentEventSequencerState, SequenceDurableAgentEventInput, SequencedDurableAgentEvent, TerminalEventCloseResult, 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 TerminalEventCloseResult, 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 };
+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/package.json

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

package/src/index.ts

@@ -28,7 +28,6 @@ export type {
   VercelAgentWorkflowStepRetryPolicy,
   VercelAgentWorkflowToolBatchStepInput,
   VercelAgentWorkflowToolBatchStepResult,
-  TerminalEventCloseResult,
   WorkflowStepResult,
   WriteDurableAgentEventInput
 } from './workflow.ts'

package/src/workflow-events.ts

@@ -42,18 +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,
   CommitError,
   TerminalWriteError,
-  CommitErrorWriteError,
-  CloseError
+  CommitErrorWriteError
 > = {
   readonly commit: Effect.Effect<void, CommitError>
   readonly terminal: TerminalEvent
@@ -61,31 +56,26 @@ export type CommitThenWriteTerminalEventInput<
   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()
@@ -136,71 +126,45 @@ export const writeDurableAgentEvent = <Event extends object>(
     return sequenced
   })
 
-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 commitThenWriteTerminalEvent = <
   TerminalEvent extends object,
   TerminalWriteResult,
   CommitErrorWriteResult,
   CommitError,
   TerminalWriteError,
-  CommitErrorWriteError,
-  CloseError
+  CommitErrorWriteError
 >(
   input: CommitThenWriteTerminalEventInput<
     TerminalEvent,
@@ -208,8 +172,7 @@ export const commitThenWriteTerminalEvent = <
     CommitErrorWriteResult,
     CommitError,
     TerminalWriteError,
-    CommitErrorWriteError,
-    CloseError
+    CommitErrorWriteError
   >
 ): Effect.Effect<
   CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult>,
@@ -219,50 +182,26 @@ export const commitThenWriteTerminalEvent = <
     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)
           })
         )
     })

package/src/workflow.ts

@@ -33,6 +33,5 @@ export type {
   CommitThenWriteTerminalEventResult,
   SequenceDurableAgentEventInput,
   SequencedDurableAgentEvent,
-  TerminalEventCloseResult,
   WriteDurableAgentEventInput
 } from './workflow-events.ts'