@dex-ai/sdk 0.1.30

package/src/resolve-schema.test.ts

@@ -0,0 +1,351 @@
+/**
+ * Tests for resolveJsonSchema — ensures correct JSON Schema resolution
+ * from Standard Schema objects (Zod v3, Zod v4, pre-computed).
+ */
+import { describe, it, expect } from "bun:test";
+import { resolveJsonSchema, validateToolSchemas } from "./resolve-schema";
+import { Schema } from "./schema";
+import type { StandardSchemaV1 } from "./schema";
+import type { AnyTool } from "./tool";
+import { z } from "zod";
+
+describe("resolveJsonSchema", () => {
+	it("resolves a Zod v3 object schema", () => {
+		const schema = z.object({
+			path: z.string().describe("File path"),
+			lineStart: z.number().int().min(1).optional().describe("Start line"),
+		});
+
+		const result = resolveJsonSchema(schema);
+
+		expect(result.type).toBe("object");
+		expect(result.properties).toBeDefined();
+		const props = result.properties as Record<string, any>;
+		expect(props.path).toBeDefined();
+		expect(props.path.type).toBe("string");
+		expect(props.lineStart).toBeDefined();
+		// Should have required array with "path" only
+		expect(result.required).toContain("path");
+		expect(result.required).not.toContain("lineStart");
+	});
+
+	it("strips $schema and additionalProperties", () => {
+		const schema = z.object({
+			name: z.string(),
+		});
+
+		const result = resolveJsonSchema(schema);
+
+		expect(result.$schema).toBeUndefined();
+		expect(result.additionalProperties).toBeUndefined();
+	});
+
+	it("sanitizes anyOf nullable patterns", () => {
+		// z.string().nullable() produces anyOf: [{type: "string"}, {type: "null"}]
+		const schema = z.object({
+			parentId: z.string().nullable().describe("Parent ID"),
+		});
+
+		const result = resolveJsonSchema(schema);
+		const props = result.properties as Record<string, any>;
+
+		// Should NOT have anyOf — should be flattened to {type: "string"}
+		expect(props.parentId.anyOf).toBeUndefined();
+		expect(props.parentId.type).toBe("string");
+	});
+
+	it("sanitizes exclusiveMinimum boolean (draft-04)", () => {
+		// Some converters emit {exclusiveMinimum: true, minimum: 0}
+		const mockSchema = {
+			"~standard": {
+				version: 1,
+				vendor: "test",
+				jsonSchema: {
+					type: "object",
+					properties: {
+						count: {
+							type: "integer",
+							exclusiveMinimum: true,
+							minimum: 0,
+						},
+					},
+				},
+				validate: (v: unknown) => ({ value: v }),
+			},
+		} as unknown as StandardSchemaV1;
+
+		const result = resolveJsonSchema(mockSchema);
+		const props = result.properties as Record<string, any>;
+
+		// Should convert to numeric exclusiveMinimum
+		expect(props.count.exclusiveMinimum).toBe(0);
+		expect(props.count.minimum).toBeUndefined();
+	});
+
+	it("reads pre-computed jsonSchema from ~standard (fast path)", () => {
+		const precomputed = {
+			"~standard": {
+				version: 1,
+				vendor: "dex",
+				jsonSchema: {
+					type: "object",
+					properties: {
+						id: { type: "string", description: "Task ID" },
+					},
+					required: ["id"],
+				},
+				validate: (v: unknown) => ({ value: v }),
+			},
+		} as unknown as StandardSchemaV1;
+
+		const result = resolveJsonSchema(precomputed);
+
+		expect(result.type).toBe("object");
+		const props = result.properties as Record<string, any>;
+		expect(props.id.type).toBe("string");
+		expect(props.id.description).toBe("Task ID");
+		expect(result.required).toEqual(["id"]);
+	});
+
+	it("caches results for the same schema object", () => {
+		const schema = z.object({ x: z.string() });
+
+		const result1 = resolveJsonSchema(schema);
+		const result2 = resolveJsonSchema(schema);
+
+		expect(result1).toBe(result2); // Same reference (cached)
+	});
+
+	it("handles nested objects", () => {
+		const schema = z.object({
+			tasks: z
+				.array(
+					z.object({
+						title: z.string().min(1).describe("Task title"),
+						priority: z.number().int().min(0).max(10).optional(),
+					}),
+				)
+				.min(1)
+				.max(100),
+		});
+
+		const result = resolveJsonSchema(schema);
+		const props = result.properties as Record<string, any>;
+
+		expect(props.tasks.type).toBe("array");
+		expect(props.tasks.minItems).toBe(1);
+		expect(props.tasks.maxItems).toBe(100);
+		expect(props.tasks.items.type).toBe("object");
+		expect(props.tasks.items.properties.title.type).toBe("string");
+	});
+
+	it("handles enum schemas", () => {
+		const schema = z.object({
+			status: z.enum(["pending", "done", "failed"]).describe("Task status"),
+		});
+
+		const result = resolveJsonSchema(schema);
+		const props = result.properties as Record<string, any>;
+
+		expect(props.status.enum).toEqual(["pending", "done", "failed"]);
+	});
+});
+
+describe("validateToolSchemas", () => {
+	function makeTool(name: string, params: any): AnyTool {
+		return {
+			name,
+			description: `Test tool ${name}`,
+			parameters: params,
+			execute: async () => "ok",
+		};
+	}
+
+	it("returns no diagnostics for valid tools", () => {
+		const tools = [
+			makeTool("read", z.object({ path: z.string() })),
+			makeTool("write", z.object({ path: z.string(), content: z.string() })),
+		];
+
+		const diags = validateToolSchemas(tools);
+		expect(diags).toHaveLength(0);
+	});
+
+	it("returns error for tool with degenerate schema (empty properties)", () => {
+		const brokenSchema = {
+			"~standard": {
+				version: 1,
+				vendor: "broken",
+				validate: () => ({ value: {} }),
+			},
+		} as unknown as StandardSchemaV1;
+
+		const tools = [makeTool("broken_tool", brokenSchema)];
+		const diags = validateToolSchemas(tools);
+
+		expect(diags.length).toBeGreaterThan(0);
+		const err = diags.find((d) => d.toolName === "broken_tool");
+		expect(err).toBeDefined();
+		expect(err!.severity).toBe("error");
+		expect(err!.issue).toContain("no properties");
+	});
+
+	it("returns warning for tool with no parameters", () => {
+		const tools = [makeTool("no_params", undefined)];
+		const diags = validateToolSchemas(tools);
+
+		expect(diags).toHaveLength(1);
+		expect(diags[0]!.severity).toBe("warning");
+		expect(diags[0]!.issue).toContain("no parameters schema");
+	});
+
+	it("includes extensionName in diagnostics when provided", () => {
+		const brokenSchema = {
+			"~standard": {
+				version: 1,
+				vendor: "broken",
+				validate: () => ({ value: {} }),
+			},
+		} as unknown as StandardSchemaV1;
+
+		const tools = [makeTool("bad", brokenSchema)];
+		const diags = validateToolSchemas(tools, { extensionName: "my-ext" });
+
+		expect(diags[0]!.extensionName).toBe("my-ext");
+	});
+
+	it("passes valid nullable patterns (sanitized by resolveJsonSchema)", () => {
+		// After sanitization, .nullable() should be flattened — no anyOf left
+		const tools = [
+			makeTool(
+				"task_create",
+				z.object({
+					title: z.string(),
+					parentId: z.string().nullable().describe("Parent"),
+				}),
+			),
+		];
+
+		const diags = validateToolSchemas(tools);
+		// After sanitize strips anyOf nullable, no warnings expected
+		expect(diags).toHaveLength(0);
+	});
+
+	it("catches schema resolution errors", () => {
+		const throwingSchema = {
+			"~standard": {
+				version: 1,
+				vendor: "zod",
+				validate: () => ({ value: {} }),
+			},
+			// Has _zod to trigger Zod v4 path, which will fail
+			_zod: { def: {} },
+			_def: { typeName: "ZodObject" },
+		} as unknown as StandardSchemaV1;
+
+		const tools = [makeTool("throws", throwingSchema)];
+		const diags = validateToolSchemas(tools);
+
+		// Should either resolve to something or produce a diagnostic — not crash
+		// The exact outcome depends on whether require('zod') succeeds in test env
+		expect(diags).toBeDefined();
+	});
+});
+
+describe("Schema.fromJsonSchema", () => {
+	it("creates a StandardSchemaV1 from raw JSON Schema", () => {
+		const params = Schema.fromJsonSchema({
+			type: "object",
+			properties: {
+				path: { type: "string", description: "File path" },
+				lineStart: { type: "integer", minimum: 1 },
+			},
+			required: ["path"],
+		});
+
+		// Should satisfy StandardSchemaV1 interface
+		expect(params["~standard"].version).toBe(1);
+		expect(params["~standard"].vendor).toBe("dex");
+		expect(typeof params["~standard"].validate).toBe("function");
+	});
+
+	it("resolves directly via resolveJsonSchema (fast path)", () => {
+		const params = Schema.fromJsonSchema({
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				age: { type: "integer", minimum: 0 },
+			},
+			required: ["name"],
+		});
+
+		const result = resolveJsonSchema(params);
+
+		expect(result.type).toBe("object");
+		const props = result.properties as Record<string, any>;
+		expect(props.name.type).toBe("string");
+		expect(props.age.type).toBe("integer");
+		expect(props.age.minimum).toBe(0);
+		expect(result.required).toEqual(["name"]);
+	});
+
+	it("passes tool schema validation", () => {
+		const tools: AnyTool[] = [
+			{
+				name: "my_tool",
+				description: "A tool",
+				parameters: Schema.fromJsonSchema({
+					type: "object",
+					properties: {
+						query: { type: "string" },
+					},
+					required: ["query"],
+				}),
+				execute: async () => "ok",
+			},
+		];
+
+		const diags = validateToolSchemas(tools);
+		expect(diags).toHaveLength(0);
+	});
+
+	it("validate function passes through input", () => {
+		const params = Schema.fromJsonSchema({ type: "object", properties: {} });
+		const input = { foo: "bar" };
+		const result = params["~standard"].validate(input);
+		expect(result).toEqual({ value: input });
+	});
+
+	it("validate rejects null/undefined for object schema", () => {
+		const params = Schema.fromJsonSchema({ type: "object", properties: {} });
+		const r1 = params["~standard"].validate(undefined);
+		expect("issues" in r1).toBe(true);
+		if ("issues" in r1) {
+			expect(r1.issues[0]!.message).toContain("Expected an object");
+		}
+		const r2 = params["~standard"].validate(null);
+		expect("issues" in r2).toBe(true);
+	});
+
+	it("validate checks required fields", () => {
+		const params = Schema.fromJsonSchema({
+			type: "object",
+			properties: { name: { type: "string" }, age: { type: "number" } },
+			required: ["name", "age"],
+		});
+		const r1 = params["~standard"].validate({ name: "foo" });
+		expect("issues" in r1).toBe(true);
+		if ("issues" in r1) {
+			expect(r1.issues).toHaveLength(1);
+			expect(r1.issues[0]!.message).toContain('"age"');
+		}
+		const r2 = params["~standard"].validate({ name: "foo", age: 30 });
+		expect("value" in r2).toBe(true);
+	});
+
+	it("validate allows non-object schemas through without checks", () => {
+		const params = Schema.fromJsonSchema({ type: "string" } as any);
+		const result = params["~standard"].validate("hello");
+		expect(result).toEqual({ value: "hello" });
+	});
+});