@ai-sdk/baseten 1.0.16 → 1.0.18

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @ai-sdk/baseten
 
+## 1.0.18
+
+### Patch Changes
+
+- 8dc54db: chore: add src folders to package bundle
+- Updated dependencies [8dc54db]
+  - @ai-sdk/openai-compatible@2.0.17
+
+## 1.0.17
+
+### Patch Changes
+
+- Updated dependencies [78555ad]
+  - @ai-sdk/openai-compatible@2.0.16
+
 ## 1.0.16
 
 ### Patch Changes

package/dist/index.js

@@ -34,7 +34,7 @@ var import_v4 = require("zod/v4");
 var import_performance_client = require("@basetenlabs/performance-client");
 
 // src/version.ts
-var VERSION = true ? "1.0.16" : "0.0.0-test";
+var VERSION = true ? "1.0.18" : "0.0.0-test";
 
 // src/baseten-provider.ts
 var basetenErrorSchema = import_v4.z.object({

package/dist/index.mjs

@@ -15,7 +15,7 @@ import { z } from "zod/v4";
 import { PerformanceClient } from "@basetenlabs/performance-client";
 
 // src/version.ts
-var VERSION = true ? "1.0.16" : "0.0.0-test";
+var VERSION = true ? "1.0.18" : "0.0.0-test";
 
 // src/baseten-provider.ts
 var basetenErrorSchema = z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/baseten",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -8,6 +8,7 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
+    "src",
     "CHANGELOG.md",
     "README.md"
   ],
@@ -21,7 +22,7 @@
   },
   "dependencies": {
     "@basetenlabs/performance-client": "^0.0.10",
-    "@ai-sdk/openai-compatible": "2.0.15",
+    "@ai-sdk/openai-compatible": "2.0.17",
     "@ai-sdk/provider": "3.0.4",
     "@ai-sdk/provider-utils": "4.0.8"
   },

package/src/baseten-chat-options.ts

@@ -0,0 +1,15 @@
+// https://docs.baseten.co/development/model-apis/overview#supported-models
+// Below is the current list of models supported by Baseten model APIs.
+// Ohter dedicated models are also supported, but not listed here.
+export type BasetenChatModelId =
+  | 'deepseek-ai/DeepSeek-R1-0528'
+  | 'deepseek-ai/DeepSeek-V3-0324'
+  | 'deepseek-ai/DeepSeek-V3.1'
+  | 'moonshotai/Kimi-K2-Instruct-0905'
+  | 'moonshotai/Kimi-K2-Thinking'
+  | 'Qwen/Qwen3-235B-A22B-Instruct-2507'
+  | 'Qwen/Qwen3-Coder-480B-A35B-Instruct'
+  | 'openai/gpt-oss-120b'
+  | 'zai-org/GLM-4.6'
+  | 'zai-org/GLM-4.7'
+  | (string & {});

package/src/baseten-embedding-options.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod/v4';
+
+// https://www.baseten.co/library/tag/embedding/
+// Pass in the model URL directly, we won't be using the model ID
+
+export type BasetenEmbeddingModelId = string & {};
+
+export const basetenEmbeddingProviderOptions = z.object({});
+
+export type BasetenEmbeddingProviderOptions = z.infer<
+  typeof basetenEmbeddingProviderOptions
+>;

package/src/baseten-provider.ts

@@ -0,0 +1,247 @@
+import {
+  OpenAICompatibleChatLanguageModel,
+  OpenAICompatibleEmbeddingModel,
+  ProviderErrorStructure,
+} from '@ai-sdk/openai-compatible';
+import {
+  EmbeddingModelV3,
+  LanguageModelV3,
+  NoSuchModelError,
+  ProviderV3,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { BasetenChatModelId } from './baseten-chat-options';
+import { BasetenEmbeddingModelId } from './baseten-embedding-options';
+import { PerformanceClient } from '@basetenlabs/performance-client';
+import { VERSION } from './version';
+
+export type BasetenErrorData = z.infer<typeof basetenErrorSchema>;
+
+const basetenErrorSchema = z.object({
+  error: z.string(),
+});
+
+const basetenErrorStructure: ProviderErrorStructure<BasetenErrorData> = {
+  errorSchema: basetenErrorSchema,
+  errorToMessage: data => data.error,
+};
+
+export interface BasetenProviderSettings {
+  /**
+   * Baseten API key. Default value is taken from the `BASETEN_API_KEY`
+   * environment variable.
+   */
+  apiKey?: string;
+
+  /**
+   * Base URL for the Model APIs. Default: 'https://inference.baseten.co/v1'
+   */
+  baseURL?: string;
+
+  /**
+   * Model URL for custom models (chat or embeddings).
+   * If not supplied, the default Model APIs will be used.
+   */
+  modelURL?: 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 BasetenProvider extends ProviderV3 {
+  /**
+Creates a chat model for text generation.
+*/
+  (modelId?: BasetenChatModelId): LanguageModelV3;
+
+  /**
+Creates a chat model for text generation.
+*/
+  chatModel(modelId?: BasetenChatModelId): LanguageModelV3;
+
+  /**
+Creates a language model for text generation. Alias for chatModel.
+*/
+  languageModel(modelId?: BasetenChatModelId): LanguageModelV3;
+
+  /**
+Creates a embedding model for text generation.
+*/
+  embeddingModel(modelId?: BasetenEmbeddingModelId): EmbeddingModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId?: BasetenEmbeddingModelId): EmbeddingModelV3;
+}
+
+// by default, we use the Model APIs
+const defaultBaseURL = 'https://inference.baseten.co/v1';
+
+export function createBaseten(
+  options: BasetenProviderSettings = {},
+): BasetenProvider {
+  const baseURL = withoutTrailingSlash(options.baseURL ?? defaultBaseURL);
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        Authorization: `Bearer ${loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'BASETEN_API_KEY',
+          description: 'Baseten API key',
+        })}`,
+        ...options.headers,
+      },
+      `ai-sdk/baseten/${VERSION}`,
+    );
+
+  interface CommonModelConfig {
+    provider: string;
+    url: ({ path }: { path: string }) => string;
+    headers: () => Record<string, string>;
+    fetch?: FetchFunction;
+  }
+
+  const getCommonModelConfig = (
+    modelType: string,
+    customURL?: string,
+  ): CommonModelConfig => ({
+    provider: `baseten.${modelType}`,
+    url: ({ path }) => {
+      // For embeddings with /sync URLs (but not /sync/v1), we need to add /v1
+      if (
+        modelType === 'embedding' &&
+        customURL?.includes('/sync') &&
+        !customURL?.includes('/sync/v1')
+      ) {
+        return `${customURL}/v1${path}`;
+      }
+      return `${customURL || baseURL}${path}`;
+    },
+    headers: getHeaders,
+    fetch: options.fetch,
+  });
+
+  const createChatModel = (modelId?: BasetenChatModelId) => {
+    // Use modelURL if provided, otherwise use default Model APIs
+    const customURL = options.modelURL;
+
+    if (customURL) {
+      // Check if this is a /sync/v1 endpoint (OpenAI-compatible) or /predict endpoint (custom)
+      const isOpenAICompatible = customURL.includes('/sync/v1');
+
+      if (isOpenAICompatible) {
+        // For /sync/v1 endpoints, use standard OpenAI-compatible format
+        return new OpenAICompatibleChatLanguageModel(modelId ?? 'placeholder', {
+          ...getCommonModelConfig('chat', customURL),
+          errorStructure: basetenErrorStructure,
+        });
+      } else if (customURL.includes('/predict')) {
+        throw new Error(
+          'Not supported. You must use a /sync/v1 endpoint for chat models.',
+        );
+      }
+    }
+
+    // Use default OpenAI-compatible format for Model APIs
+    return new OpenAICompatibleChatLanguageModel(modelId ?? 'chat', {
+      ...getCommonModelConfig('chat'),
+      errorStructure: basetenErrorStructure,
+    });
+  };
+
+  const createEmbeddingModel = (modelId?: BasetenEmbeddingModelId) => {
+    // Use modelURL if provided
+    const customURL = options.modelURL;
+    if (!customURL) {
+      throw new Error(
+        'No model URL provided for embeddings. Please set modelURL option for embeddings.',
+      );
+    }
+
+    // Check if this is a /sync or /sync/v1 endpoint (OpenAI-compatible)
+    // We support both /sync and /sync/v1, stripping /v1 before passing to Performance Client, as Performance Client adds /v1 itself
+    const isOpenAICompatible = customURL.includes('/sync');
+
+    if (isOpenAICompatible) {
+      // Create the model using OpenAICompatibleEmbeddingModel and override doEmbed
+      const model = new OpenAICompatibleEmbeddingModel(
+        modelId ?? 'embeddings',
+        {
+          ...getCommonModelConfig('embedding', customURL),
+          errorStructure: basetenErrorStructure,
+        },
+      );
+
+      // Strip /v1 from URL if present before passing to Performance Client to avoid double /v1
+      const performanceClientURL = customURL.replace('/sync/v1', '/sync');
+
+      // Initialize the B10 Performance Client once for reuse
+      const performanceClient = new PerformanceClient(
+        performanceClientURL,
+        loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'BASETEN_API_KEY',
+          description: 'Baseten API key',
+        }),
+      );
+
+      // Override the doEmbed method to use the pre-created Performance Client
+      model.doEmbed = async params => {
+        if (!params.values || !Array.isArray(params.values)) {
+          throw new Error('params.values must be an array of strings');
+        }
+
+        // Performance Client handles batching internally, so we don't need to limit in 128 here
+        const response = await performanceClient.embed(
+          params.values,
+          modelId ?? 'embeddings', // model_id is for Model APIs, we don't use it here for dedicated
+        );
+        // Transform the response to match the expected format
+        const embeddings = response.data.map((item: any) => item.embedding);
+
+        return {
+          embeddings,
+          usage: response.usage
+            ? { tokens: response.usage.total_tokens }
+            : undefined,
+          response: { headers: {}, body: response },
+          warnings: [],
+        };
+      };
+
+      return model;
+    } else {
+      throw new Error(
+        'Not supported. You must use a /sync or /sync/v1 endpoint for embeddings.',
+      );
+    }
+  };
+
+  const provider = (modelId?: BasetenChatModelId) => createChatModel(modelId);
+
+  provider.specificationVersion = 'v3' as const;
+  provider.chatModel = createChatModel;
+  provider.languageModel = createChatModel;
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+  };
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  return provider;
+}
+
+export const baseten = createBaseten();

package/src/baseten-provider.unit.test.ts

@@ -0,0 +1,446 @@
+import { describe, it, expect, vi, beforeEach, Mock } from 'vitest';
+import { createBaseten } from './baseten-provider';
+import {
+  LanguageModelV3,
+  EmbeddingModelV3,
+  NoSuchModelError,
+} from '@ai-sdk/provider';
+import { loadApiKey } from '@ai-sdk/provider-utils';
+import {
+  OpenAICompatibleChatLanguageModel,
+  OpenAICompatibleEmbeddingModel,
+} from '@ai-sdk/openai-compatible';
+
+// Mock the OpenAI-compatible classes
+const OpenAICompatibleChatLanguageModelMock =
+  OpenAICompatibleChatLanguageModel as unknown as Mock;
+const OpenAICompatibleEmbeddingModelMock =
+  OpenAICompatibleEmbeddingModel as unknown as Mock;
+
+vi.mock('@ai-sdk/openai-compatible', () => {
+  const createMockConstructor = (providerName: string) => {
+    const mockConstructor = vi.fn().mockImplementation(function (
+      this: any,
+      modelId: string,
+      settings: any,
+    ) {
+      this.provider = providerName;
+      this.modelId = modelId;
+      this.settings = settings;
+      this.doGenerate = vi.fn();
+      this.doEmbed = vi.fn();
+    });
+    return mockConstructor;
+  };
+
+  return {
+    OpenAICompatibleChatLanguageModel: createMockConstructor('baseten.chat'),
+    OpenAICompatibleEmbeddingModel: createMockConstructor('baseten.embedding'),
+  };
+});
+
+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('@basetenlabs/performance-client', () => ({
+  PerformanceClient: vi.fn().mockImplementation(() => ({
+    embed: vi.fn(),
+    embedBatch: vi.fn(),
+  })),
+}));
+
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+describe('BasetenProvider', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('createBaseten', () => {
+    it('should create a BasetenProvider instance with default options', () => {
+      const provider = createBaseten();
+      const model = provider.chatModel('deepseek-ai/DeepSeek-V3-0324');
+
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      const headers = config.headers();
+
+      expect(loadApiKey).toHaveBeenCalledWith({
+        apiKey: undefined,
+        environmentVariableName: 'BASETEN_API_KEY',
+        description: 'Baseten API key',
+      });
+      expect(headers.authorization).toBe('Bearer mock-api-key');
+      expect(config.provider).toBe('baseten.chat');
+    });
+
+    it('should create a BasetenProvider instance with custom options', () => {
+      const options = {
+        apiKey: 'custom-key',
+        baseURL: 'https://custom.url',
+        headers: { 'Custom-Header': 'value' },
+      };
+      const provider = createBaseten(options);
+      const model = provider.chatModel('deepseek-ai/DeepSeek-V3-0324');
+
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      const headers = config.headers();
+
+      expect(loadApiKey).toHaveBeenCalledWith({
+        apiKey: 'custom-key',
+        environmentVariableName: 'BASETEN_API_KEY',
+        description: 'Baseten API key',
+      });
+      expect(headers['custom-header']).toBe('value');
+    });
+
+    it('should support optional modelId parameter', () => {
+      const provider = createBaseten();
+
+      // Should work without modelId
+      const model1 = provider();
+      expect(model1).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+
+      // Should work with modelId
+      const model2 = provider('deepseek-ai/DeepSeek-V3-0324');
+      expect(model2).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+    });
+  });
+
+  describe('chatModel', () => {
+    it('should construct a chat model with correct configuration for default Model APIs', () => {
+      const provider = createBaseten();
+      const modelId = 'deepseek-ai/DeepSeek-V3-0324';
+
+      const model = provider.chatModel(modelId);
+
+      expect(model).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+      expect(OpenAICompatibleChatLanguageModelMock).toHaveBeenCalledWith(
+        modelId,
+        expect.objectContaining({
+          provider: 'baseten.chat',
+          errorStructure: expect.any(Object),
+        }),
+      );
+    });
+
+    it('should construct a chat model with optional modelId', () => {
+      const provider = createBaseten();
+
+      // Should work without modelId
+      const model1 = provider.chatModel();
+      expect(model1).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+      expect(OpenAICompatibleChatLanguageModelMock).toHaveBeenCalledWith(
+        'chat',
+        expect.any(Object),
+      );
+
+      // Should work with modelId
+      const model2 = provider.chatModel('deepseek-ai/DeepSeek-V3-0324');
+      expect(model2).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+    });
+
+    it('should handle /sync/v1 endpoints correctly', () => {
+      const provider = createBaseten({
+        modelURL:
+          'https://model-123.api.baseten.co/environments/production/sync/v1',
+      });
+
+      const model = provider.chatModel();
+
+      expect(model).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+      expect(OpenAICompatibleChatLanguageModelMock).toHaveBeenCalledWith(
+        'placeholder',
+        expect.objectContaining({
+          provider: 'baseten.chat',
+          url: expect.any(Function),
+          errorStructure: expect.any(Object),
+        }),
+      );
+
+      // Test URL construction
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      const url = config.url({ path: '/chat/completions' });
+      expect(url).toBe(
+        'https://model-123.api.baseten.co/environments/production/sync/v1/chat/completions',
+      );
+    });
+
+    it('should throw error for /predict endpoints with chat models', () => {
+      const provider = createBaseten({
+        modelURL:
+          'https://model-123.api.baseten.co/environments/production/predict',
+      });
+
+      expect(() => {
+        provider.chatModel();
+      }).toThrow(
+        'Not supported. You must use a /sync/v1 endpoint for chat models.',
+      );
+    });
+  });
+
+  describe('languageModel', () => {
+    it('should be an alias for chatModel', () => {
+      const provider = createBaseten();
+      const modelId = 'deepseek-ai/DeepSeek-V3-0324';
+
+      const chatModel = provider.chatModel(modelId);
+      const languageModel = provider.languageModel(modelId);
+
+      expect(chatModel).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+      expect(languageModel).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+    });
+
+    it('should support optional modelId parameter', () => {
+      const provider = createBaseten();
+
+      const model1 = provider.languageModel();
+      expect(model1).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+
+      const model2 = provider.languageModel('deepseek-ai/DeepSeek-V3-0324');
+      expect(model2).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+    });
+  });
+
+  describe('textEmbeddingModel', () => {
+    it('should throw error when no modelURL is provided', () => {
+      const provider = createBaseten();
+
+      expect(() => {
+        provider.embeddingModel();
+      }).toThrow(
+        'No model URL provided for embeddings. Please set modelURL option for embeddings.',
+      );
+    });
+
+    it('should construct embedding model for /sync endpoints', () => {
+      const provider = createBaseten({
+        modelURL:
+          'https://model-123.api.baseten.co/environments/production/sync',
+      });
+
+      const model = provider.embeddingModel();
+
+      expect(model).toBeInstanceOf(OpenAICompatibleEmbeddingModel);
+      expect(OpenAICompatibleEmbeddingModelMock).toHaveBeenCalledWith(
+        'embeddings',
+        expect.objectContaining({
+          provider: 'baseten.embedding',
+          url: expect.any(Function),
+          errorStructure: expect.any(Object),
+        }),
+      );
+
+      // Test URL construction for embeddings (Performance Client adds /v1/embeddings)
+      const constructorCall = OpenAICompatibleEmbeddingModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      const url = config.url({ path: '/embeddings' });
+      expect(url).toBe(
+        'https://model-123.api.baseten.co/environments/production/sync/v1/embeddings',
+      );
+    });
+
+    it('should throw error for /predict endpoints (not supported with Performance Client)', () => {
+      const provider = createBaseten({
+        modelURL:
+          'https://model-123.api.baseten.co/environments/production/predict',
+      });
+
+      expect(() => {
+        provider.embeddingModel();
+      }).toThrow(
+        'Not supported. You must use a /sync or /sync/v1 endpoint for embeddings.',
+      );
+    });
+
+    it('should support /sync/v1 endpoints (strips /v1 before passing to Performance Client)', () => {
+      const provider = createBaseten({
+        modelURL:
+          'https://model-123.api.baseten.co/environments/production/sync/v1',
+      });
+
+      const model = provider.embeddingModel();
+
+      expect(model).toBeInstanceOf(OpenAICompatibleEmbeddingModel);
+      expect(OpenAICompatibleEmbeddingModelMock).toHaveBeenCalledWith(
+        'embeddings',
+        expect.any(Object),
+      );
+    });
+
+    it('should support custom modelId for embeddings', () => {
+      const provider = createBaseten({
+        modelURL:
+          'https://model-123.api.baseten.co/environments/production/sync',
+      });
+
+      const model = provider.embeddingModel();
+
+      expect(model).toBeInstanceOf(OpenAICompatibleEmbeddingModel);
+      expect(OpenAICompatibleEmbeddingModelMock).toHaveBeenCalledWith(
+        'embeddings',
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe('imageModel', () => {
+    it('should throw NoSuchModelError for unsupported image models', () => {
+      const provider = createBaseten();
+
+      expect(() => {
+        provider.imageModel('test-model');
+      }).toThrow(NoSuchModelError);
+    });
+  });
+
+  describe('URL construction', () => {
+    it('should use default baseURL when no modelURL is provided', () => {
+      const provider = createBaseten();
+      const model = provider.chatModel('test-model');
+
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      const url = config.url({ path: '/chat/completions' });
+      expect(url).toBe('https://inference.baseten.co/v1/chat/completions');
+    });
+
+    it('should use custom baseURL when provided', () => {
+      const provider = createBaseten({
+        baseURL: 'https://custom.baseten.co/v1',
+      });
+      const model = provider.chatModel('test-model');
+
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      const url = config.url({ path: '/chat/completions' });
+      expect(url).toBe('https://custom.baseten.co/v1/chat/completions');
+    });
+
+    it('should use modelURL for custom endpoints', () => {
+      const provider = createBaseten({
+        modelURL:
+          'https://model-123.api.baseten.co/environments/production/sync/v1',
+      });
+      const model = provider.chatModel();
+
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      const url = config.url({ path: '/chat/completions' });
+      expect(url).toBe(
+        'https://model-123.api.baseten.co/environments/production/sync/v1/chat/completions',
+      );
+    });
+  });
+
+  describe('Headers', () => {
+    it('should include Authorization header with API key', () => {
+      const provider = createBaseten();
+      const model = provider.chatModel('test-model');
+
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      const headers = config.headers();
+
+      expect(headers.authorization).toBe('Bearer mock-api-key');
+    });
+
+    it('should include custom headers when provided', () => {
+      const provider = createBaseten({
+        headers: { 'Custom-Header': 'custom-value' },
+      });
+      const model = provider.chatModel('test-model');
+
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      const headers = config.headers();
+
+      expect(headers.authorization).toBe('Bearer mock-api-key');
+      expect(headers['custom-header']).toBe('custom-value');
+    });
+
+    it('should include user-agent with version', async () => {
+      const fetchMock = vi
+        .fn()
+        .mockResolvedValue(new Response('{}', { status: 200 }));
+
+      const provider = createBaseten({ fetch: fetchMock });
+      const model = provider.chatModel('test-model');
+
+      const constructorCall =
+        OpenAICompatibleChatLanguageModelMock.mock.calls[0];
+      const config = constructorCall[1];
+      const headers = config.headers();
+
+      await fetchMock('https://example.com/test', {
+        method: 'POST',
+        headers,
+      });
+
+      expect(fetchMock.mock.calls[0][1].headers['user-agent']).toContain(
+        'ai-sdk/baseten/0.0.0-test',
+      );
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle missing modelURL for embeddings gracefully', () => {
+      const provider = createBaseten();
+
+      expect(() => {
+        provider.embeddingModel();
+      }).toThrow(
+        'No model URL provided for embeddings. Please set modelURL option for embeddings.',
+      );
+    });
+
+    it('should handle unsupported image models', () => {
+      const provider = createBaseten();
+
+      expect(() => {
+        provider.imageModel('unsupported-model');
+      }).toThrow(NoSuchModelError);
+    });
+  });
+
+  describe('Provider interface', () => {
+    it('should implement all required provider methods', () => {
+      const provider = createBaseten();
+
+      expect(typeof provider).toBe('function');
+      expect(typeof provider.chatModel).toBe('function');
+      expect(typeof provider.languageModel).toBe('function');
+      expect(typeof provider.embeddingModel).toBe('function');
+      expect(typeof provider.imageModel).toBe('function');
+    });
+
+    it('should allow calling provider as function', () => {
+      const provider = createBaseten();
+
+      const model1 = provider();
+      expect(model1).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+
+      const model2 = provider('test-model');
+      expect(model2).toBeInstanceOf(OpenAICompatibleChatLanguageModel);
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,8 @@
+export type { BasetenChatModelId } from './baseten-chat-options';
+export { baseten, createBaseten } from './baseten-provider';
+export type {
+  BasetenProvider,
+  BasetenProviderSettings,
+  BasetenErrorData,
+} from './baseten-provider';
+export { VERSION } from './version';

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';