@notionhq/apps 0.0.36 → 0.0.38

package/src/cli/discover.test.ts

@@ -27,6 +27,13 @@ describe("discoverCapabilities", () => {
 				key: "onPageCreated",
 				sourcePath: path.join("src", "workflows", "onPageCreated.ts"),
 			},
+			{
+				type: "workflow",
+				tag: "workflow",
+				runtime: "worker",
+				key: "prepareReleases",
+				sourcePath: path.join("src", "workflows", "prepareReleases.ts"),
+			},
 		]);
 	});
 

package/src/events.generated.ts

@@ -2,6 +2,8 @@
 // Regenerate with: pnpm run generate
 
 import type { WorkflowConnectionDeclarations, WorkflowConnectionKeys } from "./connections.js";
+import { compileWorkflowInputSchema } from "./workflow-schema.js";
+import { j, type SchemaBuilder } from "./schema-builder.js";
 import { scheduled, notionPageCreated, notionPageUpdated } from "./configured-events.js";
 import type { NotionPageCreatedTrigger, NotionPageUpdatedTrigger, PageUpdatedOptions, RecurrenceTrigger } from "./configured-events.js";
 import type { DataSourceHandle } from "./notion-as-code/database.js";
@@ -82,6 +84,15 @@ export type {
 export type { NotionPageCreatedTrigger, NotionPageUpdatedTrigger, PageUpdatedOptions, RecurrenceTrigger } from "./configured-events.js";
 export type { RecurrenceSchedule } from "./notion-as-code/recurrence.js";
 
+declare const manualWorkflowInputSchema: unique symbol;
+const manualInputValidators = new WeakMap<object, (input: unknown) => void>();
+
+export type ManualWorkflowTrigger<TInput extends Record<string, unknown> = Record<string, unknown>> = {
+	type: "workflow.manual";
+	inputJsonSchema: Record<string, unknown>;
+	readonly [manualWorkflowInputSchema]?: TInput;
+};
+
 /** Triggers immediately after a new message is posted in Slack (includes new threads and replies) */
 export type SlackMessageTrigger<TKey extends string = string> = {
 	type: "slack.message";
@@ -194,8 +205,27 @@ export type GoogleDriveOauthFilesChangedTrigger<TKey extends string = string> =
 	connectionKey?: TKey;
 };
 
+function manual(): ManualWorkflowTrigger<Record<string, never>>;
+function manual<TInput extends Record<string, unknown>>(options: {
+	inputSchema: SchemaBuilder<TInput, "object">;
+}): ManualWorkflowTrigger<TInput>;
+function manual(options?: {
+	inputSchema: SchemaBuilder<Record<string, unknown>, "object">;
+}): ManualWorkflowTrigger {
+	const { jsonSchema, validate } = compileWorkflowInputSchema(
+		options === undefined ? j.object({}) : options.inputSchema,
+	);
+	const trigger: ManualWorkflowTrigger = {
+		type: "workflow.manual",
+		inputJsonSchema: jsonSchema,
+	};
+	manualInputValidators.set(trigger, validate);
+	return trigger;
+}
+
 /** Creators for each event that can trigger a workflow. */
 export const events = {
+	manual,
 	/**
 	 * Declare that a workflow can run on `slack.message` events.
 	 *
@@ -414,6 +444,8 @@ export const events = {
 
 /** Trigger creators restricted to the workflow's declared provider keys. */
 export type WorkflowEventCreators<TConnections extends WorkflowConnectionDeclarations> = {
+	manual(): ManualWorkflowTrigger<Record<string, never>>;
+	manual<TInput extends Record<string, unknown>>(options: { inputSchema: SchemaBuilder<TInput, "object"> }): ManualWorkflowTrigger<TInput>;
 	slackMessage(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "slack"> }): SlackMessageTrigger<WorkflowConnectionKeys<TConnections, "slack">>;
 	slackReactionAdded(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "slack"> }): SlackReactionAddedTrigger<WorkflowConnectionKeys<TConnections, "slack">>;
 	slackAppMention(options?: { connectionKey: WorkflowConnectionKeys<TConnections, "slack"> }): SlackAppMentionTrigger<WorkflowConnectionKeys<TConnections, "slack">>;
@@ -439,6 +471,7 @@ export type WorkflowEventCreators<TConnections extends WorkflowConnectionDeclara
 
 /** Triggers whose connection keys belong to the declared provider. */
 export type WorkflowTriggerForConnections<TConnections extends WorkflowConnectionDeclarations> =
+	| ManualWorkflowTrigger
 	| SlackMessageTrigger<WorkflowConnectionKeys<TConnections, "slack">>
 	| SlackReactionAddedTrigger<WorkflowConnectionKeys<TConnections, "slack">>
 	| SlackAppMentionTrigger<WorkflowConnectionKeys<TConnections, "slack">>
@@ -468,6 +501,7 @@ export function createWorkflowEvents<TConnections extends WorkflowConnectionDecl
 
 /** Event that can trigger a workflow. */
 export type WorkflowTrigger =
+	| ManualWorkflowTrigger
 	| SlackMessageTrigger
 	| SlackReactionAddedTrigger
 	| SlackAppMentionTrigger
@@ -492,6 +526,7 @@ export type WorkflowTrigger =
 
 /** All workflow trigger type strings. */
 export const WORKFLOW_TRIGGER_TYPES = [
+	"workflow.manual",
 	"slack.message",
 	"slack.reaction.added",
 	"slack.app.mention",
@@ -542,3 +577,15 @@ export type WorkflowEventMap = {
 	"googleDriveOauth.filesChanged": GoogleDriveOauthFilesChangedEvent;
 	recurrence: RecurrenceEvent;
 };
+
+/** @internal */
+export function validateManualWorkflowInput(
+	trigger: ManualWorkflowTrigger,
+	input: unknown,
+): void {
+	const validate = manualInputValidators.get(trigger);
+	if (validate === undefined) {
+		throw new Error("Manual workflow trigger is missing its input schema");
+	}
+	validate(input);
+}

package/src/schema-builder.ts

@@ -0,0 +1,149 @@
+/** Fluent JSON Schema builders following the classic Workers schema-builder API. */
+const SCHEMA: unique symbol = Symbol("schema");
+const KIND: unique symbol = Symbol("kind");
+declare const VALUE: unique symbol;
+
+export type StringFormat =
+	| "date-time"
+	| "date"
+	| "time"
+	| "duration"
+	| "email"
+	| "hostname"
+	| "ipv4"
+	| "ipv6"
+	| "uuid";
+
+type Kind = "object" | "value";
+type JsonSchema = {
+	title?: string;
+	description?: string;
+} & (
+	| {
+			type: "string" | "number" | "integer" | "boolean" | "null";
+			enum?: readonly (string | number)[];
+			format?: StringFormat;
+	  }
+	| { type: "array"; items: JsonSchema; minItems?: 0 | 1 }
+	| {
+			type: "object";
+			properties: Record<string, JsonSchema>;
+			required: string[];
+			additionalProperties: false;
+	  }
+	| { anyOf: JsonSchema[] }
+);
+
+export interface SchemaBuilder<T, K extends Kind = Kind> {
+	readonly [SCHEMA]: JsonSchema;
+	readonly [KIND]: K;
+	readonly [VALUE]?: T;
+	describe(text: string): SchemaBuilder<T, K>;
+	label(text: string): SchemaBuilder<T, K>;
+	nullable(): SchemaBuilder<T | null, "value">;
+}
+
+export type Infer<S> = S extends SchemaBuilder<infer T> ? T : never;
+
+/** Returns a copy so callers cannot mutate the builder's validation contract. */
+export function getSchema(builder: SchemaBuilder<unknown>): JsonSchema {
+	if (typeof builder !== "object" || builder === null || !(SCHEMA in builder)) {
+		throw new Error("Expected a schema builder; use j.object() for manual inputs");
+	}
+	return structuredClone(builder[SCHEMA]);
+}
+
+function makeBuilder<T, K extends Kind>(schema: JsonSchema, kind: K): SchemaBuilder<T, K> {
+	return {
+		[SCHEMA]: schema,
+		[KIND]: kind,
+		describe(description) {
+			return makeBuilder<T, K>({ ...schema, description }, kind);
+		},
+		label(title) {
+			return makeBuilder<T, K>({ ...schema, title }, kind);
+		},
+		nullable() {
+			const { title, description, ...inner } = schema;
+			return makeBuilder<T | null, "value">(
+				{
+					anyOf: [inner, { type: "null" }],
+					...(title === undefined ? {} : { title }),
+					...(description === undefined ? {} : { description }),
+				},
+				"value",
+			);
+		},
+	};
+}
+
+function string(): SchemaBuilder<string, "value"> {
+	return makeBuilder({ type: "string" }, "value");
+}
+function formattedString(format: StringFormat): SchemaBuilder<string, "value"> {
+	return makeBuilder({ type: "string", format }, "value");
+}
+
+function number(): SchemaBuilder<number, "value"> {
+	return makeBuilder({ type: "number" }, "value");
+}
+function integer(): SchemaBuilder<number, "value"> {
+	return makeBuilder({ type: "integer" }, "value");
+}
+function boolean(): SchemaBuilder<boolean, "value"> {
+	return makeBuilder({ type: "boolean" }, "value");
+}
+
+function enumBuilder<const T extends string>(first: T, ...rest: T[]): SchemaBuilder<T, "value">;
+function enumBuilder<const T extends number>(first: T, ...rest: T[]): SchemaBuilder<T, "value">;
+function enumBuilder(
+	first: string | number,
+	...rest: (string | number)[]
+): SchemaBuilder<string | number, "value"> {
+	return makeBuilder(
+		{ type: typeof first === "string" ? "string" : "number", enum: [first, ...rest] },
+		"value",
+	);
+}
+
+function array<T>(
+	items: SchemaBuilder<T>,
+	options?: { minItems?: 0 | 1 },
+): SchemaBuilder<T[], "value"> {
+	return makeBuilder({ type: "array", items: getSchema(items), ...options }, "value");
+}
+
+function object<P extends Record<string, SchemaBuilder<unknown>>>(
+	properties: P,
+): SchemaBuilder<{ -readonly [K in keyof P]: Infer<P[K]> }, "object"> {
+	return makeBuilder(
+		{
+			type: "object",
+			properties: Object.fromEntries(
+				Object.entries(properties).map(([key, value]) => [key, getSchema(value)]),
+			),
+			required: Object.keys(properties),
+			additionalProperties: false,
+		},
+		"object",
+	);
+}
+
+export const j = {
+	string,
+	number,
+	integer,
+	boolean,
+	enum: enumBuilder,
+	array,
+	object,
+	datetime: () => formattedString("date-time"),
+	date: () => formattedString("date"),
+	time: () => formattedString("time"),
+	duration: () => formattedString("duration"),
+	email: () => formattedString("email"),
+	hostname: () => formattedString("hostname"),
+	ipv4: () => formattedString("ipv4"),
+	ipv6: () => formattedString("ipv6"),
+	uuid: () => formattedString("uuid"),
+};

package/src/workflow-schema.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { getSchema, j, type Infer } from "./schema-builder.js";
+import { events } from "./events.generated.js";
+import { compileWorkflowInputSchema } from "./workflow-schema.js";
+import type { WorkflowEventForTrigger } from "./workflow.js";
+
+const releaseSchema = j.object({
+	releases: j.array(j.object({ version: j.string(), dryRun: j.boolean().nullable() })),
+});
+
+describe("manual input schema builders", () => {
+	it("infers nested nullable fields without optional keys or readonly output", () => {
+		const trigger = events.manual({ inputSchema: releaseSchema });
+		type Input = WorkflowEventForTrigger<typeof trigger>["input"];
+		expectTypeOf<Input>().toEqualTypeOf<{
+			releases: { version: string; dryRun: boolean | null }[];
+		}>();
+		expectTypeOf<Input>().toEqualTypeOf<Infer<typeof releaseSchema>>();
+	});
+
+	it("serializes a builder as standard JSON Schema with all keys required", () => {
+		const trigger = events.manual({ inputSchema: releaseSchema });
+		expect(JSON.parse(JSON.stringify(trigger))).toEqual({
+			type: "workflow.manual",
+			inputJsonSchema: {
+				type: "object",
+				required: ["releases"],
+				additionalProperties: false,
+				properties: {
+					releases: {
+						type: "array",
+						items: {
+							type: "object",
+							required: ["version", "dryRun"],
+							additionalProperties: false,
+							properties: {
+								version: { type: "string" },
+								dryRun: { anyOf: [{ type: "boolean" }, { type: "null" }] },
+							},
+						},
+					},
+				},
+			},
+		});
+	});
+
+	it("accepts explicit null and rejects missing, invalid, and extra fields without coercion", () => {
+		const { validate } = compileWorkflowInputSchema(releaseSchema);
+		for (const dryRun of [true, false, null]) {
+			expect(() => validate({ releases: [{ version: "1", dryRun }] })).not.toThrow();
+		}
+		for (const input of [
+			{},
+			{ releases: [{}] },
+			{ releases: [{ version: "1" }] },
+			{ releases: [{ version: "1", dryRun: "false" }] },
+			{ releases: null },
+			{ releases: [], extra: true },
+		]) {
+			const original = structuredClone(input);
+			expect(() => validate(input)).toThrow("Invalid manual workflow input");
+			expect(input).toEqual(original);
+		}
+	});
+
+	it("supports primitive, enum, nullable object, and nullable array inference and validation", () => {
+		const inputSchema = j.object({
+			count: j.integer(),
+			ratio: j.number(),
+			stage: j.enum("draft", "live"),
+			config: j.object({ label: j.string() }).nullable(),
+			tags: j.array(j.string(), { minItems: 1 }).nullable(),
+		});
+		const trigger = events.manual({ inputSchema });
+		type Input = WorkflowEventForTrigger<typeof trigger>["input"];
+		expectTypeOf<Input>().toEqualTypeOf<{
+			count: number;
+			ratio: number;
+			stage: "draft" | "live";
+			config: { label: string } | null;
+			tags: string[] | null;
+		}>();
+		const { validate } = compileWorkflowInputSchema(inputSchema);
+		const input = { count: 1, ratio: 0.5, stage: "draft", config: null, tags: null };
+		expect(() => validate(input)).not.toThrow();
+		for (const change of [{ count: 0.5 }, { stage: "unknown" }, { config: {} }, { tags: [] }]) {
+			expect(() => validate({ ...input, ...change })).toThrow();
+		}
+	});
+
+	it("keeps metadata outside nullable unions and builders immutable", () => {
+		const name = j.string().label("Name").describe("A name");
+		const nullable = name.nullable();
+		expect(getSchema(nullable)).toEqual({
+			title: "Name",
+			description: "A name",
+			anyOf: [{ type: "string" }, { type: "null" }],
+		});
+		const copy = getSchema(name);
+		copy.description = "Changed";
+		expect(getSchema(name)).toEqual({ type: "string", title: "Name", description: "A name" });
+		expect(getSchema(j.object({ z: name, a: name }).describe("Root"))).toMatchObject({
+			required: ["z", "a"],
+			description: "Root",
+		});
+	});
+
+	it("rejects plain JSON schemas and non-object roots from untyped callers", () => {
+		for (const inputSchema of [
+			JSON.parse('{"type":"object","properties":{}}'),
+			JSON.parse("null"),
+			JSON.parse('"string"'),
+		]) {
+			expect(() => events.manual({ inputSchema })).toThrow();
+		}
+	});
+});
+
+describe("formatted manual inputs", () => {
+	it.each([
+		{
+			builder: j.datetime,
+			format: "date-time",
+			valid: "2026-09-24T10:30:00Z",
+			invalid: "2026-09-24",
+		},
+		{ builder: j.date, format: "date", valid: "2024-02-29", invalid: "2025-02-29" },
+		{ builder: j.time, format: "time", valid: "10:30:00Z", invalid: "25:00:00Z" },
+		{ builder: j.duration, format: "duration", valid: "P1DT2H", invalid: "tomorrow" },
+		{ builder: j.email, format: "email", valid: "user@example.com", invalid: "not-an-email" },
+		{ builder: j.hostname, format: "hostname", valid: "example.com", invalid: "bad host" },
+		{ builder: j.ipv4, format: "ipv4", valid: "192.0.2.1", invalid: "256.0.0.1" },
+		{ builder: j.ipv6, format: "ipv6", valid: "2001:db8::1", invalid: "2001:db8::xyz" },
+		{
+			builder: j.uuid,
+			format: "uuid",
+			valid: "74877cbb-93f9-41fb-9143-c1a11bf88f6b",
+			invalid: "not-a-uuid",
+		},
+	])(
+		"serializes and validates $format, including nested nullable inputs",
+		({ builder, format, valid, invalid }) => {
+			const field = builder().label("Input").describe("Help").nullable();
+			expectTypeOf<Infer<typeof field>>().toEqualTypeOf<string | null>();
+			expect(getSchema(field)).toEqual({
+				title: "Input",
+				description: "Help",
+				anyOf: [{ type: "string", format }, { type: "null" }],
+			});
+			const schema = j.object({ values: j.array(j.object({ value: field })) });
+			const { validate } = compileWorkflowInputSchema(schema);
+			for (const value of [valid, null])
+				expect(() => validate({ values: [{ value }] })).not.toThrow();
+			expect(() => validate({ values: [{ value: invalid }] })).toThrow(
+				"Invalid manual workflow input",
+			);
+			expect(() => validate({ values: [{}] })).toThrow();
+		},
+	);
+});

package/src/workflow-schema.ts

@@ -0,0 +1,42 @@
+import { Ajv } from "ajv";
+import addFormats from "ajv-formats";
+import { getSchema, type SchemaBuilder } from "./schema-builder.js";
+
+/** @internal */
+export function compileWorkflowInputSchema(
+	schema: SchemaBuilder<Record<string, unknown>, "object">,
+): {
+	jsonSchema: Record<string, unknown>;
+	validate: (input: unknown) => void;
+} {
+	const jsonSchema = getSchema(schema);
+	if (!("type" in jsonSchema) || jsonSchema.type !== "object") {
+		throw new Error("workflow manual inputSchema: must be a j.object() schema");
+	}
+	const ajv = new Ajv({ allErrors: true, strict: true });
+	addFormats.default(ajv, {
+		formats: [
+			"date-time",
+			"date",
+			"time",
+			"duration",
+			"email",
+			"hostname",
+			"ipv4",
+			"ipv6",
+			"uuid",
+		],
+		keywords: false,
+	});
+	const validate = ajv.compile(jsonSchema);
+	return {
+		jsonSchema,
+		validate(input) {
+			if (!validate(input)) {
+				throw new Error(
+					`Invalid manual workflow input: ${ajv.errorsText(validate.errors)}`,
+				);
+			}
+		},
+	};
+}

package/src/workflow-types.test.ts

@@ -4,6 +4,70 @@ import { expect, it } from "vitest";
 
 it("checks provider keys on callback arguments and returned triggers", () => {
 	const cases = [
+		{
+			name: "manual",
+			valid: true,
+			connections: undefined,
+			trigger:
+				"events.manual({ inputSchema: j.object({version: j.string(), dryRun: j.boolean()}) })",
+			handler:
+				"(event) => { const version: string = event.input.version; const dryRun: boolean = event.input.dryRun; void version; void dryRun; }",
+		},
+		{
+			name: "manual_input_mismatch",
+			valid: false,
+			connections: undefined,
+			trigger: "events.manual({ inputSchema: j.object({version: j.string()}) })",
+			handler: "(event) => { const version: number = event.input.version; void version; }",
+		},
+		{
+			name: "manual_requires_object_schema",
+			valid: false,
+			connections: undefined,
+			trigger: "events.manual({ inputSchema: j.string() })",
+			handler: "() => {}",
+		},
+		{
+			name: "manual_nested",
+			valid: true,
+			connections: undefined,
+			trigger:
+				"events.manual({ inputSchema: j.object({releases: j.array(j.object({version: j.string(), dryRun: j.boolean().nullable()}))}) })",
+			handler:
+				'(event) => { const releases: { version: string; dryRun: boolean | null }[] = event.input.releases; event.input.releases = [{ version: "1.0", dryRun: null }]; void releases; }',
+		},
+		{
+			name: "manual_nullable_not_boolean",
+			valid: false,
+			connections: undefined,
+			trigger: "events.manual({ inputSchema: j.object({dryRun: j.boolean().nullable()}) })",
+			handler: "(event) => { const dryRun: boolean = event.input.dryRun; void dryRun; }",
+		},
+		{
+			name: "manual_unknown_property",
+			valid: false,
+			connections: undefined,
+			trigger: "globalTriggers.manual({ inputSchema: j.object({}) })",
+			handler: "(event) => { void event.input.unknown; }",
+		},
+		{
+			name: "manual_rejects_plain_schema",
+			valid: false,
+			connections: undefined,
+			trigger:
+				'events.manual({ inputSchema: { type: "object", properties: { name: { type: "string" } }, required: ["name"] } })',
+			handler: "() => {}",
+		},
+
+		{
+			name: "manual_open_object",
+			valid: false,
+			connections: undefined,
+			trigger:
+				'events.manual({ inputSchema: { type: "object", properties: {}, additionalProperties: true } })',
+			handler: "() => {}",
+		},
+
 		{
 			name: "valid",
 			valid: true,
@@ -166,6 +230,7 @@ it("checks provider keys on callback arguments and returned triggers", () => {
 			resolve("src", `__workflow_types_${testCase.name}.ts`),
 			`import { connections, workflow } from "./workflow.js";
 		import { events as globalTriggers } from "./events.generated.js";
+		import { j } from "./schema-builder.js";
 		const support = connections.slack();
 		const oauthConfig = { authorizationEndpoint: "https://example.com/authorize", tokenEndpoint: "https://example.com/token", clientId: "client", clientSecretEnv: "CLIENT_SECRET", scope: "read" };
 		workflow({

package/src/workflow.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 
 import { afterEach, beforeEach, describe, expect, expectTypeOf, it, vi, type Mock } from "vitest";
 
+import { j } from "./schema-builder.js";
 import { ExecutionError } from "./error.js";
 import type { RunMetadata } from "./runtime-metadata.js";
 import { events, type NotionPageCreatedEvent, type WebhookEvent } from "./events.generated.js";
@@ -57,6 +58,72 @@ afterEach(async () => {
 
 const event = { type: "notion.page.created" } as NotionPageCreatedEvent;
 
+describe("manual workflow triggers", () => {
+	it("runs a manual trigger without arguments and rejects undeclared input", async () => {
+		const handler = vi.fn();
+		const definition = workflow({
+			name: "No inputs",
+			description: "Runs without form fields",
+			triggers: [events.manual()],
+			handler: async (event) => {
+				handler(event.input);
+			},
+		});
+		await definition.handler({ type: "workflow.manual", input: {} });
+		expect(handler).toHaveBeenCalledWith({});
+		await expect(
+			definition.handler(JSON.parse('{"type":"workflow.manual","input":{"extra":true}}')),
+		).rejects.toBeInstanceOf(ExecutionError);
+		expect(handler).toHaveBeenCalledTimes(1);
+	});
+
+	it("infers and validates the manual event input", async () => {
+		const handler = vi.fn();
+		const definition = workflow({
+			name: "Publish release",
+			description: "Publishes a release from manually entered values.",
+			triggers: [
+				events.manual({
+					inputSchema: j.object({ version: j.string(), dryRun: j.boolean() }),
+				}),
+			],
+			handler: async (manualEvent) => {
+				handler(manualEvent.input);
+			},
+		});
+
+		await definition.handler({
+			type: "workflow.manual",
+			input: { version: "1.2.3", dryRun: true },
+		});
+
+		expect(handler).toHaveBeenCalledWith({
+			version: "1.2.3",
+			dryRun: true,
+		});
+	});
+
+	it("rejects invalid manual input before invoking the handler", async () => {
+		const handler = vi.fn();
+		const definition = workflow({
+			name: "Publish release",
+			description: "Publishes a release from manually entered values.",
+			triggers: [
+				events.manual({
+					inputSchema: j.object({ version: j.string() }),
+				}),
+			],
+			handler,
+		});
+
+		await expect(
+			definition.handler(JSON.parse('{"type":"workflow.manual","input":{"version":42}}')),
+		).rejects.toBeInstanceOf(ExecutionError);
+
+		expect(handler).not.toHaveBeenCalled();
+	});
+});
+
 async function createWorkflowContext(): Promise<WorkflowContext<Record<never, never>>> {
 	let context: WorkflowContext<Record<never, never>> | undefined;
 	const definition = workflow({

package/src/workflow.ts

@@ -23,9 +23,10 @@ import { ExecutionError } from "./error.js";
 import { writeOutput } from "./output.js";
 import { resolveRuntimeInput } from "./runtime-input.js";
 import { readRunMetadata, type RunMetadata } from "./runtime-metadata.js";
-import { createWorkflowEvents } from "./events.generated.js";
+import { createWorkflowEvents, validateManualWorkflowInput } from "./events.generated.js";
 import { createWorkflowStepState, type WorkflowState } from "./workflow-state.js";
 import type {
+	ManualWorkflowTrigger,
 	WebhookTrigger,
 	WorkflowEventMap,
 	WorkflowTrigger,
@@ -204,7 +205,15 @@ export type {
 export { access } from "./workflow-access.js";
 export type WorkflowEvent = WorkflowEventMap[keyof WorkflowEventMap];
 
-export type WorkflowEventForTrigger<T extends WorkflowTrigger> = WorkflowEventMap[T["type"]];
+export type WorkflowEventForTrigger<T extends WorkflowTrigger> =
+	T extends ManualWorkflowTrigger<infer TInput>
+		? {
+				type: "workflow.manual";
+				input: TInput;
+			}
+		: T extends { type: keyof WorkflowEventMap }
+			? WorkflowEventMap[T["type"]]
+			: never;
 
 export type WorkflowEventForTriggers<T extends readonly WorkflowTrigger[]> =
 	WorkflowEventForTrigger<T[number]>;
@@ -459,6 +468,12 @@ export function workflow<
 			? configuration.triggers({ events: createWorkflowEvents<TConnections>() })
 			: configuration.triggers;
 	validateTriggerConnections(triggers, requirements);
+	const manualTriggers = triggers.filter(
+		(trigger): trigger is ManualWorkflowTrigger => trigger.type === "workflow.manual",
+	);
+	if (manualTriggers.length > 1) {
+		throw new Error("Workflows support at most one manual trigger");
+	}
 
 	if (
 		configuration.verify !== undefined &&
@@ -522,6 +537,15 @@ export function workflow<
 					step,
 					wait: createWait(step),
 				};
+				if (event.type === "workflow.manual") {
+					const manualTrigger = manualTriggers[0];
+					if (manualTrigger === undefined) {
+						throw new Error(
+							"Received workflow.manual for a workflow without a manual trigger",
+						);
+					}
+					validateManualWorkflowInput(manualTrigger, event.input);
+				}
 				await configuration.handler(event, capabilityContext);
 
 				if (options?.concreteOutput) {