@notionhq/workers 0.0.85 → 0.1.0

package/src/capabilities/tool.test.ts

@@ -7,12 +7,8 @@ import {
 	type Mock,
 	vi,
 } from "vitest";
-import {
-	createToolCapability,
-	InvalidToolInputError,
-	InvalidToolOutputError,
-	ToolExecutionError,
-} from "./tool.js";
+import { j } from "../schema-builder.js";
+import { createToolCapability } from "./tool.js";
 
 describe("Worker.tool", () => {
 	let stdoutSpy: Mock<typeof process.stdout.write>;
@@ -33,14 +29,7 @@ describe("Worker.tool", () => {
 			{
 				title: "Say Hello",
 				description: "Greet a user",
-				schema: {
-					type: "object",
-					properties: {
-						name: { type: "string" },
-					},
-					required: ["name"],
-					additionalProperties: false,
-				},
+				schema: j.object({ name: j.string() }),
 				execute: (input: { name: string }) => {
 					return `Hello, ${input.name}!`;
 				},
@@ -52,7 +41,7 @@ describe("Worker.tool", () => {
 		expect(result).toEqual({ _tag: "success", value: "Hello, Alice!" });
 
 		expect(stdoutSpy).toHaveBeenCalledWith(
-			`\n<output>"Hello, Alice!"</output>\n`,
+			`\n<output>{"_tag":"success","value":"Hello, Alice!"}</output>\n`,
 		);
 	});
 
@@ -62,14 +51,7 @@ describe("Worker.tool", () => {
 			{
 				title: "Fetch Data",
 				description: "Fetch data asynchronously",
-				schema: {
-					type: "object",
-					properties: {
-						id: { type: "number" },
-					},
-					required: ["id"],
-					additionalProperties: false,
-				},
+				schema: j.object({ id: j.number() }),
 				execute: async (input: { id: number }) => {
 					// Simulate async operation
 					await new Promise((resolve) => setTimeout(resolve, 10));
@@ -86,7 +68,7 @@ describe("Worker.tool", () => {
 		});
 
 		expect(stdoutSpy).toHaveBeenCalledWith(
-			`\n<output>{"data":"Data for ID 42"}</output>\n`,
+			`\n<output>{"_tag":"success","value":{"data":"Data for ID 42"}}</output>\n`,
 		);
 	});
 
@@ -96,12 +78,7 @@ describe("Worker.tool", () => {
 			{
 				title: "Throw Error",
 				description: "Throws an error",
-				schema: {
-					type: "object",
-					properties: {},
-					required: [],
-					additionalProperties: false,
-				},
+				schema: j.object({}),
 				execute: () => {
 					throw new Error("Something went wrong");
 				},
@@ -110,15 +87,17 @@ describe("Worker.tool", () => {
 
 		const result = (await capability.handler({})) as {
 			_tag: "error";
-			error: ToolExecutionError;
+			error: { name: string; message: string; trace: string | undefined };
 		};
 
 		expect(result._tag).toBe("error");
-		expect(result.error).toBeInstanceOf(ToolExecutionError);
+		expect(result.error.name).toBe("ToolExecutionError");
 		expect(result.error.message).toBe("Something went wrong");
 
 		expect(stdoutSpy).toHaveBeenCalledWith(
-			`\n<output>{"_tag":"error","error":{"name":"ToolExecutionError","message":"Something went wrong"}}</output>\n`,
+			expect.stringContaining(
+				`"_tag":"error","error":{"name":"ToolExecutionError","message":"Something went wrong"`,
+			),
 		);
 	});
 
@@ -128,14 +107,7 @@ describe("Worker.tool", () => {
 			{
 				title: "Say Hello",
 				description: "Requires a name property",
-				schema: {
-					type: "object",
-					properties: {
-						name: { type: "string" },
-					},
-					required: ["name"],
-					additionalProperties: false,
-				},
+				schema: j.object({ name: j.string() }),
 				execute: (input: { name: string }) => {
 					return `Hello, ${input.name}!`;
 				},
@@ -144,11 +116,11 @@ describe("Worker.tool", () => {
 
 		const result = (await capability.handler({ age: 25 })) as {
 			_tag: "error";
-			error: InvalidToolInputError;
+			error: { name: string; message: string; trace: string | undefined };
 		};
 
 		expect(result._tag).toBe("error");
-		expect(result.error).toBeInstanceOf(InvalidToolInputError);
+		expect(result.error.name).toBe("InvalidToolInputError");
 		expect(result.error.message).toContain("name");
 
 		expect(stdoutSpy).toHaveBeenCalledWith(
@@ -165,20 +137,8 @@ describe("Worker.tool", () => {
 		>("invalidOutput", {
 			title: "Return Invalid Output",
 			description: "Returns output that doesn't match schema",
-			schema: {
-				type: "object",
-				properties: {},
-				required: [],
-				additionalProperties: false,
-			},
-			outputSchema: {
-				type: "object",
-				properties: {
-					result: { type: "string" },
-				},
-				required: ["result"],
-				additionalProperties: false,
-			},
+			schema: j.object({}),
+			outputSchema: j.object({ result: j.string() }),
 			// @ts-expect-error Testing invalid output - intentionally returning number instead of string
 			execute: () => {
 				return { result: 123 };
@@ -187,68 +147,20 @@ describe("Worker.tool", () => {
 
 		const result = (await capability.handler({})) as {
 			_tag: "error";
-			error: InvalidToolOutputError;
+			error: { name: string; message: string; trace: string | undefined };
 		};
 
 		expect(result._tag).toBe("error");
-		expect(result.error).toBeInstanceOf(InvalidToolOutputError);
+		expect(result.error.name).toBe("InvalidToolOutputError");
 		expect(result.error.message).toContain("result");
 
 		expect(stdoutSpy).toHaveBeenCalledWith(
 			expect.stringContaining(
-				`\n<output>{"_tag":"error","error":{"name":"InvalidToolOutputError"`,
+				`"_tag":"error","error":{"name":"InvalidToolOutputError"`,
 			),
 		);
 	});
 
-	it("rejects schema where required is missing properties", () => {
-		expect(() =>
-			createToolCapability<{ name: string; age: number }, string>("bad", {
-				title: "Bad",
-				description: "Missing required",
-				schema: {
-					type: "object",
-					properties: {
-						name: { type: "string" },
-						age: { type: "number" },
-					},
-					required: ["name"],
-					additionalProperties: false,
-				} as never,
-				execute: () => "",
-			}),
-		).toThrow(/properties \[age\] must be listed in "required"/);
-	});
-
-	it("rejects nested schema where required is missing properties", () => {
-		expect(() =>
-			createToolCapability<{ user: { name: string; email: string } }, string>(
-				"bad",
-				{
-					title: "Bad",
-					description: "Nested missing required",
-					schema: {
-						type: "object",
-						properties: {
-							user: {
-								type: "object",
-								properties: {
-									name: { type: "string" },
-									email: { type: "string" },
-								},
-								required: ["name"],
-								additionalProperties: false,
-							} as never,
-						},
-						required: ["user"],
-						additionalProperties: false,
-					},
-					execute: () => "",
-				},
-			),
-		).toThrow(/at properties\.user.*properties \[email\]/);
-	});
-
 	it("accepts schema with nullable (string | null) properties", () => {
 		const capability = createToolCapability<
 			{ name: string; nickname: string | null },
@@ -256,51 +168,16 @@ describe("Worker.tool", () => {
 		>("nullable", {
 			title: "Nullable",
 			description: "Has nullable properties",
-			schema: {
-				type: "object",
-				properties: {
-					name: { type: "string" },
-					nickname: {
-						anyOf: [{ type: "string" }, { type: "null" }],
-					},
-				},
-				required: ["name", "nickname"],
-				additionalProperties: false,
-			},
+			schema: j.object({
+				name: j.string(),
+				nickname: j.string().nullable(),
+			}),
 			execute: ({ name, nickname }) => `${name} (${nickname ?? "no nickname"})`,
 		});
 
 		expect(capability.config.schema).toBeDefined();
 	});
 
-	it("rejects output schema where required is missing properties", () => {
-		expect(() =>
-			createToolCapability<
-				Record<string, never>,
-				{ result: string; count: number }
-			>("bad", {
-				title: "Bad",
-				description: "Output missing required",
-				schema: {
-					type: "object",
-					properties: {},
-					required: [],
-					additionalProperties: false,
-				},
-				outputSchema: {
-					type: "object",
-					properties: {
-						result: { type: "string" },
-						count: { type: "number" },
-					},
-					required: ["result"],
-					additionalProperties: false,
-				} as never,
-				execute: () => ({ result: "", count: 0 }),
-			}),
-		).toThrow(/properties \[count\] must be listed in "required"/);
-	});
-
 	it("invalid output with custom output schema", async () => {
 		const capability = createToolCapability<
 			{ value: number },
@@ -308,23 +185,11 @@ describe("Worker.tool", () => {
 		>("customOutput", {
 			title: "Custom Output",
 			description: "Has custom output schema",
-			schema: {
-				type: "object",
-				properties: {
-					value: { type: "number" },
-				},
-				required: ["value"],
-				additionalProperties: false,
-			},
-			outputSchema: {
-				type: "object",
-				properties: {
-					doubled: { type: "number" },
-					message: { type: "string" },
-				},
-				required: ["doubled", "message"],
-				additionalProperties: false,
-			},
+			schema: j.object({ value: j.number() }),
+			outputSchema: j.object({
+				doubled: j.number(),
+				message: j.string(),
+			}),
 			// @ts-expect-error Testing invalid output - intentionally missing message property
 			execute: (input: { value: number }) => {
 				return {
@@ -335,16 +200,16 @@ describe("Worker.tool", () => {
 
 		const result = (await capability.handler({ value: 5 })) as {
 			_tag: "error";
-			error: InvalidToolOutputError;
+			error: { name: string; message: string; trace: string | undefined };
 		};
 
 		expect(result._tag).toBe("error");
-		expect(result.error).toBeInstanceOf(InvalidToolOutputError);
+		expect(result.error.name).toBe("InvalidToolOutputError");
 		expect(result.error.message).toContain("message");
 
 		expect(stdoutSpy).toHaveBeenCalledWith(
 			expect.stringContaining(
-				`\n<output>{"_tag":"error","error":{"name":"InvalidToolOutputError"`,
+				`"_tag":"error","error":{"name":"InvalidToolOutputError"`,
 			),
 		);
 	});

package/src/capabilities/tool.ts

@@ -1,5 +1,7 @@
 import { Ajv } from "ajv";
-import type { AnyJSONSchema, JSONSchema } from "../json-schema.js";
+import type { AnyJSONSchema } from "../json-schema.js";
+import type { SchemaBuilder } from "../schema-builder.js";
+import { getSchema } from "../schema-builder.js";
 import type { HandlerOptions, JSONValue } from "../types.js";
 import type { CapabilityContext } from "./context.js";
 import { createCapabilityContext } from "./context.js";
@@ -72,8 +74,8 @@ export interface ToolConfiguration<
 > {
 	title: string;
 	description: string;
-	schema: JSONSchema<I>;
-	outputSchema?: JSONSchema<O>;
+	schema: SchemaBuilder<I>;
+	outputSchema?: SchemaBuilder<O>;
 	execute: (input: I, context: CapabilityContext) => O | Promise<O>;
 }
 
@@ -90,6 +92,7 @@ export class InvalidToolInputError extends Error {
 		return {
 			name: this.name,
 			message: this.message,
+			trace: this.stack,
 		};
 	}
 }
@@ -107,6 +110,7 @@ export class InvalidToolOutputError extends Error {
 		return {
 			name: this.name,
 			message: this.message,
+			trace: this.stack,
 		};
 	}
 }
@@ -124,6 +128,7 @@ export class ToolExecutionError extends Error {
 		return {
 			name: this.name,
 			message: this.message,
+			trace: this.stack,
 		};
 	}
 }
@@ -143,16 +148,20 @@ export function createToolCapability<
 	I extends JSONValue,
 	O extends JSONValue = JSONValue,
 >(key: string, config: ToolConfiguration<I, O>) {
-	validateRequiredProperties(config.schema as AnyJSONSchema);
-	if (config.outputSchema) {
-		validateRequiredProperties(config.outputSchema as AnyJSONSchema);
+	const inputSchema = getSchema(config.schema);
+	validateRequiredProperties(inputSchema as AnyJSONSchema);
+
+	const outputSchema = config.outputSchema
+		? getSchema(config.outputSchema)
+		: undefined;
+
+	if (outputSchema) {
+		validateRequiredProperties(outputSchema as AnyJSONSchema);
 	}
 
 	const ajv = new Ajv();
-	const validateInput = ajv.compile(config.schema);
-	const validateOutput = config.outputSchema
-		? ajv.compile(config.outputSchema)
-		: null;
+	const validateInput = ajv.compile(inputSchema);
+	const validateOutput = outputSchema ? ajv.compile(outputSchema) : null;
 
 	async function handler(input: JSONValue, options: HandlerOptions): Promise<O>;
 	async function handler(input: JSONValue): Promise<
@@ -162,10 +171,7 @@ export function createToolCapability<
 		  }
 		| {
 				_tag: "error";
-				error:
-					| InvalidToolInputError
-					| InvalidToolOutputError
-					| ToolExecutionError;
+				error: { name: string; message: string; trace: string | undefined };
 		  }
 	>;
 	async function handler(
@@ -179,10 +185,7 @@ export function createToolCapability<
 		  }
 		| {
 				_tag: "error";
-				error:
-					| InvalidToolInputError
-					| InvalidToolOutputError
-					| ToolExecutionError;
+				error: { name: string; message: string; trace: string | undefined };
 		  }
 	> {
 		if (!validateInput(input)) {
@@ -203,7 +206,7 @@ export function createToolCapability<
 
 			const result = {
 				_tag: "error" as const,
-				error,
+				error: { name: error.name, message: error.message, trace: error.stack },
 			};
 
 			process.stdout.write(`\n<output>${JSON.stringify(result)}</output>\n`);
@@ -225,9 +228,11 @@ export function createToolCapability<
 
 				const result = {
 					_tag: "error" as const,
-					error: new InvalidToolOutputError(
-						JSON.stringify(validateOutput.errors, null, 2),
-					),
+					error: {
+						name: error.name,
+						message: error.message,
+						trace: error.stack,
+					},
 				};
 
 				process.stdout.write(`\n<output>${JSON.stringify(result)}</output>\n`);
@@ -239,7 +244,9 @@ export function createToolCapability<
 				return result;
 			}
 
-			process.stdout.write(`\n<output>${JSON.stringify(result)}</output>\n`);
+			process.stdout.write(
+				`\n<output>${JSON.stringify({ _tag: "success", value: result })}</output>\n`,
+			);
 
 			return {
 				_tag: "success" as const,
@@ -256,7 +263,7 @@ export function createToolCapability<
 
 			const result = {
 				_tag: "error" as const,
-				error,
+				error: { name: error.name, message: error.message, trace: error.stack },
 			};
 
 			process.stdout.write(`\n<output>${JSON.stringify(result)}</output>\n`);
@@ -271,8 +278,8 @@ export function createToolCapability<
 		config: {
 			title: config.title,
 			description: config.description,
-			schema: config.schema,
-			outputSchema: config.outputSchema,
+			schema: inputSchema,
+			outputSchema: outputSchema,
 		},
 		handler,
 	};

package/src/index.ts

@@ -23,6 +23,8 @@ export type {
 } from "./capabilities/sync.js";
 export type { ToolCapability, ToolConfiguration } from "./capabilities/tool.js";
 export type { AnyJSONSchema, JSONSchema } from "./json-schema.js";
+export type { Infer, SchemaBuilder } from "./schema-builder.js";
+export { getSchema, j } from "./schema-builder.js";
 export type {
 	Icon,
 	ImageIcon,