@saltcorn/large-language-model 1.0.3 → 1.0.4

package/generate.js

@@ -18,6 +18,7 @@ const {
   streamText,
   tool,
   jsonSchema,
+  Output,
   embed,
   embedMany,
   experimental_transcribe,
@@ -518,6 +519,14 @@ const getCompletionAISDK = async (
       });
     });
   }
+  if (body.response_format?.type === "json_schema" && !body.output) {
+    body.output = Output.object({
+      schema: jsonSchema(
+        lockDownSchema(body.response_format.json_schema.schema),
+      ),
+    });
+    delete body.response_format;
+  }
 
   const debugRequest = { ...body, model: use_model_name };
   if (debugResult)
@@ -619,6 +628,17 @@ const getCompletionOpenAICompatible = async (
       if (tool.function.required) tool.required = tool.function.required;
       delete tool.function;
     }
+    if (body.response_format?.type === "json_schema" && !body.text) {
+      body.text = {
+        format: {
+          type: "json_schema",
+          name: body.response_format.json_schema.name,
+          //strict: true,
+          schema: lockDownSchema(body.response_format.json_schema.schema),
+        },
+      };
+      delete body.response_format;
+    }
     let newChat;
     if (!appendToChat) {
       newChat = [];
@@ -1148,6 +1168,99 @@ const getEmbeddingGoogleVertex = async (config, opts, oauth2Client) => {
   return embeddings;
 };
 
+function lockDownSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+
+  // Handle arrays (e.g., allOf, oneOf, anyOf, items as array)
+  if (Array.isArray(schema)) {
+    schema.forEach((item) => lockDownSchema(item));
+    return schema;
+  }
+
+  // If this subschema defines properties, lock it down
+  if (schema.properties) {
+    schema.additionalProperties = false;
+  }
+
+  // Recurse into properties
+  if (schema.properties) {
+    for (const key of Object.keys(schema.properties)) {
+      lockDownSchema(schema.properties[key]);
+    }
+  }
+
+  // Recurse into additionalProperties if it's a schema (not just a boolean)
+  if (
+    schema.additionalProperties &&
+    typeof schema.additionalProperties === "object"
+  ) {
+    lockDownSchema(schema.additionalProperties);
+  }
+
+  // Recurse into patternProperties
+  if (schema.patternProperties) {
+    for (const key of Object.keys(schema.patternProperties)) {
+      lockDownSchema(schema.patternProperties[key]);
+    }
+  }
+
+  // Recurse into composition keywords
+  for (const keyword of ["allOf", "oneOf", "anyOf"]) {
+    if (Array.isArray(schema[keyword])) {
+      schema[keyword].forEach((sub) => lockDownSchema(sub));
+    }
+  }
+
+  // Recurse into not
+  if (schema.not) {
+    lockDownSchema(schema.not);
+  }
+
+  // Recurse into if/then/else
+  for (const keyword of ["if", "then", "else"]) {
+    if (schema[keyword]) {
+      lockDownSchema(schema[keyword]);
+    }
+  }
+
+  // Recurse into items (tuple or single schema)
+  if (schema.items) {
+    if (Array.isArray(schema.items)) {
+      schema.items.forEach((item) => lockDownSchema(item));
+    } else {
+      lockDownSchema(schema.items);
+    }
+  }
+
+  // Recurse into prefixItems (Draft 2020-12)
+  if (Array.isArray(schema.prefixItems)) {
+    schema.prefixItems.forEach((item) => lockDownSchema(item));
+  }
+
+  // Recurse into $defs / definitions
+  for (const defsKey of ["$defs", "definitions"]) {
+    if (schema[defsKey]) {
+      for (const key of Object.keys(schema[defsKey])) {
+        lockDownSchema(schema[defsKey][key]);
+      }
+    }
+  }
+
+  // Recurse into dependentSchemas
+  if (schema.dependentSchemas) {
+    for (const key of Object.keys(schema.dependentSchemas)) {
+      lockDownSchema(schema.dependentSchemas[key]);
+    }
+  }
+
+  // Recurse into contains
+  if (schema.contains) {
+    lockDownSchema(schema.contains);
+  }
+
+  return schema;
+}
+
 module.exports = {
   getCompletion,
   getEmbedding,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saltcorn/large-language-model",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Large language models and functionality for Saltcorn",
   "main": "index.js",
   "dependencies": {
@@ -11,9 +11,9 @@
     "@google-cloud/vertexai": "^1.9.3",
     "@google-cloud/aiplatform": "^3.34.0",
     "googleapis": "^144.0.0",
-    "ai": "5.0.44",
-    "@ai-sdk/openai": "2.0.30",
-    "@ai-sdk/anthropic": "2.0.70",
+    "ai": "6.0.116",
+    "@ai-sdk/openai": "3.0.41",
+    "@ai-sdk/anthropic": "3.0.58",
     "openai": "6.16.0",
     "@elevenlabs/elevenlabs-js": "2.31.0"
   },

package/tests/llm.test.js

@@ -29,7 +29,6 @@ for (const nameconfig of require("./configs")) {
         config,
       );
     });
-
     it("generates text", async () => {
       const answer = await getState().functions.llm_generate.run(
         "What is the Capital of France?",
@@ -165,6 +164,28 @@ for (const nameconfig of require("./configs")) {
 
       expect(cities1.length).toBe(12);
     });
+    it("uses response_format", async () => {
+      const answer = await getState().functions.llm_generate.run(
+        "Generate a list of EU capitals in JSON format",
+        {
+          response_format: {
+            type: "json_schema",
+            json_schema: {
+              name: "cities",
+              schema: cities_tool.tools[0].function.parameters,
+            },
+          },
+        },
+      );
+      expect(typeof answer).toBe("string");
+      console.log("answer", answer);
+
+      const json_answer = JSON.parse(answer);
+
+      expect(json_answer.cities.length).toBe(27);
+      expect(!!json_answer.cities[0].city_name).toBe(true);
+      expect(!!json_answer.cities[0].country_name).toBe(true);
+    });
     if (name !== "AI SDK Anthropic")
       it("gets embedding", async () => {
         const v = await getState().functions.llm_embedding.run(
@@ -186,11 +207,13 @@ const cities_tool = {
         description: "Provide a list of cities by country and city name",
         parameters: {
           type: "object",
+          required: ["cities"],
           properties: {
             cities: {
               type: "array",
               items: {
                 type: "object",
+                additionalProperties: false,
                 properties: {
                   country_name: {
                     type: "string",