@keystrokehq/keystroke 0.1.20 → 0.1.23

package/dist/dist-BekOBuw8.cjs

@@ -1,665 +0,0 @@
-const require_dist = require("./dist-BKL5duJl.cjs");
-const require_dist$1 = require("./dist-DqZUy3u_.cjs");
-const require_dist$2 = require("./dist-BFCT4aiu.cjs");
-let zod = require("zod");
-let node_async_hooks = require("node:async_hooks");
-//#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$1.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$1.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 require_dist$2.withSpan({
-			kind: options.kind,
-			name: options.key,
-			refId: `${runId}:${correlationId}`,
-			metadata: {
-				...metadata,
-				replayed: true
-			}
-		}, async () => {
-			await require_dist$2.logSystem("info", options.replayMessage, metadata);
-		});
-		return options.parseCached ? options.parseCached(cached.result) : cached.result;
-	}
-	return require_dist$2.withSpan({
-		kind: options.kind,
-		name: options.key,
-		refId: `${runId}:${correlationId}`,
-		metadata
-	}, async () => require_dist$2.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.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$1.getActionCredentialRequirements(action), runOptions?.credentialScope);
-			const credentials = requirements?.length ? await require_dist$2.resolveActionCredentials(requirements, {
-				resolveCredentials: options.resolveCredentials,
-				context: options.credentialContext,
-				oauthAdapter: options.oauthAdapter,
-				consumer: {
-					kind: "action",
-					name: action.slug,
-					id: correlationId
-				}
-			}) : {};
-			return require_dist$1.runWithMcpCredentialContext({
-				...options.mcpCredentialContext,
-				consumerId: correlationId
-			}, () => require_dist$1.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$1.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$1.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
-	}, () => require_dist$2.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$1.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
-	});
-}
-//#endregion
-Object.defineProperty(exports, "MemoryEventLog", {
-	enumerable: true,
-	get: function() {
-		return MemoryEventLog;
-	}
-});
-Object.defineProperty(exports, "RunCanceledError", {
-	enumerable: true,
-	get: function() {
-		return RunCanceledError;
-	}
-});
-Object.defineProperty(exports, "defineWorkflow", {
-	enumerable: true,
-	get: function() {
-		return defineWorkflow;
-	}
-});
-Object.defineProperty(exports, "deserializeWorkflowError", {
-	enumerable: true,
-	get: function() {
-		return deserializeWorkflowError;
-	}
-});
-Object.defineProperty(exports, "executeWorkflow", {
-	enumerable: true,
-	get: function() {
-		return executeWorkflow;
-	}
-});
-Object.defineProperty(exports, "isRunCanceledError", {
-	enumerable: true,
-	get: function() {
-		return isRunCanceledError;
-	}
-});
-Object.defineProperty(exports, "isWorkflow", {
-	enumerable: true,
-	get: function() {
-		return isWorkflow;
-	}
-});
-Object.defineProperty(exports, "promptLlm", {
-	enumerable: true,
-	get: function() {
-		return promptLlm;
-	}
-});
-Object.defineProperty(exports, "serializeWorkflowError", {
-	enumerable: true,
-	get: function() {
-		return serializeWorkflowError;
-	}
-});
-
-//# sourceMappingURL=dist-BekOBuw8.cjs.map