@ai-sdk/togetherai 2.0.16 → 2.0.18

package/src/reranking/togetherai-reranking-model.ts

@@ -0,0 +1,101 @@
+import { RerankingModelV3 } from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  FetchFunction,
+  parseProviderOptions,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import {
+  togetheraiErrorSchema,
+  TogetherAIRerankingInput,
+  togetheraiRerankingResponseSchema,
+} from './togetherai-reranking-api';
+import {
+  TogetherAIRerankingModelId,
+  togetheraiRerankingOptionsSchema,
+} from './togetherai-reranking-options';
+
+type TogetherAIRerankingConfig = {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+};
+
+export class TogetherAIRerankingModel implements RerankingModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly modelId: TogetherAIRerankingModelId;
+
+  private readonly config: TogetherAIRerankingConfig;
+
+  constructor(
+    modelId: TogetherAIRerankingModelId,
+    config: TogetherAIRerankingConfig,
+  ) {
+    this.modelId = modelId;
+    this.config = config;
+  }
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  // see https://docs.together.ai/reference/rerank-1
+  async doRerank({
+    documents,
+    headers,
+    query,
+    topN,
+    abortSignal,
+    providerOptions,
+  }: Parameters<RerankingModelV3['doRerank']>[0]): Promise<
+    Awaited<ReturnType<RerankingModelV3['doRerank']>>
+  > {
+    const rerankingOptions = await parseProviderOptions({
+      provider: 'togetherai',
+      providerOptions,
+      schema: togetheraiRerankingOptionsSchema,
+    });
+
+    const {
+      responseHeaders,
+      value: response,
+      rawValue,
+    } = await postJsonToApi({
+      url: `${this.config.baseURL}/rerank`,
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        documents: documents.values,
+        query,
+        top_n: topN,
+        rank_fields: rerankingOptions?.rankFields,
+        return_documents: false, // reduce response size
+      } satisfies TogetherAIRerankingInput,
+      failedResponseHandler: createJsonErrorResponseHandler({
+        errorSchema: togetheraiErrorSchema,
+        errorToMessage: data => data.error.message,
+      }),
+      successfulResponseHandler: createJsonResponseHandler(
+        togetheraiRerankingResponseSchema,
+      ),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      ranking: response.results.map(result => ({
+        index: result.index,
+        relevanceScore: result.relevance_score,
+      })),
+      response: {
+        id: response.id ?? undefined,
+        modelId: response.model ?? undefined,
+        headers: responseHeaders,
+        body: rawValue,
+      },
+    };
+  }
+}

package/src/reranking/togetherai-reranking-options.ts

@@ -0,0 +1,27 @@
+import { FlexibleSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+// see https://docs.together.ai/docs/serverless-models#rerank-models
+export type TogetherAIRerankingModelId =
+  | 'Salesforce/Llama-Rank-v1'
+  | 'mixedbread-ai/Mxbai-Rerank-Large-V2'
+  | (string & {});
+
+export type TogetherAIRerankingOptions = {
+  /**
+   * List of keys in the JSON Object document to rank by.
+   * Defaults to use all supplied keys for ranking.
+   *
+   * @example ["title", "text"]
+   */
+  rankFields?: string[];
+};
+
+export const togetheraiRerankingOptionsSchema: FlexibleSchema<TogetherAIRerankingOptions> =
+  lazySchema(() =>
+    zodSchema(
+      z.object({
+        rankFields: z.array(z.string()).optional(),
+      }),
+    ),
+  );

package/src/togetherai-chat-options.ts

@@ -0,0 +1,36 @@
+// https://docs.together.ai/docs/serverless-models#chat-models
+export type TogetherAIChatModelId =
+  | 'meta-llama/Llama-3.3-70B-Instruct-Turbo'
+  | 'meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo'
+  | 'meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo'
+  | 'meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo'
+  | 'meta-llama/Meta-Llama-3-8B-Instruct-Turbo'
+  | 'meta-llama/Meta-Llama-3-70B-Instruct-Turbo'
+  | 'meta-llama/Llama-3.2-3B-Instruct-Turbo'
+  | 'meta-llama/Meta-Llama-3-8B-Instruct-Lite'
+  | 'meta-llama/Meta-Llama-3-70B-Instruct-Lite'
+  | 'meta-llama/Llama-3-8b-chat-hf'
+  | 'meta-llama/Llama-3-70b-chat-hf'
+  | 'nvidia/Llama-3.1-Nemotron-70B-Instruct-HF'
+  | 'Qwen/Qwen2.5-Coder-32B-Instruct'
+  | 'Qwen/QwQ-32B-Preview'
+  | 'microsoft/WizardLM-2-8x22B'
+  | 'google/gemma-2-27b-it'
+  | 'google/gemma-2-9b-it'
+  | 'databricks/dbrx-instruct'
+  | 'deepseek-ai/deepseek-llm-67b-chat'
+  | 'deepseek-ai/DeepSeek-V3'
+  | 'google/gemma-2b-it'
+  | 'Gryphe/MythoMax-L2-13b'
+  | 'meta-llama/Llama-2-13b-chat-hf'
+  | 'mistralai/Mistral-7B-Instruct-v0.1'
+  | 'mistralai/Mistral-7B-Instruct-v0.2'
+  | 'mistralai/Mistral-7B-Instruct-v0.3'
+  | 'mistralai/Mixtral-8x7B-Instruct-v0.1'
+  | 'mistralai/Mixtral-8x22B-Instruct-v0.1'
+  | 'NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO'
+  | 'Qwen/Qwen2.5-7B-Instruct-Turbo'
+  | 'Qwen/Qwen2.5-72B-Instruct-Turbo'
+  | 'Qwen/Qwen2-72B-Instruct'
+  | 'upstage/SOLAR-10.7B-Instruct-v1.0'
+  | (string & {});

package/src/togetherai-completion-options.ts

@@ -0,0 +1,9 @@
+// https://docs.together.ai/docs/serverless-models#language-models
+export type TogetherAICompletionModelId =
+  | 'meta-llama/Llama-2-70b-hf'
+  | 'mistralai/Mistral-7B-v0.1'
+  | 'mistralai/Mixtral-8x7B-v0.1'
+  | 'Meta-Llama/Llama-Guard-7b'
+  | 'codellama/CodeLlama-34b-Instruct-hf'
+  | 'Qwen/Qwen2.5-Coder-32B-Instruct'
+  | (string & {});

package/src/togetherai-embedding-options.ts

@@ -0,0 +1,11 @@
+// https://docs.together.ai/docs/serverless-models#embedding-models
+export type TogetherAIEmbeddingModelId =
+  | 'togethercomputer/m2-bert-80M-2k-retrieval'
+  | 'togethercomputer/m2-bert-80M-32k-retrieval'
+  | 'togethercomputer/m2-bert-80M-8k-retrieval'
+  | 'WhereIsAI/UAE-Large-V1'
+  | 'BAAI/bge-large-en-v1.5'
+  | 'BAAI/bge-base-en-v1.5'
+  | 'sentence-transformers/msmarco-bert-base-dot-v5'
+  | 'bert-base-uncased'
+  | (string & {});

package/src/togetherai-image-model.test.ts

@@ -0,0 +1,488 @@
+import { FetchFunction } from '@ai-sdk/provider-utils';
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { describe, expect, it } from 'vitest';
+import { TogetherAIImageModel } from './togetherai-image-model';
+
+const prompt = 'A cute baby sea otter';
+
+function createBasicModel({
+  headers,
+  fetch,
+  currentDate,
+}: {
+  headers?: () => Record<string, string>;
+  fetch?: FetchFunction;
+  currentDate?: () => Date;
+} = {}) {
+  return new TogetherAIImageModel('stabilityai/stable-diffusion-xl', {
+    provider: 'togetherai',
+    baseURL: 'https://api.example.com',
+    headers: headers ?? (() => ({ 'api-key': 'test-key' })),
+    fetch,
+    _internal: {
+      currentDate,
+    },
+  });
+}
+
+const server = createTestServer({
+  'https://api.example.com/*': {
+    response: {
+      type: 'json-value',
+      body: {
+        id: 'test-id',
+        data: [{ index: 0, b64_json: 'test-base64-content' }],
+        model: 'stabilityai/stable-diffusion-xl',
+        object: 'list',
+      },
+    },
+  },
+});
+
+describe('doGenerate', () => {
+  it('should pass the correct parameters including size and seed', async () => {
+    const model = createBasicModel();
+
+    await model.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: '1024x1024',
+      seed: 42,
+      providerOptions: { togetherai: { additional_param: 'value' } },
+      aspectRatio: undefined,
+    });
+
+    expect(await server.calls[0].requestBodyJson).toStrictEqual({
+      model: 'stabilityai/stable-diffusion-xl',
+      prompt,
+      seed: 42,
+      width: 1024,
+      height: 1024,
+      response_format: 'base64',
+      additional_param: 'value',
+    });
+  });
+
+  it('should include n parameter when requesting multiple images', async () => {
+    const model = createBasicModel();
+
+    await model.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 3,
+      size: '1024x1024',
+      seed: 42,
+      providerOptions: {},
+      aspectRatio: undefined,
+    });
+
+    expect(await server.calls[0].requestBodyJson).toStrictEqual({
+      model: 'stabilityai/stable-diffusion-xl',
+      prompt,
+      seed: 42,
+      n: 3,
+      width: 1024,
+      height: 1024,
+      response_format: 'base64',
+    });
+  });
+
+  it('should call the correct url', async () => {
+    const model = createBasicModel();
+
+    await model.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: '1024x1024',
+      seed: 42,
+      providerOptions: {},
+      aspectRatio: undefined,
+    });
+
+    expect(server.calls[0].requestMethod).toStrictEqual('POST');
+    expect(server.calls[0].requestUrl).toStrictEqual(
+      'https://api.example.com/images/generations',
+    );
+  });
+
+  it('should pass headers', async () => {
+    const modelWithHeaders = createBasicModel({
+      headers: () => ({
+        'Custom-Provider-Header': 'provider-header-value',
+      }),
+    });
+
+    await modelWithHeaders.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      seed: undefined,
+      providerOptions: {},
+      aspectRatio: undefined,
+      headers: {
+        'Custom-Request-Header': 'request-header-value',
+      },
+    });
+
+    expect(server.calls[0].requestHeaders).toStrictEqual({
+      'content-type': 'application/json',
+      'custom-provider-header': 'provider-header-value',
+      'custom-request-header': 'request-header-value',
+    });
+  });
+
+  it('should handle API errors', async () => {
+    server.urls['https://api.example.com/*'].response = {
+      type: 'error',
+      status: 400,
+      body: JSON.stringify({
+        error: {
+          message: 'Bad Request',
+        },
+      }),
+    };
+
+    const model = createBasicModel();
+    await expect(
+      model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        seed: undefined,
+        providerOptions: {},
+        aspectRatio: undefined,
+      }),
+    ).rejects.toMatchObject({
+      message: 'Bad Request',
+    });
+  });
+
+  describe('warnings', () => {
+    it('should return aspectRatio warning when aspectRatio is provided', async () => {
+      const model = createBasicModel();
+
+      const result = await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: '1024x1024',
+        aspectRatio: '1:1',
+        seed: 123,
+        providerOptions: {},
+      });
+
+      expect(result.warnings).toMatchInlineSnapshot(`
+        [
+          {
+            "details": "This model does not support the \`aspectRatio\` option. Use \`size\` instead.",
+            "feature": "aspectRatio",
+            "type": "unsupported",
+          },
+        ]
+      `);
+    });
+  });
+
+  it('should respect the abort signal', async () => {
+    const model = createBasicModel();
+    const controller = new AbortController();
+
+    const generatePromise = model.doGenerate({
+      prompt,
+      files: undefined,
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      seed: undefined,
+      providerOptions: {},
+      aspectRatio: undefined,
+      abortSignal: controller.signal,
+    });
+
+    controller.abort();
+
+    await expect(generatePromise).rejects.toThrow('This operation was aborted');
+  });
+
+  describe('response metadata', () => {
+    it('should include timestamp, headers and modelId in response', async () => {
+      const testDate = new Date('2024-01-01T00:00:00Z');
+      const model = createBasicModel({
+        currentDate: () => testDate,
+      });
+
+      const result = await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        seed: undefined,
+        providerOptions: {},
+        aspectRatio: undefined,
+      });
+
+      expect(result.response).toStrictEqual({
+        timestamp: testDate,
+        modelId: 'stabilityai/stable-diffusion-xl',
+        headers: expect.any(Object),
+      });
+    });
+
+    it('should include response headers from API call', async () => {
+      server.urls['https://api.example.com/*'].response = {
+        type: 'json-value',
+        body: {
+          id: 'test-id',
+          data: [{ index: 0, b64_json: 'test-base64-content' }],
+          model: 'stabilityai/stable-diffusion-xl',
+          object: 'list',
+        },
+        headers: {
+          'x-request-id': 'test-request-id',
+          'content-length': '128',
+        },
+      };
+
+      const model = createBasicModel();
+      const result = await model.doGenerate({
+        prompt,
+        files: undefined,
+        mask: undefined,
+        n: 1,
+        size: undefined,
+        seed: undefined,
+        providerOptions: {},
+        aspectRatio: undefined,
+      });
+
+      expect(result.response.headers).toStrictEqual({
+        'x-request-id': 'test-request-id',
+        'content-type': 'application/json',
+        'content-length': '128',
+      });
+    });
+  });
+});
+
+describe('constructor', () => {
+  it('should expose correct provider and model information', () => {
+    const model = createBasicModel();
+
+    expect(model.provider).toBe('togetherai');
+    expect(model.modelId).toBe('stabilityai/stable-diffusion-xl');
+    expect(model.specificationVersion).toBe('v3');
+    expect(model.maxImagesPerCall).toBe(1);
+  });
+});
+
+describe('Image Editing', () => {
+  const server = createTestServer({
+    'https://api.example.com/*': {
+      response: {
+        type: 'json-value',
+        body: {
+          id: 'test-id',
+          data: [{ index: 0, b64_json: 'test-base64-content' }],
+          model: 'black-forest-labs/FLUX.1-kontext-pro',
+          object: 'list',
+        },
+      },
+    },
+  });
+
+  it('should send image_url when URL file is provided', async () => {
+    const model = createBasicModel();
+
+    await model.doGenerate({
+      prompt: 'Make the shirt yellow',
+      files: [
+        {
+          type: 'url',
+          url: 'https://example.com/input.jpg',
+        },
+      ],
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+    });
+
+    const requestBody = await server.calls[0].requestBodyJson;
+    expect(requestBody).toMatchInlineSnapshot(`
+      {
+        "image_url": "https://example.com/input.jpg",
+        "model": "stabilityai/stable-diffusion-xl",
+        "prompt": "Make the shirt yellow",
+        "response_format": "base64",
+      }
+    `);
+  });
+
+  it('should convert Uint8Array file to data URI', async () => {
+    const model = createBasicModel();
+    const testImageData = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+
+    await model.doGenerate({
+      prompt: 'Transform this image',
+      files: [
+        {
+          type: 'file',
+          data: testImageData,
+          mediaType: 'image/png',
+        },
+      ],
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+    });
+
+    const requestBody = await server.calls[0].requestBodyJson;
+    expect(requestBody.image_url).toMatch(/^data:image\/png;base64,/);
+    expect(requestBody.prompt).toBe('Transform this image');
+  });
+
+  it('should convert file with base64 string data to data URI', async () => {
+    const model = createBasicModel();
+
+    await model.doGenerate({
+      prompt: 'Edit this',
+      files: [
+        {
+          type: 'file',
+          data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+          mediaType: 'image/png',
+        },
+      ],
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+    });
+
+    const requestBody = await server.calls[0].requestBodyJson;
+    expect(requestBody.image_url).toBe(
+      'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+    );
+  });
+
+  it('should throw error when mask is provided', async () => {
+    const model = createBasicModel();
+
+    await expect(
+      model.doGenerate({
+        prompt: 'Inpaint this area',
+        files: [
+          {
+            type: 'url',
+            url: 'https://example.com/input.jpg',
+          },
+        ],
+        mask: {
+          type: 'url',
+          url: 'https://example.com/mask.png',
+        },
+        n: 1,
+        size: undefined,
+        aspectRatio: undefined,
+        seed: undefined,
+        providerOptions: {},
+      }),
+    ).rejects.toThrow(
+      'Together AI does not support mask-based image editing. ' +
+        'Use FLUX Kontext models (e.g., black-forest-labs/FLUX.1-kontext-pro) ' +
+        'with a reference image and descriptive prompt instead.',
+    );
+  });
+
+  it('should warn when multiple files are provided', async () => {
+    const model = createBasicModel();
+
+    const result = await model.doGenerate({
+      prompt: 'Edit multiple images',
+      files: [
+        {
+          type: 'url',
+          url: 'https://example.com/input1.jpg',
+        },
+        {
+          type: 'url',
+          url: 'https://example.com/input2.jpg',
+        },
+      ],
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {},
+    });
+
+    expect(result.warnings).toMatchInlineSnapshot(`
+      [
+        {
+          "message": "Together AI only supports a single input image. Additional images are ignored.",
+          "type": "other",
+        },
+      ]
+    `);
+
+    // Should only use the first image
+    const requestBody = await server.calls[0].requestBodyJson;
+    expect(requestBody.image_url).toBe('https://example.com/input1.jpg');
+  });
+
+  it('should pass provider options with image editing', async () => {
+    const model = createBasicModel();
+
+    await model.doGenerate({
+      prompt: 'Transform the style',
+      files: [
+        {
+          type: 'url',
+          url: 'https://example.com/input.jpg',
+        },
+      ],
+      mask: undefined,
+      n: 1,
+      size: undefined,
+      aspectRatio: undefined,
+      seed: undefined,
+      providerOptions: {
+        togetherai: {
+          steps: 28,
+          guidance: 3.5,
+        },
+      },
+    });
+
+    const requestBody = await server.calls[0].requestBodyJson;
+    expect(requestBody).toMatchInlineSnapshot(`
+      {
+        "guidance": 3.5,
+        "image_url": "https://example.com/input.jpg",
+        "model": "stabilityai/stable-diffusion-xl",
+        "prompt": "Transform the style",
+        "response_format": "base64",
+        "steps": 28,
+      }
+    `);
+  });
+});