@lancedb/lancedb 0.5.1 → 0.7.0

package/Cargo.toml

@@ -15,11 +15,11 @@ crate-type = ["cdylib"]
 arrow-ipc.workspace = true
 futures.workspace = true
 lancedb = { path = "../rust/lancedb" }
-napi = { version = "2.15", default-features = false, features = [
-    "napi7",
+napi = { version = "2.16.8", default-features = false, features = [
+    "napi9",
     "async",
 ] }
-napi-derive = "2"
+napi-derive = "2.16.4"
 
 # Prevent dynamic linking of lzma, which comes from datafusion
 lzma-sys = { version = "*", features = ["static"] }

package/biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/1.7.3/schema.json",
+  "$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",
   "organizeImports": {
     "enabled": true
   },
@@ -77,7 +77,7 @@
         "noDuplicateObjectKeys": "error",
         "noDuplicateParameters": "error",
         "noEmptyBlockStatements": "error",
-        "noExplicitAny": "error",
+        "noExplicitAny": "warn",
         "noExtraNonNullAssertion": "error",
         "noFallthroughSwitchClause": "error",
         "noFunctionAssign": "error",
@@ -94,12 +94,28 @@
         "useValidTypeof": "error"
       }
     },
-    "ignore": ["**/dist/**/*", "**/native.js", "**/native.d.ts"]
+    "ignore": [
+      "**/dist/**/*",
+      "**/native.js",
+      "**/native.d.ts",
+      "__test__/docs/**/*",
+      "examples/**/*"
+    ]
   },
   "javascript": {
     "globals": []
   },
   "overrides": [
+    {
+      "include": ["__test__/s3_integration.test.ts"],
+      "linter": {
+        "rules": {
+          "style": {
+            "useNamingConvention": "off"
+          }
+        }
+      }
+    },
     {
       "include": [
         "**/*.ts",

package/dist/arrow.d.ts

@@ -1,9 +1,43 @@
 /// <reference types="node" />
-import { Table as ArrowTable, Binary, DataType, FixedSizeBinary, FixedSizeList, Float, Int, LargeBinary, List, Null, Schema, Struct, Utf8 } from "apache-arrow";
+import { Table as ArrowTable, Binary, BufferType, DataType, Field, FixedSizeBinary, FixedSizeList, Float, Int, LargeBinary, List, Null, RecordBatch, Schema, Struct, Utf8 } from "apache-arrow";
+import { Buffers } from "apache-arrow/data";
 import { type EmbeddingFunction } from "./embedding/embedding_function";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
 export * from "apache-arrow";
-export declare function isArrowTable(value: object): value is ArrowTable;
+export type SchemaLike = Schema | {
+    fields: FieldLike[];
+    metadata: Map<string, string>;
+    get names(): unknown[];
+};
+export type FieldLike = Field | {
+    type: string;
+    name: string;
+    nullable?: boolean;
+    metadata?: Map<string, string>;
+};
+export type DataLike = import("apache-arrow").Data<Struct<any>> | {
+    type: any;
+    length: number;
+    offset: number;
+    stride: number;
+    nullable: boolean;
+    children: DataLike[];
+    get nullCount(): number;
+    values: Buffers<any>[BufferType.DATA];
+    typeIds: Buffers<any>[BufferType.TYPE];
+    nullBitmap: Buffers<any>[BufferType.VALIDITY];
+    valueOffsets: Buffers<any>[BufferType.OFFSET];
+};
+export type RecordBatchLike = RecordBatch | {
+    schema: SchemaLike;
+    data: DataLike;
+};
+export type TableLike = ArrowTable | {
+    schema: SchemaLike;
+    batches: RecordBatchLike[];
+};
+export type IntoVector = Float32Array | Float64Array | number[] | Promise<Float32Array | Float64Array | number[]>;
+export declare function isArrowTable(value: object): value is TableLike;
 export declare function isDataType(value: unknown): value is DataType;
 export declare function isNull(value: unknown): value is Null;
 export declare function isInt(value: unknown): value is Int;
@@ -25,7 +59,7 @@ export declare function isUnion(value: unknown): value is Struct;
 export declare function isFixedSizeBinary(value: unknown): value is FixedSizeBinary;
 export declare function isFixedSizeList(value: unknown): value is FixedSizeList;
 /** Data type accepted by NodeJS SDK */
-export type Data = Record<string, unknown>[] | ArrowTable;
+export type Data = Record<string, unknown>[] | TableLike;
 export declare class VectorColumnOptions {
     /** Vector column type. */
     type: Float;
@@ -33,9 +67,10 @@ export declare class VectorColumnOptions {
 }
 /** Options to control the makeArrowTable call. */
 export declare class MakeArrowTableOptions {
-    schema?: Schema;
+    schema?: SchemaLike;
     vectorColumns: Record<string, VectorColumnOptions>;
     embeddings?: EmbeddingFunction<unknown>;
+    embeddingFunction?: EmbeddingFunctionConfig;
     /**
      * If true then string columns will be encoded with dictionary encoding
      *
@@ -144,7 +179,7 @@ export declare function makeArrowTable(data: Array<Record<string, unknown>>, opt
 /**
  * Create an empty Arrow table with the provided schema
  */
-export declare function makeEmptyTable(schema: Schema, metadata?: Map<string, string>): ArrowTable;
+export declare function makeEmptyTable(schema: SchemaLike, metadata?: Map<string, string>): ArrowTable;
 /**
  * Convert an Array of records into an Arrow Table, optionally applying an
  * embeddings function to it.
@@ -190,7 +225,7 @@ export declare function fromRecordsToStreamBuffer(data: Array<Record<string, unk
  *
  * `schema` is required if the table is empty
  */
-export declare function fromTableToBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: Schema): Promise<Buffer>;
+export declare function fromTableToBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: SchemaLike): Promise<Buffer>;
 /**
  * Serialize an Arrow Table into a buffer using the Arrow IPC File serialization
  *
@@ -208,7 +243,7 @@ export declare function fromDataToBuffer(data: Data, embeddings?: EmbeddingFunct
  *
  * `schema` is required if the table is empty
  */
-export declare function fromTableToStreamBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: Schema): Promise<Buffer>;
+export declare function fromTableToStreamBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: SchemaLike): Promise<Buffer>;
 /**
  * Create an empty table with the given schema
  */

package/dist/arrow.js

@@ -184,6 +184,7 @@ class MakeArrowTableOptions {
         vector: new VectorColumnOptions(),
     };
     embeddings;
+    embeddingFunction;
     /**
      * If true then string columns will be encoded with dictionary encoding
      *
@@ -299,7 +300,7 @@ function makeArrowTable(data, options, metadata) {
     const opt = new MakeArrowTableOptions(options !== undefined ? options : {});
     if (opt.schema !== undefined && opt.schema !== null) {
         opt.schema = (0, sanitize_1.sanitizeSchema)(opt.schema);
-        opt.schema = validateSchemaEmbeddings(opt.schema, data, opt.embeddings);
+        opt.schema = validateSchemaEmbeddings(opt.schema, data, options?.embeddingFunction);
     }
     const columns = {};
     // TODO: sample dataset to find missing columns
@@ -504,15 +505,15 @@ async function applyEmbeddingsFromMetadata(table, schema) {
 }
 /** Helper function to apply embeddings to an input table */
 async function applyEmbeddings(table, embeddings, schema) {
+    if (schema !== undefined && schema !== null) {
+        schema = (0, sanitize_1.sanitizeSchema)(schema);
+    }
     if (schema?.metadata.has("embedding_functions")) {
         return applyEmbeddingsFromMetadata(table, schema);
     }
     else if (embeddings == null || embeddings === undefined) {
         return table;
     }
-    if (schema !== undefined && schema !== null) {
-        schema = (0, sanitize_1.sanitizeSchema)(schema);
-    }
     // Convert from ArrowTable to Record<String, Vector>
     const colEntries = [...Array(table.numCols).keys()].map((_, idx) => {
         const name = table.schema.fields[idx].name;
@@ -669,7 +670,7 @@ async function fromDataToBuffer(data, embeddings, schema) {
         schema = (0, sanitize_1.sanitizeSchema)(schema);
     }
     if (isArrowTable(data)) {
-        return fromTableToBuffer(data, embeddings, schema);
+        return fromTableToBuffer((0, sanitize_1.sanitizeTable)(data), embeddings, schema);
     }
     else {
         const table = await convertToTable(data, embeddings, { schema });

package/dist/connection.d.ts

@@ -1,20 +1,7 @@
-import { Table as ArrowTable, Schema } from "./arrow";
+import { Data, SchemaLike, TableLike } from "./arrow";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
-import { ConnectionOptions, Connection as LanceDbConnection } from "./native";
+import { Connection as LanceDbConnection } from "./native";
 import { Table } from "./table";
-/**
- * Connect to a LanceDB instance at the given URI.
- *
- * Accepted formats:
- *
- * - `/path/to/database` - local database
- * - `s3://bucket/path/to/database` or `gs://bucket/path/to/database` - database on cloud storage
- * - `db://host:port` - remote database (LanceDB cloud)
- * @param {string} uri - The uri of the database. If the database uri starts
- * with `db://` then it connects to a remote database.
- * @see {@link ConnectionOptions} for more details on the URI format.
- */
-export declare function connect(uri: string, opts?: Partial<ConnectionOptions>): Promise<Connection>;
 export interface CreateTableOptions {
     /**
      * The mode to use when creating the table.
@@ -40,7 +27,13 @@ export interface CreateTableOptions {
      * The available options are described at https://lancedb.github.io/lancedb/guides/storage/
      */
     storageOptions?: Record<string, string>;
-    schema?: Schema;
+    /**
+     * If true then data files will be written with the legacy format
+     *
+     * The default is true while the new format is in beta
+     */
+    useLegacyFormat?: boolean;
+    schema?: SchemaLike;
     embeddingFunction?: EmbeddingFunctionConfig;
 }
 export interface OpenTableOptions {
@@ -96,11 +89,11 @@ export interface TableNamesOptions {
  * Any created tables are independent and will continue to work even if
  * the underlying connection has been closed.
  */
-export declare class Connection {
-    readonly inner: LanceDbConnection;
-    constructor(inner: LanceDbConnection);
-    /** Return true if the connection has not been closed */
-    isOpen(): boolean;
+export declare abstract class Connection {
+    /**
+     * Return true if the connection has not been closed
+     */
+    abstract isOpen(): boolean;
     /**
      * Close the connection, releasing any underlying resources.
      *
@@ -108,38 +101,71 @@ export declare class Connection {
      *
      * Any attempt to use the connection after it is closed will result in an error.
      */
-    close(): void;
-    /** Return a brief description of the connection */
-    display(): string;
+    abstract close(): void;
+    /**
+     * Return a brief description of the connection
+     */
+    abstract display(): string;
     /**
      * List all the table names in this database.
      *
      * Tables will be returned in lexicographical order.
      * @param {Partial<TableNamesOptions>} options - options to control the
      * paging / start point
+     *
      */
-    tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
+    abstract tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
     /**
      * Open a table in the database.
      * @param {string} name - The name of the table
      */
-    openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    abstract openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    /**
+     * Creates a new Table and initialize it with new data.
+     * @param {object} options - The options object.
+     * @param {string} options.name - The name of the table.
+     * @param {Data} options.data - Non-empty Array of Records to be inserted into the table
+     *
+     */
+    abstract createTable(options: {
+        name: string;
+        data: Data;
+    } & Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Creates a new Table and initialize it with new data.
      * @param {string} name - The name of the table.
-     * @param {Record<string, unknown>[] | ArrowTable} data - Non-empty Array of Records
+     * @param {Record<string, unknown>[] | TableLike} data - Non-empty Array of Records
      * to be inserted into the table
      */
-    createTable(name: string, data: Record<string, unknown>[] | ArrowTable, options?: Partial<CreateTableOptions>): Promise<Table>;
+    abstract createTable(name: string, data: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Creates a new empty Table
      * @param {string} name - The name of the table.
      * @param {Schema} schema - The schema of the table
      */
-    createEmptyTable(name: string, schema: Schema, options?: Partial<CreateTableOptions>): Promise<Table>;
+    abstract createEmptyTable(name: string, schema: import("./arrow").SchemaLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Drop an existing table.
      * @param {string} name The name of the table to drop.
      */
+    abstract dropTable(name: string): Promise<void>;
+}
+export declare class LocalConnection extends Connection {
+    readonly inner: LanceDbConnection;
+    constructor(inner: LanceDbConnection);
+    isOpen(): boolean;
+    close(): void;
+    display(): string;
+    tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
+    openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    createTable(nameOrOptions: string | ({
+        name: string;
+        data: Data;
+    } & Partial<CreateTableOptions>), data?: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>): Promise<Table>;
+    createEmptyTable(name: string, schema: import("./arrow").SchemaLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     dropTable(name: string): Promise<void>;
 }
+/**
+ * Takes storage options and makes all the keys snake case.
+ */
+export declare function cleanseStorageOptions(options?: Record<string, string>): Record<string, string> | undefined;

package/dist/connection.js

@@ -13,30 +13,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = exports.connect = void 0;
+exports.cleanseStorageOptions = exports.LocalConnection = exports.Connection = void 0;
 const arrow_1 = require("./arrow");
 const registry_1 = require("./embedding/registry");
-const native_1 = require("./native");
 const table_1 = require("./table");
-/**
- * Connect to a LanceDB instance at the given URI.
- *
- * Accepted formats:
- *
- * - `/path/to/database` - local database
- * - `s3://bucket/path/to/database` or `gs://bucket/path/to/database` - database on cloud storage
- * - `db://host:port` - remote database (LanceDB cloud)
- * @param {string} uri - The uri of the database. If the database uri starts
- * with `db://` then it connects to a remote database.
- * @see {@link ConnectionOptions} for more details on the URI format.
- */
-async function connect(uri, opts) {
-    opts = opts ?? {};
-    opts.storageOptions = cleanseStorageOptions(opts.storageOptions);
-    const nativeConn = await native_1.Connection.new(uri, opts);
-    return new Connection(nativeConn);
-}
-exports.connect = connect;
 /**
  * A LanceDB Connection that allows you to open tables and create new ones.
  *
@@ -56,74 +36,45 @@ exports.connect = connect;
  * the underlying connection has been closed.
  */
 class Connection {
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return this.display();
+    }
+}
+exports.Connection = Connection;
+class LocalConnection extends Connection {
     inner;
     constructor(inner) {
+        super();
         this.inner = inner;
     }
-    /** Return true if the connection has not been closed */
     isOpen() {
         return this.inner.isOpen();
     }
-    /**
-     * Close the connection, releasing any underlying resources.
-     *
-     * It is safe to call this method multiple times.
-     *
-     * Any attempt to use the connection after it is closed will result in an error.
-     */
     close() {
         this.inner.close();
     }
-    /** Return a brief description of the connection */
     display() {
         return this.inner.display();
     }
-    /**
-     * List all the table names in this database.
-     *
-     * Tables will be returned in lexicographical order.
-     * @param {Partial<TableNamesOptions>} options - options to control the
-     * paging / start point
-     */
     async tableNames(options) {
         return this.inner.tableNames(options?.startAfter, options?.limit);
     }
-    /**
-     * Open a table in the database.
-     * @param {string} name - The name of the table
-     */
     async openTable(name, options) {
         const innerTable = await this.inner.openTable(name, cleanseStorageOptions(options?.storageOptions), options?.indexCacheSize);
-        return new table_1.Table(innerTable);
+        return new table_1.LocalTable(innerTable);
     }
-    /**
-     * Creates a new Table and initialize it with new data.
-     * @param {string} name - The name of the table.
-     * @param {Record<string, unknown>[] | ArrowTable} data - Non-empty Array of Records
-     * to be inserted into the table
-     */
-    async createTable(name, data, options) {
-        let mode = options?.mode ?? "create";
-        const existOk = options?.existOk ?? false;
-        if (mode === "create" && existOk) {
-            mode = "exist_ok";
-        }
-        let table;
-        if ((0, arrow_1.isArrowTable)(data)) {
-            table = data;
+    async createTable(nameOrOptions, data, options) {
+        if (typeof nameOrOptions !== "string" && "name" in nameOrOptions) {
+            const { name, data, ...options } = nameOrOptions;
+            return this.createTable(name, data, options);
         }
-        else {
-            table = (0, arrow_1.makeArrowTable)(data, options);
+        if (data === undefined) {
+            throw new Error("data is required");
         }
-        const buf = await (0, arrow_1.fromTableToBuffer)(table, options?.embeddingFunction, options?.schema);
-        const innerTable = await this.inner.createTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions));
-        return new table_1.Table(innerTable);
+        const { buf, mode } = await table_1.Table.parseTableData(data, options);
+        const innerTable = await this.inner.createTable(nameOrOptions, buf, mode, cleanseStorageOptions(options?.storageOptions), options?.useLegacyFormat);
+        return new table_1.LocalTable(innerTable);
     }
-    /**
-     * Creates a new empty Table
-     * @param {string} name - The name of the table.
-     * @param {Schema} schema - The schema of the table
-     */
     async createEmptyTable(name, schema, options) {
         let mode = options?.mode ?? "create";
         const existOk = options?.existOk ?? false;
@@ -138,18 +89,14 @@ class Connection {
         }
         const table = (0, arrow_1.makeEmptyTable)(schema, metadata);
         const buf = await (0, arrow_1.fromTableToBuffer)(table);
-        const innerTable = await this.inner.createEmptyTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions));
-        return new table_1.Table(innerTable);
+        const innerTable = await this.inner.createEmptyTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions), options?.useLegacyFormat);
+        return new table_1.LocalTable(innerTable);
     }
-    /**
-     * Drop an existing table.
-     * @param {string} name The name of the table to drop.
-     */
     async dropTable(name) {
         return this.inner.dropTable(name);
     }
 }
-exports.Connection = Connection;
+exports.LocalConnection = LocalConnection;
 /**
  * Takes storage options and makes all the keys snake case.
  */
@@ -166,6 +113,7 @@ function cleanseStorageOptions(options) {
     }
     return result;
 }
+exports.cleanseStorageOptions = cleanseStorageOptions;
 /**
  * Convert a string to snake case. It might already be snake case, in which case it is
  * returned unchanged.

package/dist/embedding/embedding_function.d.ts

@@ -1,15 +1,23 @@
 import "reflect-metadata";
-import { DataType, Float } from "../arrow";
+import { DataType, Float, type IntoVector } from "../arrow";
 /**
  * Options for a given embedding function
  */
 export interface FunctionOptions {
     [key: string]: any;
 }
+export interface EmbeddingFunctionConstructor<T extends EmbeddingFunction = EmbeddingFunction> {
+    new (modelOptions?: T["TOptions"]): T;
+}
 /**
  * An embedding function that automatically creates vector representation for a given column.
  */
 export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptions = FunctionOptions> {
+    /**
+     * @ignore
+     *  This is only used for associating the options type with the class for type checking
+     */
+    readonly TOptions: M;
     /**
      * Convert the embedding function to a JSON object
      * It is used to serialize the embedding function to the schema
@@ -51,7 +59,7 @@ export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptio
      *
      * @see {@link lancedb.LanceSchema}
      */
-    vectorField(options?: Partial<FieldOptions>): [DataType, Map<string, EmbeddingFunction>];
+    vectorField(optionsOrDatatype?: Partial<FieldOptions> | DataType): [DataType, Map<string, EmbeddingFunction>];
     /** The number of dimensions of the embeddings */
     ndims(): number | undefined;
     /** The datatype of the embeddings */
@@ -63,7 +71,7 @@ export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptio
     /**
     Compute the embeddings for a single query
    */
-    computeQueryEmbeddings(data: T): Promise<number[] | Float32Array | Float64Array>;
+    computeQueryEmbeddings(data: T): Promise<Awaited<IntoVector>>;
 }
 export interface FieldOptions<T extends DataType = DataType> {
     datatype: T;

package/dist/embedding/embedding_function.js

@@ -21,6 +21,12 @@ const sanitize_1 = require("../sanitize");
  * An embedding function that automatically creates vector representation for a given column.
  */
 class EmbeddingFunction {
+    /**
+     * @ignore
+     *  This is only used for associating the options type with the class for type checking
+     */
+    // biome-ignore lint/style/useNamingConvention: we want to keep the name as it is
+    TOptions;
     /**
      * sourceField is used in combination with `LanceSchema` to provide a declarative data model
      *
@@ -47,32 +53,50 @@ class EmbeddingFunction {
      *
      * @see {@link lancedb.LanceSchema}
      */
-    vectorField(options) {
+    vectorField(optionsOrDatatype) {
         let dtype;
-        const dims = this.ndims() ?? options?.dims;
-        if (!options?.datatype) {
-            if (dims === undefined) {
-                throw new Error("ndims is required for vector field");
-            }
-            dtype = new arrow_1.FixedSizeList(dims, new arrow_1.Field("item", new arrow_1.Float32(), true));
+        let vectorType;
+        let dims = this.ndims();
+        // `func.vectorField(new Float32())`
+        if ((0, arrow_1.isDataType)(optionsOrDatatype)) {
+            dtype = optionsOrDatatype;
         }
         else {
-            if ((0, arrow_1.isFixedSizeList)(options.datatype)) {
-                dtype = options.datatype;
+            // `func.vectorField({
+            //  datatype: new Float32(),
+            //  dims: 10
+            // })`
+            dims = dims ?? optionsOrDatatype?.dims;
+            dtype = optionsOrDatatype?.datatype;
+        }
+        if (dtype !== undefined) {
+            // `func.vectorField(new FixedSizeList(dims, new Field("item", new Float32(), true)))`
+            // or `func.vectorField({datatype: new FixedSizeList(dims, new Field("item", new Float32(), true))})`
+            if ((0, arrow_1.isFixedSizeList)(dtype)) {
+                vectorType = dtype;
+                // `func.vectorField(new Float32())`
+                // or `func.vectorField({datatype: new Float32()})`
             }
-            else if ((0, arrow_1.isFloat)(options.datatype)) {
+            else if ((0, arrow_1.isFloat)(dtype)) {
+                // No `ndims` impl and no `{dims: n}` provided;
                 if (dims === undefined) {
                     throw new Error("ndims is required for vector field");
                 }
-                dtype = (0, arrow_1.newVectorType)(dims, options.datatype);
+                vectorType = (0, arrow_1.newVectorType)(dims, dtype);
             }
             else {
                 throw new Error("Expected FixedSizeList or Float as datatype for vector field");
             }
         }
+        else {
+            if (dims === undefined) {
+                throw new Error("ndims is required for vector field");
+            }
+            vectorType = new arrow_1.FixedSizeList(dims, new arrow_1.Field("item", new arrow_1.Float32(), true));
+        }
         const metadata = new Map();
         metadata.set("vector_column_for", this);
-        return [dtype, metadata];
+        return [vectorType, metadata];
     }
     /** The number of dimensions of the embeddings */
     ndims() {

package/dist/embedding/openai.d.ts

@@ -1,14 +1,15 @@
+import { type EmbeddingCreateParams } from "openai/resources";
 import { Float } from "../arrow";
 import { EmbeddingFunction } from "./embedding_function";
 export type OpenAIOptions = {
-    apiKey?: string;
-    model?: string;
+    apiKey: string;
+    model: EmbeddingCreateParams["model"];
 };
-export declare class OpenAIEmbeddingFunction extends EmbeddingFunction<string, OpenAIOptions> {
+export declare class OpenAIEmbeddingFunction extends EmbeddingFunction<string, Partial<OpenAIOptions>> {
     #private;
-    constructor(options?: OpenAIOptions);
+    constructor(options?: Partial<OpenAIOptions>);
     toJSON(): {
-        model: string;
+        model: (string & {}) | "text-embedding-ada-002" | "text-embedding-3-small" | "text-embedding-3-large";
     };
     ndims(): number;
     embeddingDataType(): Float;

package/dist/embedding/openai.js

@@ -29,7 +29,9 @@ const registry_1 = require("./registry");
 let OpenAIEmbeddingFunction = class OpenAIEmbeddingFunction extends embedding_function_1.EmbeddingFunction {
     #openai;
     #modelName;
-    constructor(options = { model: "text-embedding-ada-002" }) {
+    constructor(options = {
+        model: "text-embedding-ada-002",
+    }) {
         super();
         const openAIKey = options?.apiKey ?? process.env.OPENAI_API_KEY;
         if (!openAIKey) {
@@ -68,7 +70,7 @@ let OpenAIEmbeddingFunction = class OpenAIEmbeddingFunction extends embedding_fu
             case "text-embedding-3-small":
                 return 1536;
             default:
-                return null;
+                throw new Error(`Unknown model: ${this.#modelName}`);
         }
     }
     embeddingDataType() {