@ai-sdk/google 3.0.12 → 3.0.13

package/src/convert-to-google-generative-ai-messages.test.ts

@@ -1,495 +0,0 @@
-import { convertToGoogleGenerativeAIMessages } from './convert-to-google-generative-ai-messages';
-import { describe, it, expect } from 'vitest';
-
-describe('system messages', () => {
-  it('should store system message in system instruction', async () => {
-    const result = convertToGoogleGenerativeAIMessages([
-      { role: 'system', content: 'Test' },
-    ]);
-
-    expect(result).toEqual({
-      systemInstruction: { parts: [{ text: 'Test' }] },
-      contents: [],
-    });
-  });
-
-  it('should throw error when there was already a user message', async () => {
-    expect(() =>
-      convertToGoogleGenerativeAIMessages([
-        { role: 'user', content: [{ type: 'text', text: 'Test' }] },
-        { role: 'system', content: 'Test' },
-      ]),
-    ).toThrow(
-      'system messages are only supported at the beginning of the conversation',
-    );
-  });
-});
-
-describe('thought signatures', () => {
-  it('should preserve thought signatures in assistant messages', async () => {
-    const result = convertToGoogleGenerativeAIMessages([
-      {
-        role: 'assistant',
-        content: [
-          {
-            type: 'text',
-            text: 'Regular text',
-            providerOptions: { google: { thoughtSignature: 'sig1' } },
-          },
-          {
-            type: 'reasoning',
-            text: 'Reasoning text',
-            providerOptions: { google: { thoughtSignature: 'sig2' } },
-          },
-          {
-            type: 'tool-call',
-            toolCallId: 'call1',
-            toolName: 'test',
-            input: { value: 'test' },
-            providerOptions: { google: { thoughtSignature: 'sig3' } },
-          },
-        ],
-      },
-    ]);
-
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "contents": [
-          {
-            "parts": [
-              {
-                "text": "Regular text",
-                "thoughtSignature": "sig1",
-              },
-              {
-                "text": "Reasoning text",
-                "thought": true,
-                "thoughtSignature": "sig2",
-              },
-              {
-                "functionCall": {
-                  "args": {
-                    "value": "test",
-                  },
-                  "name": "test",
-                },
-                "thoughtSignature": "sig3",
-              },
-            ],
-            "role": "model",
-          },
-        ],
-        "systemInstruction": undefined,
-      }
-    `);
-  });
-});
-
-describe('Gemma model system instructions', () => {
-  it('should prepend system instruction to first user message for Gemma models', async () => {
-    const result = convertToGoogleGenerativeAIMessages(
-      [
-        { role: 'system', content: 'You are a helpful assistant.' },
-        { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
-      ],
-      { isGemmaModel: true },
-    );
-
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "contents": [
-          {
-            "parts": [
-              {
-                "text": "You are a helpful assistant.
-
-      ",
-              },
-              {
-                "text": "Hello",
-              },
-            ],
-            "role": "user",
-          },
-        ],
-        "systemInstruction": undefined,
-      }
-    `);
-  });
-
-  it('should handle multiple system messages for Gemma models', async () => {
-    const result = convertToGoogleGenerativeAIMessages(
-      [
-        { role: 'system', content: 'You are helpful.' },
-        { role: 'system', content: 'Be concise.' },
-        { role: 'user', content: [{ type: 'text', text: 'Hi' }] },
-      ],
-      { isGemmaModel: true },
-    );
-
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "contents": [
-          {
-            "parts": [
-              {
-                "text": "You are helpful.
-
-      Be concise.
-
-      ",
-              },
-              {
-                "text": "Hi",
-              },
-            ],
-            "role": "user",
-          },
-        ],
-        "systemInstruction": undefined,
-      }
-    `);
-  });
-
-  it('should not affect non-Gemma models', async () => {
-    const result = convertToGoogleGenerativeAIMessages(
-      [
-        { role: 'system', content: 'You are helpful.' },
-        { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
-      ],
-      { isGemmaModel: false },
-    );
-
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "contents": [
-          {
-            "parts": [
-              {
-                "text": "Hello",
-              },
-            ],
-            "role": "user",
-          },
-        ],
-        "systemInstruction": {
-          "parts": [
-            {
-              "text": "You are helpful.",
-            },
-          ],
-        },
-      }
-    `);
-  });
-
-  it('should handle Gemma model with system instruction but no user messages', async () => {
-    const result = convertToGoogleGenerativeAIMessages(
-      [{ role: 'system', content: 'You are helpful.' }],
-      { isGemmaModel: true },
-    );
-
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "contents": [],
-        "systemInstruction": undefined,
-      }
-    `);
-  });
-});
-
-describe('user messages', () => {
-  it('should add image parts', async () => {
-    const result = convertToGoogleGenerativeAIMessages([
-      {
-        role: 'user',
-        content: [
-          {
-            type: 'file',
-            data: 'AAECAw==',
-            mediaType: 'image/png',
-          },
-        ],
-      },
-    ]);
-
-    expect(result).toEqual({
-      systemInstruction: undefined,
-      contents: [
-        {
-          role: 'user',
-          parts: [
-            {
-              inlineData: {
-                data: 'AAECAw==',
-                mimeType: 'image/png',
-              },
-            },
-          ],
-        },
-      ],
-    });
-  });
-
-  it('should add file parts for base64 encoded files', async () => {
-    const result = convertToGoogleGenerativeAIMessages([
-      {
-        role: 'user',
-        content: [{ type: 'file', data: 'AAECAw==', mediaType: 'image/png' }],
-      },
-    ]);
-
-    expect(result).toEqual({
-      systemInstruction: undefined,
-      contents: [
-        {
-          role: 'user',
-          parts: [
-            {
-              inlineData: {
-                data: 'AAECAw==',
-                mimeType: 'image/png',
-              },
-            },
-          ],
-        },
-      ],
-    });
-  });
-});
-
-describe('tool messages', () => {
-  it('should convert tool result messages to function responses', async () => {
-    const result = convertToGoogleGenerativeAIMessages([
-      {
-        role: 'tool',
-        content: [
-          {
-            type: 'tool-result',
-            toolName: 'testFunction',
-            toolCallId: 'testCallId',
-            output: { type: 'json', value: { someData: 'test result' } },
-          },
-        ],
-      },
-    ]);
-
-    expect(result).toEqual({
-      systemInstruction: undefined,
-      contents: [
-        {
-          role: 'user',
-          parts: [
-            {
-              functionResponse: {
-                name: 'testFunction',
-                response: {
-                  name: 'testFunction',
-                  content: { someData: 'test result' },
-                },
-              },
-            },
-          ],
-        },
-      ],
-    });
-  });
-});
-
-describe('assistant messages', () => {
-  it('should add PNG image parts for base64 encoded files', async () => {
-    const result = convertToGoogleGenerativeAIMessages([
-      {
-        role: 'assistant',
-        content: [{ type: 'file', data: 'AAECAw==', mediaType: 'image/png' }],
-      },
-    ]);
-
-    expect(result).toEqual({
-      systemInstruction: undefined,
-      contents: [
-        {
-          role: 'model',
-          parts: [
-            {
-              inlineData: {
-                data: 'AAECAw==',
-                mimeType: 'image/png',
-              },
-            },
-          ],
-        },
-      ],
-    });
-  });
-
-  it('should throw error for URL file data in assistant messages', async () => {
-    expect(() =>
-      convertToGoogleGenerativeAIMessages([
-        {
-          role: 'assistant',
-          content: [
-            {
-              type: 'file',
-              data: new URL('https://example.com/image.png'),
-              mediaType: 'image/png',
-            },
-          ],
-        },
-      ]),
-    ).toThrow('File data URLs in assistant messages are not supported');
-  });
-
-  it('should convert tool result messages with content type (multipart with images)', async () => {
-    const result = convertToGoogleGenerativeAIMessages([
-      {
-        role: 'tool',
-        content: [
-          {
-            type: 'tool-result',
-            toolName: 'imageGenerator',
-            toolCallId: 'testCallId',
-            output: {
-              type: 'content',
-              value: [
-                {
-                  type: 'text',
-                  text: 'Here is the generated image:',
-                },
-                {
-                  type: 'image-data',
-                  data: 'base64encodedimagedata',
-                  mediaType: 'image/jpeg',
-                },
-              ],
-            },
-          },
-        ],
-      },
-    ]);
-
-    expect(result).toEqual({
-      systemInstruction: undefined,
-      contents: [
-        {
-          role: 'user',
-          parts: [
-            {
-              functionResponse: {
-                name: 'imageGenerator',
-                response: {
-                  name: 'imageGenerator',
-                  content: 'Here is the generated image:',
-                },
-              },
-            },
-            {
-              inlineData: {
-                mimeType: 'image/jpeg',
-                data: 'base64encodedimagedata',
-              },
-            },
-            {
-              text: 'Tool executed successfully and returned this image as a response',
-            },
-          ],
-        },
-      ],
-    });
-  });
-});
-
-describe('parallel tool calls', () => {
-  it('should include thought signature on functionCall when provided', async () => {
-    const result = convertToGoogleGenerativeAIMessages([
-      {
-        role: 'assistant',
-        content: [
-          {
-            type: 'tool-call',
-            toolCallId: 'call1',
-            toolName: 'checkweather',
-            input: { city: 'paris' },
-            providerOptions: { google: { thoughtSignature: 'sig_parallel' } },
-          },
-          {
-            type: 'tool-call',
-            toolCallId: 'call2',
-            toolName: 'checkweather',
-            input: { city: 'london' },
-          },
-        ],
-      },
-    ]);
-
-    expect(result.contents[0].parts[0]).toEqual({
-      functionCall: {
-        args: { city: 'paris' },
-        name: 'checkweather',
-      },
-      thoughtSignature: 'sig_parallel',
-    });
-
-    expect(result.contents[0].parts[1]).toEqual({
-      functionCall: {
-        args: { city: 'london' },
-        name: 'checkweather',
-      },
-      thoughtSignature: undefined,
-    });
-  });
-});
-
-describe('tool results with thought signatures', () => {
-  it('should include thought signature on functionCall but not on functionResponse', async () => {
-    const result = convertToGoogleGenerativeAIMessages([
-      {
-        role: 'assistant',
-        content: [
-          {
-            type: 'tool-call',
-            toolCallId: 'call1',
-            toolName: 'readdata',
-            input: { userId: '123' },
-            providerOptions: { google: { thoughtSignature: 'sig_original' } },
-          },
-        ],
-      },
-      {
-        role: 'tool',
-        content: [
-          {
-            type: 'tool-result',
-            toolCallId: 'call1',
-            toolName: 'readdata',
-            output: {
-              type: 'error-text',
-              value: 'file not found',
-            },
-            providerOptions: { google: { thoughtSignature: 'sig_original' } },
-          },
-        ],
-      },
-    ]);
-
-    expect(result.contents[0].parts[0]).toEqual({
-      functionCall: {
-        args: { userId: '123' },
-        name: 'readdata',
-      },
-      thoughtSignature: 'sig_original',
-    });
-
-    expect(result.contents[1].parts[0]).toEqual({
-      functionResponse: {
-        name: 'readdata',
-        response: {
-          content: 'file not found',
-          name: 'readdata',
-        },
-      },
-    });
-
-    expect(result.contents[1].parts[0]).not.toHaveProperty('thoughtSignature');
-  });
-});

package/src/get-model-path.test.ts

@@ -1,16 +0,0 @@
-import { getModelPath } from './get-model-path';
-import { it, expect } from 'vitest';
-
-it('should pass through model path for models/*', async () => {
-  expect(getModelPath('models/some-model')).toEqual('models/some-model');
-});
-
-it('should pass through model path for tunedModels/*', async () => {
-  expect(getModelPath('tunedModels/some-model')).toEqual(
-    'tunedModels/some-model',
-  );
-});
-
-it('should add model path prefix to models without slash', async () => {
-  expect(getModelPath('some-model')).toEqual('models/some-model');
-});

package/src/google-generative-ai-embedding-model.test.ts

@@ -1,204 +0,0 @@
-import { EmbeddingModelV3Embedding } from '@ai-sdk/provider';
-import { createTestServer } from '@ai-sdk/test-server/with-vitest';
-import { GoogleGenerativeAIEmbeddingModel } from './google-generative-ai-embedding-model';
-import { createGoogleGenerativeAI } from './google-provider';
-import { describe, it, expect, vi } from 'vitest';
-
-vi.mock('./version', () => ({
-  VERSION: '0.0.0-test',
-}));
-
-const dummyEmbeddings = [
-  [0.1, 0.2, 0.3, 0.4, 0.5],
-  [0.6, 0.7, 0.8, 0.9, 1.0],
-];
-const testValues = ['sunny day at the beach', 'rainy day in the city'];
-
-const provider = createGoogleGenerativeAI({ apiKey: 'test-api-key' });
-const model = provider.embeddingModel('gemini-embedding-001');
-
-const URL =
-  'https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:something';
-
-const server = createTestServer({
-  [URL]: {},
-});
-
-describe('GoogleGenerativeAIEmbeddingModel', () => {
-  function prepareBatchJsonResponse({
-    embeddings = dummyEmbeddings,
-    headers,
-  }: {
-    embeddings?: EmbeddingModelV3Embedding[];
-    headers?: Record<string, string>;
-  } = {}) {
-    server.urls[URL].response = {
-      type: 'json-value',
-      headers,
-      body: {
-        embeddings: embeddings.map(embedding => ({ values: embedding })),
-      },
-    };
-  }
-
-  function prepareSingleJsonResponse({
-    embeddings = dummyEmbeddings,
-    headers,
-  }: {
-    embeddings?: EmbeddingModelV3Embedding[];
-    headers?: Record<string, string>;
-  } = {}) {
-    server.urls[URL].response = {
-      type: 'json-value',
-      headers,
-      body: {
-        embedding: { values: embeddings[0] },
-      },
-    };
-  }
-
-  it('should extract embedding', async () => {
-    prepareBatchJsonResponse();
-
-    const { embeddings } = await model.doEmbed({ values: testValues });
-
-    expect(embeddings).toStrictEqual(dummyEmbeddings);
-  });
-
-  it('should expose the raw response', async () => {
-    prepareBatchJsonResponse({
-      headers: {
-        'test-header': 'test-value',
-      },
-    });
-
-    const { response } = await model.doEmbed({ values: testValues });
-
-    expect(response?.headers).toStrictEqual({
-      // default headers:
-      'content-length': '80',
-      'content-type': 'application/json',
-
-      // custom header
-      'test-header': 'test-value',
-    });
-    expect(response).toMatchSnapshot();
-  });
-
-  it('should pass the model and the values', async () => {
-    prepareBatchJsonResponse();
-
-    await model.doEmbed({ values: testValues });
-
-    expect(await server.calls[0].requestBodyJson).toStrictEqual({
-      requests: testValues.map(value => ({
-        model: 'models/gemini-embedding-001',
-        content: { role: 'user', parts: [{ text: value }] },
-      })),
-    });
-  });
-
-  it('should pass the outputDimensionality setting', async () => {
-    prepareBatchJsonResponse();
-
-    await provider.embedding('gemini-embedding-001').doEmbed({
-      values: testValues,
-      providerOptions: {
-        google: { outputDimensionality: 64 },
-      },
-    });
-
-    expect(await server.calls[0].requestBodyJson).toStrictEqual({
-      requests: testValues.map(value => ({
-        model: 'models/gemini-embedding-001',
-        content: { role: 'user', parts: [{ text: value }] },
-        outputDimensionality: 64,
-      })),
-    });
-  });
-
-  it('should pass the taskType setting', async () => {
-    prepareBatchJsonResponse();
-
-    await provider.embedding('gemini-embedding-001').doEmbed({
-      values: testValues,
-      providerOptions: { google: { taskType: 'SEMANTIC_SIMILARITY' } },
-    });
-
-    expect(await server.calls[0].requestBodyJson).toStrictEqual({
-      requests: testValues.map(value => ({
-        model: 'models/gemini-embedding-001',
-        content: { role: 'user', parts: [{ text: value }] },
-        taskType: 'SEMANTIC_SIMILARITY',
-      })),
-    });
-  });
-
-  it('should pass headers', async () => {
-    prepareBatchJsonResponse();
-
-    const provider = createGoogleGenerativeAI({
-      apiKey: 'test-api-key',
-      headers: {
-        'Custom-Provider-Header': 'provider-header-value',
-      },
-    });
-
-    await provider.embedding('gemini-embedding-001').doEmbed({
-      values: testValues,
-      headers: {
-        'Custom-Request-Header': 'request-header-value',
-      },
-    });
-
-    expect(server.calls[0].requestHeaders).toStrictEqual({
-      'x-goog-api-key': 'test-api-key',
-      'content-type': 'application/json',
-      'custom-provider-header': 'provider-header-value',
-      'custom-request-header': 'request-header-value',
-    });
-    expect(server.calls[0].requestUserAgent).toContain(
-      `ai-sdk/google/0.0.0-test`,
-    );
-  });
-
-  it('should throw an error if too many values are provided', async () => {
-    const model = new GoogleGenerativeAIEmbeddingModel('gemini-embedding-001', {
-      provider: 'google.generative-ai',
-      baseURL: 'https://generativelanguage.googleapis.com/v1beta',
-      headers: () => ({}),
-    });
-
-    const tooManyValues = Array(2049).fill('test');
-
-    await expect(model.doEmbed({ values: tooManyValues })).rejects.toThrow(
-      'Too many values for a single embedding call. The google.generative-ai model "gemini-embedding-001" can only embed up to 2048 values per call, but 2049 values were provided.',
-    );
-  });
-
-  it('should use the batch embeddings endpoint', async () => {
-    prepareBatchJsonResponse();
-    const model = provider.embeddingModel('gemini-embedding-001');
-    await model.doEmbed({
-      values: testValues,
-    });
-
-    expect(server.calls[0].requestUrl).toBe(
-      'https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:batchEmbedContents',
-    );
-  });
-
-  it('should use the single embeddings endpoint', async () => {
-    prepareSingleJsonResponse();
-
-    const model = provider.embeddingModel('gemini-embedding-001');
-
-    await model.doEmbed({
-      values: [testValues[0]],
-    });
-
-    expect(server.calls[0].requestUrl).toBe(
-      'https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent',
-    );
-  });
-});