@keystrokehq/keystroke 0.1.20 → 0.1.22

package/dist/{dist-KpQEao0i.mjs → dist-B1Pjv-cM.mjs}

@@ -1,5 +1,6 @@
 import { n as __require, r as __toESM, t as __commonJSMin } from "./chunk-DnnnRqeS.mjs";
-import { _ as normalizeCredentialList, a as buildConnectDeeplink, h as mcpEntityId } from "./dist-_i6Rguqn.mjs";
+import { _ as normalizeCredentialList, a as buildConnectDeeplink, h as mcpEntityId, l as defineTool } from "./dist-_i6Rguqn.mjs";
+import { _ as runWithMcpCredentialContext, a as getActionCredentialRequirements, c as getRunSignal, i as executeAction, l as getWorkflowRunHandle, m as registerWorkflowRunGetter } from "./dist-CAZlfg_P.mjs";
 import { createRequire } from "node:module";
 import { z } from "zod";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -2179,7 +2180,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) => {
@@ -2231,7 +2232,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);
 }
@@ -2692,7 +2693,7 @@ var require_get_vercel_oidc_token = /* @__PURE__ */ __commonJSMin(((exports, mod
 			err = error;
 		}
 		try {
-			const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([await Promise.resolve().then(() => /* @__PURE__ */ __toESM(require_token_util())), await import("./token-shJjdG3B.mjs").then((m) => /* @__PURE__ */ __toESM(m.default))]);
+			const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([await Promise.resolve().then(() => /* @__PURE__ */ __toESM(require_token_util())), await import("./token-D_x8iwF8.mjs").then((m) => /* @__PURE__ */ __toESM(m.default))]);
 			if (!token || isExpired(getTokenPayload(token), options?.expirationBufferMs)) {
 				await refreshToken(options);
 				token = getVercelOidcTokenSync();
@@ -3276,7 +3277,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(z$1.object({ modelId: z$1.string() })));
+var modelNotFoundParamSchema = lazySchema(() => zodSchema$1(z$1.object({ modelId: z$1.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 } = {}) {
@@ -3457,7 +3458,7 @@ async function createGatewayErrorFromResponse({ response, statusCode, defaultMes
 		});
 	}
 }
-var gatewayErrorResponseSchema = lazySchema(() => zodSchema(z$1.object({
+var gatewayErrorResponseSchema = lazySchema(() => zodSchema$1(z$1.object({
 	error: z$1.object({
 		message: z$1.string(),
 		type: z$1.string().nullish(),
@@ -3555,7 +3556,7 @@ async function parseAuthMethod(headers) {
 	});
 	return result.success ? result.value : void 0;
 }
-var gatewayAuthMethodSchema = lazySchema(() => zodSchema(z$1.union([z$1.literal("api-key"), z$1.literal("oidc")])));
+var gatewayAuthMethodSchema = lazySchema(() => zodSchema$1(z$1.union([z$1.literal("api-key"), z$1.literal("oidc")])));
 var KNOWN_MODEL_TYPES = [
 	"embedding",
 	"image",
@@ -3605,7 +3606,7 @@ var GatewayFetchMetadata = class {
 		}
 	}
 };
-var gatewayAvailableModelsResponseSchema = lazySchema(() => zodSchema(z$1.object({ models: z$1.array(z$1.object({
+var gatewayAvailableModelsResponseSchema = lazySchema(() => zodSchema$1(z$1.object({ models: z$1.array(z$1.object({
 	id: z$1.string(),
 	name: z$1.string(),
 	description: z$1.string().nullish(),
@@ -3627,7 +3628,7 @@ var gatewayAvailableModelsResponseSchema = lazySchema(() => zodSchema(z$1.object
 	}),
 	modelType: z$1.string().nullish()
 })).transform((models) => models.filter((m) => m.modelType == null || KNOWN_MODEL_TYPES.includes(m.modelType))) })));
-var gatewayCreditsResponseSchema = lazySchema(() => zodSchema(z$1.object({
+var gatewayCreditsResponseSchema = lazySchema(() => zodSchema$1(z$1.object({
 	balance: z$1.string(),
 	total_used: z$1.string()
 }).transform(({ balance, total_used }) => ({
@@ -3667,7 +3668,7 @@ var GatewaySpendReport = class {
 		}
 	}
 };
-var gatewaySpendReportResponseSchema = lazySchema(() => zodSchema(z$1.object({ results: z$1.array(z$1.object({
+var gatewaySpendReportResponseSchema = lazySchema(() => zodSchema$1(z$1.object({ results: z$1.array(z$1.object({
 	day: z$1.string().optional(),
 	hour: z$1.string().optional(),
 	user: z$1.string().optional(),
@@ -3717,7 +3718,7 @@ var GatewayGenerationInfoFetcher = class {
 		}
 	}
 };
-var gatewayGenerationInfoResponseSchema = lazySchema(() => zodSchema(z$1.object({ data: z$1.object({
+var gatewayGenerationInfoResponseSchema = lazySchema(() => zodSchema$1(z$1.object({ data: z$1.object({
 	id: z$1.string(),
 	total_cost: z$1.number(),
 	upstream_inference_cost: z$1.number(),
@@ -3969,7 +3970,7 @@ var gatewayEmbeddingWarningSchema = z$1.discriminatedUnion("type", [
 		message: z$1.string()
 	})
 ]);
-var gatewayEmbeddingResponseSchema = lazySchema(() => zodSchema(z$1.object({
+var gatewayEmbeddingResponseSchema = lazySchema(() => zodSchema$1(z$1.object({
 	embeddings: z$1.array(z$1.array(z$1.number())),
 	usage: z$1.object({ tokens: z$1.number() }).nullish(),
 	warnings: z$1.array(gatewayEmbeddingWarningSchema).optional(),
@@ -4321,7 +4322,7 @@ var gatewayRerankingWarningSchema = z$1.discriminatedUnion("type", [
 		message: z$1.string()
 	})
 ]);
-var gatewayRerankingResponseSchema = lazySchema(() => zodSchema(z$1.object({
+var gatewayRerankingResponseSchema = lazySchema(() => zodSchema$1(z$1.object({
 	ranking: z$1.array(z$1.object({
 		index: z$1.number(),
 		relevanceScore: z$1.number()
@@ -4556,7 +4557,7 @@ function toGatewayRealtimeUrl(baseURL, modelId) {
 }
 var exaSearchToolFactory = createProviderExecutedToolFactory({
 	id: "gateway.exa_search",
-	inputSchema: lazySchema(() => zodSchema(z.object({
+	inputSchema: lazySchema(() => zodSchema$1(z.object({
 		query: z.string().describe("Natural-language web search query. This is required."),
 		type: z.enum([
 			"auto",
@@ -4619,7 +4620,7 @@ var exaSearchToolFactory = createProviderExecutedToolFactory({
 			}).optional()
 		}).optional().describe("Controls extracted page content and freshness.")
 	}))),
-	outputSchema: lazySchema(() => zodSchema(z.union([z.object({
+	outputSchema: lazySchema(() => zodSchema$1(z.union([z.object({
 		requestId: z.string(),
 		searchType: z.string().optional(),
 		resolvedSearchType: z.string().optional(),
@@ -4662,7 +4663,7 @@ var exaSearchToolFactory = createProviderExecutedToolFactory({
 var exaSearch = (config = {}) => exaSearchToolFactory(config);
 var parallelSearchToolFactory = createProviderExecutedToolFactory({
 	id: "gateway.parallel_search",
-	inputSchema: lazySchema(() => zodSchema(z.object({
+	inputSchema: lazySchema(() => zodSchema$1(z.object({
 		objective: 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: z.array(z.string()).optional().describe("Optional search queries to supplement the objective. Maximum 200 characters per query."),
 		mode: 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."),
@@ -4678,7 +4679,7 @@ var parallelSearchToolFactory = createProviderExecutedToolFactory({
 		}).optional().describe("Excerpt configuration for controlling result length."),
 		fetch_policy: z.object({ max_age_seconds: 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(z.union([z.object({
+	outputSchema: lazySchema(() => zodSchema$1(z.union([z.object({
 		searchId: z.string(),
 		results: z.array(z.object({
 			url: z.string(),
@@ -4703,7 +4704,7 @@ var parallelSearchToolFactory = createProviderExecutedToolFactory({
 var parallelSearch = (config = {}) => parallelSearchToolFactory(config);
 var perplexitySearchToolFactory = createProviderExecutedToolFactory({
 	id: "gateway.perplexity_search",
-	inputSchema: lazySchema(() => zodSchema(z.object({
+	inputSchema: lazySchema(() => zodSchema$1(z.object({
 		query: z.union([z.string(), z.array(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: z.number().optional().describe("Maximum number of search results to return (1-20, default: 10)"),
 		max_tokens_per_page: z.number().optional().describe("Maximum number of tokens to extract per search result page (256-2048, default: 2048)"),
@@ -4722,7 +4723,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(z.union([z.object({
+	outputSchema: lazySchema(() => zodSchema$1(z.union([z.object({
 		results: z.array(z.object({
 			title: z.string(),
 			url: z.string(),
@@ -46107,6 +46108,650 @@ async function resolveActionCredentials(requirements, options) {
 	return parseResolvedCredentials(requirements, await resolveCredentials(requirements, options.consumer, options.contextOverride));
 }
 //#endregion
-export { getSession as A, withSpan as B, addAgentSessionDuration as C, failAgentSession as D, createSession as E, setSessionTitle as F, jsonSchema as G, require_token_util as H, touchSession as I, tool as K, captureConsole as L, recordLlmUsageFromAssistantMessage as M, resolveRunSourceFromTraceContext as N, getAgentByRoute as O, setSessionLiveMessage as P, getTraceContext as R, MESSAGE_EVENT_TYPE as S, clearLiveMessage as T, require_token_error as U, createGateway as V, generateId as W, generateText as _, isCredentialError as a, readUIMessageStream as b, withCredentialAssignments as c, connectMcpStdio as d, defineMcp as f, generateObject as g, convertToModelMessages as h, enrichCredentialError as i, listMessageEvents as j, getProjectScopeId as k, connectMcpDefinition as l, ToolLoopAgent as m, captureCredentialToolErrors as n, resolveActionCredentials as o, isMcp as p, createCredentialResolver as r, resolveMcpTools as s, buildCredentialRunContext as t, connectMcpServer as u, isFileUIPart as v, appendEvent as w, toUIMessageStream as x, output_exports as y, logSystem as z };
+//#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 = 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 = z.custom((v) => v instanceof z.ZodType, "must be a Zod schema");
+/** Runtime validation for an unbranded workflow definition. */
+const workflowCoreSchema = z.object({
+	slug: z.string().trim().min(1),
+	name: z.string().optional(),
+	description: z.string().optional(),
+	subscription: z.object({ mode: z.enum(["system", "subscribable"]).optional() }).optional(),
+	input: zodSchema,
+	output: zodSchema,
+	run: 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 ? 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;
+	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 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(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 runWithMcpCredentialContext({
+				...options.mcpCredentialContext,
+				consumerId: correlationId
+			}, () => 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 AsyncLocalStorage();
+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 = 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 = 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 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
+export { require_token_error as $, output_exports as A, getProjectScopeId as B, defineMcp as C, generateObject as D, convertToModelMessages as E, appendEvent as F, setSessionLiveMessage as G, listMessageEvents as H, clearLiveMessage as I, captureConsole as J, setSessionTitle as K, createSession as L, toUIMessageStream as M, MESSAGE_EVENT_TYPE as N, generateText as O, addAgentSessionDuration as P, require_token_util as Q, failAgentSession as R, connectMcpStdio as S, ToolLoopAgent as T, recordLlmUsageFromAssistantMessage as U, getSession as V, resolveRunSourceFromTraceContext as W, withSpan as X, getTraceContext as Y, createGateway as Z, resolveActionCredentials as _, executeWorkflow as a, connectMcpDefinition as b, promptLlm as c, serializeWorkflowError as d, generateId as et, buildCredentialRunContext as f, isCredentialError as g, enrichCredentialError as h, deserializeWorkflowError as i, readUIMessageStream as j, isFileUIPart as k, registerWorkflowToolExecutor as l, createCredentialResolver as m, RunCanceledError as n, tool as nt, isRunCanceledError as o, captureCredentialToolErrors as p, touchSession as q, defineWorkflow as r, isWorkflow as s, MemoryEventLog as t, jsonSchema as tt, resolveWorkflowTool as u, resolveMcpTools as v, isMcp as w, connectMcpServer as x, withCredentialAssignments as y, getAgentByRoute as z };
 
-//# sourceMappingURL=dist-KpQEao0i.mjs.map
+//# sourceMappingURL=dist-B1Pjv-cM.mjs.map