@ai-sdk/cohere 3.0.10 → 3.0.11

package/src/cohere-embedding-model.test.ts

@@ -1,143 +0,0 @@
-import { EmbeddingModelV3Embedding } from '@ai-sdk/provider';
-import { createTestServer } from '@ai-sdk/test-server/with-vitest';
-import { createCohere } from './cohere-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 = createCohere({ apiKey: 'test-api-key' });
-const model = provider.embeddingModel('embed-english-v3.0');
-
-const server = createTestServer({
-  'https://api.cohere.com/v2/embed': {},
-});
-
-describe('doEmbed', () => {
-  function prepareJsonResponse({
-    embeddings = dummyEmbeddings,
-    meta = { billed_units: { input_tokens: 8 } },
-    headers,
-  }: {
-    embeddings?: EmbeddingModelV3Embedding[];
-    meta?: { billed_units: { input_tokens: number } };
-    headers?: Record<string, string>;
-  } = {}) {
-    server.urls['https://api.cohere.com/v2/embed'].response = {
-      type: 'json-value',
-      headers,
-      body: {
-        id: 'test-id',
-        texts: testValues,
-        embeddings: { float: embeddings },
-        meta,
-      },
-    };
-  }
-
-  it('should extract embedding', async () => {
-    prepareJsonResponse();
-
-    const { embeddings } = await model.doEmbed({ values: testValues });
-
-    expect(embeddings).toStrictEqual(dummyEmbeddings);
-  });
-
-  it('should expose the raw response', async () => {
-    prepareJsonResponse({
-      headers: { 'test-header': 'test-value' },
-    });
-
-    const { response } = await model.doEmbed({ values: testValues });
-
-    expect(response?.headers).toStrictEqual({
-      // default headers:
-      'content-length': '185',
-      'content-type': 'application/json',
-
-      // custom header
-      'test-header': 'test-value',
-    });
-    expect(response).toMatchSnapshot();
-  });
-
-  it('should extract usage', async () => {
-    prepareJsonResponse({
-      meta: { billed_units: { input_tokens: 20 } },
-    });
-
-    const { usage } = await model.doEmbed({ values: testValues });
-
-    expect(usage).toStrictEqual({ tokens: 20 });
-  });
-
-  it('should pass the model and the values', async () => {
-    prepareJsonResponse();
-
-    await model.doEmbed({ values: testValues });
-
-    expect(await server.calls[0].requestBodyJson).toStrictEqual({
-      model: 'embed-english-v3.0',
-      embedding_types: ['float'],
-      texts: testValues,
-      input_type: 'search_query',
-    });
-  });
-
-  it('should pass the input_type setting', async () => {
-    prepareJsonResponse();
-
-    await provider.embeddingModel('embed-english-v3.0').doEmbed({
-      values: testValues,
-      providerOptions: {
-        cohere: {
-          inputType: 'search_document',
-        },
-      },
-    });
-
-    expect(await server.calls[0].requestBodyJson).toStrictEqual({
-      model: 'embed-english-v3.0',
-      embedding_types: ['float'],
-      texts: testValues,
-      input_type: 'search_document',
-    });
-  });
-
-  it('should pass headers', async () => {
-    prepareJsonResponse();
-
-    const provider = createCohere({
-      apiKey: 'test-api-key',
-      headers: {
-        'Custom-Provider-Header': 'provider-header-value',
-      },
-    });
-
-    await provider.embeddingModel('embed-english-v3.0').doEmbed({
-      values: testValues,
-      headers: {
-        'Custom-Request-Header': 'request-header-value',
-      },
-    });
-
-    const requestHeaders = server.calls[0].requestHeaders;
-
-    expect(requestHeaders).toStrictEqual({
-      authorization: 'Bearer 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/cohere/0.0.0-test`,
-    );
-  });
-});

package/src/cohere-prepare-tools.test.ts

@@ -1,152 +0,0 @@
-import { prepareTools } from './cohere-prepare-tools';
-import { describe, it, expect } from 'vitest';
-
-it('should return undefined tools when no tools are provided', () => {
-  const result = prepareTools({
-    tools: [],
-  });
-
-  expect(result).toStrictEqual({
-    tools: undefined,
-    toolChoice: undefined,
-    toolWarnings: [],
-  });
-});
-
-it('should process function tools correctly', () => {
-  const functionTool = {
-    type: 'function' as const,
-    name: 'testFunction',
-    description: 'test description',
-    inputSchema: { type: 'object' as const, properties: {} },
-  };
-
-  const result = prepareTools({
-    tools: [functionTool],
-  });
-
-  expect(result).toStrictEqual({
-    tools: [
-      {
-        type: 'function',
-        function: {
-          name: 'testFunction',
-          description: 'test description',
-          parameters: { type: 'object' as const, properties: {} },
-        },
-      },
-    ],
-    toolChoice: undefined,
-    toolWarnings: [],
-  });
-});
-
-it('should add warnings for provider-defined tools', () => {
-  const result = prepareTools({
-    tools: [
-      {
-        type: 'provider' as const,
-        id: 'provider.tool',
-        name: 'tool',
-        args: {},
-      },
-    ],
-  });
-
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "toolChoice": undefined,
-      "toolWarnings": [
-        {
-          "feature": "provider-defined tool provider.tool",
-          "type": "unsupported",
-        },
-      ],
-      "tools": [],
-    }
-  `);
-});
-
-describe('tool choice handling', () => {
-  const basicTool = {
-    type: 'function' as const,
-    name: 'testFunction',
-    description: 'test description',
-    inputSchema: { type: 'object' as const, properties: {} },
-  };
-
-  it('should handle auto tool choice', () => {
-    const result = prepareTools({
-      tools: [basicTool],
-      toolChoice: { type: 'auto' },
-    });
-
-    expect(result.toolChoice).toBe(undefined);
-  });
-
-  it('should handle none tool choice', () => {
-    const result = prepareTools({
-      tools: [basicTool],
-      toolChoice: { type: 'none' },
-    });
-
-    expect(result).toStrictEqual({
-      tools: [
-        {
-          type: 'function',
-          function: {
-            name: 'testFunction',
-            description: 'test description',
-            parameters: { type: 'object', properties: {} },
-          },
-        },
-      ],
-      toolChoice: 'NONE',
-      toolWarnings: [],
-    });
-  });
-
-  it('should handle required tool choice', () => {
-    const result = prepareTools({
-      tools: [basicTool],
-      toolChoice: { type: 'required' },
-    });
-
-    expect(result).toStrictEqual({
-      tools: [
-        {
-          type: 'function',
-          function: {
-            name: 'testFunction',
-            description: 'test description',
-            parameters: { type: 'object', properties: {} },
-          },
-        },
-      ],
-      toolChoice: 'REQUIRED',
-      toolWarnings: [],
-    });
-  });
-
-  it('should handle tool type tool choice by filtering tools', () => {
-    const result = prepareTools({
-      tools: [basicTool],
-      toolChoice: { type: 'tool', toolName: 'testFunction' },
-    });
-
-    expect(result).toStrictEqual({
-      tools: [
-        {
-          type: 'function',
-          function: {
-            name: 'testFunction',
-            description: 'test description',
-            parameters: { type: 'object', properties: {} },
-          },
-        },
-      ],
-      toolChoice: 'REQUIRED',
-      toolWarnings: [],
-    });
-  });
-});

package/src/convert-to-cohere-chat-prompt.test.ts

@@ -1,175 +0,0 @@
-import { convertToCohereChatPrompt } from './convert-to-cohere-chat-prompt';
-import { describe, it, expect } from 'vitest';
-
-describe('convert to cohere chat prompt', () => {
-  describe('file processing', () => {
-    it('should extract documents from file parts', () => {
-      const result = convertToCohereChatPrompt([
-        {
-          role: 'user',
-          content: [
-            { type: 'text', text: 'Analyze this file: ' },
-            {
-              type: 'file',
-              data: Buffer.from('This is file content'),
-              mediaType: 'text/plain',
-              filename: 'test.txt',
-            },
-          ],
-        },
-      ]);
-
-      expect(result).toEqual({
-        messages: [
-          {
-            role: 'user',
-            content: 'Analyze this file: ',
-          },
-        ],
-        documents: [
-          {
-            data: {
-              text: 'This is file content',
-              title: 'test.txt',
-            },
-          },
-        ],
-        warnings: [],
-      });
-    });
-
-    it('should throw error for unsupported media types', () => {
-      expect(() => {
-        convertToCohereChatPrompt([
-          {
-            role: 'user',
-            content: [
-              {
-                type: 'file',
-                data: Buffer.from('PDF content'),
-                mediaType: 'application/pdf',
-                filename: 'test.pdf',
-              },
-            ],
-          },
-        ]);
-      }).toThrow("Media type 'application/pdf' is not supported");
-    });
-  });
-
-  describe('tool messages', () => {
-    it('should convert a tool call into a cohere chatbot message', async () => {
-      const result = convertToCohereChatPrompt([
-        {
-          role: 'assistant',
-          content: [
-            {
-              type: 'text',
-              text: 'Calling a tool',
-            },
-            {
-              type: 'tool-call',
-              toolName: 'tool-1',
-              toolCallId: 'tool-call-1',
-              input: { test: 'This is a tool message' },
-            },
-          ],
-        },
-      ]);
-
-      expect(result).toEqual({
-        messages: [
-          {
-            content: undefined,
-            role: 'assistant',
-            tool_calls: [
-              {
-                id: 'tool-call-1',
-                type: 'function',
-                function: {
-                  name: 'tool-1',
-                  arguments: JSON.stringify({ test: 'This is a tool message' }),
-                },
-              },
-            ],
-          },
-        ],
-        documents: [],
-        warnings: [],
-      });
-    });
-
-    it('should convert a single tool result into a cohere tool message', async () => {
-      const result = convertToCohereChatPrompt([
-        {
-          role: 'tool',
-          content: [
-            {
-              type: 'tool-result',
-              toolName: 'tool-1',
-              toolCallId: 'tool-call-1',
-              output: {
-                type: 'json',
-                value: { test: 'This is a tool message' },
-              },
-            },
-          ],
-        },
-      ]);
-
-      expect(result).toEqual({
-        messages: [
-          {
-            role: 'tool',
-            content: JSON.stringify({ test: 'This is a tool message' }),
-            tool_call_id: 'tool-call-1',
-          },
-        ],
-        documents: [],
-        warnings: [],
-      });
-    });
-
-    it('should convert multiple tool results into a cohere tool message', async () => {
-      const result = convertToCohereChatPrompt([
-        {
-          role: 'tool',
-          content: [
-            {
-              type: 'tool-result',
-              toolName: 'tool-1',
-              toolCallId: 'tool-call-1',
-              output: {
-                type: 'json',
-                value: { test: 'This is a tool message' },
-              },
-            },
-            {
-              type: 'tool-result',
-              toolName: 'tool-2',
-              toolCallId: 'tool-call-2',
-              output: { type: 'json', value: { something: 'else' } },
-            },
-          ],
-        },
-      ]);
-
-      expect(result).toEqual({
-        messages: [
-          {
-            role: 'tool',
-            content: JSON.stringify({ test: 'This is a tool message' }),
-            tool_call_id: 'tool-call-1',
-          },
-          {
-            role: 'tool',
-            content: JSON.stringify({ something: 'else' }),
-            tool_call_id: 'tool-call-2',
-          },
-        ],
-        documents: [],
-        warnings: [],
-      });
-    });
-  });
-});

package/src/reranking/__fixtures__/cohere-reranking.1.json

@@ -1,21 +0,0 @@
-{
-  "id": "b44fe75b-e3d3-489a-b61e-1a1aede3ef72",
-  "results": [
-    {
-      "index": 1,
-      "relevance_score": 0.10183054
-    },
-    {
-      "index": 0,
-      "relevance_score": 0.03762639
-    }
-  ],
-  "meta": {
-    "api_version": {
-      "version": "2"
-    },
-    "billed_units": {
-      "search_units": 1
-    }
-  }
-}