@polpo-ai/server 0.15.38 → 0.15.39

package/dist/routes/completions/tool-mapping.test.js

@@ -1,5 +1,7 @@
 import { describe, expect, it, vi } from "vitest";
-import { persistAssistantMessage } from "./tool-mapping.js";
+import { generateText } from "ai";
+import { MockLanguageModelV3 } from "ai/test";
+import { persistAssistantMessage, toAITools, toPortableToolInputSchema, } from "./tool-mapping.js";
 function fakeStore() {
     return { updateMessage: vi.fn().mockResolvedValue(true) };
 }
@@ -45,4 +47,643 @@ describe("persistAssistantMessage", () => {
         expect(toolCalls[0].arguments.credentials.password).toBe("s3cret");
     });
 });
+describe("toPortableToolInputSchema", () => {
+    it("moves minimum into descriptions without mutating the source", () => {
+        const schema = {
+            type: "object",
+            additionalProperties: false,
+            required: ["targetCalories", "missing"],
+            properties: {
+                targetCalories: {
+                    type: "number",
+                    minimum: 1000,
+                    maximum: 5000,
+                    multipleOf: 5,
+                    description: "Daily calorie target.",
+                },
+                label: {
+                    type: "string",
+                    minLength: 2,
+                    maxLength: 40,
+                    pattern: "^[A-Za-z ]+$",
+                },
+            },
+        };
+        const original = structuredClone(schema);
+        expect(toPortableToolInputSchema(schema)).toEqual({
+            type: "object",
+            additionalProperties: false,
+            required: ["targetCalories", "missing"],
+            properties: {
+                targetCalories: {
+                    type: "number",
+                    maximum: 5000,
+                    multipleOf: 5,
+                    description: "Daily calorie target. Minimum: 1000.",
+                },
+                label: {
+                    type: "string",
+                    minLength: 2,
+                    maxLength: 40,
+                    pattern: "^[A-Za-z ]+$",
+                },
+            },
+        });
+        expect(schema).toEqual(original);
+    });
+    it("preserves unions, references, dictionaries, tuples, and nullability", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                choice: {
+                    oneOf: [
+                        { $ref: "#/$defs/named" },
+                        { type: ["number", "null"], minimum: 10 },
+                    ],
+                },
+                metadata: {
+                    type: "object",
+                    additionalProperties: { type: "string" },
+                },
+                tuple: {
+                    type: "array",
+                    items: [{ type: "string" }, { type: "number", minimum: 2 }],
+                    additionalItems: { type: "number", minimum: 3 },
+                },
+            },
+            $defs: {
+                named: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                    },
+                    required: ["name"],
+                },
+            },
+        };
+        expect(toPortableToolInputSchema(schema)).toEqual({
+            type: "object",
+            properties: {
+                choice: {
+                    oneOf: [
+                        { $ref: "#/$defs/named" },
+                        {
+                            type: ["number", "null"],
+                            description: "Minimum: 10.",
+                        },
+                    ],
+                },
+                metadata: {
+                    type: "object",
+                    additionalProperties: { type: "string" },
+                },
+                tuple: {
+                    type: "array",
+                    items: [
+                        { type: "string" },
+                        { type: "number", description: "Minimum: 2." },
+                    ],
+                    additionalItems: {
+                        type: "number",
+                        description: "Minimum: 3.",
+                    },
+                },
+            },
+            $defs: {
+                named: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                    },
+                    required: ["name"],
+                },
+            },
+        });
+    });
+    it("preserves allOf branches instead of inventing merged semantics", () => {
+        const schema = {
+            type: "object",
+            allOf: [
+                {
+                    properties: {
+                        value: { type: "number", minimum: 10 },
+                    },
+                    required: ["value"],
+                },
+                {
+                    properties: {
+                        value: { type: "number", maximum: 5 },
+                    },
+                },
+            ],
+        };
+        expect(toPortableToolInputSchema(schema)).toEqual({
+            type: "object",
+            allOf: [
+                {
+                    properties: {
+                        value: { type: "number", description: "Minimum: 10." },
+                    },
+                    required: ["value"],
+                },
+                {
+                    properties: {
+                        value: { type: "number", maximum: 5 },
+                    },
+                },
+            ],
+        });
+    });
+    it("falls back only for non-object schemas", () => {
+        expect(toPortableToolInputSchema(null)).toEqual({
+            type: "object",
+            properties: {},
+        });
+        expect(toPortableToolInputSchema(true)).toEqual({
+            type: "object",
+            properties: {},
+        });
+    });
+    it("does not rewrite object-valued enum, const, default, or examples", () => {
+        const literal = {
+            minimum: 1,
+            nested: { minimum: 2 },
+        };
+        const schema = {
+            type: "object",
+            properties: {
+                payload: {
+                    enum: [literal],
+                    const: literal,
+                    default: literal,
+                    examples: [literal],
+                },
+            },
+        };
+        expect(toPortableToolInputSchema(schema)).toEqual(schema);
+        expect(toPortableToolInputSchema(schema)).not.toBe(schema);
+    });
+    it("uses the portable schema for providers and the original for validation", async () => {
+        const tools = toAITools([
+            {
+                name: "calculate",
+                description: "Calculate a target.",
+                parameters: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        target: {
+                            type: "number",
+                            minimum: 1000,
+                            maximum: 5000,
+                        },
+                    },
+                    required: ["target"],
+                },
+            },
+        ]);
+        expect(tools.calculate.inputSchema.jsonSchema).toEqual({
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                target: {
+                    type: "number",
+                    maximum: 5000,
+                    description: "Minimum: 1000.",
+                },
+            },
+            required: ["target"],
+        });
+        expect(await tools.calculate.inputSchema.validate({ target: 999 })).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.any(Error),
+        }));
+        expect(await tools.calculate.inputSchema.validate({ target: 1000 })).toEqual({
+            success: true,
+            value: { target: 1000 },
+        });
+        expect(await tools.calculate.inputSchema.validate({
+            target: 1000,
+            unexpected: true,
+        })).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.any(Error),
+        }));
+    });
+    it.each([
+        "http://json-schema.org/draft-07/schema#",
+        "https://json-schema.org/draft/2019-09/schema",
+        "https://json-schema.org/draft/2020-12/schema",
+    ])("validates numeric constraints declared with %s", async ($schema) => {
+        const tools = toAITools([
+            {
+                name: "draft_check",
+                parameters: {
+                    $schema,
+                    type: "object",
+                    properties: {
+                        value: { type: "number", minimum: 10 },
+                    },
+                    required: ["value"],
+                },
+            },
+        ]);
+        const validate = tools.draft_check.inputSchema.validate;
+        expect(await validate({ value: 9 })).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.any(Error),
+        }));
+        expect(await validate({ value: 10 })).toEqual({
+            success: true,
+            value: { value: 10 },
+        });
+    });
+    it("validates registered string formats", async () => {
+        const tools = toAITools([
+            {
+                name: "contact",
+                parameters: {
+                    $schema: "https://json-schema.org/draft/2020-12/schema",
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        email: { type: "string", format: "email" },
+                    },
+                    required: ["email"],
+                },
+            },
+        ]);
+        const validate = tools.contact.inputSchema.validate;
+        expect(await validate({ email: "not-an-email" })).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.any(Error),
+        }));
+        expect(await validate({ email: "person@example.com" })).toEqual({
+            success: true,
+            value: { email: "person@example.com" },
+        });
+    });
+    it("fails closed for nonstandard async schemas in edge runtimes", async () => {
+        const tools = toAITools([
+            {
+                name: "async_check",
+                parameters: {
+                    $async: true,
+                    type: "object",
+                    properties: {
+                        value: { type: "number", minimum: 10 },
+                    },
+                    required: ["value"],
+                },
+            },
+        ]);
+        const validate = tools.async_check.inputSchema.validate;
+        expect(tools.async_check.inputSchema.jsonSchema).not.toHaveProperty("$async");
+        expect(await validate({ value: 9 })).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.objectContaining({
+                message: expect.stringContaining("$async is not supported"),
+            }),
+        }));
+        expect(await validate({ value: 10 })).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.objectContaining({
+                message: expect.stringContaining("$async is not supported"),
+            }),
+        }));
+    });
+    it("fails closed when an original schema cannot be compiled", async () => {
+        const tools = toAITools([
+            {
+                name: "broken",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        payload: { $ref: "#/$defs/missing" },
+                    },
+                },
+            },
+        ]);
+        const result = await tools.broken.inputSchema.validate({
+            payload: "unsafe",
+        });
+        expect(result).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.objectContaining({
+                message: expect.stringContaining("Invalid tool input schema"),
+            }),
+        }));
+    });
+    it("isolates separately decoded schemas that reuse the same $id", async () => {
+        const first = toAITools([{
+                name: "first",
+                parameters: {
+                    $id: "https://example.com/reused-tool-schema",
+                    type: "object",
+                    properties: { first: { type: "string" } },
+                    required: ["first"],
+                },
+            }]);
+        const second = toAITools([{
+                name: "second",
+                parameters: {
+                    $id: "https://example.com/reused-tool-schema",
+                    type: "object",
+                    properties: { second: { type: "number" } },
+                    required: ["second"],
+                },
+            }]);
+        const [firstResult, secondResult] = await Promise.all([
+            first.first.inputSchema.validate({ first: "ok" }),
+            second.second.inputSchema.validate({ second: 2 }),
+        ]);
+        expect(firstResult).toEqual({
+            success: true,
+            value: { first: "ok" },
+        });
+        expect(secondResult).toEqual({
+            success: true,
+            value: { second: 2 },
+        });
+    });
+    it("validates ordinary local references without mutating the source schema", async () => {
+        const schema = {
+            $schema: "https://json-schema.org/draft/2020-12/schema",
+            type: "object",
+            properties: {
+                payload: { $ref: "#/$defs/payload" },
+            },
+            required: ["payload"],
+            $defs: {
+                payload: {
+                    type: "object",
+                    properties: { name: { type: "string" } },
+                    required: ["name"],
+                },
+            },
+        };
+        const original = structuredClone(schema);
+        const tools = toAITools([{ name: "local_ref", parameters: schema }]);
+        const validate = tools.local_ref.inputSchema.validate;
+        expect(await validate({ payload: { name: "safe" } })).toEqual({
+            success: true,
+            value: { payload: { name: "safe" } },
+        });
+        expect(await validate({ payload: { name: 42 } })).toEqual(expect.objectContaining({ success: false, error: expect.any(Error) }));
+        expect(schema).toEqual(original);
+    });
+    it("enforces recursive Draft 2020-12 dynamic references", async () => {
+        const tools = toAITools([{
+                name: "recursive_tree",
+                parameters: {
+                    $schema: "https://json-schema.org/draft/2020-12/schema",
+                    $dynamicAnchor: "node",
+                    type: "object",
+                    properties: {
+                        data: { type: "string" },
+                        children: {
+                            type: "array",
+                            items: { $dynamicRef: "#node" },
+                        },
+                    },
+                    required: ["data"],
+                },
+            }]);
+        const validate = tools.recursive_tree.inputSchema.validate;
+        expect(await validate({
+            data: "root",
+            children: [{ data: "child" }],
+        })).toEqual({
+            success: true,
+            value: { data: "root", children: [{ data: "child" }] },
+        });
+        expect(await validate({
+            data: "root",
+            children: [{ data: 42 }],
+        })).toEqual(expect.objectContaining({ success: false, error: expect.any(Error) }));
+    });
+    it("fails closed for malformed schemas instead of treating them as parameterless", async () => {
+        const tools = toAITools([{
+                name: "malformed",
+                parameters: {
+                    $schema: "https://json-schema.org/draft/2020-12/schema",
+                    type: "object",
+                    properties: {
+                        value: { type: "number", minimum: "not-a-number" },
+                    },
+                },
+            }]);
+        expect(await tools.malformed.inputSchema.validate({ value: 100 })).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.objectContaining({
+                message: expect.stringContaining("Invalid tool input schema"),
+            }),
+        }));
+        expect(tools.malformed.inputSchema.jsonSchema).toEqual({
+            type: "object",
+            properties: {
+                value: {
+                    type: "number",
+                    description: "Minimum: not-a-number.",
+                },
+            },
+            $schema: "https://json-schema.org/draft/2020-12/schema",
+        });
+    });
+    it("fails closed for unknown schema dialects", async () => {
+        const tools = toAITools([{
+                name: "unknown_draft",
+                parameters: {
+                    $schema: "https://example.com/unknown-schema-dialect",
+                    type: "object",
+                },
+            }]);
+        expect(await tools.unknown_draft.inputSchema.validate({})).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.objectContaining({
+                message: expect.stringContaining("Unsupported JSON Schema dialect"),
+            }),
+        }));
+        expect(tools.unknown_draft.inputSchema.jsonSchema).toEqual({
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        });
+    });
+    it("rejects external references before the validator can perform network I/O", async () => {
+        const tools = toAITools([{
+                name: "external_ref",
+                parameters: {
+                    $schema: "https://json-schema.org/draft/2020-12/schema",
+                    type: "object",
+                    properties: {
+                        payload: { $ref: "https://attacker.example/schema.json" },
+                    },
+                },
+            }]);
+        expect(await tools.external_ref.inputSchema.validate({ payload: {} })).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.objectContaining({
+                message: expect.stringContaining("External tool schema references are not supported"),
+            }),
+        }));
+        expect(tools.external_ref.inputSchema.jsonSchema).toEqual({
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        });
+    });
+    it("does not interpret references embedded in literal instance values", async () => {
+        const literal = { $ref: "https://example.com/this-is-data" };
+        const tools = toAITools([{
+                name: "literal_reference",
+                parameters: {
+                    $schema: "https://json-schema.org/draft/2020-12/schema",
+                    type: "object",
+                    properties: {
+                        payload: { const: literal },
+                    },
+                    required: ["payload"],
+                },
+            }]);
+        const validate = tools.literal_reference.inputSchema.validate;
+        expect(await validate({ payload: literal })).toEqual({
+            success: true,
+            value: { payload: literal },
+        });
+    });
+    it("fails closed for non-JSON schema values without poisoning structural cache entries", async () => {
+        const malformed = toAITools([{
+                name: "malformed_runtime_value",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        value: {
+                            type: "number",
+                            custom: () => "not JSON",
+                        },
+                    },
+                },
+            }]);
+        const valid = toAITools([{
+                name: "valid_runtime_value",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        value: { type: "number" },
+                    },
+                },
+            }]);
+        expect(await malformed.malformed_runtime_value.inputSchema.validate({
+            value: 1,
+        })).toEqual(expect.objectContaining({
+            success: false,
+            error: expect.objectContaining({
+                message: expect.stringContaining("non-JSON function"),
+            }),
+        }));
+        expect(await valid.valid_runtime_value.inputSchema.validate({
+            value: 1,
+        })).toEqual({ success: true, value: { value: 1 } });
+    });
+    it("accepts TypeBox-style symbol metadata that is absent from serialized JSON Schema", async () => {
+        const valueSchema = { type: "number" };
+        const schema = {
+            type: "object",
+            properties: { value: valueSchema },
+            required: ["value"],
+        };
+        Object.defineProperty(schema, Symbol.for("TypeBox.Kind"), {
+            value: "Object",
+            enumerable: true,
+        });
+        Object.defineProperty(valueSchema, Symbol.for("TypeBox.Kind"), {
+            value: "Number",
+            enumerable: true,
+        });
+        const tools = toAITools([{
+                name: "typebox_metadata",
+                parameters: schema,
+            }]);
+        const validate = tools.typebox_metadata.inputSchema.validate;
+        expect(await validate({ value: 1 })).toEqual({
+            success: true,
+            value: { value: 1 },
+        });
+        expect(await validate({ value: "wrong" })).toEqual(expect.objectContaining({ success: false, error: expect.any(Error) }));
+    });
+    it("ignores validator-internal-looking fields instead of redirecting references", async () => {
+        const schema = {
+            $schema: "https://json-schema.org/draft/2020-12/schema",
+            type: "object",
+            properties: {
+                value: {
+                    $ref: "#/$defs/strict",
+                    __absolute_ref__: "#/$defs/permissive",
+                },
+            },
+            required: ["value"],
+            $defs: {
+                strict: { type: "string" },
+                permissive: {},
+            },
+        };
+        const original = structuredClone(schema);
+        const tools = toAITools([{ name: "reserved_field", parameters: schema }]);
+        const validate = tools.reserved_field.inputSchema.validate;
+        expect(await validate({ value: 42 })).toEqual(expect.objectContaining({ success: false, error: expect.any(Error) }));
+        expect(await validate({ value: "safe" })).toEqual({
+            success: true,
+            value: { value: "safe" },
+        });
+        expect(schema).toEqual(original);
+    });
+    it("marks provider tool calls invalid when they violate the original schema", async () => {
+        const model = new MockLanguageModelV3({
+            doGenerate: {
+                content: [
+                    {
+                        type: "tool-call",
+                        toolCallId: "call_1",
+                        toolName: "calculate",
+                        input: JSON.stringify({ target: 999 }),
+                    },
+                ],
+                finishReason: { unified: "tool-calls", raw: undefined },
+                usage: {
+                    inputTokens: { total: 1 },
+                    outputTokens: { total: 1 },
+                },
+                warnings: [],
+            },
+        });
+        const tools = toAITools([
+            {
+                name: "calculate",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        target: { type: "number", minimum: 1000 },
+                    },
+                    required: ["target"],
+                },
+            },
+        ]);
+        const result = await generateText({
+            model,
+            prompt: "Calculate a target.",
+            tools,
+        });
+        expect(result.toolCalls).toEqual([
+            expect.objectContaining({
+                toolName: "calculate",
+                input: { target: 999 },
+                invalid: true,
+                error: expect.objectContaining({
+                    message: expect.stringContaining("minimum"),
+                }),
+            }),
+        ]);
+    });
+});
 //# sourceMappingURL=tool-mapping.test.js.map