ai-world-sdk 1.5.11 → 1.5.13

package/pacakges/ai-sdk-provider/src/embedding/index.test.ts

@@ -1,262 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createOpenRouter } from '../provider';
-import { OpenRouterEmbeddingModel } from './index';
-
-describe('OpenRouterEmbeddingModel', () => {
-  const mockFetch = async (
-    _url: URL | RequestInfo,
-    _init?: RequestInit,
-  ): Promise<Response> => {
-    return new Response(
-      JSON.stringify({
-        id: 'test-id',
-        object: 'list',
-        data: [
-          {
-            object: 'embedding',
-            embedding: new Array(1536).fill(0.1),
-            index: 0,
-          },
-        ],
-        model: 'openai/text-embedding-3-small',
-        usage: {
-          prompt_tokens: 5,
-          total_tokens: 5,
-          cost: 0.00001,
-        },
-      }),
-      {
-        status: 200,
-        headers: {
-          'content-type': 'application/json',
-        },
-      },
-    );
-  };
-
-  describe('provider methods', () => {
-    it('should expose textEmbeddingModel method', () => {
-      const provider = createOpenRouter({ apiKey: 'test-key' });
-      expect(provider.textEmbeddingModel).toBeDefined();
-      expect(typeof provider.textEmbeddingModel).toBe('function');
-    });
-
-    it('should expose embedding method (deprecated)', () => {
-      const provider = createOpenRouter({ apiKey: 'test-key' });
-      expect(provider.embedding).toBeDefined();
-      expect(typeof provider.embedding).toBe('function');
-    });
-
-    it('should create an embedding model instance', () => {
-      const provider = createOpenRouter({ apiKey: 'test-key' });
-      const model = provider.textEmbeddingModel(
-        'openai/text-embedding-3-small',
-      );
-      expect(model).toBeInstanceOf(OpenRouterEmbeddingModel);
-      expect(model.modelId).toBe('openai/text-embedding-3-small');
-      expect(model.provider).toBe('openrouter');
-      expect(model.specificationVersion).toBe('v3');
-    });
-  });
-
-  describe('doEmbed', () => {
-    it('should embed a single value', async () => {
-      const provider = createOpenRouter({
-        apiKey: 'test-key',
-        fetch: mockFetch,
-      });
-      const model = provider.textEmbeddingModel(
-        'openai/text-embedding-3-small',
-      );
-
-      const result = await model.doEmbed({
-        values: ['sunny day at the beach'],
-      });
-
-      expect(result.embeddings).toHaveLength(1);
-      expect(result.embeddings[0]).toHaveLength(1536);
-      expect(result.usage).toEqual({ tokens: 5 });
-      expect(
-        (result.providerMetadata?.openrouter as { usage?: { cost?: number } })
-          ?.usage?.cost,
-      ).toBe(0.00001);
-    });
-
-    it('should embed multiple values', async () => {
-      const mockFetchMultiple = async (
-        _url: URL | RequestInfo,
-        _init?: RequestInit,
-      ): Promise<Response> => {
-        return new Response(
-          JSON.stringify({
-            object: 'list',
-            data: [
-              {
-                object: 'embedding',
-                embedding: new Array(1536).fill(0.1),
-                index: 0,
-              },
-              {
-                object: 'embedding',
-                embedding: new Array(1536).fill(0.2),
-                index: 1,
-              },
-              {
-                object: 'embedding',
-                embedding: new Array(1536).fill(0.3),
-                index: 2,
-              },
-            ],
-            model: 'openai/text-embedding-3-small',
-            usage: {
-              prompt_tokens: 15,
-              total_tokens: 15,
-            },
-          }),
-          {
-            status: 200,
-            headers: {
-              'content-type': 'application/json',
-            },
-          },
-        );
-      };
-
-      const provider = createOpenRouter({
-        apiKey: 'test-key',
-        fetch: mockFetchMultiple,
-      });
-      const model = provider.textEmbeddingModel(
-        'openai/text-embedding-3-small',
-      );
-
-      const result = await model.doEmbed({
-        values: [
-          'sunny day at the beach',
-          'rainy day in the city',
-          'snowy mountain peak',
-        ],
-      });
-
-      expect(result.embeddings).toHaveLength(3);
-      expect(result.embeddings[0]).toHaveLength(1536);
-      expect(result.embeddings[1]).toHaveLength(1536);
-      expect(result.embeddings[2]).toHaveLength(1536);
-      expect(result.usage).toEqual({ tokens: 15 });
-    });
-
-    it('should pass custom settings to API', async () => {
-      let capturedRequest: Record<string, unknown> | undefined;
-
-      const mockFetchWithCapture = async (
-        _url: URL | RequestInfo,
-        init?: RequestInit,
-      ): Promise<Response> => {
-        capturedRequest = JSON.parse(init?.body as string);
-        return new Response(
-          JSON.stringify({
-            object: 'list',
-            data: [
-              {
-                object: 'embedding',
-                embedding: new Array(1536).fill(0.1),
-                index: 0,
-              },
-            ],
-            model: 'openai/text-embedding-3-small',
-            usage: {
-              prompt_tokens: 5,
-              total_tokens: 5,
-            },
-          }),
-          {
-            status: 200,
-            headers: {
-              'content-type': 'application/json',
-            },
-          },
-        );
-      };
-
-      const provider = createOpenRouter({
-        apiKey: 'test-key',
-        fetch: mockFetchWithCapture,
-      });
-
-      const model = provider.textEmbeddingModel(
-        'openai/text-embedding-3-small',
-        {
-          user: 'test-user-123',
-          provider: {
-            order: ['openai'],
-            allow_fallbacks: false,
-          },
-        },
-      );
-
-      await model.doEmbed({
-        values: ['test input'],
-      });
-
-      expect(capturedRequest?.user).toBe('test-user-123');
-      expect(capturedRequest?.provider).toEqual({
-        order: ['openai'],
-        allow_fallbacks: false,
-      });
-      expect(capturedRequest?.model).toBe('openai/text-embedding-3-small');
-      expect(capturedRequest?.input).toEqual(['test input']);
-    });
-
-    it('should handle response without usage information', async () => {
-      const mockFetchNoUsage = async (
-        _url: URL | RequestInfo,
-        _init?: RequestInit,
-      ): Promise<Response> => {
-        return new Response(
-          JSON.stringify({
-            object: 'list',
-            data: [
-              {
-                object: 'embedding',
-                embedding: new Array(1536).fill(0.1),
-                index: 0,
-              },
-            ],
-            model: 'openai/text-embedding-3-small',
-          }),
-          {
-            status: 200,
-            headers: {
-              'content-type': 'application/json',
-            },
-          },
-        );
-      };
-
-      const provider = createOpenRouter({
-        apiKey: 'test-key',
-        fetch: mockFetchNoUsage,
-      });
-      const model = provider.textEmbeddingModel(
-        'openai/text-embedding-3-small',
-      );
-
-      const result = await model.doEmbed({
-        values: ['test'],
-      });
-
-      expect(result.embeddings).toHaveLength(1);
-      expect(result.usage).toBeUndefined();
-      expect(result.providerMetadata).toStrictEqual({
-        openrouter: {
-          provider: '',
-          usage: {
-            promptTokens: 0,
-            completionTokens: 0,
-            totalTokens: 0,
-          },
-        },
-      });
-    });
-  });
-});

package/pacakges/ai-sdk-provider/src/embedding/index.ts

@@ -1,113 +0,0 @@
-import type {
-  EmbeddingModelV3,
-  SharedV3Headers,
-  SharedV3ProviderMetadata,
-} from '@ai-sdk/provider';
-import type {
-  OpenRouterEmbeddingModelId,
-  OpenRouterEmbeddingSettings,
-} from '../types/openrouter-embedding-settings';
-
-import {
-  combineHeaders,
-  createJsonResponseHandler,
-  postJsonToApi,
-} from '@ai-sdk/provider-utils';
-import { openrouterFailedResponseHandler } from '../schemas/error-response';
-import { OpenRouterProviderMetadataSchema } from '../schemas/provider-metadata';
-import { OpenRouterEmbeddingResponseSchema } from './schemas';
-
-type OpenRouterEmbeddingConfig = {
-  provider: string;
-  headers: () => Record<string, string | undefined>;
-  url: (options: { modelId: string; path: string }) => string;
-  fetch?: typeof fetch;
-  extraBody?: Record<string, unknown>;
-};
-
-export class OpenRouterEmbeddingModel implements EmbeddingModelV3 {
-  readonly specificationVersion = 'v3' as const;
-  readonly provider = 'openrouter';
-  readonly modelId: OpenRouterEmbeddingModelId;
-  readonly settings: OpenRouterEmbeddingSettings;
-  readonly maxEmbeddingsPerCall = undefined;
-  readonly supportsParallelCalls = true;
-
-  private readonly config: OpenRouterEmbeddingConfig;
-
-  constructor(
-    modelId: OpenRouterEmbeddingModelId,
-    settings: OpenRouterEmbeddingSettings,
-    config: OpenRouterEmbeddingConfig,
-  ) {
-    this.modelId = modelId;
-    this.settings = settings;
-    this.config = config;
-  }
-
-  async doEmbed(options: {
-    values: Array<string>;
-    abortSignal?: AbortSignal;
-    headers?: Record<string, string | undefined>;
-  }): Promise<{
-    embeddings: Array<Array<number>>;
-    usage?: { tokens: number };
-    providerMetadata?: SharedV3ProviderMetadata;
-    response?: {
-      headers?: SharedV3Headers;
-      body?: unknown;
-    };
-    warnings: Array<import('@ai-sdk/provider').SharedV3Warning>;
-  }> {
-    const { values, abortSignal, headers } = options;
-
-    const args = {
-      model: this.modelId,
-      input: values,
-      user: this.settings.user,
-      provider: this.settings.provider,
-      ...this.config.extraBody,
-      ...this.settings.extraBody,
-    };
-
-    const { value: responseValue, responseHeaders } = await postJsonToApi({
-      url: this.config.url({
-        path: '/embeddings',
-        modelId: this.modelId,
-      }),
-      headers: combineHeaders(this.config.headers(), headers),
-      body: args,
-      failedResponseHandler: openrouterFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        OpenRouterEmbeddingResponseSchema,
-      ),
-      abortSignal,
-      fetch: this.config.fetch,
-    });
-
-    return {
-      embeddings: responseValue.data.map((item) => item.embedding),
-      usage: responseValue.usage
-        ? { tokens: responseValue.usage.prompt_tokens }
-        : undefined,
-      providerMetadata: {
-        openrouter: OpenRouterProviderMetadataSchema.parse({
-          provider: responseValue.provider ?? '',
-          usage: {
-            promptTokens: responseValue.usage?.prompt_tokens ?? 0,
-            completionTokens: 0,
-            totalTokens: responseValue.usage?.total_tokens ?? 0,
-            ...(responseValue.usage?.cost != null
-              ? { cost: responseValue.usage.cost }
-              : {}),
-          },
-        }),
-      },
-      response: {
-        headers: responseHeaders,
-        body: responseValue,
-      },
-      warnings: [],
-    };
-  }
-}

package/pacakges/ai-sdk-provider/src/embedding/schemas.ts

@@ -1,26 +0,0 @@
-import { z } from 'zod/v4';
-
-const openrouterEmbeddingUsageSchema = z.object({
-  prompt_tokens: z.number(),
-  total_tokens: z.number(),
-  cost: z.number().optional(),
-});
-
-const openrouterEmbeddingDataSchema = z.object({
-  object: z.literal('embedding'),
-  embedding: z.array(z.number()),
-  index: z.number().optional(),
-});
-
-export const OpenRouterEmbeddingResponseSchema = z.object({
-  id: z.string().optional(),
-  object: z.literal('list'),
-  data: z.array(openrouterEmbeddingDataSchema),
-  model: z.string(),
-  provider: z.string().optional(),
-  usage: openrouterEmbeddingUsageSchema.optional(),
-});
-
-export type OpenRouterEmbeddingResponse = z.infer<
-  typeof OpenRouterEmbeddingResponseSchema
->;

package/pacakges/ai-sdk-provider/src/facade.ts

@@ -1,131 +0,0 @@
-import type { OpenRouterProviderSettings } from './provider';
-import type {
-  OpenRouterChatModelId,
-  OpenRouterChatSettings,
-} from './types/openrouter-chat-settings';
-import type {
-  OpenRouterCompletionModelId,
-  OpenRouterCompletionSettings,
-} from './types/openrouter-completion-settings';
-import type {
-  OpenRouterEmbeddingModelId,
-  OpenRouterEmbeddingSettings,
-} from './types/openrouter-embedding-settings';
-
-import { loadApiKey, withoutTrailingSlash } from '@ai-sdk/provider-utils';
-import { OpenRouterChatLanguageModel } from './chat';
-import { OpenRouterCompletionLanguageModel } from './completion';
-import { OpenRouterEmbeddingModel } from './embedding';
-
-/**
-@deprecated Use `createOpenRouter` instead.
- */
-export class OpenRouter {
-  /**
-Use a different URL prefix for API calls, e.g. to use proxy servers.
-The default prefix is `https://openrouter.ai/api/v1`.
-   */
-  readonly baseURL: string;
-
-  /**
-API key that is being sent using the `Authorization` header.
-It defaults to the `OPENROUTER_API_KEY` environment variable.
- */
-  readonly apiKey?: string;
-
-  /**
-Custom headers to include in the requests.
-   */
-  readonly headers?: Record<string, string>;
-
-  /**
-   * Record of provider slugs to API keys for injecting into provider routing.
-   */
-  readonly api_keys?: Record<string, string>;
-
-  /**
-   * App display name for the `X-OpenRouter-Title` header.
-   */
-  readonly appName?: string;
-
-  /**
-   * App URL for the `HTTP-Referer` header.
-   */
-  readonly appUrl?: string;
-
-  /**
-   * Creates a new OpenRouter provider instance.
-   */
-  constructor(options: OpenRouterProviderSettings = {}) {
-    this.baseURL =
-      withoutTrailingSlash(options.baseURL ?? options.baseUrl) ??
-      'https://openrouter.ai/api/v1';
-    this.apiKey = options.apiKey;
-    this.headers = options.headers;
-    this.api_keys = options.api_keys;
-    this.appName = options.appName;
-    this.appUrl = options.appUrl;
-  }
-
-  private get baseConfig() {
-    return {
-      baseURL: this.baseURL,
-      headers: () => ({
-        Authorization: `Bearer ${loadApiKey({
-          apiKey: this.apiKey,
-          environmentVariableName: 'OPENROUTER_API_KEY',
-          description: 'OpenRouter',
-        })}`,
-        ...(this.appName && { 'X-OpenRouter-Title': this.appName }),
-        ...(this.appUrl && { 'HTTP-Referer': this.appUrl }),
-        ...this.headers,
-        ...(this.api_keys &&
-          Object.keys(this.api_keys).length > 0 && {
-            'X-Provider-API-Keys': JSON.stringify(this.api_keys),
-          }),
-      }),
-    };
-  }
-
-  chat(modelId: OpenRouterChatModelId, settings: OpenRouterChatSettings = {}) {
-    return new OpenRouterChatLanguageModel(modelId, settings, {
-      provider: 'openrouter.chat',
-      ...this.baseConfig,
-      compatibility: 'strict',
-      url: ({ path }) => `${this.baseURL}${path}`,
-    });
-  }
-
-  completion(
-    modelId: OpenRouterCompletionModelId,
-    settings: OpenRouterCompletionSettings = {},
-  ) {
-    return new OpenRouterCompletionLanguageModel(modelId, settings, {
-      provider: 'openrouter.completion',
-      ...this.baseConfig,
-      compatibility: 'strict',
-      url: ({ path }) => `${this.baseURL}${path}`,
-    });
-  }
-
-  textEmbeddingModel(
-    modelId: OpenRouterEmbeddingModelId,
-    settings: OpenRouterEmbeddingSettings = {},
-  ) {
-    return new OpenRouterEmbeddingModel(modelId, settings, {
-      provider: 'openrouter.embedding',
-      ...this.baseConfig,
-      url: ({ path }) => `${this.baseURL}${path}`,
-    });
-  }
-
-  /**
-   * @deprecated Use textEmbeddingModel instead
-   */
-  embedding(
-    modelId: OpenRouterEmbeddingModelId,
-    settings: OpenRouterEmbeddingSettings = {},
-  ) {
-    return this.textEmbeddingModel(modelId, settings);
-  }
-}