npm - @yolk-sdk/vercel-workflows - Versions diffs - 0.1.0-canary.30 → 0.1.0-canary.32 - Mend

@yolk-sdk/vercel-workflows 0.1.0-canary.30 → 0.1.0-canary.32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md CHANGED Viewed

@@ -16,6 +16,7 @@ Canary APIs are unstable. Keep all `@yolk-sdk/*` packages on the same version.
 | --- | --- |
 | `@yolk-sdk/vercel-workflows` | Workflow-safe agent loop orchestration APIs |
 | `@yolk-sdk/vercel-workflows/workflow` | Explicit equivalent subpath |
+| `@yolk-sdk/vercel-workflows/effect` | Effect-native wrapper around public `workflow/api` APIs |
 ## Imports
@@ -33,6 +34,23 @@ import {
 The `./workflow` subpath is also exported for explicit imports.
+Use `./effect` at host boundaries that start, replay, resume, or cancel Workflow runs:
+```ts
+import { Effect } from 'effect'
+import { VercelWorkflows } from '@yolk-sdk/vercel-workflows/effect'
+const program = Effect.gen(function* () {
+  const workflows = yield* VercelWorkflows
+  const run = yield* workflows.start(runAgentWorkflow, [{ request, context }])
+  return yield* run.getReadable<Uint8Array>()
+}).pipe(Effect.provide(VercelWorkflows.layer))
+```
+The API wrapper keeps Vercel's SDK underneath. It does not reimplement Vercel backend HTTP,
+queues, hooks, or stream storage.
 ## Runtime model
 `runVercelAgentWorkflow` coordinates host-provided callbacks:

package/dist/effect.d.mts ADDED Viewed

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

package/dist/effect.d.mts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"effect.d.mts","names":[],"sources":["../src/effect.ts"],"mappings":";;;;KAUY,wBAAA;AAAA,cAQK,yBAAA;;;cAEJ,oBAAA,SAA6B,yBAAA;EAAA,SAC/B,SAAA,EAAW,wBAAA;EAAA,SACX,OAAA;EAAA,SACA,KAAA;AAAA;AAAA,KAGC,sBAAA,yCACP,IAAA,EAAM,KAAA,KACN,OAAA,CAAQ,OAAA;AAAA,KAED,6BAAA,GAAgC,6BAA6B;AAAA,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,OAiF5B,KAAA,EAAK,KAAA,CAAA,KAAA,CAAA,eAAA;EAAA,OACL,YAAA,EAAY,KAAA,CAAA,KAAA,CAAA,eAAA,SAAA,kBAAA;AAAA"}

package/dist/effect.mjs ADDED Viewed

@@ -0,0 +1,66 @@
+import { Context, Data, Effect, Layer } from "effect";
+import { getRun, resumeHook, start } from "workflow/api";
+//#region src/effect.ts
+var VercelWorkflowsError = class extends Data.TaggedError("VercelWorkflowsError") {};
+var VercelWorkflowsSdk = class extends Context.Service()("@yolk-sdk/vercel-workflows/VercelWorkflowsSdk") {};
+const workflowsError = (operation, cause) => new VercelWorkflowsError({
+	operation,
+	message: `Vercel Workflow ${operation} failed`,
+	cause
+});
+const spanAttributes = (runId) => ({ "workflow.run.id": runId });
+const 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) }))
+});
+const VercelWorkflowsSdkLive = Layer.succeed(VercelWorkflowsSdk, {
+	start: (workflow, args) => start(workflow, args),
+	getRun: (runId) => getRun(runId),
+	resumeHook: (token, payload) => 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) }));
+	return {
+		start: (workflow, args) => Effect.tryPromise({
+			try: () => sdk.start(workflow, args),
+			catch: (cause) => workflowsError("start", cause)
+		}).pipe(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")),
+		cancel: (runId) => getRun(runId).pipe(Effect.flatMap((run) => run.cancel), Effect.withSpan("VercelWorkflows.cancel", { attributes: spanAttributes(runId) }))
+	};
+}) }) {
+	static layer = Layer.effect(this, this.make).pipe(Layer.provide(VercelWorkflowsSdkLive));
+	static layerFromSdk = Layer.effect(this, this.make);
+};
+//#endregion
+export { VercelWorkflows, VercelWorkflowsError, VercelWorkflowsSdk };
+//# sourceMappingURL=effect.mjs.map

package/dist/effect.mjs.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"effect.mjs","names":["workflowStart","workflowGetRun","workflowResumeHook"],"sources":["../src/effect.ts"],"sourcesContent":["import { Context, Data, Effect, Layer } from 'effect'\nimport {\n getRun as workflowGetRun,\n resumeHook as workflowResumeHook,\n start as workflowStart,\n type WorkflowReadableStream,\n type WorkflowReadableStreamOptions,\n type WorkflowRun\n} from 'workflow/api'\n\nexport type VercelWorkflowsOperation =\n | 'start'\n | 'getRun'\n | 'getReadable'\n | 'tailIndex'\n | 'resumeHook'\n | 'cancel'\n | 'status'\n | 'returnValue'\n\nexport class VercelWorkflowsError extends Data.TaggedError('VercelWorkflowsError')<{\n readonly operation: VercelWorkflowsOperation\n readonly message: string\n readonly cause: unknown\n}> {}\n\nexport type VercelWorkflowFunction<TArgs extends unknown[], TResult> = (\n ...args: TArgs\n) => Promise<TResult>\n\nexport type VercelWorkflowReadableOptions = WorkflowReadableStreamOptions\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<\n VercelWorkflows,\n VercelWorkflowsClient\n>()(\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(\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: (\n token: string,\n payload: unknown\n ): 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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"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yolk-sdk/vercel-workflows",
-  "version": "0.1.0-canary.30",
+  "version": "0.1.0-canary.32",
   "description": "Vercel Workflow orchestration primitives for Yolk agent loops.",
   "license": "MIT",
   "type": "module",
@@ -35,6 +35,11 @@
       "types": "./dist/workflow.d.mts",
       "import": "./dist/workflow.mjs",
       "default": "./dist/workflow.mjs"
+    },
+    "./effect": {
+      "types": "./dist/effect.d.mts",
+      "import": "./dist/effect.mjs",
+      "default": "./dist/effect.mjs"
     }
   },
   "files": [

package/src/effect.ts ADDED Viewed

@@ -0,0 +1,229 @@
+import { Context, Data, Effect, Layer } from 'effect'
+import {
+  getRun as workflowGetRun,
+  resumeHook as workflowResumeHook,
+  start as workflowStart,
+  type WorkflowReadableStream,
+  type WorkflowReadableStreamOptions,
+  type WorkflowRun
+} from 'workflow/api'
+export type VercelWorkflowsOperation =
+  | 'start'
+  | 'getRun'
+  | 'getReadable'
+  | 'tailIndex'
+  | 'resumeHook'
+  | 'cancel'
+  | 'status'
+  | 'returnValue'
+export class VercelWorkflowsError extends Data.TaggedError('VercelWorkflowsError')<{
+  readonly operation: VercelWorkflowsOperation
+  readonly message: string
+  readonly cause: unknown
+}> {}
+export type VercelWorkflowFunction<TArgs extends unknown[], TResult> = (
+  ...args: TArgs
+) => Promise<TResult>
+export type VercelWorkflowReadableOptions = WorkflowReadableStreamOptions
+export type VercelWorkflowReadableStream<Chunk> = WorkflowReadableStream<Chunk>
+export type VercelWorkflowRunStatus = WorkflowRun['status']
+export type VercelWorkflowsSdkRun<TResult> = {
+  readonly runId: string
+  readonly getReadable: <Chunk>(
+    options?: VercelWorkflowReadableOptions
+  ) => VercelWorkflowReadableStream<Chunk>
+  readonly cancel: () => Promise<void>
+  readonly status: Promise<VercelWorkflowRunStatus>
+  readonly returnValue: Promise<TResult>
+}
+export 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>
+}
+export type VercelWorkflowRun<TResult> = {
+  readonly runId: string
+  readonly getReadable: <Chunk>(
+    options?: VercelWorkflowReadableOptions
+  ) => Effect.Effect<VercelWorkflowReadableStream<Chunk>, VercelWorkflowsError>
+  readonly cancel: Effect.Effect<void, VercelWorkflowsError>
+  readonly status: Effect.Effect<VercelWorkflowRunStatus, VercelWorkflowsError>
+  readonly returnValue: Effect.Effect<TResult, VercelWorkflowsError>
+}
+export type VercelWorkflowsClient = {
+  readonly start: <TArgs extends unknown[], TResult>(
+    workflow: VercelWorkflowFunction<TArgs, TResult>,
+    args: TArgs
+  ) => Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError>
+  readonly getRun: <TResult>(
+    runId: string
+  ) => Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError>
+  readonly getReadable: <Chunk>(
+    runId: string,
+    options?: VercelWorkflowReadableOptions
+  ) => Effect.Effect<VercelWorkflowReadableStream<Chunk>, VercelWorkflowsError>
+  readonly tailIndex: (runId: string) => Effect.Effect<number, VercelWorkflowsError>
+  readonly resumeHook: (
+    token: string,
+    payload: unknown
+  ) => Effect.Effect<void, VercelWorkflowsError>
+  readonly cancel: (runId: string) => Effect.Effect<void, VercelWorkflowsError>
+}
+export class VercelWorkflowsSdk extends Context.Service<
+  VercelWorkflowsSdk,
+  VercelWorkflowsSdkClient
+>()('@yolk-sdk/vercel-workflows/VercelWorkflowsSdk') {}
+const workflowsError = (operation: VercelWorkflowsOperation, cause: unknown) =>
+  new VercelWorkflowsError({
+    operation,
+    message: `Vercel Workflow ${operation} failed`,
+    cause
+  })
+const spanAttributes = (runId: string) => ({ 'workflow.run.id': runId })
+const makeWorkflowRun = <TResult>(
+  run: VercelWorkflowsSdkRun<TResult>
+): VercelWorkflowRun<TResult> => ({
+  runId: run.runId,
+  getReadable: <Chunk>(options?: VercelWorkflowReadableOptions) =>
+    Effect.try({
+      try: () => run.getReadable<Chunk>(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)
+    })
+  )
+})
+const VercelWorkflowsSdkLive = Layer.succeed(VercelWorkflowsSdk, {
+  start: <TArgs extends unknown[], TResult>(
+    workflow: VercelWorkflowFunction<TArgs, TResult>,
+    args: TArgs
+  ) => workflowStart(workflow, args),
+  getRun: <TResult>(runId: string) => workflowGetRun<TResult>(runId),
+  resumeHook: (token: string, payload: unknown) => workflowResumeHook<unknown>(token, payload)
+})
+export class VercelWorkflows extends Context.Service<
+  VercelWorkflows,
+  VercelWorkflowsClient
+>()(
+  '@yolk-sdk/vercel-workflows/VercelWorkflows',
+  {
+    make: Effect.gen(function* () {
+      const sdk = yield* VercelWorkflowsSdk
+      const getRun = <TResult>(
+        runId: string
+      ): Effect.Effect<VercelWorkflowRun<TResult>, VercelWorkflowsError> =>
+        Effect.try({
+          try: () => makeWorkflowRun(sdk.getRun<TResult>(runId)),
+          catch: cause => workflowsError('getRun', cause)
+        }).pipe(
+          Effect.withSpan('VercelWorkflows.getRun', {
+            attributes: spanAttributes(runId)
+          })
+        )
+      return {
+        start: <TArgs extends unknown[], TResult>(
+          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')
+          ),
+        getRun,
+        getReadable: <Chunk>(
+          runId: string,
+          options?: VercelWorkflowReadableOptions
+        ): Effect.Effect<VercelWorkflowReadableStream<Chunk>, VercelWorkflowsError> =>
+          getRun<unknown>(runId).pipe(
+            Effect.flatMap(run => run.getReadable<Chunk>(options)),
+            Effect.withSpan('VercelWorkflows.getReadable', {
+              attributes: spanAttributes(runId)
+            })
+          ),
+        tailIndex: (runId: string): Effect.Effect<number, VercelWorkflowsError> =>
+          getRun<unknown>(runId).pipe(
+            Effect.flatMap(run => run.getReadable<unknown>({ startIndex: -1 })),
+            Effect.flatMap(readable =>
+              Effect.tryPromise({
+                try: () => readable.getTailIndex(),
+                catch: cause => workflowsError('tailIndex', cause)
+              })
+            ),
+            Effect.withSpan('VercelWorkflows.tailIndex', {
+              attributes: spanAttributes(runId)
+            })
+          ),
+        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')),
+        cancel: (runId: string): Effect.Effect<void, VercelWorkflowsError> =>
+          getRun<unknown>(runId).pipe(
+            Effect.flatMap(run => run.cancel),
+            Effect.withSpan('VercelWorkflows.cancel', {
+              attributes: spanAttributes(runId)
+            })
+          )
+      }
+    })
+  }
+) {
+  static layer = Layer.effect(this, this.make).pipe(Layer.provide(VercelWorkflowsSdkLive))
+  static layerFromSdk = Layer.effect(this, this.make)
+}