@notionhq/apps 0.0.26 → 0.0.28

package/src/providers.generated.ts

@@ -2,6 +2,7 @@
 import type { ConnectionActionInvoker } from "./connection-actions.js"
 import type { WorkflowConnection } from "./connections.js"
 import { CalendarConnectionClient } from "./calendar.generated.js"
+import { MailConnectionClient } from "./mail.generated.js"
 import { SlackConnectionClient } from "./slack.generated.js"
 import { GoogleDriveOauthConnectionClient } from "./googleDriveOauth.generated.js"
 import { DiscordConnectionClient } from "./discord.generated.js"
@@ -15,6 +16,7 @@ import { OutlookConnectionClient } from "./outlook.generated.js"
 import { SalesforceConnectionClient } from "./salesforce.generated.js"
 export const connections = {
 	calendar,
+	mail,
 	slack,
 	googleDriveOauth,
 	discord,
@@ -29,6 +31,7 @@ export const connections = {
 }
 export type ConnectionClients = {
 	calendar: CalendarConnectionClient
+	mail: MailConnectionClient
 	slack: SlackConnectionClient
 	googleDriveOauth: GoogleDriveOauthConnectionClient
 	discord: DiscordConnectionClient
@@ -48,6 +51,8 @@ export function createConnectionClient(
 	switch (provider) {
 		case "calendar":
 			return new CalendarConnectionClient(invoker)
+		case "mail":
+			return new MailConnectionClient(invoker)
 		case "slack":
 			return new SlackConnectionClient(invoker)
 		case "googleDriveOauth":
@@ -77,6 +82,9 @@ export function createConnectionClient(
 function calendar(): WorkflowConnection<"calendar"> {
 	return { type: "calendar" }
 }
+function mail(): WorkflowConnection<"mail"> {
+	return { type: "mail" }
+}
 function slack(): WorkflowConnection<"slack"> {
 	return { type: "slack" }
 }

package/src/triggers.generated.ts

@@ -102,19 +102,25 @@ export type DiscordInteractionTrigger<TKey extends string = string> = {
 	connectionKey?: TKey;
 };
 
-/** An email was received. */
-export type MailEmailReceivedTrigger = {
+/** Triggers immediately when a new email is received in Notion Mail */
+export type MailEmailReceivedTrigger<TKey extends string = string> = {
 	type: "mail.email.received";
+	/** Key of the declared mail connection. */
+	connectionKey?: TKey;
 };
 
-/** An email was sent. */
-export type MailEmailSentTrigger = {
+/** Triggers immediately when a new email is sent from Notion Mail */
+export type MailEmailSentTrigger<TKey extends string = string> = {
 	type: "mail.email.sent";
+	/** Key of the declared mail connection. */
+	connectionKey?: TKey;
 };
 
-/** A label was applied to an email. */
-export type MailLabelAppliedTrigger = {
+/** Triggers immediately when a label is applied to an email in Notion Mail */
+export type MailLabelAppliedTrigger<TKey extends string = string> = {
 	type: "mail.label.applied";
+	/** Key of the declared mail connection. */
+	connectionKey?: TKey;
 };
 
 /** Triggers immediately when a calendar event is created */
@@ -248,33 +254,36 @@ export const triggers = {
 	/**
 	 * Declare that a workflow can run on `mail.email.received` events.
 	 *
-	 * An email was received.
+	 * Triggers immediately when a new email is received in Notion Mail
 	 */
-	mailEmailReceived(): MailEmailReceivedTrigger {
+	mailEmailReceived<const TKey extends string = never>(options: { connectionKey: TKey } | undefined = undefined): MailEmailReceivedTrigger<TKey> {
 		return {
 			type: "mail.email.received",
+			...(options === undefined ? {} : { connectionKey: options.connectionKey }),
 		};
 	},
 
 	/**
 	 * Declare that a workflow can run on `mail.email.sent` events.
 	 *
-	 * An email was sent.
+	 * Triggers immediately when a new email is sent from Notion Mail
 	 */
-	mailEmailSent(): MailEmailSentTrigger {
+	mailEmailSent<const TKey extends string = never>(options: { connectionKey: TKey } | undefined = undefined): MailEmailSentTrigger<TKey> {
 		return {
 			type: "mail.email.sent",
+			...(options === undefined ? {} : { connectionKey: options.connectionKey }),
 		};
 	},
 
 	/**
 	 * Declare that a workflow can run on `mail.label.applied` events.
 	 *
-	 * A label was applied to an email.
+	 * Triggers immediately when a label is applied to an email in Notion Mail
 	 */
-	mailLabelApplied(): MailLabelAppliedTrigger {
+	mailLabelApplied<const TKey extends string = never>(options: { connectionKey: TKey } | undefined = undefined): MailLabelAppliedTrigger<TKey> {
 		return {
 			type: "mail.label.applied",
+			...(options === undefined ? {} : { connectionKey: options.connectionKey }),
 		};
 	},
 
@@ -443,9 +452,9 @@ export type WorkflowTriggerCreators<TConnections extends WorkflowConnectionDecla
 	slackReactionAdded(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "slack"> }): SlackReactionAddedTrigger<WorkflowConnectionKeys<TConnections, "slack">>;
 	slackAppMention(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "slack"> }): SlackAppMentionTrigger<WorkflowConnectionKeys<TConnections, "slack">>;
 	discordInteraction(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "discord"> }): DiscordInteractionTrigger<WorkflowConnectionKeys<TConnections, "discord">>;
-	mailEmailReceived(): MailEmailReceivedTrigger;
-	mailEmailSent(): MailEmailSentTrigger;
-	mailLabelApplied(): MailLabelAppliedTrigger;
+	mailEmailReceived(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "mail"> }): MailEmailReceivedTrigger<WorkflowConnectionKeys<TConnections, "mail">>;
+	mailEmailSent(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "mail"> }): MailEmailSentTrigger<WorkflowConnectionKeys<TConnections, "mail">>;
+	mailLabelApplied(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "mail"> }): MailLabelAppliedTrigger<WorkflowConnectionKeys<TConnections, "mail">>;
 	calendarEventCreated(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "calendar"> }): CalendarEventCreatedTrigger<WorkflowConnectionKeys<TConnections, "calendar">>;
 	calendarEventUpdated(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "calendar"> }): CalendarEventUpdatedTrigger<WorkflowConnectionKeys<TConnections, "calendar">>;
 	calendarEventCanceled(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "calendar"> }): CalendarEventCanceledTrigger<WorkflowConnectionKeys<TConnections, "calendar">>;
@@ -468,9 +477,9 @@ export type WorkflowTriggerForConnections<TConnections extends WorkflowConnectio
 	| SlackReactionAddedTrigger<WorkflowConnectionKeys<TConnections, "slack">>
 	| SlackAppMentionTrigger<WorkflowConnectionKeys<TConnections, "slack">>
 	| DiscordInteractionTrigger<WorkflowConnectionKeys<TConnections, "discord">>
-	| MailEmailReceivedTrigger
-	| MailEmailSentTrigger
-	| MailLabelAppliedTrigger
+	| MailEmailReceivedTrigger<WorkflowConnectionKeys<TConnections, "mail">>
+	| MailEmailSentTrigger<WorkflowConnectionKeys<TConnections, "mail">>
+	| MailLabelAppliedTrigger<WorkflowConnectionKeys<TConnections, "mail">>
 	| CalendarEventCreatedTrigger<WorkflowConnectionKeys<TConnections, "calendar">>
 	| CalendarEventUpdatedTrigger<WorkflowConnectionKeys<TConnections, "calendar">>
 	| CalendarEventCanceledTrigger<WorkflowConnectionKeys<TConnections, "calendar">>

package/src/workflow-connections-types.test.ts

@@ -3,6 +3,19 @@ import { triggers } from "./triggers.generated.js";
 import { connections, workflow, type WorkflowConnectionDeclarations } from "./workflow.js";
 
 it("infers only the declared provider clients", () => {
+	workflow({
+		name: "Mail",
+		description: "Read the configured mailbox",
+		connections: { inbox: connections.mail() },
+		triggers: ({ triggers }) => [triggers.mailEmailReceived({ connectionKey: "inbox" })],
+		handler(_event, context) {
+			expectTypeOf<keyof typeof context.connections>().toEqualTypeOf<"inbox">();
+			expectTypeOf(context.connections.inbox.searchEmails).toBeFunction();
+			expectTypeOf(context.connections.inbox.listLabels).toBeFunction();
+			expectTypeOf(context.connections.inbox.sendNewEmail).toBeFunction();
+			expectTypeOf(context.connections.inbox.createMailBlock).toBeFunction();
+		},
+	});
 	workflow({
 		name: "Calendar",
 		description: "Calendar only",
@@ -11,6 +24,9 @@ it("infers only the declared provider clients", () => {
 		handler(_event, context) {
 			expectTypeOf<keyof typeof context.connections>().toEqualTypeOf<"work">();
 			expectTypeOf(context.connections.work.listCalendars).toBeFunction();
+			expectTypeOf(context.connections.work.createEvents).toBeFunction();
+			expectTypeOf(context.connections.work.updateEvents).toBeFunction();
+			expectTypeOf(context.connections.work.cancelEvents).toBeFunction();
 		},
 	});
 	const requirements = {

package/src/workflow.test.ts

@@ -14,9 +14,11 @@ import { page } from "./notion-as-code/page.js";
 import {
 	access,
 	connections,
+	input,
 	workflow,
 	type StepContext,
 	type WorkflowContext,
+	type WorkflowInputDate,
 	type WorkflowWaitDuration,
 } from "./workflow.js";
 
@@ -1017,6 +1019,214 @@ describe("wait.until", () => {
 	});
 });
 
+describe("wait.forInput", () => {
+	it("stops the workflow with a typed form schema", async () => {
+		let continued = false;
+		const definition = workflow({
+			name: "Collect launch details",
+			description: "Waits for a person to provide launch details",
+			triggers: [triggers.notionPageCreated()],
+			handler: async (_event, context) => {
+				await context.wait.forInput("Launch details", {
+					input: {
+						summary: input.text(),
+						priority: input.select(["low", "medium", "high"]),
+						notes: input.text({ optional: true }),
+						teams: input.multiSelect(["Design", "Engineering"]),
+					},
+				});
+				continued = true;
+			},
+		});
+
+		await expect(definition.handler(event, { concreteOutput: true })).resolves.toEqual({
+			status: "waiting",
+			wait: {
+				type: "input",
+				name: "Launch details",
+				stepKey: workflowStepKey(["wait", "input", "Launch details"]),
+				input: {
+					summary: { type: "text" },
+					priority: {
+						type: "select",
+						options: ["low", "medium", "high"],
+					},
+					notes: { type: "text", optional: true },
+					teams: { type: "multi_select", options: ["Design", "Engineering"] },
+				},
+			},
+		});
+		expect(continued).toBe(false);
+	});
+
+	it("returns the typed response stored in its durable checkpoint", async () => {
+		const directory = await createCheckpointDirectory();
+		const stepKey = workflowStepKey(["wait", "input", "Launch details"]);
+		await writeFile(
+			checkpointPath(directory, stepKey),
+			JSON.stringify({
+				version: 0,
+				key: stepKey,
+				value: {
+					value: {
+						summary: "Ship the new workflow",
+						priority: "high",
+						labels: ["Design", "Engineering"],
+						owners: ["first-user-id", "second-user-id"],
+						window: {
+							start: "2026-09-22T09:00",
+							end: "2026-09-23T17:00",
+							timeZone: "America/Los_Angeles",
+						},
+						attachments: ["https://example.com/plan.pdf", "attachment-block-id"],
+					},
+					respondedBy: "user-id",
+					respondedAt: "2026-09-18T12:00:00.000Z",
+				},
+				sourceRunId: "input-run",
+				sourceStepId: "input-step",
+			}),
+		);
+
+		let capturedPriority: "low" | "medium" | "high" | undefined;
+		let capturedInputs: unknown;
+		const definition = workflow({
+			name: "Collect launch details",
+			description: "Waits for a person to provide launch details",
+			triggers: [triggers.notionPageCreated()],
+			handler: async (_event, context) => {
+				const response = await context.wait.forInput("Launch details", {
+					input: {
+						summary: input.text(),
+						priority: input.select(["low", "medium", "high"]),
+						labels: input.multiSelect(["Design", "Engineering"]),
+						owners: input.person(),
+						notes: input.text({ optional: true }),
+						window: input.date(),
+						attachments: input.files({ optional: true }),
+					},
+				});
+				expectTypeOf(response.value.summary).toEqualTypeOf<string>();
+				expectTypeOf(response.value.priority).toEqualTypeOf<"low" | "medium" | "high">();
+				capturedPriority = response.value.priority;
+				expectTypeOf(response.value.labels).toEqualTypeOf<("Design" | "Engineering")[]>();
+				expectTypeOf(response.value.owners).toEqualTypeOf<string[]>();
+				expectTypeOf(response.value.window).toEqualTypeOf<WorkflowInputDate>();
+				expectTypeOf(response.value.attachments).toEqualTypeOf<string[] | undefined>();
+				capturedInputs = response.value;
+			},
+		});
+
+		await expect(definition.handler(event, { concreteOutput: true })).resolves.toEqual({
+			status: "success",
+		});
+		expect(capturedPriority).toBe("high");
+		expect(capturedInputs).toEqual({
+			summary: "Ship the new workflow",
+			priority: "high",
+			labels: ["Design", "Engineering"],
+			owners: ["first-user-id", "second-user-id"],
+			window: {
+				start: "2026-09-22T09:00",
+				end: "2026-09-23T17:00",
+				timeZone: "America/Los_Angeles",
+			},
+			attachments: ["https://example.com/plan.pdf", "attachment-block-id"],
+		});
+	});
+
+	it.each([
+		{ extra: { admin: true } },
+		{ extra: { options: { admin: true } } },
+		{ extra: { ["__proto__"]: { admin: true } } },
+	])("rejects undeclared response fields: $extra", async ({ extra }) => {
+		const directory = await createCheckpointDirectory();
+		const stepKey = workflowStepKey(["wait", "input", "Review"]);
+		await writeFile(
+			checkpointPath(directory, stepKey),
+			JSON.stringify({
+				version: 0,
+				key: stepKey,
+				value: {
+					value: { priority: "high", ...extra },
+					respondedBy: "user-id",
+					respondedAt: "2026-09-18T12:00:00.000Z",
+				},
+				sourceRunId: "input-run",
+				sourceStepId: "input-step",
+			}),
+		);
+		const definition = workflow({
+			name: "Review",
+			description: "Rejects undeclared input",
+			triggers: [triggers.notionPageCreated()],
+			handler: async (_event, context) => {
+				await context.wait.forInput("Review", {
+					input: {
+						priority: input.select(["low", "high"]),
+						notes: input.text({ optional: true }),
+					},
+				});
+			},
+		});
+		await expect(definition.handler(event, { concreteOutput: true })).rejects.toThrow(
+			"does not match its schema",
+		);
+	});
+
+	it.each([
+		{ name: "unknown select", field: input.select(["low", "medium", "high"]), value: "urgent" },
+		{
+			name: "unknown multi-select",
+			field: input.multiSelect(["Design", "Engineering"]),
+			value: ["Design", "Other"],
+		},
+		{ name: "scalar multi-select", field: input.multiSelect(["Design"]), value: "Design" },
+		{ name: "scalar person", field: input.person(), value: "user-id" },
+		{ name: "invalid person array", field: input.person(), value: ["user-id", 123] },
+		{ name: "date string", field: input.date(), value: "2026-09-22" },
+		{
+			name: "invalid date timezone",
+			field: input.date(),
+			value: { start: "2026-09-22", timeZone: 123 },
+		},
+	])("rejects a checkpoint with $name", async ({ field, value }) => {
+		const directory = await createCheckpointDirectory();
+		const stepKey = workflowStepKey(["wait", "input", "Launch details"]);
+		await writeFile(
+			checkpointPath(directory, stepKey),
+			JSON.stringify({
+				version: 0,
+				key: stepKey,
+				value: {
+					value: { priority: value },
+					respondedBy: "user-id",
+					respondedAt: "2026-09-18T12:00:00.000Z",
+				},
+				sourceRunId: "input-run",
+				sourceStepId: "input-step",
+			}),
+		);
+
+		const definition = workflow({
+			name: "Collect launch details",
+			description: "Waits for a person to provide launch details",
+			triggers: [triggers.notionPageCreated()],
+			handler: async (_event, context) => {
+				await context.wait.forInput("Launch details", {
+					input: {
+						priority: field,
+					},
+				});
+			},
+		});
+
+		await expect(definition.handler(event, { concreteOutput: true })).rejects.toThrow(
+			"does not match its schema",
+		);
+	});
+});
+
 async function createCheckpointDirectory(): Promise<string> {
 	checkpointDirectory = await mkdtemp(join(tmpdir(), "apps-step-checkpoints-"));
 	process.env.NOTION_WORKFLOW_STEP_DIRECTORY = checkpointDirectory;

package/src/workflow.ts

@@ -53,6 +53,100 @@ export type WorkflowWaitDuration = {
 
 type WorkflowWaitKey = string | string[];
 
+type WorkflowInputFieldOptions = {
+	optional?: boolean;
+};
+
+declare const workflowInputValueType: unique symbol;
+
+export type WorkflowInputField<T> = {
+	type: "text" | "number" | "checkbox" | "select" | "multi_select" | "date" | "person" | "files";
+	optional?: boolean;
+	options?: readonly string[];
+	readonly [workflowInputValueType]?: T;
+};
+
+type WorkflowInputValue<
+	T,
+	TOptions extends WorkflowInputFieldOptions | undefined,
+> = TOptions extends { optional: true } ? T | undefined : T;
+
+/** Date-only or local date-time endpoints, with the selected IANA time zone. */
+export type WorkflowInputDate = {
+	start: string;
+	end?: string;
+	timeZone?: string;
+};
+export const input = {
+	text<const TOptions extends WorkflowInputFieldOptions | undefined>(
+		options?: TOptions,
+	): WorkflowInputField<WorkflowInputValue<string, TOptions>> {
+		return { type: "text", ...options };
+	},
+	number<const TOptions extends WorkflowInputFieldOptions | undefined>(
+		options?: TOptions,
+	): WorkflowInputField<WorkflowInputValue<number, TOptions>> {
+		return { type: "number", ...options };
+	},
+	checkbox<const TOptions extends WorkflowInputFieldOptions | undefined>(
+		options?: TOptions,
+	): WorkflowInputField<WorkflowInputValue<boolean, TOptions>> {
+		return { type: "checkbox", ...options };
+	},
+	select<
+		const TOptions extends readonly [string, ...string[]],
+		const TFieldOptions extends WorkflowInputFieldOptions | undefined,
+	>(
+		values: TOptions,
+		options?: TFieldOptions,
+	): WorkflowInputField<WorkflowInputValue<TOptions[number], TFieldOptions>> {
+		return { type: "select", options: values, ...options };
+	},
+	date<const TOptions extends WorkflowInputFieldOptions | undefined>(
+		options?: TOptions,
+	): WorkflowInputField<WorkflowInputValue<WorkflowInputDate, TOptions>> {
+		return { type: "date", ...options };
+	},
+	multiSelect<
+		const TOptions extends readonly [string, ...string[]],
+		const TFieldOptions extends WorkflowInputFieldOptions | undefined,
+	>(
+		values: TOptions,
+		options?: TFieldOptions,
+	): WorkflowInputField<WorkflowInputValue<TOptions[number][], TFieldOptions>> {
+		return { type: "multi_select", options: values, ...options };
+	},
+	/** Returns the user ID of every selected person. */
+	person<const TOptions extends WorkflowInputFieldOptions | undefined>(
+		options?: TOptions,
+	): WorkflowInputField<WorkflowInputValue<string[], TOptions>> {
+		return { type: "person", ...options };
+	},
+	/** Returns each attachment's URL or Notion attachment block ID. */
+	files<const TOptions extends WorkflowInputFieldOptions | undefined>(
+		options?: TOptions,
+	): WorkflowInputField<WorkflowInputValue<string[], TOptions>> {
+		return { type: "files", ...options };
+	},
+};
+
+export type WorkflowInputSchema = Record<string, WorkflowInputField<unknown>>;
+
+export type WorkflowInputValues<TSchema extends WorkflowInputSchema> = {
+	[Key in keyof TSchema]: TSchema[Key] extends WorkflowInputField<infer Value> ? Value : never;
+};
+
+export type WorkflowInputResponse<TSchema extends WorkflowInputSchema> = {
+	value: WorkflowInputValues<TSchema>;
+	respondedBy: string;
+	respondedAt: string;
+};
+
+export type WorkflowWaitForInputOptions<TSchema extends WorkflowInputSchema> = {
+	input: TSchema;
+	key?: WorkflowWaitKey;
+};
+
 export type WorkflowWaitUntilOptions =
 	| {
 			at: Date;
@@ -72,7 +166,19 @@ export type WorkflowWaitUntilResult = {
 	};
 };
 
-type WorkflowHandlerResult = { status: "success" } | WorkflowWaitUntilResult;
+export type WorkflowWaitForInputResult = {
+	status: "waiting";
+	wait: {
+		type: "input";
+		name: string;
+		stepKey: string;
+		input: WorkflowInputSchema;
+	};
+};
+
+type WorkflowWaitResult = WorkflowWaitUntilResult | WorkflowWaitForInputResult;
+
+type WorkflowHandlerResult = { status: "success" } | WorkflowWaitResult;
 
 const MAX_WORKFLOW_WAIT_MS = 7 * 24 * 60 * 60 * 1_000;
 
@@ -360,6 +466,15 @@ type WorkflowWait = {
 	 * date has been reached.
 	 */
 	until(name: string, options: WorkflowWaitUntilOptions): Promise<void>;
+	/**
+	 * Suspend the workflow until a person submits values matching the input
+	 * schema. The returned value is restored from the durable workflow
+	 * checkpoint when the request is fulfilled.
+	 */
+	forInput<const TSchema extends WorkflowInputSchema>(
+		name: string,
+		options: WorkflowWaitForInputOptions<TSchema>,
+	): Promise<WorkflowInputResponse<TSchema>>;
 };
 
 /** Context passed to a workflow handler. */
@@ -528,13 +643,22 @@ function createStep(
 }
 
 class WorkflowWaitInterrupt extends Error {
-	constructor(readonly result: WorkflowWaitUntilResult) {
-		super(`Workflow is waiting until ${new Date(result.wait.resumeAtMs).toISOString()}`);
+	constructor(readonly result: WorkflowWaitResult) {
+		super(workflowWaitMessage(result));
 		this.name = "WorkflowWaitInterrupt";
 	}
 }
 
+function workflowWaitMessage(result: WorkflowWaitResult): string {
+	if (result.wait.type === "until") {
+		return `Workflow is waiting until ${new Date(result.wait.resumeAtMs).toISOString()}`;
+	}
+	return `Workflow is waiting for input: ${result.wait.name}`;
+}
+
 function createWait(step: WorkflowStep): WorkflowWait {
+	const inputWaitNameByKey = new Map<string, string>();
+
 	return {
 		async until(name, options) {
 			const keyInput = options.key ?? name;
@@ -560,9 +684,108 @@ function createWait(step: WorkflowStep): WorkflowWait {
 				},
 			});
 		},
+		async forInput(name, options) {
+			const keyInput = options.key ?? name;
+			const stepKey = createWorkflowStepKey([
+				"wait",
+				"input",
+				...(typeof keyInput === "string" ? [keyInput] : keyInput),
+			]);
+			const existingName = inputWaitNameByKey.get(stepKey);
+			if (existingName !== undefined) {
+				throw new Error(
+					`Workflow input wait "${name}" has the same key as "${existingName}". Provide a unique name or an explicit key.`,
+				);
+			}
+			inputWaitNameByKey.set(stepKey, name);
+
+			const checkpoint = await readWorkflowStepCheckpoint(stepKey);
+			if (checkpoint) {
+				if (!isWorkflowInputResponse(checkpoint.value, options.input)) {
+					throw new Error(
+						`Workflow input checkpoint ${hashWorkflowStepKey(stepKey)} does not match its schema.`,
+					);
+				}
+				return checkpoint.value;
+			}
+
+			throw new WorkflowWaitInterrupt({
+				status: "waiting",
+				wait: {
+					type: "input",
+					name,
+					stepKey,
+					input: options.input,
+				},
+			});
+		},
 	};
 }
 
+function isWorkflowInputResponse<TSchema extends WorkflowInputSchema>(
+	value: unknown,
+	schema: TSchema,
+): value is WorkflowInputResponse<TSchema> {
+	if (
+		!isRecord(value) ||
+		!isRecord(value.value) ||
+		typeof value.respondedBy !== "string" ||
+		typeof value.respondedAt !== "string"
+	) {
+		return false;
+	}
+
+	if (Object.keys(value.value).some((key) => !Object.hasOwn(schema, key))) {
+		return false;
+	}
+
+	for (const [key, field] of Object.entries(schema)) {
+		const fieldValue = value.value[key];
+		if (fieldValue === undefined && field.optional === true) {
+			continue;
+		}
+		if (!isWorkflowInputFieldValue(fieldValue, field)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function isWorkflowInputFieldValue(value: unknown, field: WorkflowInputField<unknown>): boolean {
+	switch (field.type) {
+		case "text":
+			return typeof value === "string";
+		case "date":
+			return (
+				isRecord(value) &&
+				typeof value.start === "string" &&
+				(value.end === undefined || typeof value.end === "string") &&
+				(value.timeZone === undefined || typeof value.timeZone === "string")
+			);
+		case "number":
+			return typeof value === "number" && Number.isFinite(value);
+		case "checkbox":
+			return typeof value === "boolean";
+		case "select":
+			return (
+				typeof value === "string" &&
+				field.options !== undefined &&
+				field.options.includes(value)
+			);
+		case "person":
+		case "files":
+			return Array.isArray(value) && value.every((item) => typeof item === "string");
+		case "multi_select": {
+			const options = field.options;
+			return (
+				Array.isArray(value) &&
+				options !== undefined &&
+				value.every((item) => typeof item === "string" && options.includes(item))
+			);
+		}
+	}
+}
+
 function resolveWaitUntilMs(options: WorkflowWaitUntilOptions): number {
 	const now = Date.now();
 	if ("at" in options) {