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

package/dist/workflow-events.mjs

@@ -0,0 +1,54 @@
+import { Data, Effect } from "effect";
+//#region src/workflow-events.ts
+const CommitThenWriteTerminalEventResult = Data.taggedEnum();
+const textEncoder = new TextEncoder();
+const makeDurableAgentEventSequencerState = (eventSequence = 0) => ({ eventSequence });
+const durableAgentEventId = (input) => `${input.streamId}:${input.turn}:${input.eventSequence}`;
+const sequenceDurableAgentEvent = (input) => {
+	const eventSequence = input.state.eventSequence;
+	const nextEventSequence = eventSequence + 1;
+	const event = {
+		...input.event,
+		eventId: durableAgentEventId({
+			streamId: input.streamId,
+			turn: input.turn,
+			eventSequence
+		})
+	};
+	if (input.createdAtMs !== void 0) event.createdAtMs = input.createdAtMs;
+	return {
+		event,
+		eventSequence,
+		nextEventSequence,
+		nextState: makeDurableAgentEventSequencerState(nextEventSequence)
+	};
+};
+const encodeDurableAgentEventNdjson = (event) => textEncoder.encode(`${JSON.stringify(event)}\n`);
+const writeDurableAgentEvent = (input) => Effect.gen(function* () {
+	const sequenced = sequenceDurableAgentEvent(input);
+	yield* Effect.tryPromise({
+		try: () => input.writer.write(encodeDurableAgentEventNdjson(sequenced.event)),
+		catch: (cause) => cause
+	});
+	return sequenced;
+});
+const commitThenWriteTerminalEvent = (input) => input.commit.pipe(Effect.matchEffect({
+	onFailure: (commitError) => input.writeCommitError(commitError).pipe(Effect.match({
+		onFailure: (error) => CommitThenWriteTerminalEventResult.CommitErrorWriteFailed({
+			commitError,
+			error
+		}),
+		onSuccess: (writeResult) => CommitThenWriteTerminalEventResult.CommitFailed({
+			commitError,
+			writeResult
+		})
+	})),
+	onSuccess: () => input.write(input.terminal).pipe(Effect.match({
+		onFailure: (error) => CommitThenWriteTerminalEventResult.TerminalWriteFailed({ error }),
+		onSuccess: (writeResult) => CommitThenWriteTerminalEventResult.Committed({ writeResult })
+	}))
+}));
+//#endregion
+export { CommitThenWriteTerminalEventResult, commitThenWriteTerminalEvent, durableAgentEventId, makeDurableAgentEventSequencerState, sequenceDurableAgentEvent, writeDurableAgentEvent };
+
+//# sourceMappingURL=workflow-events.mjs.map

package/dist/workflow-events.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-events.mjs","names":[],"sources":["../src/workflow-events.ts"],"sourcesContent":["import { Data, 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: CommitError\n  ) => Effect.Effect<CommitErrorWriteResult, CommitErrorWriteError>\n}\n\nexport type CommitThenWriteTerminalEventResult<TerminalWriteResult, CommitErrorWriteResult> =\n  Data.TaggedEnum<{\n    Committed: {\n      readonly writeResult: TerminalWriteResult\n    }\n    CommitFailed: {\n      readonly commitError: unknown\n      readonly writeResult: CommitErrorWriteResult\n    }\n    TerminalWriteFailed: {\n      readonly error: unknown\n    }\n    CommitErrorWriteFailed: {\n      readonly commitError: unknown\n      readonly error: unknown\n    }\n  }>\n\ninterface CommitThenWriteTerminalEventResultDefinition extends Data.TaggedEnum.WithGenerics<2> {\n  readonly taggedEnum: CommitThenWriteTerminalEventResult<this['A'], this['B']>\n}\n\nexport const CommitThenWriteTerminalEventResult =\n  Data.taggedEnum<CommitThenWriteTerminalEventResultDefinition>()\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\n  type SequencedDurableAgentEventFields = Event & {\n    eventId: string\n    createdAtMs?: number\n  }\n\n  const event: SequencedDurableAgentEventFields = {\n    ...input.event,\n    eventId: durableAgentEventId({\n      streamId: input.streamId,\n      turn: input.turn,\n      eventSequence\n    })\n  }\n\n  if (input.createdAtMs !== undefined) {\n    event.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\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              CommitThenWriteTerminalEventResult.CommitErrorWriteFailed<\n                TerminalWriteResult,\n                CommitErrorWriteResult\n              >({\n                commitError,\n                error\n              }),\n            onSuccess: writeResult =>\n              CommitThenWriteTerminalEventResult.CommitFailed<\n                TerminalWriteResult,\n                CommitErrorWriteResult\n              >({\n                commitError,\n                writeResult\n              })\n          })\n        ),\n      onSuccess: () =>\n        input.write(input.terminal).pipe(\n          Effect.match({\n            onFailure: error =>\n              CommitThenWriteTerminalEventResult.TerminalWriteFailed<\n                TerminalWriteResult,\n                CommitErrorWriteResult\n              >({ error }),\n            onSuccess: writeResult =>\n              CommitThenWriteTerminalEventResult.Committed<\n                TerminalWriteResult,\n                CommitErrorWriteResult\n              >({ writeResult })\n          })\n        )\n    })\n  )\n"],"mappings":";;AAkFA,MAAa,qCACX,KAAK,WAAyD;AAEhE,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;CAO1C,MAAM,QAA0C;EAC9C,GAAG,MAAM;EACT,SAAS,oBAAoB;GAC3B,UAAU,MAAM;GAChB,MAAM,MAAM;GACZ;EACF,CAAC;CACH;CAEA,IAAI,MAAM,gBAAgB,KAAA,GACxB,MAAM,cAAc,MAAM;CAG5B,OAAO;EACL;EACA;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,MAAa,gCAQX,UAYA,MAAM,OAAO,KACX,OAAO,YAAY;CACjB,YAAW,gBACT,MAAM,iBAAiB,WAAW,EAAE,KAClC,OAAO,MAAM;EACX,YAAW,UACT,mCAAmC,uBAGjC;GACA;GACA;EACF,CAAC;EACH,YAAW,gBACT,mCAAmC,aAGjC;GACA;GACA;EACF,CAAC;CACL,CAAC,CACH;CACF,iBACE,MAAM,MAAM,MAAM,QAAQ,EAAE,KAC1B,OAAO,MAAM;EACX,YAAW,UACT,mCAAmC,oBAGjC,EAAE,MAAM,CAAC;EACb,YAAW,gBACT,mCAAmC,UAGjC,EAAE,YAAY,CAAC;CACrB,CAAC,CACH;AACJ,CAAC,CACH"}

package/dist/workflow-loop.d.mts

@@ -0,0 +1,416 @@
+import { Data } from "effect";
+
+//#region src/workflow-loop.d.ts
+type VercelAgentWorkflowInput = {
+  readonly request: unknown;
+  readonly context: unknown;
+};
+type SerializableWorkflowState = {
+  readonly request: unknown;
+  readonly messages?: ReadonlyArray<unknown>;
+  readonly createdMessages: ReadonlyArray<unknown>;
+  readonly usage?: unknown;
+  readonly turn: number;
+  readonly eventSequence?: number;
+};
+type VercelAgentWorkflowModelStepInput = {
+  readonly context: unknown;
+  readonly state: SerializableWorkflowState;
+};
+type VercelAgentWorkflowModelStepResult = {
+  readonly done: boolean;
+  readonly messages: ReadonlyArray<unknown>;
+  readonly createdMessages: ReadonlyArray<unknown>;
+  readonly toolCalls: ReadonlyArray<unknown>;
+  readonly usage: unknown;
+  readonly turn: number;
+  readonly eventSequence?: number;
+};
+type VercelAgentWorkflowToolBatchStepInput = {
+  readonly context: unknown;
+  readonly request: unknown;
+  readonly calls: ReadonlyArray<unknown>;
+  readonly createdMessages: ReadonlyArray<unknown>;
+  readonly hitlResponses?: ReadonlyArray<unknown>;
+  readonly usage?: unknown;
+  readonly turn?: number;
+  readonly eventSequence?: number;
+};
+type VercelAgentWorkflowAwaitingInput = {
+  readonly hookToken: string;
+  readonly requests: ReadonlyArray<unknown>;
+  readonly messages: ReadonlyArray<unknown>;
+  readonly usage: unknown;
+  readonly turns: number;
+  readonly eventSequence?: number;
+};
+type VercelAgentWorkflowToolBatchStepResult = {
+  readonly messages: ReadonlyArray<unknown>;
+  readonly createdMessages: ReadonlyArray<unknown>; /** Updated cumulative usage when tools run nested model work such as subagents. */
+  readonly usage?: unknown;
+  readonly awaitingInput?: VercelAgentWorkflowAwaitingInput;
+  readonly eventSequence?: number;
+  /**
+   * A plain wire-safe failure captured after partial progress. Returning it instead of rejecting
+   * lets orchestration retain usage and event sequencing from completed sibling tools.
+   */
+  readonly failure?: unknown;
+};
+type WorkflowStepResult<A> = Data.TaggedEnum<{
+  Success: {
+    readonly value: A;
+  };
+  Failure: {
+    readonly error: unknown;
+  };
+}>;
+declare const WorkflowStepResult: {
+  readonly Success: <A>(args: {
+    readonly value: A;
+  }) => {
+    readonly _tag: "Success";
+    readonly value: A;
+  };
+  readonly Failure: <A>(args: {
+    readonly error: unknown;
+  }) => {
+    readonly _tag: "Failure";
+    readonly error: unknown;
+  };
+  readonly $is: <Tag extends "Success" | "Failure">(tag: Tag) => {
+    <T extends {
+      readonly _tag: "Success";
+      readonly value: any;
+    } | {
+      readonly _tag: "Failure";
+      readonly error: unknown;
+    }>(u: T): u is T & {
+      readonly _tag: Tag;
+    };
+    (u: unknown): u is Extract<{
+      readonly _tag: "Success";
+      readonly value: unknown;
+    }, {
+      readonly _tag: Tag;
+    }> | Extract<{
+      readonly _tag: "Failure";
+      readonly error: unknown;
+    }, {
+      readonly _tag: Tag;
+    }>;
+  };
+  readonly $match: {
+    <A, B, C, D, Cases extends {
+      readonly Success: (args: {
+        readonly _tag: "Success";
+        readonly value: A;
+      }) => any;
+      readonly Failure: (args: {
+        readonly _tag: "Failure";
+        readonly error: unknown;
+      }) => any;
+    }>(cases: Cases): (self: {
+      readonly _tag: "Success";
+      readonly value: A;
+    } | {
+      readonly _tag: "Failure";
+      readonly error: unknown;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Success" | "Failure"]>>;
+    <A, B, C, D, Cases extends {
+      readonly Success: (args: {
+        readonly _tag: "Success";
+        readonly value: A;
+      }) => any;
+      readonly Failure: (args: {
+        readonly _tag: "Failure";
+        readonly error: unknown;
+      }) => any;
+    }>(self: {
+      readonly _tag: "Success";
+      readonly value: A;
+    } | {
+      readonly _tag: "Failure";
+      readonly error: unknown;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Success" | "Failure"]>>;
+  };
+};
+type VercelAgentWorkflowStepRetryPolicy = {
+  readonly maxAttempts: number;
+};
+type VercelAgentWorkflowRunResult = Data.TaggedEnum<{
+  Completed: {
+    readonly turns: number;
+    readonly state: SerializableWorkflowState;
+  };
+  ModelStepFailed: {
+    readonly turn: number;
+    readonly error: unknown;
+    readonly state: SerializableWorkflowState;
+  };
+  ToolBatchStepFailed: {
+    readonly turn: number;
+    readonly error: unknown;
+    readonly state: SerializableWorkflowState;
+  };
+  AwaitInputFailed: {
+    readonly turn: number;
+    readonly error: unknown;
+    readonly awaitingInput: VercelAgentWorkflowAwaitingInput;
+    readonly state: SerializableWorkflowState;
+  };
+  CloseStreamFailed: {
+    readonly turns: number;
+    readonly error: unknown;
+    readonly state: SerializableWorkflowState;
+  };
+  MaxTurnsExceeded: {
+    readonly maxTurns: number;
+    readonly error: Error;
+    readonly state: SerializableWorkflowState;
+  };
+}>;
+declare const VercelAgentWorkflowRunResult: {
+  readonly Completed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Completed";
+    readonly turns: number;
+    readonly state: SerializableWorkflowState;
+  }, "_tag">;
+  readonly ModelStepFailed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ModelStepFailed";
+    readonly turn: number;
+    readonly error: unknown;
+    readonly state: SerializableWorkflowState;
+  }, "_tag">;
+  readonly ToolBatchStepFailed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ToolBatchStepFailed";
+    readonly turn: number;
+    readonly error: unknown;
+    readonly state: SerializableWorkflowState;
+  }, "_tag">;
+  readonly AwaitInputFailed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "AwaitInputFailed";
+    readonly turn: number;
+    readonly error: unknown;
+    readonly awaitingInput: VercelAgentWorkflowAwaitingInput;
+    readonly state: SerializableWorkflowState;
+  }, "_tag">;
+  readonly CloseStreamFailed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "CloseStreamFailed";
+    readonly turns: number;
+    readonly error: unknown;
+    readonly state: SerializableWorkflowState;
+  }, "_tag">;
+  readonly MaxTurnsExceeded: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "MaxTurnsExceeded";
+    readonly maxTurns: number;
+    readonly error: Error;
+    readonly state: SerializableWorkflowState;
+  }, "_tag">;
+  readonly $is: <Tag extends "Completed" | "ModelStepFailed" | "ToolBatchStepFailed" | "AwaitInputFailed" | "CloseStreamFailed" | "MaxTurnsExceeded">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Completed";
+    readonly turns: number;
+    readonly state: SerializableWorkflowState;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ModelStepFailed";
+    readonly turn: number;
+    readonly error: unknown;
+    readonly state: SerializableWorkflowState;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ToolBatchStepFailed";
+    readonly turn: number;
+    readonly error: unknown;
+    readonly state: SerializableWorkflowState;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "AwaitInputFailed";
+    readonly turn: number;
+    readonly error: unknown;
+    readonly awaitingInput: VercelAgentWorkflowAwaitingInput;
+    readonly state: SerializableWorkflowState;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "CloseStreamFailed";
+    readonly turns: number;
+    readonly error: unknown;
+    readonly state: SerializableWorkflowState;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "MaxTurnsExceeded";
+    readonly maxTurns: number;
+    readonly error: Error;
+    readonly state: SerializableWorkflowState;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly Completed: (args: {
+        readonly _tag: "Completed";
+        readonly turns: number;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+      readonly ModelStepFailed: (args: {
+        readonly _tag: "ModelStepFailed";
+        readonly turn: number;
+        readonly error: unknown;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+      readonly ToolBatchStepFailed: (args: {
+        readonly _tag: "ToolBatchStepFailed";
+        readonly turn: number;
+        readonly error: unknown;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+      readonly AwaitInputFailed: (args: {
+        readonly _tag: "AwaitInputFailed";
+        readonly turn: number;
+        readonly error: unknown;
+        readonly awaitingInput: VercelAgentWorkflowAwaitingInput;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+      readonly CloseStreamFailed: (args: {
+        readonly _tag: "CloseStreamFailed";
+        readonly turns: number;
+        readonly error: unknown;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+      readonly MaxTurnsExceeded: (args: {
+        readonly _tag: "MaxTurnsExceeded";
+        readonly maxTurns: number;
+        readonly error: Error;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "Completed";
+      readonly turns: number;
+      readonly state: SerializableWorkflowState;
+    } | {
+      readonly _tag: "ModelStepFailed";
+      readonly turn: number;
+      readonly error: unknown;
+      readonly state: SerializableWorkflowState;
+    } | {
+      readonly _tag: "ToolBatchStepFailed";
+      readonly turn: number;
+      readonly error: unknown;
+      readonly state: SerializableWorkflowState;
+    } | {
+      readonly _tag: "AwaitInputFailed";
+      readonly turn: number;
+      readonly error: unknown;
+      readonly awaitingInput: VercelAgentWorkflowAwaitingInput;
+      readonly state: SerializableWorkflowState;
+    } | {
+      readonly _tag: "CloseStreamFailed";
+      readonly turns: number;
+      readonly error: unknown;
+      readonly state: SerializableWorkflowState;
+    } | {
+      readonly _tag: "MaxTurnsExceeded";
+      readonly maxTurns: number;
+      readonly error: Error;
+      readonly state: SerializableWorkflowState;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Completed" | "ModelStepFailed" | "ToolBatchStepFailed" | "AwaitInputFailed" | "CloseStreamFailed" | "MaxTurnsExceeded"]>>;
+    <Cases extends {
+      readonly Completed: (args: {
+        readonly _tag: "Completed";
+        readonly turns: number;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+      readonly ModelStepFailed: (args: {
+        readonly _tag: "ModelStepFailed";
+        readonly turn: number;
+        readonly error: unknown;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+      readonly ToolBatchStepFailed: (args: {
+        readonly _tag: "ToolBatchStepFailed";
+        readonly turn: number;
+        readonly error: unknown;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+      readonly AwaitInputFailed: (args: {
+        readonly _tag: "AwaitInputFailed";
+        readonly turn: number;
+        readonly error: unknown;
+        readonly awaitingInput: VercelAgentWorkflowAwaitingInput;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+      readonly CloseStreamFailed: (args: {
+        readonly _tag: "CloseStreamFailed";
+        readonly turns: number;
+        readonly error: unknown;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+      readonly MaxTurnsExceeded: (args: {
+        readonly _tag: "MaxTurnsExceeded";
+        readonly maxTurns: number;
+        readonly error: Error;
+        readonly state: SerializableWorkflowState;
+      }) => any;
+    }>(value: {
+      readonly _tag: "Completed";
+      readonly turns: number;
+      readonly state: SerializableWorkflowState;
+    } | {
+      readonly _tag: "ModelStepFailed";
+      readonly turn: number;
+      readonly error: unknown;
+      readonly state: SerializableWorkflowState;
+    } | {
+      readonly _tag: "ToolBatchStepFailed";
+      readonly turn: number;
+      readonly error: unknown;
+      readonly state: SerializableWorkflowState;
+    } | {
+      readonly _tag: "AwaitInputFailed";
+      readonly turn: number;
+      readonly error: unknown;
+      readonly awaitingInput: VercelAgentWorkflowAwaitingInput;
+      readonly state: SerializableWorkflowState;
+    } | {
+      readonly _tag: "CloseStreamFailed";
+      readonly turns: number;
+      readonly error: unknown;
+      readonly state: SerializableWorkflowState;
+    } | {
+      readonly _tag: "MaxTurnsExceeded";
+      readonly maxTurns: number;
+      readonly error: Error;
+      readonly state: SerializableWorkflowState;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Completed" | "ModelStepFailed" | "ToolBatchStepFailed" | "AwaitInputFailed" | "CloseStreamFailed" | "MaxTurnsExceeded"]>>;
+  };
+};
+type VercelAgentWorkflowLoopConfig = {
+  readonly input: VercelAgentWorkflowInput;
+  readonly maxTurns?: number;
+  readonly runModelStep: (input: VercelAgentWorkflowModelStepInput) => Promise<VercelAgentWorkflowModelStepResult>;
+  readonly runToolBatchStep: (input: VercelAgentWorkflowToolBatchStepInput) => Promise<VercelAgentWorkflowToolBatchStepResult>; /** Called only after a model step returns `done: true`. */
+  readonly closeStream: () => Promise<void>;
+  /**
+   * Best-effort final failure handler. It must write a safe final error and
+   * close the failure stream; rejection is suppressed in favor of the
+   * original structured run result.
+   */
+  readonly writeError: (error: unknown) => Promise<void>; /** A successful await suspends/resumes without invoking either finalizer. */
+  readonly awaitInput?: (input: VercelAgentWorkflowAwaitingInput) => Promise<unknown>;
+  readonly modelStepRetry?: VercelAgentWorkflowStepRetryPolicy;
+  readonly toolBatchStepRetry?: VercelAgentWorkflowStepRetryPolicy;
+  readonly awaitInputRetry?: VercelAgentWorkflowStepRetryPolicy;
+  readonly closeStreamRetry?: VercelAgentWorkflowStepRetryPolicy;
+};
+declare const defaultMaxWorkflowTurns = 500;
+declare const noWorkflowStepRetry: VercelAgentWorkflowStepRetryPolicy;
+declare const settleWorkflowStep: <A>(promise: Promise<A>) => Promise<WorkflowStepResult<A>>;
+declare function retryWorkflowStep<A>(runStep: () => Promise<A>, policy?: VercelAgentWorkflowStepRetryPolicy): Promise<A>;
+declare function runVercelAgentWorkflow(config: VercelAgentWorkflowLoopConfig): Promise<VercelAgentWorkflowRunResult>;
+//#endregion
+export { SerializableWorkflowState, VercelAgentWorkflowAwaitingInput, VercelAgentWorkflowInput, VercelAgentWorkflowLoopConfig, VercelAgentWorkflowModelStepInput, VercelAgentWorkflowModelStepResult, VercelAgentWorkflowRunResult, VercelAgentWorkflowStepRetryPolicy, VercelAgentWorkflowToolBatchStepInput, VercelAgentWorkflowToolBatchStepResult, WorkflowStepResult, defaultMaxWorkflowTurns, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, settleWorkflowStep };
+//# sourceMappingURL=workflow-loop.d.mts.map

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

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

package/dist/workflow-loop.mjs

@@ -0,0 +1,177 @@
+import { Data, Predicate } from "effect";
+//#region src/workflow-loop.ts
+const WorkflowStepResult = Data.taggedEnum();
+const VercelAgentWorkflowRunResult = Data.taggedEnum();
+const defaultMaxWorkflowTurns = 500;
+const noWorkflowStepRetry = { maxAttempts: 1 };
+const settleWorkflowStep = (promise) => promise.then((value) => WorkflowStepResult.Success({ value }), (error) => WorkflowStepResult.Failure({ error }));
+const workflowMaxTurnsError = (maxTurns) => /* @__PURE__ */ new Error(`Vercel agent workflow exceeded max turns: ${maxTurns}`);
+const writeErrorSafely = (writeError, error) => writeError(error).catch(() => void 0);
+const missingAwaitInputHandlerError = () => /* @__PURE__ */ new Error("Vercel agent workflow awaiting input requested but no awaitInput handler is configured");
+const maxRetryAttempts = (policy) => {
+	const configured = policy?.maxAttempts ?? noWorkflowStepRetry.maxAttempts;
+	return Number.isFinite(configured) ? Math.max(1, Math.floor(configured)) : 1;
+};
+const maxWorkflowTurns = (configured) => {
+	if (configured === void 0 || !Number.isFinite(configured)) return 500;
+	return Math.max(1, Math.floor(configured));
+};
+async function retryWorkflowStep(runStep, policy) {
+	const maxAttempts = maxRetryAttempts(policy);
+	let attempt = 1;
+	for (;;) try {
+		return await runStep();
+	} catch (error) {
+		if (attempt >= maxAttempts) throw error;
+		attempt += 1;
+	}
+}
+async function runVercelAgentWorkflow(config) {
+	const { input, maxTurns: configuredMaxTurns, runModelStep, runToolBatchStep, closeStream, writeError, awaitInput, modelStepRetry, toolBatchStepRetry, awaitInputRetry, closeStreamRetry } = config;
+	let state = {
+		request: input.request,
+		createdMessages: [],
+		turn: 1,
+		eventSequence: 0
+	};
+	const maxTurns = maxWorkflowTurns(configuredMaxTurns);
+	for (let step = 0; step < maxTurns; step++) {
+		const modelResult = await settleWorkflowStep(retryWorkflowStep(() => runModelStep({
+			context: input.context,
+			state
+		}), modelStepRetry));
+		if (Predicate.isTagged(modelResult, "Failure")) {
+			await writeErrorSafely(writeError, modelResult.error);
+			return VercelAgentWorkflowRunResult.ModelStepFailed({
+				turn: state.turn,
+				error: modelResult.error,
+				state
+			});
+		}
+		if (modelResult.value.done) {
+			const terminalState = {
+				request: input.request,
+				messages: modelResult.value.messages,
+				createdMessages: modelResult.value.createdMessages,
+				usage: modelResult.value.usage,
+				turn: modelResult.value.turn,
+				eventSequence: modelResult.value.eventSequence ?? state.eventSequence
+			};
+			const closeResult = await settleWorkflowStep(retryWorkflowStep(closeStream, closeStreamRetry));
+			if (Predicate.isTagged(closeResult, "Failure")) {
+				await writeErrorSafely(writeError, closeResult.error);
+				return VercelAgentWorkflowRunResult.CloseStreamFailed({
+					turns: modelResult.value.turn,
+					error: closeResult.error,
+					state: terminalState
+				});
+			}
+			return VercelAgentWorkflowRunResult.Completed({
+				turns: modelResult.value.turn,
+				state: terminalState
+			});
+		}
+		if (modelResult.value.toolCalls.length === 0) {
+			state = {
+				request: input.request,
+				messages: modelResult.value.messages,
+				createdMessages: modelResult.value.createdMessages,
+				usage: modelResult.value.usage,
+				turn: modelResult.value.turn + 1,
+				eventSequence: modelResult.value.eventSequence ?? state.eventSequence
+			};
+			continue;
+		}
+		let completedToolsResult;
+		const toolHitlResponses = [];
+		let cumulativeUsage = modelResult.value.usage;
+		let toolEventSequence = modelResult.value.eventSequence ?? state.eventSequence;
+		const currentTurnState = (toolResult) => ({
+			request: input.request,
+			messages: toolResult === void 0 ? modelResult.value.messages : [...modelResult.value.messages, ...toolResult.messages],
+			createdMessages: toolResult?.createdMessages ?? modelResult.value.createdMessages,
+			usage: cumulativeUsage,
+			turn: modelResult.value.turn,
+			eventSequence: toolEventSequence
+		});
+		for (;;) {
+			const toolsResult = await settleWorkflowStep(retryWorkflowStep(() => runToolBatchStep({
+				context: input.context,
+				request: input.request,
+				calls: modelResult.value.toolCalls,
+				createdMessages: modelResult.value.createdMessages,
+				hitlResponses: toolHitlResponses.slice(),
+				usage: cumulativeUsage,
+				turn: modelResult.value.turn,
+				eventSequence: toolEventSequence
+			}), toolBatchStepRetry));
+			if (Predicate.isTagged(toolsResult, "Failure")) {
+				await writeErrorSafely(writeError, toolsResult.error);
+				return VercelAgentWorkflowRunResult.ToolBatchStepFailed({
+					turn: modelResult.value.turn,
+					error: toolsResult.error,
+					state: currentTurnState()
+				});
+			}
+			cumulativeUsage = toolsResult.value.usage ?? cumulativeUsage;
+			toolEventSequence = toolsResult.value.eventSequence ?? toolEventSequence;
+			if (toolsResult.value.failure !== void 0) {
+				await writeErrorSafely(writeError, toolsResult.value.failure);
+				return VercelAgentWorkflowRunResult.ToolBatchStepFailed({
+					turn: modelResult.value.turn,
+					error: toolsResult.value.failure,
+					state: currentTurnState(toolsResult.value)
+				});
+			}
+			if (toolsResult.value.awaitingInput === void 0) {
+				completedToolsResult = toolsResult.value;
+				break;
+			}
+			const awaitingInput = toolsResult.value.awaitingInput;
+			cumulativeUsage = toolsResult.value.usage ?? awaitingInput.usage ?? cumulativeUsage;
+			toolEventSequence = awaitingInput.eventSequence ?? toolEventSequence;
+			const hitlResponse = await settleWorkflowStep(retryWorkflowStep(() => {
+				if (awaitInput === void 0) return Promise.reject(missingAwaitInputHandlerError());
+				return awaitInput(awaitingInput);
+			}, awaitInputRetry));
+			if (Predicate.isTagged(hitlResponse, "Failure")) {
+				await writeErrorSafely(writeError, hitlResponse.error);
+				return VercelAgentWorkflowRunResult.AwaitInputFailed({
+					turn: modelResult.value.turn,
+					error: hitlResponse.error,
+					awaitingInput,
+					state: currentTurnState(toolsResult.value)
+				});
+			}
+			toolHitlResponses.push(hitlResponse.value);
+		}
+		if (completedToolsResult === void 0) {
+			const error = /* @__PURE__ */ new Error("Vercel agent workflow tool batch did not complete");
+			await writeErrorSafely(writeError, error);
+			return VercelAgentWorkflowRunResult.ToolBatchStepFailed({
+				turn: modelResult.value.turn,
+				error,
+				state
+			});
+		}
+		state = {
+			request: input.request,
+			messages: [...modelResult.value.messages, ...completedToolsResult.messages],
+			createdMessages: completedToolsResult.createdMessages,
+			usage: completedToolsResult.usage ?? cumulativeUsage,
+			turn: modelResult.value.turn + 1,
+			eventSequence: completedToolsResult.eventSequence ?? toolEventSequence
+		};
+	}
+	const error = workflowMaxTurnsError(maxTurns);
+	await writeErrorSafely(writeError, error);
+	return VercelAgentWorkflowRunResult.MaxTurnsExceeded({
+		maxTurns,
+		error,
+		state
+	});
+}
+//#endregion
+export { VercelAgentWorkflowRunResult, WorkflowStepResult, defaultMaxWorkflowTurns, noWorkflowStepRetry, retryWorkflowStep, runVercelAgentWorkflow, settleWorkflowStep };
+
+//# sourceMappingURL=workflow-loop.mjs.map