@mixedbread/sdk 0.4.0 → 0.6.0

package/src/client.ts

@@ -32,7 +32,17 @@ import { APIPromise } from './core/api-promise';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
 import { FinalRequestOptions, RequestOptions } from './internal/request-options';
-import { EmbeddingCreateParams, Embeddings } from './resources/embeddings';
+import {
+  APIKey,
+  APIKeyCreateParams,
+  APIKeyCreated,
+  APIKeyDeleteResponse,
+  APIKeyListParams,
+  APIKeys,
+  APIKeysLimitOffset,
+} from './resources/api-keys';
+import { Chat, ChatCreateCompletionResponse } from './resources/chat';
+import { EmbeddingCreateParams, Embeddings, EncodingFormat, ObjectType } from './resources/embeddings';
 import {
   FileCreateParams,
   FileDeleteResponse,
@@ -41,21 +51,34 @@ import {
   FileObjectsLimitOffset,
   FileUpdateParams,
   Files,
+  PaginationWithTotal,
 } from './resources/files';
 import { readEnv } from './internal/utils/env';
 import { formatRequestDetails, loggerFor } from './internal/utils/log';
 import { isEmptyObj } from './internal/utils/values';
+import {
+  DataSource,
+  DataSourceCreateParams,
+  DataSourceDeleteResponse,
+  DataSourceListParams,
+  DataSourceOauth2Params,
+  DataSourceType,
+  DataSourceUpdateParams,
+  DataSources,
+  DataSourcesLimitOffset,
+} from './resources/data-sources/data-sources';
 import { Extractions } from './resources/extractions/extractions';
 import { Parsing } from './resources/parsing/parsing';
 import {
   ExpiresAfter,
-  FileCounts,
-  ScoredVectorStoreChunk,
+  ScoredAudioURLInputChunk,
+  ScoredImageURLInputChunk,
+  ScoredTextInputChunk,
+  ScoredVideoURLInputChunk,
   VectorStore,
   VectorStoreChunkSearchOptions,
   VectorStoreCreateParams,
   VectorStoreDeleteResponse,
-  VectorStoreFileSearchOptions,
   VectorStoreListParams,
   VectorStoreQuestionAnsweringParams,
   VectorStoreQuestionAnsweringResponse,
@@ -229,6 +252,24 @@ export class Mixedbread {
     this.apiKey = apiKey;
   }
 
+  /**
+   * Create a new client instance re-using the same options given to the current client with optional overriding.
+   */
+  withOptions(options: Partial<ClientOptions>): this {
+    return new (this.constructor as any as new (props: ClientOptions) => typeof this)({
+      ...this._options,
+      environment: options.environment ? options.environment : undefined,
+      baseURL: options.environment ? undefined : this.baseURL,
+      maxRetries: this.maxRetries,
+      timeout: this.timeout,
+      logger: this.logger,
+      logLevel: this.logLevel,
+      fetchOptions: this.fetchOptions,
+      apiKey: this.apiKey,
+      ...options,
+    });
+  }
+
   /**
    * Create embeddings for text or images using the specified model, encoding format,
    * and normalization.
@@ -587,12 +628,12 @@ export class Mixedbread {
       fetchOptions.method = method.toUpperCase();
     }
 
-    return (
+    try {
       // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
-      this.fetch.call(undefined, url, fetchOptions).finally(() => {
-        clearTimeout(timeout);
-      })
-    );
+      return await this.fetch.call(undefined, url, fetchOptions);
+    } finally {
+      clearTimeout(timeout);
+    }
   }
 
   private shouldRetry(response: Response): boolean {
@@ -673,17 +714,17 @@ export class Mixedbread {
   }
 
   buildRequest(
-    options: FinalRequestOptions,
+    inputOptions: FinalRequestOptions,
     { retryCount = 0 }: { retryCount?: number } = {},
   ): { req: FinalizedRequestInit; url: string; timeout: number } {
-    options = { ...options };
+    const options = { ...inputOptions };
     const { method, path, query } = options;
 
     const url = this.buildURL(path!, query as Record<string, unknown>);
     if ('timeout' in options) validatePositiveInteger('timeout', options.timeout);
     options.timeout = options.timeout ?? this.timeout;
     const { bodyHeaders, body } = this.buildBody({ options });
-    const reqHeaders = this.buildHeaders({ options, method, bodyHeaders, retryCount });
+    const reqHeaders = this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
 
     const req: FinalizedRequestInit = {
       method,
@@ -797,12 +838,18 @@ export class Mixedbread {
   files: API.Files = new API.Files(this);
   extractions: API.Extractions = new API.Extractions(this);
   embeddings: API.Embeddings = new API.Embeddings(this);
+  chat: API.Chat = new API.Chat(this);
+  dataSources: API.DataSources = new API.DataSources(this);
+  apiKeys: API.APIKeys = new API.APIKeys(this);
 }
 Mixedbread.VectorStores = VectorStores;
 Mixedbread.Parsing = Parsing;
 Mixedbread.Files = Files;
 Mixedbread.Extractions = Extractions;
 Mixedbread.Embeddings = Embeddings;
+Mixedbread.Chat = Chat;
+Mixedbread.DataSources = DataSources;
+Mixedbread.APIKeys = APIKeys;
 export declare namespace Mixedbread {
   export type RequestOptions = Opts.RequestOptions;
 
@@ -822,11 +869,12 @@ export declare namespace Mixedbread {
   export {
     VectorStores as VectorStores,
     type ExpiresAfter as ExpiresAfter,
-    type FileCounts as FileCounts,
-    type ScoredVectorStoreChunk as ScoredVectorStoreChunk,
+    type ScoredAudioURLInputChunk as ScoredAudioURLInputChunk,
+    type ScoredImageURLInputChunk as ScoredImageURLInputChunk,
+    type ScoredTextInputChunk as ScoredTextInputChunk,
+    type ScoredVideoURLInputChunk as ScoredVideoURLInputChunk,
     type VectorStore as VectorStore,
     type VectorStoreChunkSearchOptions as VectorStoreChunkSearchOptions,
-    type VectorStoreFileSearchOptions as VectorStoreFileSearchOptions,
     type VectorStoreDeleteResponse as VectorStoreDeleteResponse,
     type VectorStoreQuestionAnsweringResponse as VectorStoreQuestionAnsweringResponse,
     type VectorStoreSearchResponse as VectorStoreSearchResponse,
@@ -843,6 +891,7 @@ export declare namespace Mixedbread {
   export {
     Files as Files,
     type FileObject as FileObject,
+    type PaginationWithTotal as PaginationWithTotal,
     type FileDeleteResponse as FileDeleteResponse,
     type FileObjectsLimitOffset as FileObjectsLimitOffset,
     type FileCreateParams as FileCreateParams,
@@ -852,7 +901,36 @@ export declare namespace Mixedbread {
 
   export { Extractions as Extractions };
 
-  export { Embeddings as Embeddings, type EmbeddingCreateParams as EmbeddingCreateParams };
+  export {
+    Embeddings as Embeddings,
+    type EncodingFormat as EncodingFormat,
+    type ObjectType as ObjectType,
+    type EmbeddingCreateParams as EmbeddingCreateParams,
+  };
+
+  export { Chat as Chat, type ChatCreateCompletionResponse as ChatCreateCompletionResponse };
+
+  export {
+    DataSources as DataSources,
+    type DataSource as DataSource,
+    type DataSourceOauth2Params as DataSourceOauth2Params,
+    type DataSourceType as DataSourceType,
+    type DataSourceDeleteResponse as DataSourceDeleteResponse,
+    type DataSourcesLimitOffset as DataSourcesLimitOffset,
+    type DataSourceCreateParams as DataSourceCreateParams,
+    type DataSourceUpdateParams as DataSourceUpdateParams,
+    type DataSourceListParams as DataSourceListParams,
+  };
+
+  export {
+    APIKeys as APIKeys,
+    type APIKey as APIKey,
+    type APIKeyCreated as APIKeyCreated,
+    type APIKeyDeleteResponse as APIKeyDeleteResponse,
+    type APIKeysLimitOffset as APIKeysLimitOffset,
+    type APIKeyCreateParams as APIKeyCreateParams,
+    type APIKeyListParams as APIKeyListParams,
+  };
 
   export type SearchFilter = API.SearchFilter;
   export type SearchFilterCondition = API.SearchFilterCondition;

package/src/internal/headers.ts

@@ -3,7 +3,7 @@
 type HeaderValue = string | undefined | null;
 export type HeadersLike =
   | Headers
-  | readonly [string, HeaderValue][]
+  | readonly HeaderValue[][]
   | Record<string, HeaderValue | readonly HeaderValue[]>
   | undefined
   | null
@@ -40,7 +40,7 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [strin
   }
 
   let shouldClear = false;
-  let iter: Iterable<readonly [string, HeaderValue | readonly HeaderValue[]]>;
+  let iter: Iterable<readonly (HeaderValue | readonly HeaderValue[])[]>;
   if (headers instanceof Headers) {
     iter = headers.entries();
   } else if (isArray(headers)) {
@@ -51,6 +51,7 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [strin
   }
   for (let row of iter) {
     const name = row[0];
+    if (typeof name !== 'string') throw new TypeError('expected header name to be a string');
     const values = isArray(row[1]) ? row[1] : [row[1]];
     let didClear = false;
     for (const value of values) {
@@ -70,8 +71,8 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [strin
 export const buildHeaders = (newHeaders: HeadersLike[]): NullableHeaders => {
   const targetHeaders = new Headers();
   const nullHeaders = new Set<string>();
-  const seenHeaders = new Set<string>();
   for (const headers of newHeaders) {
+    const seenHeaders = new Set<string>();
     for (const [name, value] of iterateHeaders(headers)) {
       const lowerName = name.toLowerCase();
       if (!seenHeaders.has(lowerName)) {

package/src/internal/to-file.ts

@@ -1,6 +1,6 @@
-import { type File, getFile } from './shims/file';
 import { BlobPart, getName, makeFile, isAsyncIterable } from './uploads';
 import type { FilePropertyBag } from './builtin-types';
+import { checkFileSupport } from './uploads';
 
 type BlobLikePart = string | ArrayBuffer | ArrayBufferView | BlobLike | DataView;
 
@@ -85,12 +85,14 @@ export async function toFile(
   name?: string | null | undefined,
   options?: FilePropertyBag | undefined,
 ): Promise<File> {
+  checkFileSupport();
+
   // If it's a promise, resolve it.
   value = await value;
 
   // If we've been given a `File` we don't need to do anything
   if (isFileLike(value)) {
-    if (value instanceof getFile()) {
+    if (value instanceof File) {
       return value;
     }
     return makeFile([await value.arrayBuffer()], value.name);

package/src/internal/uploads.ts

@@ -1,7 +1,6 @@
 import { type RequestOptions } from './request-options';
 import type { FilePropertyBag, Fetch } from './builtin-types';
 import type { Mixedbread } from '../client';
-import { type File, getFile } from './shims/file';
 import { ReadableStreamFrom } from './shims';
 
 export type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob | DataView;
@@ -12,6 +11,20 @@ interface BunFile extends Blob {
   readonly name?: string | undefined;
 }
 
+export const checkFileSupport = () => {
+  if (typeof File === 'undefined') {
+    const { process } = globalThis as any;
+    const isOldNode =
+      typeof process?.versions?.node === 'string' && parseInt(process.versions.node.split('.')) < 20;
+    throw new Error(
+      '`File` is not defined as a global, which is required for file uploads.' +
+        (isOldNode ?
+          " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`."
+        : ''),
+    );
+  }
+};
+
 /**
  * Typically, this is a native "File" class.
  *
@@ -32,7 +45,7 @@ export function makeFile(
   fileName: string | undefined,
   options?: FilePropertyBag,
 ): File {
-  const File = getFile();
+  checkFileSupport();
   return new File(fileBits as any, fileName ?? 'unknown_file', options);
 }
 
@@ -125,8 +138,7 @@ export const createForm = async <T = Record<string, unknown>>(
 
 // We check for Blob not File because Bun.File doesn't inherit from File,
 // but they both inherit from Blob and have a `name` property at runtime.
-const isNamedBlob = (value: object) =>
-  value instanceof getFile() || (value instanceof Blob && 'name' in value);
+const isNamedBlob = (value: object) => value instanceof Blob && 'name' in value;
 
 const isUploadable = (value: unknown) =>
   typeof value === 'object' &&

package/src/internal/utils/base64.ts

@@ -1,18 +1,19 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { MixedbreadError } from '../../core/error';
+import { encodeUTF8 } from './bytes';
 
 export const toBase64 = (data: string | Uint8Array | null | undefined): string => {
   if (!data) return '';
 
-  if (typeof data === 'string') {
-    data = new (globalThis as any).TextEncoder().encode(data);
-  }
-
   if (typeof (globalThis as any).Buffer !== 'undefined') {
     return (globalThis as any).Buffer.from(data).toString('base64');
   }
 
+  if (typeof data === 'string') {
+    data = encodeUTF8(data);
+  }
+
   if (typeof btoa !== 'undefined') {
     return btoa(String.fromCharCode.apply(null, data as any));
   }
@@ -22,15 +23,17 @@ export const toBase64 = (data: string | Uint8Array | null | undefined): string =
 
 export const fromBase64 = (str: string): Uint8Array => {
   if (typeof (globalThis as any).Buffer !== 'undefined') {
-    return new Uint8Array((globalThis as any).Buffer.from(str, 'base64'));
+    const buf = (globalThis as any).Buffer.from(str, 'base64');
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
   }
 
   if (typeof atob !== 'undefined') {
-    return new Uint8Array(
-      atob(str)
-        .split('')
-        .map((c) => c.charCodeAt(0)),
-    );
+    const bstr = atob(str);
+    const buf = new Uint8Array(bstr.length);
+    for (let i = 0; i < bstr.length; i++) {
+      buf[i] = bstr.charCodeAt(i);
+    }
+    return buf;
   }
 
   throw new MixedbreadError('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined');

package/src/internal/utils/bytes.ts

@@ -0,0 +1,32 @@
+export function concatBytes(buffers: Uint8Array[]): Uint8Array {
+  let length = 0;
+  for (const buffer of buffers) {
+    length += buffer.length;
+  }
+  const output = new Uint8Array(length);
+  let index = 0;
+  for (const buffer of buffers) {
+    output.set(buffer, index);
+    index += buffer.length;
+  }
+
+  return output;
+}
+
+let encodeUTF8_: (str: string) => Uint8Array;
+export function encodeUTF8(str: string) {
+  let encoder;
+  return (
+    encodeUTF8_ ??
+    ((encoder = new (globalThis as any).TextEncoder()), (encodeUTF8_ = encoder.encode.bind(encoder)))
+  )(str);
+}
+
+let decodeUTF8_: (bytes: Uint8Array) => string;
+export function decodeUTF8(bytes: Uint8Array) {
+  let decoder;
+  return (
+    decodeUTF8_ ??
+    ((decoder = new (globalThis as any).TextDecoder()), (decodeUTF8_ = decoder.decode.bind(decoder)))
+  )(bytes);
+}

package/src/internal/utils/uuid.ts

@@ -1,12 +1,10 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { getCrypto } from '../shims/crypto';
-
 /**
  * https://stackoverflow.com/a/2117523
  */
 export let uuid4 = function () {
-  const crypto = getCrypto();
+  const { crypto } = globalThis as any;
   if (crypto?.randomUUID) {
     uuid4 = crypto.randomUUID.bind(crypto);
     return crypto.randomUUID();

package/src/resources/api-keys.ts

@@ -0,0 +1,225 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { LimitOffset, type LimitOffsetParams, PagePromise } from '../core/pagination';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class APIKeys extends APIResource {
+  /**
+   * Create a new API key.
+   *
+   * Args: params: The parameters for creating the API key.
+   *
+   * Returns: ApiKeyCreated: The response containing the details of the created API
+   * key.
+   */
+  create(body: APIKeyCreateParams, options?: RequestOptions): APIPromise<APIKeyCreated> {
+    return this._client.post('/v1/api-keys', { body, ...options });
+  }
+
+  /**
+   * Retrieve details of a specific API key by its ID.
+   *
+   * Args: api_key_id: The ID of the API key to retrieve.
+   *
+   * Returns: ApiKey: The response containing the API key details.
+   */
+  retrieve(apiKeyID: string, options?: RequestOptions): APIPromise<APIKey> {
+    return this._client.get(path`/v1/api-keys/${apiKeyID}`, options);
+  }
+
+  /**
+   * List all API keys for the authenticated user.
+   *
+   * Args: pagination: The pagination options
+   *
+   * Returns: A list of API keys belonging to the user.
+   */
+  list(
+    query: APIKeyListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<APIKeysLimitOffset, APIKey> {
+    return this._client.getAPIList('/v1/api-keys', LimitOffset<APIKey>, { query, ...options });
+  }
+
+  /**
+   * Delete a specific API key by its ID.
+   *
+   * Args: api_key_id: The ID of the API key to delete.
+   *
+   * Returns: ApiKeyDeleted: The response containing the details of the deleted API
+   * key.
+   */
+  delete(apiKeyID: string, options?: RequestOptions): APIPromise<APIKeyDeleteResponse> {
+    return this._client.delete(path`/v1/api-keys/${apiKeyID}`, options);
+  }
+
+  /**
+   * Reroll the secret for a specific API key by its ID.
+   *
+   * This generates a new secret key, invalidating the old one.
+   *
+   * Args: api_key_id: The ID of the API key to reroll.
+   *
+   * Returns: ApiKeyCreated: The response containing the API key details with the new
+   * secret key.
+   */
+  reroll(apiKeyID: string, options?: RequestOptions): APIPromise<APIKeyCreated> {
+    return this._client.post(path`/v1/api-keys/${apiKeyID}/reroll`, options);
+  }
+
+  /**
+   * Revoke a specific API key by its ID.
+   *
+   * Args: api_key_id: The ID of the API key to revoke.
+   *
+   * Returns: ApiKey: The response containing the details of the revoked API key.
+   */
+  revoke(apiKeyID: string, options?: RequestOptions): APIPromise<APIKey> {
+    return this._client.post(path`/v1/api-keys/${apiKeyID}/revoke`, options);
+  }
+}
+
+export type APIKeysLimitOffset = LimitOffset<APIKey>;
+
+/**
+ * Response model for an API key.
+ */
+export interface APIKey {
+  /**
+   * The ID of the API key
+   */
+  id: string;
+
+  /**
+   * The name of the API key
+   */
+  name: string;
+
+  /**
+   * The redacted value of the API key
+   */
+  redacted_value: string;
+
+  /**
+   * The expiration datetime of the API key
+   */
+  expires_at?: string | null;
+
+  /**
+   * The creation datetime of the API key
+   */
+  created_at: string;
+
+  /**
+   * The last update datetime of the API key
+   */
+  updated_at: string;
+
+  /**
+   * The last active datetime of the API key
+   */
+  last_active_at?: string | null;
+
+  /**
+   * The type of the object
+   */
+  object?: 'api_key';
+}
+
+/**
+ * Response model for creating an API key.
+ */
+export interface APIKeyCreated {
+  /**
+   * The ID of the API key
+   */
+  id: string;
+
+  /**
+   * The name of the API key
+   */
+  name: string;
+
+  /**
+   * The redacted value of the API key
+   */
+  redacted_value: string;
+
+  /**
+   * The expiration datetime of the API key
+   */
+  expires_at?: string | null;
+
+  /**
+   * The creation datetime of the API key
+   */
+  created_at: string;
+
+  /**
+   * The last update datetime of the API key
+   */
+  updated_at: string;
+
+  /**
+   * The last active datetime of the API key
+   */
+  last_active_at?: string | null;
+
+  /**
+   * The type of the object
+   */
+  object?: 'api_key';
+
+  /**
+   * The value of the API key
+   */
+  value: string;
+}
+
+/**
+ * Response model for deleting an API key.
+ */
+export interface APIKeyDeleteResponse {
+  /**
+   * The ID of the deleted API key
+   */
+  id: string;
+
+  /**
+   * Whether the API key was deleted
+   */
+  deleted: boolean;
+
+  /**
+   * The type of the object deleted
+   */
+  object?: 'api_key';
+}
+
+export interface APIKeyCreateParams {
+  /**
+   * A name/description for the API key
+   */
+  name?: string;
+
+  /**
+   * Optional expiration datetime
+   */
+  expires_at?: string | null;
+}
+
+export interface APIKeyListParams extends LimitOffsetParams {}
+
+export declare namespace APIKeys {
+  export {
+    type APIKey as APIKey,
+    type APIKeyCreated as APIKeyCreated,
+    type APIKeyDeleteResponse as APIKeyDeleteResponse,
+    type APIKeysLimitOffset as APIKeysLimitOffset,
+    type APIKeyCreateParams as APIKeyCreateParams,
+    type APIKeyListParams as APIKeyListParams,
+  };
+}

package/src/resources/chat.ts

@@ -0,0 +1,33 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+
+export class Chat extends APIResource {
+  /**
+   * Create a chat completion using the provided parameters.
+   *
+   * Generates a completion response based on the chat messages and model parameters
+   * provided. The response can be either a full completion or streamed chunks
+   * depending on the request parameters.
+   *
+   * Args: params: Parameters for creating the chat completion including messages,
+   * model selection, and generation settings user: The authenticated user making the
+   * request
+   *
+   * Returns: Either a ChatCompletion containing the full response, or
+   * ChatCompletionChunk for streaming
+   *
+   * Raises: HTTPException: If there is an error creating the completion (500)
+   */
+  createCompletion(options?: RequestOptions): APIPromise<unknown> {
+    return this._client.post('/v1/chat/completions', options);
+  }
+}
+
+export type ChatCreateCompletionResponse = unknown;
+
+export declare namespace Chat {
+  export { type ChatCreateCompletionResponse as ChatCreateCompletionResponse };
+}