vectra 0.12.2 → 0.14.0

package/src/OpenAIEmbeddings.spec.ts

@@ -0,0 +1,354 @@
+import assert from 'node:assert';
+import sinon from 'sinon';
+import {
+  OpenAIEmbeddings,
+  AzureOpenAIEmbeddingsOptions,
+  OSSEmbeddingsOptions,
+  OpenAIEmbeddingsOptions
+} from './OpenAIEmbeddings';
+
+describe('OpenAIEmbeddings', () => {
+  let sandbox: sinon.SinonSandbox;
+  let fetchStub: sinon.SinonStub;
+
+  function makeFetchResponse(status: number, data: any, statusText = ''): Response {
+    return {
+      status,
+      statusText,
+      ok: status >= 200 && status < 300,
+      headers: new Headers(),
+      json: async () => data,
+      text: async () => JSON.stringify(data),
+    } as Response;
+  }
+
+  const successData = {
+    object: 'list',
+    model: 'any',
+    data: [
+      { index: 0, object: 'embedding', embedding: [0.1, 0.2] }
+    ],
+    usage: { prompt_tokens: 1, total_tokens: 1 }
+  };
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+    fetchStub = sandbox.stub(globalThis, 'fetch');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('Azure: trims trailing slash, enforces https, defaults apiVersion and maxTokens', () => {
+    const inst = new OpenAIEmbeddings({
+      azureApiKey: 'key',
+      azureEndpoint: 'https://example.com/',
+      azureDeployment: 'dep'
+    } as AzureOpenAIEmbeddingsOptions);
+
+    const opts = (inst as any).options as AzureOpenAIEmbeddingsOptions;
+    assert.strictEqual(opts.azureEndpoint, 'https://example.com');
+    assert.strictEqual(opts.azureApiVersion, '2023-05-15');
+    assert.strictEqual(inst.maxTokens, 500);
+
+    // Private enum: ClientType.AzureOpenAI == 1
+    assert.strictEqual((inst as any)._clientType, 1);
+  });
+
+  it('Azure: throws for non-https endpoint', () => {
+    assert.throws(() => {
+      new OpenAIEmbeddings({
+        azureApiKey: 'key',
+        azureEndpoint: 'http://example.com',
+        azureDeployment: 'dep'
+      } as AzureOpenAIEmbeddingsOptions);
+    }, /Client created with an invalid endpoint of 'http:\/\/example.com'. The endpoint must be a valid HTTPS url\./);
+  });
+
+  it('OSS: selects OSS client type, defaults retryPolicy, respects maxTokens', () => {
+    const inst = new OpenAIEmbeddings({
+      ossModel: 'oss-emb',
+      ossEndpoint: 'https://oss.example.com',
+      maxTokens: 1234
+    } as OSSEmbeddingsOptions);
+
+    const opts = (inst as any).options as OSSEmbeddingsOptions;
+    assert.deepStrictEqual(opts.retryPolicy, [2000, 5000]);
+    assert.strictEqual(inst.maxTokens, 1234);
+
+    // Private enum: ClientType.OSS == 2
+    assert.strictEqual((inst as any)._clientType, 2);
+  });
+
+  it('OpenAI: selects OpenAI client type and defaults retryPolicy', () => {
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'text-embedding-3-small'
+    } as OpenAIEmbeddingsOptions);
+
+    const opts = (inst as any).options as OpenAIEmbeddingsOptions;
+    assert.deepStrictEqual(opts.retryPolicy, [2000, 5000]);
+
+    // Private enum: ClientType.OpenAI == 0
+    assert.strictEqual((inst as any)._clientType, 0);
+  });
+
+  it('Azure: URL formation and dimensions passthrough', async () => {
+    fetchStub.resolves(makeFetchResponse(200, successData));
+
+    const inst = new OpenAIEmbeddings({
+      azureApiKey: 'key',
+      azureEndpoint: 'https://example.com/',
+      azureDeployment: 'dep',
+      dimensions: 256
+    } as AzureOpenAIEmbeddingsOptions);
+
+    await inst.createEmbeddings('hello');
+
+    const [url, init] = fetchStub.getCall(0).args;
+    assert.strictEqual(url, 'https://example.com/openai/deployments/dep/embeddings?api-version=2023-05-15');
+    const body = JSON.parse(init.body);
+    assert.strictEqual(body.input, 'hello');
+    assert.strictEqual(body.dimensions, 256);
+  });
+
+  it('OSS: URL formation and model injection', async () => {
+    fetchStub.resolves(makeFetchResponse(200, successData));
+
+    const inst = new OpenAIEmbeddings({
+      ossModel: 'oss-emb',
+      ossEndpoint: 'https://oss.example.com'
+    } as OSSEmbeddingsOptions);
+
+    await inst.createEmbeddings('text');
+    const [url, init] = fetchStub.getCall(0).args;
+    assert.strictEqual(url, 'https://oss.example.com/v1/embeddings');
+    const body = JSON.parse(init.body);
+    assert.strictEqual(body.input, 'text');
+    assert.strictEqual(body.model, 'oss-emb');
+  });
+
+  it('OpenAI: URL formation (default endpoint) and model injection', async () => {
+    fetchStub.resolves(makeFetchResponse(200, successData));
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm'
+    } as OpenAIEmbeddingsOptions);
+
+    await inst.createEmbeddings('x');
+    const [url, init] = fetchStub.getCall(0).args;
+    assert.strictEqual(url, 'https://api.openai.com/v1/embeddings');
+    const body = JSON.parse(init.body);
+    assert.strictEqual(body.model, 'm');
+  });
+
+  it('OpenAI: URL formation (custom endpoint)', async () => {
+    fetchStub.resolves(makeFetchResponse(200, successData));
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm',
+      endpoint: 'https://custom'
+    } as OpenAIEmbeddingsOptions);
+
+    await inst.createEmbeddings('x');
+    const [url] = fetchStub.getCall(0).args;
+    assert.strictEqual(url, 'https://custom/v1/embeddings');
+  });
+
+  it('Azure: headers include Content-Type, User-Agent, api-key', async () => {
+    fetchStub.resolves(makeFetchResponse(200, successData));
+
+    const inst = new OpenAIEmbeddings({
+      azureApiKey: 'key',
+      azureEndpoint: 'https://example.com/',
+      azureDeployment: 'dep'
+    } as AzureOpenAIEmbeddingsOptions);
+
+    await inst.createEmbeddings('x');
+    const [, init] = fetchStub.getCall(0).args;
+    const headers = new Headers(init.headers);
+    assert.strictEqual(headers.get('Content-Type'), 'application/json');
+    assert.strictEqual(headers.get('User-Agent'), 'AlphaWave');
+    assert.strictEqual(headers.get('api-key'), 'key');
+  });
+
+  it('OpenAI: headers include Authorization and OpenAI-Organization when provided', async () => {
+    fetchStub.resolves(makeFetchResponse(200, successData));
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm',
+      organization: 'org1'
+    } as OpenAIEmbeddingsOptions);
+
+    await inst.createEmbeddings('x');
+    const [, init] = fetchStub.getCall(0).args;
+    const headers = new Headers(init.headers);
+    assert.strictEqual(headers.get('Authorization'), 'Bearer sk');
+    assert.strictEqual(headers.get('OpenAI-Organization'), 'org1');
+  });
+
+  it('Respects pre-supplied headers from requestConfig and does not overwrite them', async () => {
+    fetchStub.resolves(makeFetchResponse(200, successData));
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm',
+      requestConfig: {
+        headers: {
+          'Content-Type': 'application/x-custom',
+          'User-Agent': 'MyUA',
+          'X-Custom': '1'
+        }
+      }
+    } as OpenAIEmbeddingsOptions);
+
+    await inst.createEmbeddings('x');
+    const [, init] = fetchStub.getCall(0).args;
+    const headers = new Headers(init.headers);
+
+    assert.strictEqual(headers.get('Content-Type'), 'application/x-custom'); // preserved
+    assert.strictEqual(headers.get('User-Agent'), 'MyUA'); // preserved
+    assert.strictEqual(headers.get('X-Custom'), '1'); // preserved
+    assert.strictEqual(headers.get('Authorization'), 'Bearer sk'); // added
+  });
+
+  it('429 retry path obeys retryPolicy delays and eventually succeeds', async () => {
+    const clock = sandbox.useFakeTimers();
+
+    const resp429 = makeFetchResponse(429, {} as any);
+    const resp200 = makeFetchResponse(200, successData);
+
+    fetchStub.onCall(0).resolves(resp429);
+    fetchStub.onCall(1).resolves(resp429);
+    fetchStub.onCall(2).resolves(resp200);
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm',
+      retryPolicy: [10, 20]
+    } as OpenAIEmbeddingsOptions);
+
+    const p = inst.createEmbeddings('x');
+    await clock.tickAsync(10);
+    await clock.tickAsync(20);
+    const result = await p;
+
+    assert.strictEqual(fetchStub.callCount, 3);
+    assert.strictEqual(result.status, 'success');
+
+    clock.restore();
+  });
+
+  it('429 with empty retryPolicy returns rate_limited', async () => {
+    const resp429 = makeFetchResponse(429, {} as any);
+    fetchStub.resolves(resp429);
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm',
+      retryPolicy: []
+    } as OpenAIEmbeddingsOptions);
+
+    const result = await inst.createEmbeddings('x');
+    assert.strictEqual(result.status, 'rate_limited');
+    assert.ok((result.message || '').includes('rate limit'));
+  });
+
+  it('Success maps embeddings sorted by index', async () => {
+    const data = {
+      object: 'list',
+      model: 'any',
+      data: [
+        { index: 2, object: 'embedding', embedding: [3] },
+        { index: 0, object: 'embedding', embedding: [1] },
+        { index: 1, object: 'embedding', embedding: [2] }
+      ],
+      usage: { prompt_tokens: 1, total_tokens: 1 }
+    };
+    fetchStub.resolves(makeFetchResponse(200, data));
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm'
+    } as OpenAIEmbeddingsOptions);
+
+    const result = await inst.createEmbeddings(['a', 'b', 'c']);
+    assert.strictEqual(result.status, 'success');
+    assert.deepStrictEqual(result.output, [[1], [2], [3]]);
+  });
+
+  it('Non-429 error returns status error with message', async () => {
+    fetchStub.resolves(makeFetchResponse(500, {} as any, 'Internal Server Error'));
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm'
+    } as OpenAIEmbeddingsOptions);
+
+    const result = await inst.createEmbeddings('x');
+    assert.strictEqual(result.status, 'error');
+    assert.strictEqual(result.message, 'The embeddings API returned an error status of 500: Internal Server Error');
+  });
+
+  it('logRequests true logs request and response details', async () => {
+    fetchStub.resolves(makeFetchResponse(200, successData));
+    const logSpy = sandbox.stub(console, 'log');
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm',
+      logRequests: true
+    } as OpenAIEmbeddingsOptions);
+
+    await inst.createEmbeddings('x');
+
+    assert.ok(logSpy.callCount >= 4);
+  });
+
+  it('Input handling: string preserved in body', async () => {
+    fetchStub.resolves(makeFetchResponse(200, successData));
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm'
+    } as OpenAIEmbeddingsOptions);
+
+    await inst.createEmbeddings('hello');
+    const [, init] = fetchStub.getCall(0).args;
+    const body = JSON.parse(init.body);
+    assert.strictEqual(body.input, 'hello');
+  });
+
+  it('Input handling: string[] preserved in body', async () => {
+    fetchStub.resolves(makeFetchResponse(200, successData));
+
+    const inst = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm'
+    } as OpenAIEmbeddingsOptions);
+
+    await inst.createEmbeddings(['a', 'b']);
+    const [, init] = fetchStub.getCall(0).args;
+    const body = JSON.parse(init.body);
+    assert.deepStrictEqual(body.input, ['a', 'b']);
+  });
+
+  it('maxTokens default and override', () => {
+    const instDefault = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm'
+    } as OpenAIEmbeddingsOptions);
+    assert.strictEqual(instDefault.maxTokens, 500);
+
+    const instOverride = new OpenAIEmbeddings({
+      apiKey: 'sk',
+      model: 'm',
+      maxTokens: 1024
+    } as OpenAIEmbeddingsOptions);
+    assert.strictEqual(instOverride.maxTokens, 1024);
+  });
+});

package/src/OpenAIEmbeddings.ts

@@ -1,4 +1,3 @@
-import axios, { AxiosInstance, AxiosResponse, AxiosRequestConfig } from 'axios';
 import { EmbeddingsModel, EmbeddingsResponse } from "./types";
 import { CreateEmbeddingRequest, CreateEmbeddingResponse, OpenAICreateEmbeddingRequest } from "./internals";
 import { Colorize } from "./internals";
@@ -32,7 +31,7 @@ export interface BaseOpenAIEmbeddingsOptions {
     /**
      * Optional. Request options to use when calling the OpenAI API.
      */
-    requestConfig?: AxiosRequestConfig;
+    requestConfig?: RequestInit;
 }
 
 
@@ -112,13 +111,12 @@ export interface AzureOpenAIEmbeddingsOptions extends BaseOpenAIEmbeddingsOption
  * @remarks
  */
 export class OpenAIEmbeddings implements EmbeddingsModel {
-    private readonly _httpClient: AxiosInstance;
     private readonly _clientType: ClientType;
 
     private readonly UserAgent = 'AlphaWave';
 
     public readonly maxTokens;
-    
+
     /**
      * Options the client was configured with.
      */
@@ -161,11 +159,6 @@ export class OpenAIEmbeddings implements EmbeddingsModel {
                 retryPolicy: [2000, 5000]
             }, options) as OpenAIEmbeddingsOptions;
         }
-
-        // Create client
-        this._httpClient = axios.create({
-            validateStatus: (status) => status < 400 || status == 429
-        });
     }
 
     /**
@@ -185,17 +178,19 @@ export class OpenAIEmbeddings implements EmbeddingsModel {
             input: inputs,
         });
 
+        const data = await response.json() as CreateEmbeddingResponse;
+
         if (this.options.logRequests) {
             console.log(Colorize.title('RESPONSE:'));
             console.log(Colorize.value('status', response.status));
             console.log(Colorize.value('duration', Date.now() - startTime, 'ms'));
-            console.log(Colorize.output(response.data));
+            console.log(Colorize.output(data));
         }
 
 
         // Process response
         if (response.status < 300) {
-            return { status: 'success', output: response.data.data.sort((a, b) => a.index - b.index).map((item) => item.embedding) };
+            return { status: 'success', output: data.data.sort((a, b) => a.index - b.index).map((item) => item.embedding) };
         } else if (response.status == 429) {
             return { status: 'rate_limited', message: `The embeddings API returned a rate limit error.` }
         } else {
@@ -206,7 +201,7 @@ export class OpenAIEmbeddings implements EmbeddingsModel {
     /**
      * @private
      */
-    protected createEmbeddingRequest(request: CreateEmbeddingRequest): Promise<AxiosResponse<CreateEmbeddingResponse>> {
+    protected createEmbeddingRequest(request: CreateEmbeddingRequest): Promise<Response> {
         if (this.options.dimensions) {
             request.dimensions = this.options.dimensions;
         }
@@ -230,33 +225,37 @@ export class OpenAIEmbeddings implements EmbeddingsModel {
     /**
      * @private
      */
-    protected async post<TData>(url: string, body: object, retryCount = 0): Promise<AxiosResponse<TData>> {
-        // Initialize request config
-        const requestConfig: AxiosRequestConfig = Object.assign({}, this.options.requestConfig);
+    protected async post(url: string, body: object, retryCount = 0): Promise<Response> {
+        // Initialize headers from requestConfig
+        const baseHeaders = new Headers((this.options.requestConfig?.headers as Record<string, string>) ?? {});
 
-        // Initialize request headers
-        if (!requestConfig.headers) {
-            requestConfig.headers = {};
+        // Set defaults if not already provided
+        if (!baseHeaders.has('Content-Type')) {
+            baseHeaders.set('Content-Type', 'application/json');
         }
-        if (!requestConfig.headers['Content-Type']) {
-            requestConfig.headers['Content-Type'] = 'application/json';
-        }
-        if (!requestConfig.headers['User-Agent']) {
-            requestConfig.headers['User-Agent'] = this.UserAgent;
+        if (!baseHeaders.has('User-Agent')) {
+            baseHeaders.set('User-Agent', this.UserAgent);
         }
+
+        // Set auth headers
         if (this._clientType == ClientType.AzureOpenAI) {
             const options = this.options as AzureOpenAIEmbeddingsOptions;
-            requestConfig.headers['api-key'] = options.azureApiKey;
+            baseHeaders.set('api-key', options.azureApiKey);
         } else if (this._clientType == ClientType.OpenAI) {
             const options = this.options as OpenAIEmbeddingsOptions;
-            requestConfig.headers['Authorization'] = `Bearer ${options.apiKey}`;
+            baseHeaders.set('Authorization', `Bearer ${options.apiKey}`);
             if (options.organization) {
-                requestConfig.headers['OpenAI-Organization'] = options.organization;
+                baseHeaders.set('OpenAI-Organization', options.organization);
             }
         }
 
         // Send request
-        const response = await this._httpClient.post(url, body, requestConfig);
+        const response = await fetch(url, {
+            ...this.options.requestConfig,
+            method: 'POST',
+            headers: baseHeaders,
+            body: JSON.stringify(body),
+        });
 
         // Check for rate limit error
         if (response.status == 429 && Array.isArray(this.options.retryPolicy) && retryCount < this.options.retryPolicy.length) {