@saltcorn/large-language-model 1.0.2 → 1.0.4

package/generate.js

@@ -18,6 +18,7 @@ const {
   streamText,
   tool,
   jsonSchema,
+  Output,
   embed,
   embedMany,
   experimental_transcribe,
@@ -423,17 +424,20 @@ const getCompletion = async (config, opts) => {
   }
 };
 
-const getAiSdkModel = ({
-  provider,
-  api_key,
-  model_name,
-  anthropic_api_key,
-}) => {
+const getAiSdkModel = (
+  { provider, api_key, model_name, anthropic_api_key },
+  isEmbedding,
+) => {
   switch (provider) {
     case "OpenAI":
       const openai = createOpenAI({ apiKey: api_key });
-      return openai(model_name);
+      return isEmbedding
+        ? openai.textEmbeddingModel(model_name)
+        : openai(model_name);
+
     case "Anthropic":
+      if (isEmbedding)
+        throw new Error("Anthropic does not provide embedding models");
       const anthropic = createAnthropic({
         apiKey: anthropic_api_key,
       });
@@ -515,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)
@@ -616,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 = [];
@@ -949,19 +972,17 @@ const getEmbeddingOpenAICompatible = async (
 
 const getEmbeddingAISDK = async (config, { prompt, model, debugResult }) => {
   const { provider, apiKey, embed_model } = config;
-  let model_obj,
-    providerOptions = {};
-  const model_name = model || embed_model;
-
-  switch (provider) {
-    case "OpenAI":
-      const openai = createOpenAI({ apiKey: apiKey });
-      model_obj = openai.textEmbeddingModel(
-        model_name || "text-embedding-3-small",
-      );
-      //providerOptions.openai = {};
-      break;
-  }
+  let providerOptions = {};
+  const model_name = model || embed_model || "text-embedding-3-small";
+  let model_obj = getAiSdkModel(
+    {
+      ...config,
+      model_name,
+      api_key: apiKey,
+      provider,
+    },
+    true,
+  );
   const body = {
     model: model_obj,
     providerOptions,
@@ -1147,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/index.js

@@ -126,7 +126,7 @@ ${domReady(`
                 label: "Embedding model", //gpt-3.5-turbo
                 type: "String",
                 required: true,
-                showIf: { backend: "AI SDK" },
+                showIf: { backend: "AI SDK", ai_sdk_provider: ["OpenAI"] },
                 attributes: {
                   calcOptions: [
                     "ai_sdk_provider",
@@ -136,14 +136,6 @@ ${domReady(`
                         "text-embedding-3-large",
                         "text-embedding-ada-002",
                       ],
-                      Anthropic: [
-                        "voyage-3-large",
-                        "voyage-3",
-                        "voyage-3-lite",
-                        "voyage-code-3",
-                        "voyage-finance-2",
-                        "voyage-law-2",
-                      ],
                     },
                   ],
                 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saltcorn/large-language-model",
-  "version": "1.0.2",
+  "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/configs.js

@@ -36,7 +36,6 @@ module.exports = [
     model: "claude-sonnet-4-6",
     api_key: process.env.ANTHROPIC_API_KEY,
     backend: "AI SDK",
-    embed_model: "text-embedding-3-small",
     image_model: "gpt-image-1",
     temperature: 0.7,
     ai_sdk_provider: "Anthropic",

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,37 @@ 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(
+          "The quick brown fox jumps over the lazy dog",
+        );
+        expect(Array.isArray(v)).toBe(true);
+        expect(v.length).toBeGreaterThan(50);
+        expect(typeof v[0]).toBe("number");
+      });
   });
 }
 
@@ -177,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",