Update Vercel AI SDK to support tools call (#2383)

vercel-ai-sdk/tests/mem0-provider-tests/mem0-cohere.test.ts

@@ -0,0 +1,59 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+import { createMem0, retrieveMemories } from "../../src";
+import { generateText, LanguageModelV1Prompt } from "ai";
+import { testConfig } from "../../config/test-config";
+import { createCohere } from "@ai-sdk/cohere";
+
+describe("COHERE MEM0 Tests", () => {
+  const { userId } = testConfig;
+  jest.setTimeout(30000);
+  let mem0: any;
+
+  beforeEach(() => {
+    mem0 = createMem0({
+      provider: "cohere",
+      apiKey: process.env.COHERE_API_KEY,
+      mem0Config: {
+        user_id: userId
+      }
+    });
+  });
+
+  it("should retrieve memories and generate text using COHERE provider", async () => {
+    const messages: LanguageModelV1Prompt = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Suggest me a good car to buy." },
+          { type: "text", text: " Write only the car name and it's color." },
+        ],
+      },
+    ];
+
+    
+    const { text } = await generateText({
+      // @ts-ignore
+      model: mem0("command-r-plus"),
+      messages: messages
+    });
+
+    // Expect text to be a string
+    expect(typeof text).toBe('string');
+    expect(text.length).toBeGreaterThan(0);
+  });
+
+  it("should generate text using COHERE provider with memories", async () => {
+    const prompt = "Suggest me a good car to buy.";
+
+    const { text } = await generateText({
+      // @ts-ignore
+      model: mem0("command-r-plus"),
+      prompt: prompt
+    });
+
+    expect(typeof text).toBe('string');
+    expect(text.length).toBeGreaterThan(0);
+  });
+});

vercel-ai-sdk/tests/mem0-provider-tests/mem0-groq.test.ts

@@ -0,0 +1,60 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+import { createMem0, retrieveMemories } from "../../src";
+import { generateText, LanguageModelV1Prompt } from "ai";
+import { testConfig } from "../../config/test-config";
+import { createGroq } from "@ai-sdk/groq";
+
+describe("GROQ MEM0 Tests", () => {
+  const { userId } = testConfig;
+  jest.setTimeout(30000);
+
+  let mem0: any;
+
+  beforeEach(() => {
+    mem0 = createMem0({
+      provider: "groq",
+      apiKey: process.env.GROQ_API_KEY,
+      mem0Config: {
+        user_id: userId
+      }
+    });
+  });
+
+  it("should retrieve memories and generate text using GROQ provider", async () => {
+    const messages: LanguageModelV1Prompt = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Suggest me a good car to buy." },
+          { type: "text", text: " Write only the car name and it's color." },
+        ],
+      },
+    ];
+
+    
+    const { text } = await generateText({
+      // @ts-ignore
+      model: mem0("llama3-8b-8192"),
+      messages: messages
+    });
+
+    // Expect text to be a string
+    expect(typeof text).toBe('string');
+    expect(text.length).toBeGreaterThan(0);
+  });
+
+  it("should generate text using GROQ provider with memories", async () => {
+    const prompt = "Suggest me a good car to buy.";
+
+    const { text } = await generateText({
+      // @ts-ignore
+      model: mem0("llama3-8b-8192"),
+      prompt: prompt
+    });
+
+    expect(typeof text).toBe('string');
+    expect(text.length).toBeGreaterThan(0);
+  });
+});

vercel-ai-sdk/tests/mem0-provider-tests/mem0-openai-structured-ouput.test.ts

@@ -0,0 +1,110 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+import { generateObject } from "ai";
+import { testConfig } from "../../config/test-config";
+import { z } from "zod";
+
+interface Provider {
+  name: string;
+  activeModel: string;
+  apiKey: string | undefined;
+}
+
+const provider: Provider = {
+  name: "openai",
+  activeModel: "gpt-4-turbo",
+  apiKey: process.env.OPENAI_API_KEY,
+}
+describe("OPENAI Structured Outputs", () => {
+  const { userId } = testConfig;
+  let mem0: ReturnType<typeof testConfig.createTestClient>;
+  jest.setTimeout(30000);
+
+  beforeEach(() => {
+    mem0 = testConfig.createTestClient(provider);
+  });
+
+  describe("openai Object Generation Tests", () => {
+    // Test 1: Generate a car preference object
+    it("should generate a car preference object with name and steps", async () => {
+      const { object } = await generateObject({
+        model: mem0(provider.activeModel, {
+          user_id: userId,
+        }),
+        schema: z.object({
+          car: z.object({
+            name: z.string(),
+            steps: z.array(z.string()),
+          }),
+        }),
+        prompt: "Which car would I like?",
+      });
+
+      expect(object.car).toBeDefined();
+      expect(typeof object.car.name).toBe("string");
+      expect(Array.isArray(object.car.steps)).toBe(true);
+      expect(object.car.steps.every((step) => typeof step === "string")).toBe(true);
+    });
+
+    // Test 2: Generate an array of car objects
+    it("should generate an array of three car objects with name, class, and description", async () => {
+      const { object } = await generateObject({
+        model: mem0(provider.activeModel, {
+          user_id: userId,
+        }),
+        output: "array",
+        schema: z.object({
+          name: z.string(),
+          class: z.string().describe('Cars should be "SUV", "Sedan", or "Hatchback"'),
+          description: z.string(),
+        }),
+        prompt: "Write name of three cars that I would like.",
+      });
+
+      expect(Array.isArray(object)).toBe(true);
+      expect(object.length).toBe(3);
+      object.forEach((car) => {
+        expect(car).toHaveProperty("name");
+        expect(typeof car.name).toBe("string");
+        expect(car).toHaveProperty("class");
+        expect(typeof car.class).toBe("string");
+        expect(car).toHaveProperty("description");
+        expect(typeof car.description).toBe("string");
+      });
+    });
+
+    // Test 3: Generate an enum for movie genre classification
+    it("should classify the genre of a movie plot", async () => {
+      const { object } = await generateObject({
+        model: mem0(provider.activeModel, {
+          user_id: userId,
+        }),
+        output: "enum",
+        enum: ["action", "comedy", "drama", "horror", "sci-fi"],
+        prompt: 'Classify the genre of this movie plot: "A group of astronauts travel through a wormhole in search of a new habitable planet for humanity."',
+      });
+
+      expect(object).toBeDefined();
+      expect(object).toBe("sci-fi");
+    });
+
+    // Test 4: Generate an object of car names without schema
+    it("should generate an object with car names", async () => {
+      const { object } = await generateObject({
+        model: mem0(provider.activeModel, {
+          user_id: userId,
+        }),
+        output: "no-schema",
+        prompt: "Write name of 3 cars that I would like.",
+      });
+
+      const carObject = object as { cars: string[] };
+
+      expect(carObject).toBeDefined();
+      expect(Array.isArray(carObject.cars)).toBe(true);
+      expect(carObject.cars.length).toBe(3);
+      expect(carObject.cars.every((car) => typeof car === "string")).toBe(true);
+    });
+  });
+});

vercel-ai-sdk/tests/mem0-provider-tests/mem0-openai.test.ts

@@ -0,0 +1,55 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+import { createMem0 } from "../../src";
+import { generateText, LanguageModelV1Prompt } from "ai";
+import { testConfig } from "../../config/test-config";
+
+describe("OPENAI MEM0 Tests", () => {
+  const { userId } = testConfig;
+  jest.setTimeout(30000);
+  let mem0: any;
+
+  beforeEach(() => {
+    mem0 = createMem0({
+      provider: "openai",
+      apiKey: process.env.OPENAI_API_KEY,
+      mem0Config: {
+        user_id: userId
+      }
+    });
+  });
+
+  it("should retrieve memories and generate text using Mem0 OpenAI provider", async () => {
+    const messages: LanguageModelV1Prompt = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Suggest me a good car to buy." },
+          { type: "text", text: " Write only the car name and it's color." },
+        ],
+      },
+    ];
+    
+    const { text } = await generateText({
+      model: mem0("gpt-4-turbo"),
+      messages: messages
+    });
+
+    // Expect text to be a string
+    expect(typeof text).toBe('string');
+    expect(text.length).toBeGreaterThan(0);
+  });
+
+  it("should generate text using openai provider with memories", async () => {
+    const prompt = "Suggest me a good car to buy.";
+
+    const { text } = await generateText({
+      model: mem0("gpt-4-turbo"),
+      prompt: prompt
+    });
+
+    expect(typeof text).toBe('string');
+    expect(text.length).toBeGreaterThan(0);
+  });
+});

vercel-ai-sdk/tests/mem0-provider-tests/mem0_anthropic.test.ts

@@ -0,0 +1,59 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+import { createMem0, retrieveMemories } from "../../src";
+import { generateText, LanguageModelV1Prompt } from "ai";
+import { testConfig } from "../../config/test-config";
+import { createAnthropic } from "@ai-sdk/anthropic";
+
+describe("ANTHROPIC MEM0 Tests", () => {
+  const { userId } = testConfig;
+  jest.setTimeout(30000);
+
+  let mem0: any;
+
+  beforeEach(() => {
+    mem0 = createMem0({
+      provider: "anthropic",
+      apiKey: process.env.ANTHROPIC_API_KEY,
+      mem0Config: {
+        user_id: userId
+      }
+    });
+  });
+
+  it("should retrieve memories and generate text using ANTHROPIC provider", async () => {
+    const messages: LanguageModelV1Prompt = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Suggest me a good car to buy." },
+          { type: "text", text: " Write only the car name and it's color." },
+        ],
+      },
+    ];
+    
+    const { text } = await generateText({
+      // @ts-ignore
+      model: mem0("claude-3-haiku-20240307"),
+      messages: messages,
+    });
+
+    // Expect text to be a string
+    expect(typeof text).toBe('string');
+    expect(text.length).toBeGreaterThan(0);
+  });
+
+  it("should generate text using ANTHROPIC provider with memories", async () => {
+    const prompt = "Suggest me a good car to buy.";
+
+    const { text } = await generateText({
+      // @ts-ignore
+      model: mem0("claude-3-haiku-20240307"),
+      prompt: prompt,
+    });
+
+    expect(typeof text).toBe('string');
+    expect(text.length).toBeGreaterThan(0);
+  });
+});