klas/t6_mem0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(ai-sdk): Added Support for Google Provider in AI SDK (#2771)

Browse Source
This commit is contained in:
Saket Aryan
2025-05-23 00:37:58 +05:30
committed by GitHub
parent 816039036d
commit d21970efcc
7 changed files with 172 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
docs/changelog.mdx
View File

@@ -288,7 +288,7 @@ mode: "wide"
<Tab title="TypeScript">
<Update label="2025-05-08" description="v2.1.25">
<Update label="2025-05-23" description="v2.1.26">
**Improvements:**
- **Client:** Removed type `string` from `messages` interface
</Update>
@@ -669,6 +669,11 @@ mode: "wide"
<Tab title="Vercel AI SDK">
<Update label="2025-05-23" description="v1.0.5">
**New Features:**
- **Vercel AI SDK:** Added support for Google provider.
</Update>
<Update label="2025-05-10" description="v1.0.4">
**New Features:**
- **Vercel AI SDK:** Added support for new param `output_format`.

2
vercel-ai-sdk/src/mem0-provider-selector.ts
View File

@@ -7,7 +7,7 @@ class Mem0ClassSelector {
provider_wrapper: string;
config: Mem0ProviderSettings;
provider_config?: ProviderSettings;
static supportedProviders = ["openai", "anthropic", "cohere", "groq"];
static supportedProviders = ["openai", "anthropic", "cohere", "groq", "google"];
constructor(modelId: string, config: Mem0ProviderSettings, provider_config?: ProviderSettings) {
this.modelId = modelId;

104
vercel-ai-sdk/src/provider-response-provider.ts
View File

@@ -1,104 +1,82 @@
import { LanguageModelV1, LanguageModelV1CallOptions, LanguageModelV1Prompt } from "ai";
import { LanguageModelV1, LanguageModelV1CallOptions } from "ai";
import { Mem0ProviderSettings } from "./mem0-provider";
import { createOpenAI, OpenAIProviderSettings } from "@ai-sdk/openai";
import { CohereProviderSettings, createCohere } from "@ai-sdk/cohere";
import { AnthropicProviderSettings, createAnthropic } from "@ai-sdk/anthropic";
import { createGoogleGenerativeAI, GoogleGenerativeAIProviderSettings } from "@ai-sdk/google";
import { createGroq, GroqProviderSettings } from "@ai-sdk/groq";
export type Provider = ReturnType<typeof createOpenAI> | ReturnType<typeof createCohere> | ReturnType<typeof createAnthropic> | ReturnType<typeof createGroq> | any;
export type ProviderSettings = OpenAIProviderSettings | CohereProviderSettings | AnthropicProviderSettings | GroqProviderSettings;
const convertMessagesToMem0Format = (messages: LanguageModelV1Prompt) => {
return messages.map((message) => {
// If the content is a string, return it as is
if (typeof message.content === "string") {
return message;
}
// Flatten the content array into a single string
if (Array.isArray(message.content)) {
message.content = message.content
.map((contentItem) => {
if ("text" in contentItem) {
return contentItem.text;
}
return "";
})
.join(" ");
}
const contentText = message.content;
return {
role: message.role,
content: contentText,
};
});
}
// Define a private provider field
class Mem0AITextGenerator implements LanguageModelV1 {
readonly specificationVersion = "v1";
readonly defaultObjectGenerationMode = "json";
readonly supportsImageUrls = false;
readonly modelId: string;
readonly provider = "mem0";
provider: Provider;
provider_config?: ProviderSettings;
config: Mem0ProviderSettings;
private languageModel: any; // Use any type to avoid version conflicts
constructor(modelId: string, config: Mem0ProviderSettings, provider_config: ProviderSettings) {
this.modelId = modelId;
switch (config.provider) {
case "openai":
this.provider = createOpenAI({
apiKey: config?.apiKey,
...provider_config,
}).languageModel;
if(config?.modelType === "completion"){
this.provider = createOpenAI({
this.languageModel = createOpenAI({
apiKey: config?.apiKey,
...provider_config,
}).completion;
}else if(config?.modelType === "chat"){
this.provider = createOpenAI({
...provider_config as OpenAIProviderSettings,
}).completion(modelId);
} else if(config?.modelType === "chat"){
this.languageModel = createOpenAI({
apiKey: config?.apiKey,
...provider_config,
}).chat;
...provider_config as OpenAIProviderSettings,
}).chat(modelId);
} else {
this.languageModel = createOpenAI({
apiKey: config?.apiKey,
...provider_config as OpenAIProviderSettings,
}).languageModel(modelId);
}
break;
case "cohere":
this.provider = createCohere({
this.languageModel = createCohere({
apiKey: config?.apiKey,
...provider_config,
});
...provider_config as CohereProviderSettings,
})(modelId);
break;
case "anthropic":
this.provider = createAnthropic({
this.languageModel = createAnthropic({
apiKey: config?.apiKey,
...provider_config,
}).languageModel;
...provider_config as AnthropicProviderSettings,
}).languageModel(modelId);
break;
case "groq":
this.provider = createGroq({
this.languageModel = createGroq({
apiKey: config?.apiKey,
...provider_config,
});
...provider_config as GroqProviderSettings,
})(modelId);
break;
case "google":
this.languageModel = createGoogleGenerativeAI({
apiKey: config?.apiKey,
...provider_config as GoogleGenerativeAIProviderSettings,
})(modelId);
break;
default:
throw new Error("Invalid provider");
}
this.modelId = modelId;
this.provider_config = provider_config;
this.config = config!;
}
doGenerate(options: LanguageModelV1CallOptions): Promise<Awaited<ReturnType<LanguageModelV1['doGenerate']>>> {
return this.provider(this.modelId, this.provider_config).doGenerate(options);
async doGenerate(options: LanguageModelV1CallOptions): Promise<Awaited<ReturnType<LanguageModelV1['doGenerate']>>> {
const result = await this.languageModel.doGenerate(options);
return result as Awaited<ReturnType<LanguageModelV1['doGenerate']>>;
}
doStream(options: LanguageModelV1CallOptions): Promise<Awaited<ReturnType<LanguageModelV1['doStream']>>> {
return this.provider(this.modelId, this.provider_config).doStream(options);
async doStream(options: LanguageModelV1CallOptions): Promise<Awaited<ReturnType<LanguageModelV1['doStream']>>> {
const result = await this.languageModel.doStream(options);
return result as Awaited<ReturnType<LanguageModelV1['doStream']>>;
}
}
export type ProviderSettings = OpenAIProviderSettings | CohereProviderSettings | AnthropicProviderSettings | GroqProviderSettings | GoogleGenerativeAIProviderSettings;
export default Mem0AITextGenerator;

58
vercel-ai-sdk/tests/mem0-provider-tests/mem0-google.test.ts Normal file
View File

@@ -0,0 +1,58 @@
import dotenv from "dotenv";
dotenv.config();
import { createMem0 } from "../../src";
import { generateText, LanguageModelV1Prompt } from "ai";
import { testConfig } from "../../config/test-config";
describe("GOOGLE MEM0 Tests", () => {
const { userId } = testConfig;
jest.setTimeout(50000);
let mem0: any;
beforeEach(() => {
mem0 = createMem0({
provider: "google",
apiKey: process.env.GOOGLE_API_KEY,
mem0Config: {
user_id: userId
}
});
});
it("should retrieve memories and generate text using Google 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("gemini-2.5-pro-preview-05-06"),
messages: messages
});
// Expect text to be a string
expect(typeof text).toBe('string');
expect(text.length).toBeGreaterThan(0);
});
it("should generate text using Google provider with memories", async () => {
const prompt = "Suggest me a good car to buy.";
const { text } = await generateText({
// @ts-ignore
model: mem0("gemini-2.5-pro-preview-05-06"),
prompt: prompt
});
expect(typeof text).toBe('string');
expect(text.length).toBeGreaterThan(0);
});
});

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

@@ -102,7 +102,7 @@ describe("OPENAI Structured Outputs", () => {
const carObject = object as { cars: string[] };
expect(carObject).toBeDefined();
expect(Array.isArray(carObject.cars)).toBe(true);
expect(typeof carObject.cars).toBe("object");
expect(carObject.cars.length).toBe(3);
expect(carObject.cars.every((car) => typeof car === "string")).toBe(true);
});

13
vercel-ai-sdk/tests/text-properties.test.ts
View File

@@ -18,7 +18,7 @@ describe.each(testConfig.providers)('TEXT/STREAM PROPERTIES: Tests with model %s
it("should stream text with onChunk handler", async () => {
const chunkTexts: string[] = [];
const { textStream } = await streamText({
const { textStream } = streamText({
model: mem0(provider.activeModel, {
user_id: userId, // Use the uniform userId
}),
@@ -57,7 +57,9 @@ describe.each(testConfig.providers)('TEXT/STREAM PROPERTIES: Tests with model %s
text, // combined text
usage, // combined usage of all steps
} = await generateText({
model: mem0.completion(provider.activeModel), // Ensure the model name is correct
model: mem0.completion(provider.activeModel, {
user_id: userId,
}), // Ensure the model name is correct
maxSteps: 5, // Enable multi-step calls
experimental_continueSteps: true,
prompt:
@@ -68,10 +70,9 @@ describe.each(testConfig.providers)('TEXT/STREAM PROPERTIES: Tests with model %s
expect(typeof text).toBe("string");
// Check usage
// promptTokens is a number, so we use toBeCloseTo instead of toBe and it should be in the range 155 to 165
expect(usage.promptTokens).toBeGreaterThanOrEqual(100);
expect(usage.promptTokens).toBeGreaterThanOrEqual(10);
expect(usage.promptTokens).toBeLessThanOrEqual(500);
expect(usage.completionTokens).toBeGreaterThanOrEqual(250); // Check completion tokens are above 250
expect(usage.totalTokens).toBeGreaterThan(400); // Check total tokens are above 400
expect(usage.completionTokens).toBeGreaterThanOrEqual(10);
expect(usage.totalTokens).toBeGreaterThan(10);
});
});

58
vercel-ai-sdk/tests/utils-test/google-integration.test.ts Normal file
View File

@@ -0,0 +1,58 @@
import dotenv from "dotenv";
dotenv.config();
import { retrieveMemories } from "../../src";
import { generateText, LanguageModelV1Prompt } from "ai";
import { testConfig } from "../../config/test-config";
import { createGoogleGenerativeAI } from "@ai-sdk/google";
describe("GOOGLE Integration Tests", () => {
const { userId } = testConfig;
jest.setTimeout(30000);
let google: any;
beforeEach(() => {
google = createGoogleGenerativeAI({
apiKey: process.env.GOOGLE_API_KEY,
});
});
it("should retrieve memories and generate text using Google 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." },
],
},
];
// Retrieve memories based on previous messages
const memories = await retrieveMemories(messages, { user_id: userId });
const { text } = await generateText({
model: google("gemini-2.5-pro-preview-05-06"),
messages: messages,
system: memories,
});
// Expect text to be a string
expect(typeof text).toBe('string');
expect(text.length).toBeGreaterThan(0);
});
it("should generate text using Google provider with memories", async () => {
const prompt = "Suggest me a good car to buy.";
const memories = await retrieveMemories(prompt, { user_id: userId });
const { text } = await generateText({
model: google("gemini-2.5-pro-preview-05-06"),
prompt: prompt,
system: memories
});
expect(typeof text).toBe('string');
expect(text.length).toBeGreaterThan(0);
});
});