@keystrokehq/keystroke 0.1.20 → 0.1.23

package/dist/{dist-BFCT4aiu.cjs → dist-D69ocJ7u.cjs}

@@ -1,5 +1,6 @@
 const require_chunk = require("./chunk-emK7D4bc.cjs");
 const require_dist$3 = require("./dist-BKL5duJl.cjs");
+const require_dist$4 = require("./dist-DqZUy3u_.cjs");
 let zod = require("zod");
 let node_async_hooks = require("node:async_hooks");
 let zod_v4 = require("zod/v4");
@@ -2180,7 +2181,7 @@ function asSchema(schema) {
 		type: "object",
 		properties: {},
 		additionalProperties: false
-	}) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
+	}) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema$1(schema) : standardSchema(schema) : schema();
 }
 function standardSchema(standardSchema2) {
 	return jsonSchema(() => addAdditionalPropertiesToJsonSchema(standardSchema2["~standard"].jsonSchema.input({ target: "draft-07" })), { validate: async (value) => {
@@ -2232,7 +2233,7 @@ function zod4Schema(zodSchema2, options) {
 function isZod4Schema(zodSchema2) {
 	return "_zod" in zodSchema2;
 }
-function zodSchema(zodSchema2, options) {
+function zodSchema$1(zodSchema2, options) {
 	if (isZod4Schema(zodSchema2)) return zod4Schema(zodSchema2, options);
 	else return zod3Schema(zodSchema2, options);
 }
@@ -2693,7 +2694,7 @@ var require_get_vercel_oidc_token = /* @__PURE__ */ require_chunk.__commonJSMin(
 			err = error;
 		}
 		try {
-			const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([await Promise.resolve().then(() => /* @__PURE__ */ require_chunk.__toESM(require_token_util())), await Promise.resolve().then(() => /* @__PURE__ */ require_chunk.__toESM(require("./token-dA7JRmgB.cjs").default))]);
+			const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([await Promise.resolve().then(() => /* @__PURE__ */ require_chunk.__toESM(require_token_util())), await Promise.resolve().then(() => /* @__PURE__ */ require_chunk.__toESM(require("./token-DZEJHEnH.cjs").default))]);
 			if (!token || isExpired(getTokenPayload(token), options?.expirationBufferMs)) {
 				await refreshToken(options);
 				token = getVercelOidcTokenSync();
@@ -3277,7 +3278,7 @@ var GatewayRateLimitError = class extends (_b4 = GatewayError, _a4$1 = symbol4$1
 var name4$1 = "GatewayModelNotFoundError";
 var marker5$1 = `vercel.ai.gateway.error.${name4$1}`;
 var symbol5$1 = Symbol.for(marker5$1);
-var modelNotFoundParamSchema = lazySchema(() => zodSchema(zod_v4.z.object({ modelId: zod_v4.z.string() })));
+var modelNotFoundParamSchema = lazySchema(() => zodSchema$1(zod_v4.z.object({ modelId: zod_v4.z.string() })));
 var _a5$1, _b5;
 var GatewayModelNotFoundError = class extends (_b5 = GatewayError, _a5$1 = symbol5$1, _b5) {
 	constructor({ message = "Model not found", statusCode = 404, modelId, cause, generationId } = {}) {
@@ -3458,7 +3459,7 @@ async function createGatewayErrorFromResponse({ response, statusCode, defaultMes
 		});
 	}
 }
-var gatewayErrorResponseSchema = lazySchema(() => zodSchema(zod_v4.z.object({
+var gatewayErrorResponseSchema = lazySchema(() => zodSchema$1(zod_v4.z.object({
 	error: zod_v4.z.object({
 		message: zod_v4.z.string(),
 		type: zod_v4.z.string().nullish(),
@@ -3556,7 +3557,7 @@ async function parseAuthMethod(headers) {
 	});
 	return result.success ? result.value : void 0;
 }
-var gatewayAuthMethodSchema = lazySchema(() => zodSchema(zod_v4.z.union([zod_v4.z.literal("api-key"), zod_v4.z.literal("oidc")])));
+var gatewayAuthMethodSchema = lazySchema(() => zodSchema$1(zod_v4.z.union([zod_v4.z.literal("api-key"), zod_v4.z.literal("oidc")])));
 var KNOWN_MODEL_TYPES = [
 	"embedding",
 	"image",
@@ -3606,7 +3607,7 @@ var GatewayFetchMetadata = class {
 		}
 	}
 };
-var gatewayAvailableModelsResponseSchema = lazySchema(() => zodSchema(zod_v4.z.object({ models: zod_v4.z.array(zod_v4.z.object({
+var gatewayAvailableModelsResponseSchema = lazySchema(() => zodSchema$1(zod_v4.z.object({ models: zod_v4.z.array(zod_v4.z.object({
 	id: zod_v4.z.string(),
 	name: zod_v4.z.string(),
 	description: zod_v4.z.string().nullish(),
@@ -3628,7 +3629,7 @@ var gatewayAvailableModelsResponseSchema = lazySchema(() => zodSchema(zod_v4.z.o
 	}),
 	modelType: zod_v4.z.string().nullish()
 })).transform((models) => models.filter((m) => m.modelType == null || KNOWN_MODEL_TYPES.includes(m.modelType))) })));
-var gatewayCreditsResponseSchema = lazySchema(() => zodSchema(zod_v4.z.object({
+var gatewayCreditsResponseSchema = lazySchema(() => zodSchema$1(zod_v4.z.object({
 	balance: zod_v4.z.string(),
 	total_used: zod_v4.z.string()
 }).transform(({ balance, total_used }) => ({
@@ -3668,7 +3669,7 @@ var GatewaySpendReport = class {
 		}
 	}
 };
-var gatewaySpendReportResponseSchema = lazySchema(() => zodSchema(zod_v4.z.object({ results: zod_v4.z.array(zod_v4.z.object({
+var gatewaySpendReportResponseSchema = lazySchema(() => zodSchema$1(zod_v4.z.object({ results: zod_v4.z.array(zod_v4.z.object({
 	day: zod_v4.z.string().optional(),
 	hour: zod_v4.z.string().optional(),
 	user: zod_v4.z.string().optional(),
@@ -3718,7 +3719,7 @@ var GatewayGenerationInfoFetcher = class {
 		}
 	}
 };
-var gatewayGenerationInfoResponseSchema = lazySchema(() => zodSchema(zod_v4.z.object({ data: zod_v4.z.object({
+var gatewayGenerationInfoResponseSchema = lazySchema(() => zodSchema$1(zod_v4.z.object({ data: zod_v4.z.object({
 	id: zod_v4.z.string(),
 	total_cost: zod_v4.z.number(),
 	upstream_inference_cost: zod_v4.z.number(),
@@ -3970,7 +3971,7 @@ var gatewayEmbeddingWarningSchema = zod_v4.z.discriminatedUnion("type", [
 		message: zod_v4.z.string()
 	})
 ]);
-var gatewayEmbeddingResponseSchema = lazySchema(() => zodSchema(zod_v4.z.object({
+var gatewayEmbeddingResponseSchema = lazySchema(() => zodSchema$1(zod_v4.z.object({
 	embeddings: zod_v4.z.array(zod_v4.z.array(zod_v4.z.number())),
 	usage: zod_v4.z.object({ tokens: zod_v4.z.number() }).nullish(),
 	warnings: zod_v4.z.array(gatewayEmbeddingWarningSchema).optional(),
@@ -4322,7 +4323,7 @@ var gatewayRerankingWarningSchema = zod_v4.z.discriminatedUnion("type", [
 		message: zod_v4.z.string()
 	})
 ]);
-var gatewayRerankingResponseSchema = lazySchema(() => zodSchema(zod_v4.z.object({
+var gatewayRerankingResponseSchema = lazySchema(() => zodSchema$1(zod_v4.z.object({
 	ranking: zod_v4.z.array(zod_v4.z.object({
 		index: zod_v4.z.number(),
 		relevanceScore: zod_v4.z.number()
@@ -4557,7 +4558,7 @@ function toGatewayRealtimeUrl(baseURL, modelId) {
 }
 var exaSearchToolFactory = createProviderExecutedToolFactory({
 	id: "gateway.exa_search",
-	inputSchema: lazySchema(() => zodSchema(zod.z.object({
+	inputSchema: lazySchema(() => zodSchema$1(zod.z.object({
 		query: zod.z.string().describe("Natural-language web search query. This is required."),
 		type: zod.z.enum([
 			"auto",
@@ -4620,7 +4621,7 @@ var exaSearchToolFactory = createProviderExecutedToolFactory({
 			}).optional()
 		}).optional().describe("Controls extracted page content and freshness.")
 	}))),
-	outputSchema: lazySchema(() => zodSchema(zod.z.union([zod.z.object({
+	outputSchema: lazySchema(() => zodSchema$1(zod.z.union([zod.z.object({
 		requestId: zod.z.string(),
 		searchType: zod.z.string().optional(),
 		resolvedSearchType: zod.z.string().optional(),
@@ -4663,7 +4664,7 @@ var exaSearchToolFactory = createProviderExecutedToolFactory({
 var exaSearch = (config = {}) => exaSearchToolFactory(config);
 var parallelSearchToolFactory = createProviderExecutedToolFactory({
 	id: "gateway.parallel_search",
-	inputSchema: lazySchema(() => zodSchema(zod.z.object({
+	inputSchema: lazySchema(() => zodSchema$1(zod.z.object({
 		objective: zod.z.string().describe("Natural-language description of the web research goal, including source or freshness guidance and broader context from the task. Maximum 5000 characters."),
 		search_queries: zod.z.array(zod.z.string()).optional().describe("Optional search queries to supplement the objective. Maximum 200 characters per query."),
 		mode: zod.z.enum(["one-shot", "agentic"]).optional().describe("Mode preset: \"one-shot\" for comprehensive results with longer excerpts (default), \"agentic\" for concise, token-efficient results for multi-step workflows."),
@@ -4679,7 +4680,7 @@ var parallelSearchToolFactory = createProviderExecutedToolFactory({
 		}).optional().describe("Excerpt configuration for controlling result length."),
 		fetch_policy: zod.z.object({ max_age_seconds: zod.z.number().optional().describe("Maximum age in seconds for cached content. Set to 0 to always fetch fresh content.") }).optional().describe("Fetch policy for controlling content freshness.")
 	}))),
-	outputSchema: lazySchema(() => zodSchema(zod.z.union([zod.z.object({
+	outputSchema: lazySchema(() => zodSchema$1(zod.z.union([zod.z.object({
 		searchId: zod.z.string(),
 		results: zod.z.array(zod.z.object({
 			url: zod.z.string(),
@@ -4704,7 +4705,7 @@ var parallelSearchToolFactory = createProviderExecutedToolFactory({
 var parallelSearch = (config = {}) => parallelSearchToolFactory(config);
 var perplexitySearchToolFactory = createProviderExecutedToolFactory({
 	id: "gateway.perplexity_search",
-	inputSchema: lazySchema(() => zodSchema(zod.z.object({
+	inputSchema: lazySchema(() => zodSchema$1(zod.z.object({
 		query: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).describe("Search query (string) or multiple queries (array of up to 5 strings). Multi-query searches return combined results from all queries."),
 		max_results: zod.z.number().optional().describe("Maximum number of search results to return (1-20, default: 10)"),
 		max_tokens_per_page: zod.z.number().optional().describe("Maximum number of tokens to extract per search result page (256-2048, default: 2048)"),
@@ -4723,7 +4724,7 @@ var perplexitySearchToolFactory = createProviderExecutedToolFactory({
 			"year"
 		]).optional().describe("Filter results by relative time period. Cannot be used with search_after_date or search_before_date.")
 	}))),
-	outputSchema: lazySchema(() => zodSchema(zod.z.union([zod.z.object({
+	outputSchema: lazySchema(() => zodSchema$1(zod.z.union([zod.z.object({
 		results: zod.z.array(zod.z.object({
 			title: zod.z.string(),
 			url: zod.z.string(),
@@ -46108,12 +46109,668 @@ async function resolveActionCredentials(requirements, options) {
 	return parseResolvedCredentials(requirements, await resolveCredentials(requirements, options.consumer, options.contextOverride));
 }
 //#endregion
+//#region ../workflow/dist/index.mjs
+var RunCanceledError = class extends Error {
+	constructor(runId) {
+		super(runId ? `Workflow run ${runId} was canceled` : "Workflow run was canceled");
+		this.name = "RunCanceledError";
+	}
+};
+function isRunCanceledError(error) {
+	return error instanceof RunCanceledError;
+}
+function executeWorkflowStep(state) {
+	const handle = require_dist$4.getWorkflowRunHandle();
+	if (!handle?.workflowRunner) throw new Error(`Workflow "${state.workflow.slug}" can only be called as a step inside a running workflow. Run it standalone with executeWorkflow(...).`);
+	return handle.workflowRunner(state.workflow, state.input, { id: state.id });
+}
+function createWorkflowStepInvocation(state) {
+	return {
+		stepId(id) {
+			return createWorkflowStepInvocation({
+				...state,
+				id
+			});
+		},
+		then(onfulfilled, onrejected) {
+			return executeWorkflowStep(state).then(onfulfilled, onrejected);
+		}
+	};
+}
+const zodSchema = zod.z.custom((v) => v instanceof zod.z.ZodType, "must be a Zod schema");
+/** Runtime validation for an unbranded workflow definition. */
+const workflowCoreSchema = zod.z.object({
+	slug: zod.z.string().trim().min(1),
+	name: zod.z.string().optional(),
+	description: zod.z.string().optional(),
+	subscription: zod.z.object({ mode: zod.z.enum(["system", "subscribable"]).optional() }).optional(),
+	input: zodSchema,
+	output: zodSchema,
+	run: zod.z.function()
+});
+const WORKFLOW = Symbol.for("keystroke.workflow");
+/**
+* Validates brand + shape via `workflowCoreSchema` so discovery and guards
+* reject malformed definitions.
+*/
+function isWorkflow(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!(WORKFLOW in value) || value[WORKFLOW] !== true) return false;
+	return workflowCoreSchema.safeParse(value).success;
+}
+function defineWorkflow(def) {
+	const result = workflowCoreSchema.safeParse(def);
+	if (!result.success) throw new Error(`Invalid workflow definition: ${formatIssues(result.error.issues)}`);
+	const body = def.run;
+	const workflow = {
+		...result.data,
+		[WORKFLOW]: true
+	};
+	workflow.run = ((input, ctx) => {
+		if (ctx !== void 0) return body(input, ctx);
+		return createWorkflowStepInvocation({
+			workflow,
+			input
+		});
+	});
+	return workflow;
+}
+function formatIssues(issues) {
+	return issues.map((issue) => {
+		return `${issue.path.length > 0 ? `${issue.path.join(".")}: ` : ""}${issue.message}`;
+	}).join("; ");
+}
+function serializeWorkflowError(error) {
+	if (error instanceof Error) return {
+		name: error.name,
+		message: error.message
+	};
+	return { message: String(error) };
+}
+/** Rebuild an Error from a recorded error so replay re-raises the same failure. */
+function deserializeWorkflowError(data) {
+	const serialized = data;
+	const error = new Error(serialized?.message ?? "Workflow step failed");
+	if (serialized?.name) error.name = serialized.name;
+	return error;
+}
+const UNIT_MS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5
+};
+/** Resolve a sleep duration to an absolute resume time. */
+function resolveResumeAt(duration, now = /* @__PURE__ */ new Date()) {
+	if (duration instanceof Date) return duration;
+	if (typeof duration === "number") return new Date(now.getTime() + Math.max(0, duration));
+	return new Date(now.getTime() + parseDurationToMs(duration));
+}
+function parseDurationToMs(value) {
+	const match = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/.exec(value.trim());
+	if (!match) throw new Error(`Invalid sleep duration "${value}". Use a number of ms, a Date, or a string like "5s", "10m", "1h".`);
+	const amount = Number(match[1]);
+	const unit = match[2];
+	return Math.round(amount * UNIT_MS[unit]);
+}
+/** Indexes replay events by correlationId for O(1) cache-hit checks during replay. */
+var EventsConsumer = class {
+	byCorrelationId = /* @__PURE__ */ new Map();
+	constructor(events) {
+		for (const event of events) {
+			if (!event.correlationId) continue;
+			const list = this.byCorrelationId.get(event.correlationId);
+			if (list) list.push(event);
+			else this.byCorrelationId.set(event.correlationId, [event]);
+		}
+	}
+	events(correlationId) {
+		return this.byCorrelationId.get(correlationId) ?? [];
+	}
+	hasEventType(correlationId, type) {
+		return this.events(correlationId).some((event) => event.type === type);
+	}
+	/**
+	* Cache lookup for a step. Returns the recorded output on a `step_completed`,
+	* re-raises the recorded error on a terminal `step_failed` (so a permanently
+	* failed step is not re-executed), and otherwise reports a miss — including
+	* when only `step_retrying` events exist (the step re-runs on the next pass).
+	*/
+	getStepResult(correlationId) {
+		const events = this.events(correlationId);
+		const failed = events.find((event) => event.type === "step_failed");
+		if (failed) throw deserializeWorkflowError(failed.data);
+		const completed = events.find((event) => event.type === "step_completed");
+		if (completed) return {
+			completed: true,
+			result: completed.data
+		};
+		return { completed: false };
+	}
+	/** Number of prior `step_retrying` events recorded for a step (= failed attempts so far). */
+	countRetrying(correlationId) {
+		return this.events(correlationId).filter((event) => event.type === "step_retrying").length;
+	}
+	isSleepCompleted(correlationId) {
+		return this.hasEventType(correlationId, "sleep_completed");
+	}
+	/** Returns the persisted resumeAt for a scheduled-but-not-completed sleep, if any. */
+	getSleepResumeAt(correlationId) {
+		const scheduled = this.events(correlationId).find((event) => event.type === "sleep_scheduled");
+		if (!scheduled) return;
+		const data = scheduled.data;
+		return data?.resumeAt ? new Date(data.resumeAt) : void 0;
+	}
+	getHookToken(correlationId) {
+		return (this.events(correlationId).find((event) => event.type === "hook_created")?.data)?.token;
+	}
+	getHookResult(correlationId) {
+		const resumed = this.events(correlationId).find((event) => event.type === "hook_resumed");
+		if (!resumed) return { resolved: false };
+		return {
+			resolved: true,
+			payload: resumed.data?.payload
+		};
+	}
+};
+/** A promise that never settles — returned by a suspending primitive so the body parks. */
+function createPendingPromise() {
+	return new Promise(() => {});
+}
+/**
+* Collects pending items requested within a single tick and resolves once, so
+* parallel suspensions (e.g. Promise.all of two sleeps) batch into one suspension.
+*/
+var SuspensionCoordinator = class {
+	items = /* @__PURE__ */ new Map();
+	scheduled = false;
+	resolve;
+	promise;
+	constructor() {
+		this.promise = new Promise((resolve) => {
+			this.resolve = resolve;
+		});
+	}
+	request(item) {
+		this.items.set(item.correlationId, item);
+		if (!this.scheduled) {
+			this.scheduled = true;
+			queueMicrotask(() => {
+				this.resolve([...this.items.values()]);
+			});
+		}
+	}
+	waitForSuspension() {
+		return this.promise;
+	}
+};
+function createReplayState(params) {
+	return {
+		runId: params.runId,
+		consumer: params.consumer,
+		coordinator: params.coordinator,
+		eventLog: params.eventLog,
+		newEvents: [],
+		now: params.now ?? /* @__PURE__ */ new Date(),
+		hookBaseUrl: params.hookBaseUrl,
+		sleepCounter: 0,
+		hookCounter: 0,
+		stepOccurrences: /* @__PURE__ */ new Map(),
+		stepCorrelationIds: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* Allocate the correlation id for a step. An explicit `.stepId(x)` maps to
+* `step:x` (and must be unique within a run); otherwise the key is
+* `step:<actionKey>#<occurrence>` so that two calls to the same action get
+* distinct, replay-stable ids and inserting an unrelated call never shifts the
+* ids of later calls (unlike a single global ordinal).
+*/
+function nextStepCorrelationId(state, actionKey, explicitId) {
+	if (explicitId !== void 0) {
+		const correlationId = `step:${explicitId}`;
+		if (state.stepCorrelationIds.has(correlationId)) throw new Error(`Duplicate step id "${explicitId}" in workflow run ${state.runId}`);
+		state.stepCorrelationIds.add(correlationId);
+		return correlationId;
+	}
+	const occurrence = state.stepOccurrences.get(actionKey) ?? 0;
+	state.stepOccurrences.set(actionKey, occurrence + 1);
+	const correlationId = `step:${actionKey}#${occurrence}`;
+	state.stepCorrelationIds.add(correlationId);
+	return correlationId;
+}
+function createSleep(state) {
+	return function sleep(duration) {
+		const correlationId = `sleep#${state.sleepCounter++}`;
+		if (state.consumer.isSleepCompleted(correlationId)) return Promise.resolve();
+		const scheduledResumeAt = state.consumer.getSleepResumeAt(correlationId);
+		const resumeAt = scheduledResumeAt ?? resolveResumeAt(duration, state.now);
+		if (scheduledResumeAt && resumeAt.getTime() <= state.now.getTime()) {
+			state.newEvents.push({
+				id: `sleep_completed:${state.runId}:${correlationId}`,
+				runId: state.runId,
+				type: "sleep_completed",
+				correlationId
+			});
+			return Promise.resolve();
+		}
+		if (!scheduledResumeAt) state.newEvents.push({
+			id: `sleep_scheduled:${state.runId}:${correlationId}`,
+			runId: state.runId,
+			type: "sleep_scheduled",
+			correlationId,
+			data: { resumeAt: resumeAt.toISOString() }
+		});
+		state.coordinator.request({
+			kind: "sleep",
+			correlationId,
+			resumeAt
+		});
+		return createPendingPromise();
+	};
+}
+function createHook(state) {
+	return function hook(options) {
+		const correlationId = `hook#${state.hookCounter++}`;
+		const token = options?.token ?? state.consumer.getHookToken(correlationId) ?? `hook_${crypto.randomUUID()}`;
+		const resumeUrl = state.hookBaseUrl ? `${state.hookBaseUrl}/hooks/${token}/resume` : `/hooks/${token}/resume`;
+		const schema = options?.schema ? zod.z.toJSONSchema(options.schema) : void 0;
+		return {
+			token,
+			resumeUrl,
+			then(onFulfilled, onRejected) {
+				const result = state.consumer.getHookResult(correlationId);
+				if (result.resolved) {
+					const payload = options?.schema ? options.schema.parse(result.payload) : result.payload;
+					return Promise.resolve(payload).then(onFulfilled, onRejected);
+				}
+				if (!state.consumer.hasEventType(correlationId, "hook_created")) state.newEvents.push({
+					id: `hook_created:${state.runId}:${correlationId}`,
+					runId: state.runId,
+					type: "hook_created",
+					correlationId,
+					data: schema ? {
+						token,
+						schema
+					} : { token }
+				});
+				state.coordinator.request({
+					kind: "hook",
+					correlationId,
+					token,
+					...schema ? { schema } : {}
+				});
+				return createPendingPromise().then(onFulfilled, onRejected);
+			}
+		};
+	};
+}
+/**
+* Shared durable-step shell: resolve a stable `correlation_id`, short-circuit
+* from the event log on a cache hit, otherwise execute and append
+* `step_completed` immediately (per-step crash durability). A thrown step
+* appends `step_retrying` (non-fatal, re-run on the next attempt) and
+* rethrows; the terminal `step_failed` is written by the job handler once the
+* queue exhausts retries.
+*/
+async function runDurableStep(state, options) {
+	const { runId, consumer, eventLog } = state;
+	require_dist$4.getRunSignal().throwIfAborted();
+	const correlationId = nextStepCorrelationId(state, options.key, options.id);
+	const cached = consumer.getStepResult(correlationId);
+	const metadata = {
+		runId,
+		[options.metadataKey]: options.key,
+		correlationId
+	};
+	if (cached.completed) {
+		await withSpan({
+			kind: options.kind,
+			name: options.key,
+			refId: `${runId}:${correlationId}`,
+			metadata: {
+				...metadata,
+				replayed: true
+			}
+		}, async () => {
+			await logSystem("info", options.replayMessage, metadata);
+		});
+		return options.parseCached ? options.parseCached(cached.result) : cached.result;
+	}
+	return withSpan({
+		kind: options.kind,
+		name: options.key,
+		refId: `${runId}:${correlationId}`,
+		metadata
+	}, async () => captureConsole(async () => {
+		try {
+			const result = await options.execute(correlationId);
+			await eventLog.append({
+				id: `step_completed:${runId}:${correlationId}`,
+				runId,
+				type: "step_completed",
+				correlationId,
+				data: result
+			});
+			return result;
+		} catch (error) {
+			const attempt = consumer.countRetrying(correlationId);
+			await eventLog.append({
+				id: `step_retrying:${runId}:${correlationId}:${attempt}`,
+				runId,
+				type: "step_retrying",
+				correlationId,
+				data: serializeWorkflowError(error)
+			});
+			state.failedCorrelationId = correlationId;
+			throw error;
+		}
+	}));
+}
+function withCredentialScopeOverride(requirements, scope) {
+	if (!requirements || !scope) return requirements;
+	return require_dist$3.normalizeCredentialList(requirements).map((requirement) => ({
+		...requirement,
+		scope
+	}));
+}
+/** Builds the per-run action runner; durability lives in {@link runDurableStep}. */
+function createActionRunner(state, options = {}) {
+	return (action, input, runOptions) => runDurableStep(state, {
+		kind: "action",
+		key: action.slug,
+		id: runOptions?.id,
+		metadataKey: "actionKey",
+		replayMessage: "action replayed from checkpoint",
+		parseCached: (cached) => action.output.parse(cached),
+		execute: async (correlationId) => {
+			const requirements = withCredentialScopeOverride(require_dist$4.getActionCredentialRequirements(action), runOptions?.credentialScope);
+			const credentials = requirements?.length ? await resolveActionCredentials(requirements, {
+				resolveCredentials: options.resolveCredentials,
+				context: options.credentialContext,
+				oauthAdapter: options.oauthAdapter,
+				consumer: {
+					kind: "action",
+					name: action.slug,
+					id: correlationId
+				}
+			}) : {};
+			return require_dist$4.runWithMcpCredentialContext({
+				...options.mcpCredentialContext,
+				consumerId: correlationId
+			}, () => require_dist$4.executeAction(action, input, credentials));
+		}
+	});
+}
+/**
+* Builds the per-run agent runner: each `agent.prompt()` in a workflow body
+* becomes a durable step keyed `step:<agentKey>#<occurrence>` (same scheme as
+* actions). The actual prompt execution is delegated to `runAgent`, supplied
+* by the host (server) via `executeWorkflow({ runAgent })`.
+*/
+function createAgentStepRunner(state, runAgent) {
+	return (agent, input, options) => {
+		const slug = agent.slug;
+		return runDurableStep(state, {
+			kind: "agent_session",
+			key: slug,
+			id: options?.id,
+			metadataKey: "agentKey",
+			replayMessage: "agent step replayed from checkpoint",
+			execute: (_correlationId) => runAgent(agent, input, options?.runPrompt)
+		});
+	};
+}
+/**
+* Builds the per-run LLM runner: each `promptLlm()` in a workflow body becomes a
+* durable step keyed `step:promptLlm#<occurrence>`. The actual LLM call is
+* delegated to `runLlm`, supplied by the host (server) via `executeWorkflow({ runLlm })`.
+*/
+function createLlmStepRunner(state, runLlm) {
+	return (opts) => runDurableStep(state, {
+		kind: "llm",
+		key: "promptLlm",
+		id: opts.stepId,
+		metadataKey: "llmKey",
+		replayMessage: "llm step replayed from checkpoint",
+		parseCached: (cached) => opts.outputSchema ? opts.outputSchema.parse(cached) : cached,
+		execute: (_correlationId) => runLlm(opts)
+	});
+}
+/**
+* Builds the per-run sub-workflow runner: each `workflow.run(input)` inside a
+* workflow body becomes a durable step keyed `step:<slug>#<occurrence>`. The
+* sub-workflow's body runs inline in the same replay state (its action/agent/
+* LLM steps and `ctx.sleep`/`ctx.hook` stay durable), and its validated output
+* is checkpointed so a replay skips the whole sub-workflow once it completes.
+*/
+function createWorkflowStepRunner(state, ctx) {
+	return (workflowUnknown, input, options) => {
+		const workflow = workflowUnknown;
+		const parsedInput = workflow.input.parse(input);
+		return runDurableStep(state, {
+			kind: "workflow_run",
+			key: workflow.slug,
+			id: options?.id,
+			metadataKey: "workflowKey",
+			replayMessage: "workflow step replayed from checkpoint",
+			parseCached: (cached) => workflow.output.parse(cached),
+			execute: async () => {
+				const output = await workflow.run(parsedInput, ctx);
+				return workflow.output.parse(output);
+			}
+		});
+	};
+}
+const storage = new node_async_hooks.AsyncLocalStorage();
+require_dist$4.registerWorkflowRunGetter(() => {
+	const store = storage.getStore();
+	if (!store) return;
+	return {
+		actionRunner: store.actionRunner,
+		agentRunner: store.agentRunner,
+		llmRunner: store.llmRunner,
+		workflowRunner: store.workflowRunner
+	};
+});
+function runWithWorkflowContext(store, fn) {
+	return storage.run(store, fn);
+}
+/** In-memory durable log for inline execution and tests. */
+var MemoryEventLog = class {
+	events = [];
+	ids = /* @__PURE__ */ new Set();
+	async append(event) {
+		const id = event.id ?? crypto.randomUUID();
+		if (this.ids.has(id)) return false;
+		this.ids.add(id);
+		this.events.push({
+			id,
+			runId: event.runId,
+			seq: this.events.length,
+			type: event.type,
+			correlationId: event.correlationId ?? null,
+			data: event.data ?? null
+		});
+		return true;
+	}
+	async listReplay(runId) {
+		return this.events.filter((event) => event.runId === runId).map((event) => ({ ...event }));
+	}
+};
+/**
+* The single way to run a workflow: replay its event log from the top, execute
+* un-cached primitives, and either complete/fail or suspend at the first
+* un-satisfied sleep/hook. New events (sleep_scheduled/sleep_completed/
+* hook_created/run_completed/run_failed) are flushed before returning.
+*
+* Durability comes entirely from the log — a suspended run resumes by calling
+* this again with the same `runId` and event log once the sleep is due or the
+* hook is resumed.
+*/
+async function executeWorkflow(workflow, input, options = {}) {
+	const runId = options.runId ?? crypto.randomUUID();
+	const eventLog = options.eventLog ?? new MemoryEventLog();
+	const signal = require_dist$4.getRunSignal();
+	const consumer = new EventsConsumer(await eventLog.listReplay(runId));
+	const coordinator = new SuspensionCoordinator();
+	const state = createReplayState({
+		runId,
+		consumer,
+		coordinator,
+		eventLog,
+		hookBaseUrl: options.hookBaseUrl,
+		now: options.now
+	});
+	const actionRunner = createActionRunner(state, {
+		resolveCredentials: options.resolveCredentials,
+		credentialContext: options.credentialContext,
+		oauthAdapter: options.oauthAdapter,
+		mcpCredentialContext: { assignmentTarget: {
+			type: "workflow",
+			key: workflow.slug
+		} }
+	});
+	const ctx = {
+		runId,
+		sleep: createSleep(state),
+		hook: createHook(state),
+		...options.context
+	};
+	const agentRunner = options.runAgent ? createAgentStepRunner(state, options.runAgent) : void 0;
+	const llmRunner = options.runLlm ? createLlmStepRunner(state, options.runLlm) : void 0;
+	const workflowRunner = createWorkflowStepRunner(state, ctx);
+	const validatedInput = workflow.input.parse(input);
+	const bodyPromise = runWithWorkflowContext({
+		actionRunner,
+		agentRunner,
+		llmRunner,
+		workflowRunner,
+		runId
+	}, () => captureConsole(async () => workflow.run(validatedInput, ctx)));
+	let onAbort;
+	const waitForAbort = signal.aborted ? Promise.resolve({ type: "canceled" }) : new Promise((resolve) => {
+		onAbort = () => resolve({ type: "canceled" });
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	const outcome = await Promise.race([
+		bodyPromise.then((output) => ({
+			type: "done",
+			output
+		}), (error) => ({
+			type: "error",
+			error
+		})),
+		coordinator.waitForSuspension().then((items) => ({
+			type: "suspended",
+			items
+		})),
+		waitForAbort
+	]);
+	if (onAbort) signal.removeEventListener("abort", onAbort);
+	let result;
+	if (outcome.type === "suspended") {
+		bodyPromise.catch(() => {});
+		result = {
+			status: "suspended",
+			items: outcome.items
+		};
+	} else if (outcome.type === "done") {
+		const output = workflow.output.parse(outcome.output);
+		state.newEvents.push({
+			id: `run_completed:${runId}`,
+			runId,
+			type: "run_completed",
+			data: { output }
+		});
+		result = {
+			status: "completed",
+			output
+		};
+	} else if (outcome.type === "canceled" || isRunCanceledError(outcome.error)) {
+		bodyPromise.catch(() => {});
+		state.newEvents.push({
+			id: `run_canceled:${runId}`,
+			runId,
+			type: "run_canceled"
+		});
+		result = { status: "canceled" };
+	} else result = {
+		status: "failed",
+		error: outcome.error,
+		failedCorrelationId: state.failedCorrelationId
+	};
+	for (const event of state.newEvents) await eventLog.append(event);
+	return result;
+}
+function promptLlm(prompt, opts) {
+	const handle = require_dist$4.getWorkflowRunHandle();
+	if (!handle?.llmRunner) throw new Error("promptLlm must run inside a workflow with an injected llm executor (executeWorkflow({ runLlm })).");
+	return handle.llmRunner({
+		prompt,
+		...opts
+	});
+}
+let executor;
+function registerWorkflowToolExecutor(fn) {
+	if (executor) throw new Error("workflow tool executor already registered");
+	executor = fn;
+}
+function getWorkflowToolExecutor() {
+	if (!executor) throw new Error("workflow tool executor not registered");
+	return executor;
+}
+function assertWorkflowToolInput(workflow) {
+	if (!("shape" in workflow.input) || typeof workflow.input.shape !== "object") throw new Error(`Workflow "${workflow.slug}" cannot be used as an agent tool: input schema must be a Zod object.`);
+}
+function resolveWorkflowTool(workflow) {
+	assertWorkflowToolInput(workflow);
+	const key = workflow.slug;
+	return require_dist$3.defineTool({
+		name: key,
+		label: key,
+		description: workflow.description ?? key,
+		parameters: workflow.input,
+		async execute(toolCallId, params) {
+			const output = await withSpan({
+				kind: "tool_call",
+				name: key,
+				refId: toolCallId,
+				metadata: {
+					tool: key,
+					type: "workflow"
+				}
+			}, () => getWorkflowToolExecutor()(workflow, params, { workflowKey: key }));
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(output)
+				}],
+				details: output
+			};
+		}
+	});
+}
+//#endregion
 Object.defineProperty(exports, "MESSAGE_EVENT_TYPE", {
 	enumerable: true,
 	get: function() {
 		return MESSAGE_EVENT_TYPE;
 	}
 });
+Object.defineProperty(exports, "MemoryEventLog", {
+	enumerable: true,
+	get: function() {
+		return MemoryEventLog;
+	}
+});
+Object.defineProperty(exports, "RunCanceledError", {
+	enumerable: true,
+	get: function() {
+		return RunCanceledError;
+	}
+});
 Object.defineProperty(exports, "ToolLoopAgent", {
 	enumerable: true,
 	get: function() {
@@ -46204,12 +46861,30 @@ Object.defineProperty(exports, "defineMcp", {
 		return defineMcp;
 	}
 });
+Object.defineProperty(exports, "defineWorkflow", {
+	enumerable: true,
+	get: function() {
+		return defineWorkflow;
+	}
+});
+Object.defineProperty(exports, "deserializeWorkflowError", {
+	enumerable: true,
+	get: function() {
+		return deserializeWorkflowError;
+	}
+});
 Object.defineProperty(exports, "enrichCredentialError", {
 	enumerable: true,
 	get: function() {
 		return enrichCredentialError;
 	}
 });
+Object.defineProperty(exports, "executeWorkflow", {
+	enumerable: true,
+	get: function() {
+		return executeWorkflow;
+	}
+});
 Object.defineProperty(exports, "failAgentSession", {
 	enumerable: true,
 	get: function() {
@@ -46276,6 +46951,18 @@ Object.defineProperty(exports, "isMcp", {
 		return isMcp;
 	}
 });
+Object.defineProperty(exports, "isRunCanceledError", {
+	enumerable: true,
+	get: function() {
+		return isRunCanceledError;
+	}
+});
+Object.defineProperty(exports, "isWorkflow", {
+	enumerable: true,
+	get: function() {
+		return isWorkflow;
+	}
+});
 Object.defineProperty(exports, "jsonSchema", {
 	enumerable: true,
 	get: function() {
@@ -46288,16 +46975,16 @@ Object.defineProperty(exports, "listMessageEvents", {
 		return listMessageEvents;
 	}
 });
-Object.defineProperty(exports, "logSystem", {
+Object.defineProperty(exports, "output_exports", {
 	enumerable: true,
 	get: function() {
-		return logSystem;
+		return output_exports;
 	}
 });
-Object.defineProperty(exports, "output_exports", {
+Object.defineProperty(exports, "promptLlm", {
 	enumerable: true,
 	get: function() {
-		return output_exports;
+		return promptLlm;
 	}
 });
 Object.defineProperty(exports, "readUIMessageStream", {
@@ -46312,6 +46999,12 @@ Object.defineProperty(exports, "recordLlmUsageFromAssistantMessage", {
 		return recordLlmUsageFromAssistantMessage;
 	}
 });
+Object.defineProperty(exports, "registerWorkflowToolExecutor", {
+	enumerable: true,
+	get: function() {
+		return registerWorkflowToolExecutor;
+	}
+});
 Object.defineProperty(exports, "require_token_error", {
 	enumerable: true,
 	get: function() {
@@ -46342,6 +47035,18 @@ Object.defineProperty(exports, "resolveRunSourceFromTraceContext", {
 		return resolveRunSourceFromTraceContext;
 	}
 });
+Object.defineProperty(exports, "resolveWorkflowTool", {
+	enumerable: true,
+	get: function() {
+		return resolveWorkflowTool;
+	}
+});
+Object.defineProperty(exports, "serializeWorkflowError", {
+	enumerable: true,
+	get: function() {
+		return serializeWorkflowError;
+	}
+});
 Object.defineProperty(exports, "setSessionLiveMessage", {
 	enumerable: true,
 	get: function() {
@@ -46385,4 +47090,4 @@ Object.defineProperty(exports, "withSpan", {
 	}
 });
 
-//# sourceMappingURL=dist-BFCT4aiu.cjs.map
+//# sourceMappingURL=dist-D69ocJ7u.cjs.map