@ai-sdk/togetherai 2.0.16 → 2.0.18

package/src/togetherai-image-model.ts

@@ -0,0 +1,188 @@
+import { ImageModelV3, SharedV3Warning } from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertImageModelFileToDataUri,
+  createJsonResponseHandler,
+  createJsonErrorResponseHandler,
+  FetchFunction,
+  InferSchema,
+  lazySchema,
+  parseProviderOptions,
+  postJsonToApi,
+  zodSchema,
+} from '@ai-sdk/provider-utils';
+import { TogetherAIImageModelId } from './togetherai-image-settings';
+import { z } from 'zod/v4';
+
+interface TogetherAIImageModelConfig {
+  provider: string;
+  baseURL: string;
+  headers: () => Record<string, string>;
+  fetch?: FetchFunction;
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+export class TogetherAIImageModel implements ImageModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly maxImagesPerCall = 1;
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: TogetherAIImageModelId,
+    private config: TogetherAIImageModelConfig,
+  ) {}
+
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    seed,
+    providerOptions,
+    headers,
+    abortSignal,
+    files,
+    mask,
+  }: Parameters<ImageModelV3['doGenerate']>[0]): Promise<
+    Awaited<ReturnType<ImageModelV3['doGenerate']>>
+  > {
+    const warnings: Array<SharedV3Warning> = [];
+
+    if (mask != null) {
+      throw new Error(
+        '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.',
+      );
+    }
+
+    if (size != null) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'aspectRatio',
+        details:
+          'This model does not support the `aspectRatio` option. Use `size` instead.',
+      });
+    }
+
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+
+    const togetheraiOptions = await parseProviderOptions({
+      provider: 'togetherai',
+      providerOptions,
+      schema: togetheraiImageProviderOptionsSchema,
+    });
+
+    // Handle image input from files
+    let imageUrl: string | undefined;
+    if (files != null && files.length > 0) {
+      imageUrl = convertImageModelFileToDataUri(files[0]);
+
+      if (files.length > 1) {
+        warnings.push({
+          type: 'other',
+          message:
+            'Together AI only supports a single input image. Additional images are ignored.',
+        });
+      }
+    }
+
+    const splitSize = size?.split('x');
+    // https://docs.together.ai/reference/post_images-generations
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: `${this.config.baseURL}/images/generations`,
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        prompt,
+        seed,
+        ...(n > 1 ? { n } : {}),
+        ...(splitSize && {
+          width: parseInt(splitSize[0]),
+          height: parseInt(splitSize[1]),
+        }),
+        ...(imageUrl != null ? { image_url: imageUrl } : {}),
+        response_format: 'base64',
+        ...(togetheraiOptions ?? {}),
+      },
+      failedResponseHandler: createJsonErrorResponseHandler({
+        errorSchema: togetheraiErrorSchema,
+        errorToMessage: data => data.error.message,
+      }),
+      successfulResponseHandler: createJsonResponseHandler(
+        togetheraiImageResponseSchema,
+      ),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      images: response.data.map(item => item.b64_json),
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+      },
+    };
+  }
+}
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+const togetheraiImageResponseSchema = z.object({
+  data: z.array(
+    z.object({
+      b64_json: z.string(),
+    }),
+  ),
+});
+
+// limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+const togetheraiErrorSchema = z.object({
+  error: z.object({
+    message: z.string(),
+  }),
+});
+
+/**
+ * Provider options schema for Together AI image generation.
+ */
+export const togetheraiImageProviderOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z
+      .object({
+        /**
+         * Number of generation steps. Higher values can improve quality.
+         */
+        steps: z.number().nullish(),
+
+        /**
+         * Guidance scale for image generation.
+         */
+        guidance: z.number().nullish(),
+
+        /**
+         * Negative prompt to guide what to avoid.
+         */
+        negative_prompt: z.string().nullish(),
+
+        /**
+         * Disable the safety checker for image generation.
+         * When true, the API will not reject images flagged as potentially NSFW.
+         * Not available for Flux Schnell Free and Flux Pro models.
+         */
+        disable_safety_checker: z.boolean().nullish(),
+      })
+      .passthrough(),
+  ),
+);
+
+export type TogetherAIImageProviderOptions = InferSchema<
+  typeof togetheraiImageProviderOptionsSchema
+>;

package/src/togetherai-image-settings.ts

@@ -0,0 +1,18 @@
+// https://api.together.ai/models
+export type TogetherAIImageModelId =
+  // Text-to-image models
+  | 'stabilityai/stable-diffusion-xl-base-1.0'
+  | 'black-forest-labs/FLUX.1-dev'
+  | 'black-forest-labs/FLUX.1-dev-lora'
+  | 'black-forest-labs/FLUX.1-schnell'
+  | 'black-forest-labs/FLUX.1-canny'
+  | 'black-forest-labs/FLUX.1-depth'
+  | 'black-forest-labs/FLUX.1-redux'
+  | 'black-forest-labs/FLUX.1.1-pro'
+  | 'black-forest-labs/FLUX.1-pro'
+  | 'black-forest-labs/FLUX.1-schnell-Free'
+  // FLUX Kontext models for image editing
+  | 'black-forest-labs/FLUX.1-kontext-pro'
+  | 'black-forest-labs/FLUX.1-kontext-max'
+  | 'black-forest-labs/FLUX.1-kontext-dev'
+  | (string & {});

package/src/togetherai-provider.test.ts

@@ -0,0 +1,196 @@
+import {
+  OpenAICompatibleChatLanguageModel,
+  OpenAICompatibleCompletionLanguageModel,
+  OpenAICompatibleEmbeddingModel,
+} from '@ai-sdk/openai-compatible';
+import {
+  EmbeddingModelV3,
+  LanguageModelV3,
+  RerankingModelV3,
+} from '@ai-sdk/provider';
+import { loadApiKey } from '@ai-sdk/provider-utils';
+import { beforeEach, describe, expect, it, Mock, vi } from 'vitest';
+import { TogetherAIRerankingModel } from './reranking/togetherai-reranking-model';
+import { TogetherAIImageModel } from './togetherai-image-model';
+import { createTogetherAI } from './togetherai-provider';
+
+// Add type assertion for the mocked class
+const OpenAICompatibleChatLanguageModelMock =
+  OpenAICompatibleChatLanguageModel as unknown as Mock;
+
+vi.mock('@ai-sdk/openai-compatible', () => ({
+  OpenAICompatibleChatLanguageModel: vi.fn(),
+  OpenAICompatibleCompletionLanguageModel: vi.fn(),
+  OpenAICompatibleEmbeddingModel: vi.fn(),
+}));
+
+vi.mock('@ai-sdk/provider-utils', async () => {
+  const actual = await vi.importActual('@ai-sdk/provider-utils');
+  return {
+    ...actual,
+    loadApiKey: vi.fn().mockReturnValue('mock-api-key'),
+    withoutTrailingSlash: vi.fn(url => url),
+  };
+});
+
+vi.mock('./togetherai-image-model', () => ({
+  TogetherAIImageModel: vi.fn(),
+}));
+
+vi.mock('./reranking/togetherai-reranking-model', () => ({
+  TogetherAIRerankingModel: vi.fn(),
+}));
+
+describe('TogetherAIProvider', () => {
+  let mockLanguageModel: LanguageModelV3;
+  let mockEmbeddingModel: EmbeddingModelV3;
+  let mockRerankingModel: RerankingModelV3;
+
+  beforeEach(() => {
+    // Mock implementations of models
+    mockLanguageModel = {
+      // Add any required methods for LanguageModelV3
+    } as LanguageModelV3;
+    mockEmbeddingModel = {
+      // Add any required methods for EmbeddingModelV3
+    } as EmbeddingModelV3;
+    mockRerankingModel = {
+      // Add any required methods for RerankingModelV3
+    } as RerankingModelV3;
+
+    // Reset mocks
+    vi.clearAllMocks();
+  });
+
+  describe('createTogetherAI', () => {
+    it('should create a TogetherAIProvider instance with default options', () => {
+      const provider = createTogetherAI();
+      const model = provider('model-id');
+
+      // Use the mocked version
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      config.headers();
+
+      expect(loadApiKey).toHaveBeenCalledWith({
+        apiKey: undefined,
+        environmentVariableName: 'TOGETHER_AI_API_KEY',
+        description: 'TogetherAI',
+      });
+    });
+
+    it('should create a TogetherAIProvider instance with custom options', () => {
+      const options = {
+        apiKey: 'custom-key',
+        baseURL: 'https://custom.url',
+        headers: { 'Custom-Header': 'value' },
+      };
+      const provider = createTogetherAI(options);
+      const model = provider('model-id');
+
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      config.headers();
+
+      expect(loadApiKey).toHaveBeenCalledWith({
+        apiKey: 'custom-key',
+        environmentVariableName: 'TOGETHER_AI_API_KEY',
+        description: 'TogetherAI',
+      });
+    });
+
+    it('should return a chat model when called as a function', () => {
+      const provider = createTogetherAI();
+      const modelId = 'foo-model-id';
+
+      const model = provider(modelId);
+      expect(model).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+    });
+  });
+
+  describe('chatModel', () => {
+    it('should construct a chat model with correct configuration', () => {
+      const provider = createTogetherAI();
+      const modelId = 'together-chat-model';
+
+      const model = provider.chatModel(modelId);
+
+      expect(model).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+    });
+  });
+
+  describe('completionModel', () => {
+    it('should construct a completion model with correct configuration', () => {
+      const provider = createTogetherAI();
+      const modelId = 'together-completion-model';
+
+      const model = provider.completionModel(modelId);
+
+      expect(model).toBeInstanceOf(OpenAICompatibleCompletionLanguageModel);
+    });
+  });
+
+  describe('embeddingModel', () => {
+    it('should construct a text embedding model with correct configuration', () => {
+      const provider = createTogetherAI();
+      const modelId = 'together-embedding-model';
+
+      const model = provider.embeddingModel(modelId);
+
+      expect(model).toBeInstanceOf(OpenAICompatibleEmbeddingModel);
+    });
+  });
+
+  describe('image', () => {
+    it('should construct an image model with correct configuration', () => {
+      const provider = createTogetherAI();
+      const modelId = 'stabilityai/stable-diffusion-xl';
+
+      const model = provider.image(modelId);
+
+      expect(TogetherAIImageModel).toHaveBeenCalledWith(
+        modelId,
+        expect.objectContaining({
+          provider: 'togetherai.image',
+          baseURL: 'https://api.together.xyz/v1/',
+        }),
+      );
+      expect(model).toBeInstanceOf(TogetherAIImageModel);
+    });
+
+    it('should pass custom baseURL to image model', () => {
+      const provider = createTogetherAI({
+        baseURL: 'https://custom.url/',
+      });
+      const modelId = 'stabilityai/stable-diffusion-xl';
+
+      provider.image(modelId);
+
+      expect(TogetherAIImageModel).toHaveBeenCalledWith(
+        modelId,
+        expect.objectContaining({
+          baseURL: 'https://custom.url/',
+        }),
+      );
+    });
+  });
+
+  describe('rerankingModel', () => {
+    it('should construct a reranking model with correct configuration', () => {
+      const provider = createTogetherAI();
+      const modelId = 'Salesforce/Llama-Rank-v1';
+      0;
+      const model = provider.rerankingModel(modelId);
+
+      expect(TogetherAIRerankingModel).toHaveBeenCalledWith(
+        modelId,
+        expect.objectContaining({
+          baseURL: 'https://api.together.xyz/v1/',
+        }),
+      );
+      expect(model).toBeInstanceOf(TogetherAIRerankingModel);
+    });
+  });
+});

package/src/togetherai-provider.ts

@@ -0,0 +1,180 @@
+import {
+  OpenAICompatibleChatLanguageModel,
+  OpenAICompatibleCompletionLanguageModel,
+  OpenAICompatibleEmbeddingModel,
+} from '@ai-sdk/openai-compatible';
+import {
+  EmbeddingModelV3,
+  ImageModelV3,
+  LanguageModelV3,
+  ProviderV3,
+  RerankingModelV3,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { TogetherAIRerankingModel } from './reranking/togetherai-reranking-model';
+import { TogetherAIRerankingModelId } from './reranking/togetherai-reranking-options';
+import { TogetherAIChatModelId } from './togetherai-chat-options';
+import { TogetherAICompletionModelId } from './togetherai-completion-options';
+import { TogetherAIEmbeddingModelId } from './togetherai-embedding-options';
+import { TogetherAIImageModel } from './togetherai-image-model';
+import { TogetherAIImageModelId } from './togetherai-image-settings';
+import { VERSION } from './version';
+
+export interface TogetherAIProviderSettings {
+  /**
+TogetherAI API key.
+*/
+  apiKey?: string;
+  /**
+Base URL for the API calls.
+*/
+  baseURL?: string;
+  /**
+Custom headers to include in the requests.
+*/
+  headers?: Record<string, string>;
+  /**
+Custom fetch implementation. You can use it as a middleware to intercept requests,
+or to provide a custom fetch implementation for e.g. testing.
+*/
+  fetch?: FetchFunction;
+}
+
+export interface TogetherAIProvider extends ProviderV3 {
+  /**
+Creates a model for text generation.
+*/
+  (modelId: TogetherAIChatModelId): LanguageModelV3;
+
+  /**
+Creates a chat model for text generation.
+*/
+  chatModel(modelId: TogetherAIChatModelId): LanguageModelV3;
+
+  /**
+Creates a chat model for text generation.
+*/
+  languageModel(modelId: TogetherAIChatModelId): LanguageModelV3;
+
+  /**
+Creates a completion model for text generation.
+*/
+  completionModel(modelId: TogetherAICompletionModelId): LanguageModelV3;
+
+  /**
+Creates a text embedding model for text generation.
+*/
+  embeddingModel(modelId: TogetherAIEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: TogetherAIEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+Creates a model for image generation.
+*/
+  image(modelId: TogetherAIImageModelId): ImageModelV3;
+
+  /**
+Creates a model for image generation.
+*/
+  imageModel(modelId: TogetherAIImageModelId): ImageModelV3;
+
+  /**
+   * Creates a model for reranking.
+   */
+  reranking(modelId: TogetherAIRerankingModelId): RerankingModelV3;
+
+  /**
+   * Creates a model for reranking.
+   */
+  rerankingModel(modelId: TogetherAIRerankingModelId): RerankingModelV3;
+}
+
+export function createTogetherAI(
+  options: TogetherAIProviderSettings = {},
+): TogetherAIProvider {
+  const baseURL = withoutTrailingSlash(
+    options.baseURL ?? 'https://api.together.xyz/v1/',
+  );
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'TOGETHER_AI_API_KEY',
+          description: 'TogetherAI',
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/togetherai/${VERSION}`,
+    );
+
+  interface CommonModelConfig {
+    provider: string;
+    url: ({ path }: { path: string }) => string;
+    headers: () => Record<string, string>;
+    fetch?: FetchFunction;
+  }
+
+  const getCommonModelConfig = (modelType: string): CommonModelConfig => ({
+    provider: `togetherai.${modelType}`,
+    url: ({ path }) => `${baseURL}${path}`,
+    headers: getHeaders,
+    fetch: options.fetch,
+  });
+
+  const createChatModel = (modelId: TogetherAIChatModelId) => {
+    return new OpenAICompatibleChatLanguageModel(
+      modelId,
+      getCommonModelConfig('chat'),
+    );
+  };
+
+  const createCompletionModel = (modelId: TogetherAICompletionModelId) =>
+    new OpenAICompatibleCompletionLanguageModel(
+      modelId,
+      getCommonModelConfig('completion'),
+    );
+
+  const createEmbeddingModel = (modelId: TogetherAIEmbeddingModelId) =>
+    new OpenAICompatibleEmbeddingModel(
+      modelId,
+      getCommonModelConfig('embedding'),
+    );
+
+  const createImageModel = (modelId: TogetherAIImageModelId) =>
+    new TogetherAIImageModel(modelId, {
+      ...getCommonModelConfig('image'),
+      baseURL: baseURL ?? 'https://api.together.xyz/v1/',
+    });
+
+  const createRerankingModel = (modelId: TogetherAIRerankingModelId) =>
+    new TogetherAIRerankingModel(modelId, {
+      ...getCommonModelConfig('reranking'),
+      baseURL: baseURL ?? 'https://api.together.xyz/v1/',
+    });
+
+  const provider = (modelId: TogetherAIChatModelId) => createChatModel(modelId);
+
+  provider.specificationVersion = 'v3' as const;
+  provider.completionModel = createCompletionModel;
+  provider.languageModel = createChatModel;
+  provider.chatModel = createChatModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  provider.reranking = createRerankingModel;
+  provider.rerankingModel = createRerankingModel;
+
+  return provider;
+}
+
+export const togetherai = createTogetherAI();

package/src/version.ts

@@ -0,0 +1,6 @@
+// Version string of this package injected at build time.
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';