@saltcorn/large-language-model 1.0.3 → 1.0.5

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)
@@ -611,13 +620,28 @@ const getCompletionOpenAICompatible = async (
   }
   if (responses_api) {
     delete body.tool_choice;
-    for (const tool of body.tools || []) {
-      if (tool.type !== "function" || !tool.function) continue;
-      tool.name = tool.function.name;
-      tool.description = tool.function.description;
-      tool.parameters = tool.function.parameters;
-      if (tool.function.required) tool.required = tool.function.required;
-      delete tool.function;
+    if (body.tools) {
+      const newtools = JSON.parse(JSON.stringify(body.tools))
+      for (const tool of newtools) {
+        if (tool.type !== "function" || !tool.function) continue;
+        tool.name = tool.function.name;
+        tool.description = tool.function.description;
+        tool.parameters = tool.function.parameters;
+        if (tool.function.required) tool.required = tool.function.required;
+        delete tool.function;
+      }
+      body.tools = newtools
+    }
+    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) {
@@ -1148,6 +1172,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.5",
   "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"
   },
@@ -21,7 +21,7 @@
     "jest": "^29.7.0"
   },
   "scripts": {
-    "test": "jest tests --runInBand"
+    "test": "jest tests --runInBand --verbose"
   },
   "author": "Tom Nielsen",
   "license": "MIT",

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?",
@@ -98,7 +97,7 @@ for (const nameconfig of require("./configs")) {
     });
     it("uses tools", async () => {
       const answer = await getState().functions.llm_generate.run(
-        "Generate a list of EU capitals in a structured format using the provided tool",
+        "Generate a list of all the EU capitals in a structured format using the provided tool",
         cities_tool,
       );
       expect(typeof answer).toBe("object");
@@ -132,7 +131,7 @@ for (const nameconfig of require("./configs")) {
     it("tool use sequence", async () => {
       const chat = [];
       const answer = await getState().functions.llm_generate.run(
-        "Generate a list of EU capitals in a structured format using the provided tool",
+        "Generate a list of all the EU capitals in a structured format using the provided tool",
         {
           chat,
           appendToChat: true,
@@ -165,6 +164,27 @@ 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 all the 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");
+
+      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 +206,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",