@langchain/google-cloud-sql-pg 1.0.5 → 1.0.6-dev-1765432861398

package/dist/chat_message_history.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat_message_history.d.cts","names":["BaseChatMessageHistory","BaseMessage","PostgresEngine","PostgresChatMessageHistoryInput","PostgresChatMessageHistory","engine","sessionId","tableName","schemaName","Promise"],"sources":["../src/chat_message_history.d.ts"],"sourcesContent":["import { BaseChatMessageHistory } from \"@langchain/core/chat_history\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport PostgresEngine from \"./engine.js\";\nexport interface PostgresChatMessageHistoryInput {\n    engine: PostgresEngine;\n    sessionId: string;\n    tableName: string;\n    schemaName: string;\n}\nexport declare class PostgresChatMessageHistory extends BaseChatMessageHistory {\n    lc_namespace: string[];\n    engine: PostgresEngine;\n    sessionId: string;\n    tableName: string;\n    schemaName: string;\n    constructor({ engine, sessionId, tableName, schemaName }: PostgresChatMessageHistoryInput);\n    /**\n     * Create a new PostgresChatMessageHistory instance.\n     *\n     * @param {PostgresEngine} engine Postgres engine instance to use.\n     * @param {string} sessionId Retrieve the table content with this session ID.\n     * @param {string} tableName Table name that stores that chat message history. Parameter is not escaped. Do not use with end user input.\n     * @param {string} schemaName Schema name for the chat message history table. Default: \"public\". Parameter is not escaped. Do not use with end user input.\n     * @returns PostgresChatMessageHistory instance.\n     */\n    static initialize(engine: PostgresEngine, sessionId: string, tableName: string, schemaName?: string): Promise<PostgresChatMessageHistory>;\n    addUserMessage(message: string): Promise<void>;\n    addAIChatMessage(message: string): Promise<void>;\n    /**\n     * Returns a list of messages stored in the store.\n     */\n    getMessages(): Promise<BaseMessage[]>;\n    /**\n     * Add a message object to the store.\n     * @param {BaseMessage} message Message to be added to the store\n     */\n    addMessage(message: BaseMessage): Promise<void>;\n    /**\n     * Add a list of messages object to the store.\n     * @param {Array<BaseMessage>} messages List of messages to be added to the store\n     */\n    addMessages(messages: BaseMessage[]): Promise<void>;\n    /**\n     * Remove all messages from the store.\n     */\n    clear(): Promise<void>;\n}\n//# sourceMappingURL=chat_message_history.d.ts.map"],"mappings":";;;;;UAGiBG,+BAAAA;UACLD;EADKC,SAAAA,EAAAA,MAAAA;EAMIC,SAAAA,EAAAA,MAAAA;EAETF,UAAAA,EAAAA,MAAAA;;AAIcI,cANLF,0BAAAA,SAAmCJ,sBAAAA,CAM9BM;EAAWC,YAAAA,EAAAA,MAAAA,EAAAA;EAAWC,MAAAA,EAJpCN,cAIoCM;EAAcL,SAAAA,EAAAA,MAAAA;EAUhCD,SAAAA,EAAAA,MAAAA;EAAoFE,UAAAA,EAAAA,MAAAA;EAARK,WAAAA,CAAAA;IAAAA,MAAAA;IAAAA,SAAAA;IAAAA,SAAAA;IAAAA;EAAAA,CAAAA,EAV5CN,+BAU4CM;EACrEA;;;;;;;;;EAjBmBT,OAAAA,UAAAA,CAAAA,MAAAA,EAgB1BE,cAhB0BF,EAAAA,SAAAA,EAAAA,MAAAA,EAAAA,SAAAA,EAAAA,MAAAA,EAAAA,UAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAgBkDS,OAhBlDT,CAgB0DI,0BAhB1DJ,CAAAA;EAAsB,cAAA,CAAA,OAAA,EAAA,MAAA,CAAA,EAiBzCS,OAjByC,CAAA,IAAA,CAAA;qCAkBvCA;;;;iBAIpBA,QAAQR;;;;;sBAKHA,cAAcQ;;;;;wBAKZR,gBAAgBQ;;;;WAI7BA"}

package/dist/chat_message_history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat_message_history.d.ts","names":["BaseChatMessageHistory","BaseMessage","PostgresEngine","PostgresChatMessageHistoryInput","PostgresChatMessageHistory","engine","sessionId","tableName","schemaName","Promise"],"sources":["../src/chat_message_history.d.ts"],"sourcesContent":["import { BaseChatMessageHistory } from \"@langchain/core/chat_history\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport PostgresEngine from \"./engine.js\";\nexport interface PostgresChatMessageHistoryInput {\n    engine: PostgresEngine;\n    sessionId: string;\n    tableName: string;\n    schemaName: string;\n}\nexport declare class PostgresChatMessageHistory extends BaseChatMessageHistory {\n    lc_namespace: string[];\n    engine: PostgresEngine;\n    sessionId: string;\n    tableName: string;\n    schemaName: string;\n    constructor({ engine, sessionId, tableName, schemaName }: PostgresChatMessageHistoryInput);\n    /**\n     * Create a new PostgresChatMessageHistory instance.\n     *\n     * @param {PostgresEngine} engine Postgres engine instance to use.\n     * @param {string} sessionId Retrieve the table content with this session ID.\n     * @param {string} tableName Table name that stores that chat message history. Parameter is not escaped. Do not use with end user input.\n     * @param {string} schemaName Schema name for the chat message history table. Default: \"public\". Parameter is not escaped. Do not use with end user input.\n     * @returns PostgresChatMessageHistory instance.\n     */\n    static initialize(engine: PostgresEngine, sessionId: string, tableName: string, schemaName?: string): Promise<PostgresChatMessageHistory>;\n    addUserMessage(message: string): Promise<void>;\n    addAIChatMessage(message: string): Promise<void>;\n    /**\n     * Returns a list of messages stored in the store.\n     */\n    getMessages(): Promise<BaseMessage[]>;\n    /**\n     * Add a message object to the store.\n     * @param {BaseMessage} message Message to be added to the store\n     */\n    addMessage(message: BaseMessage): Promise<void>;\n    /**\n     * Add a list of messages object to the store.\n     * @param {Array<BaseMessage>} messages List of messages to be added to the store\n     */\n    addMessages(messages: BaseMessage[]): Promise<void>;\n    /**\n     * Remove all messages from the store.\n     */\n    clear(): Promise<void>;\n}\n//# sourceMappingURL=chat_message_history.d.ts.map"],"mappings":";;;;;UAGiBG,+BAAAA;UACLD;EADKC,SAAAA,EAAAA,MAAAA;EAMIC,SAAAA,EAAAA,MAAAA;EAETF,UAAAA,EAAAA,MAAAA;;AAIcI,cANLF,0BAAAA,SAAmCJ,sBAAAA,CAM9BM;EAAWC,YAAAA,EAAAA,MAAAA,EAAAA;EAAWC,MAAAA,EAJpCN,cAIoCM;EAAcL,SAAAA,EAAAA,MAAAA;EAUhCD,SAAAA,EAAAA,MAAAA;EAAoFE,UAAAA,EAAAA,MAAAA;EAARK,WAAAA,CAAAA;IAAAA,MAAAA;IAAAA,SAAAA;IAAAA,SAAAA;IAAAA;EAAAA,CAAAA,EAV5CN,+BAU4CM;EACrEA;;;;;;;;;EAjBmBT,OAAAA,UAAAA,CAAAA,MAAAA,EAgB1BE,cAhB0BF,EAAAA,SAAAA,EAAAA,MAAAA,EAAAA,SAAAA,EAAAA,MAAAA,EAAAA,UAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAgBkDS,OAhBlDT,CAgB0DI,0BAhB1DJ,CAAAA;EAAsB,cAAA,CAAA,OAAA,EAAA,MAAA,CAAA,EAiBzCS,OAjByC,CAAA,IAAA,CAAA;qCAkBvCA;;;;iBAIpBA,QAAQR;;;;;sBAKHA,cAAcQ;;;;;wBAKZR,gBAAgBQ;;;;WAI7BA"}

package/dist/engine.d.cts

@@ -130,7 +130,6 @@ declare class PostgresEngine {
    *  Dispose of connection pool
    */
   closeConnection(): Promise<void>;
-  // Just to test the connection to the database
   testConnection(): knex.Knex.Raw<any>;
 }
 //#endregion

package/dist/engine.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.cts","names":["Connector","IpAddressTypes","knex","PostgresEngineArgs","VectorStoreTableArgs","Column","PostgresEngine","Knex","ipType","user","password","iamAccountEmail","Promise","StaticConnectionConfig","PoolConfig","schemaName","contentColumn","embeddingColumn","embeddingColumnType","metadataColumns","metadataJsonColumn","idColumn","overwriteExisting","storeMetadata","Raw","default"],"sources":["../src/engine.d.ts"],"sourcesContent":["import { Connector, IpAddressTypes } from \"@google-cloud/cloud-sql-connector\";\nimport knex from \"knex\";\nexport interface PostgresEngineArgs {\n    ipType?: IpAddressTypes;\n    user?: string;\n    password?: string;\n    iamAccountEmail?: string;\n}\nexport interface VectorStoreTableArgs {\n    schemaName?: string;\n    contentColumn?: string;\n    embeddingColumn?: string;\n    embeddingColumnType?: \"vector\" | \"halfvec\" | \"bit\" | \"sparsevec\";\n    metadataColumns?: Column[];\n    metadataJsonColumn?: string;\n    idColumn?: string | Column;\n    overwriteExisting?: boolean;\n    storeMetadata?: boolean;\n}\nexport declare class Column {\n    name: string;\n    dataType: string;\n    nullable: boolean;\n    constructor(name: string, dataType: string, nullable?: boolean);\n    private postInitilization;\n}\n/**\n * Cloud SQL shared connection pool\n *\n * Setup:\n * Install `@langchain/google-cloud-sql-pg`\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { Column, PostgresEngine, PostgresEngineArgs } from \"@langchain/google-cloud-sql-pg\";\n *\n * const pgArgs: PostgresEngineArgs = {\n *    user: \"db-user\",\n *    password: \"password\"\n *}\n *\n * const engine: PostgresEngine = await PostgresEngine.fromInstance(\n *  \"project-id\",\n *  \"region\",\n *  \"instance-name\",\n *  \"database-name\",\n *  pgArgs\n * );\n * ```\n * </details>\n *\n * <br />\n *\n */\nexport declare class PostgresEngine {\n    private static _createKey;\n    pool: knex.Knex;\n    static connector: Connector;\n    constructor(key: symbol, pool: knex.Knex);\n    /**\n     * @param projectId Required - GCP Project ID\n     * @param region Required - Postgres Instance Region\n     * @param instance Required - Postgres Instance name\n     * @param database Required - Database name\n     * @param ipType Optional - IP address type. Defaults to IPAddressType.PUBLIC\n     * @param user Optional - Postgres user name. Defaults to undefined\n     * @param password Optional - Postgres user password. Defaults to undefined\n     * @param iamAccountEmail Optional - IAM service account email. Defaults to undefined\n     * @returns PostgresEngine instance\n     */\n    static fromInstance(projectId: string, region: string, instance: string, database: string, { ipType, user, password, iamAccountEmail }?: PostgresEngineArgs): Promise<PostgresEngine>;\n    /**\n     * Create a PostgresEngine instance from an Knex instance.\n     *\n     * @param engine knex instance\n     * @returns PostgresEngine instance from a knex instance\n     */\n    static fromPool(engine: knex.Knex): Promise<PostgresEngine>;\n    /**\n     * Create a PostgresEngine instance from arguments.\n     *\n     * @param url URL use to connect to a database\n     * @param poolConfig Optional - Configuration pool to use in the Knex configuration\n     * @returns PostgresEngine instance\n     */\n    static fromConnectionString(url: string | knex.Knex.StaticConnectionConfig, poolConfig?: knex.Knex.PoolConfig): Promise<PostgresEngine>;\n    /**\n     * Create a table for saving of vectors to be used with PostgresVectorStore.\n     *\n     * @param tableName Postgres database table name. Parameter is not escaped. Do not use with end user input.\n     * @param vectorSize Vector size for the embedding model to be used.\n     * @param schemaName The schema name to store Postgres database table. Default: \"public\". Parameter is not escaped. Do not use with end user input.\n     * @param contentColumn Name of the column to store document content. Default: \"content\".\n     * @param embeddingColumn Name of the column to store vector embeddings. Default: \"embedding\".\n     * @param embeddingColumnType Type of the embedding column (\"vector\" | \"halfvec\" | \"bit\" | \"sparsevec\"). Default: \"vector\". More info on HNSW-supported types: https://github.com/pgvector/pgvector#hnsw\n     * @param metadataColumns Optional - A list of Columns to create for custom metadata. Default: [].\n     * @param metadataJsonColumn Optional - The column to store extra metadata in JSON format. Default: \"langchain_metadata\".\n     * @param idColumn Optional - Column to store ids. Default: \"langchain_id\" column name with data type UUID.\n     * @param overwriteExisting Whether to drop existing table. Default: False.\n     * @param storeMetadata Whether to store metadata in the table. Default: True.\n     */\n    initVectorstoreTable(tableName: string, vectorSize: number, { schemaName, contentColumn, embeddingColumn, embeddingColumnType, metadataColumns, metadataJsonColumn, idColumn, overwriteExisting, storeMetadata }?: VectorStoreTableArgs): Promise<void>;\n    /**\n     * Create a Cloud SQL table to store chat history.\n     *\n     * @param tableName Table name to store chat history\n     * @param schemaName Schema name to store chat history table\n     */\n    initChatHistoryTable(tableName: string, schemaName?: string): Promise<void>;\n    /**\n     *  Dispose of connection pool\n     */\n    closeConnection(): Promise<void>;\n    testConnection(): knex.Knex.Raw<any>;\n}\nexport default PostgresEngine;\n//# sourceMappingURL=engine.d.ts.map"],"mappings":";;;;UAEiBG,kBAAAA;WACJF;EADIE,IAAAA,CAAAA,EAAAA,MAAAA;EAMAC,QAAAA,CAAAA,EAAAA,MAAAA;EAWIC,eAAM,CAAA,EAAA,MAAA;AAqC3B;AAEeE,UAlDEH,oBAAAA,CAkDFG;EACOP,UAAAA,CAAAA,EAAAA,MAAAA;EACaE,aAAKK,CAAAA,EAAAA,MAAAA;EAYyDC,eAAAA,CAAAA,EAAAA,MAAAA;EAAQC,mBAAAA,CAAAA,EAAAA,QAAAA,GAAAA,SAAAA,GAAAA,KAAAA,GAAAA,WAAAA;EAAMC,eAAAA,CAAAA,EA3DzFL,MA2DyFK,EAAAA;EAAUC,kBAAAA,CAAAA,EAAAA,MAAAA;EAAoBR,QAAAA,CAAAA,EAAAA,MAAAA,GAzDrHE,MAyDqHF;EAA6BG,iBAAAA,CAAAA,EAAAA,OAAAA;EAARM,aAAAA,CAAAA,EAAAA,OAAAA;;AAOlHN,cA5D3BD,MAAAA,CA4D2BC;EAARM,IAAAA,EAAAA,MAAAA;EAQMV,QAAUW,EAAAA,MAAAA;EAAqCX,QAAUY,EAAAA,OAAAA;EAAqBR,WAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,MAAAA,EAAAA,QAAAA,CAAAA,EAAAA,OAAAA;EAARM,QAAAA,iBAAAA;;;;;;;;;;;;;;;AA4BjF;;;;;;;;;;;;;;;;;cA3DdN,cAAAA;;QAEXJ,IAAAA,CAAKK;oBACOP;iCACaE,IAAAA,CAAKK;;;;;;;;;;;;;;;;;MAYqGJ,qBAAqBS,QAAQN;;;;;;;0BAO9IJ,IAAAA,CAAKK,OAAOK,QAAQN;;;;;;;;4CAQFJ,IAAAA,CAAKK,IAAAA,CAAKM,qCAAqCX,IAAAA,CAAKK,IAAAA,CAAKO,aAAaF,QAAQN;;;;;;;;;;;;;;;;;;;;;;;;;;MAgB2FF,uBAAuBQ;;;;;;;gEAO5KA;;;;qBAI3CA;oBACDV,IAAAA,CAAKK,IAAAA,CAAKiB"}

package/dist/engine.d.ts

@@ -130,7 +130,6 @@ declare class PostgresEngine {
    *  Dispose of connection pool
    */
   closeConnection(): Promise<void>;
-  // Just to test the connection to the database
   testConnection(): knex.Knex.Raw<any>;
 }
 //#endregion

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","names":["Connector","IpAddressTypes","knex","PostgresEngineArgs","VectorStoreTableArgs","Column","PostgresEngine","Knex","ipType","user","password","iamAccountEmail","Promise","StaticConnectionConfig","PoolConfig","schemaName","contentColumn","embeddingColumn","embeddingColumnType","metadataColumns","metadataJsonColumn","idColumn","overwriteExisting","storeMetadata","Raw","default"],"sources":["../src/engine.d.ts"],"sourcesContent":["import { Connector, IpAddressTypes } from \"@google-cloud/cloud-sql-connector\";\nimport knex from \"knex\";\nexport interface PostgresEngineArgs {\n    ipType?: IpAddressTypes;\n    user?: string;\n    password?: string;\n    iamAccountEmail?: string;\n}\nexport interface VectorStoreTableArgs {\n    schemaName?: string;\n    contentColumn?: string;\n    embeddingColumn?: string;\n    embeddingColumnType?: \"vector\" | \"halfvec\" | \"bit\" | \"sparsevec\";\n    metadataColumns?: Column[];\n    metadataJsonColumn?: string;\n    idColumn?: string | Column;\n    overwriteExisting?: boolean;\n    storeMetadata?: boolean;\n}\nexport declare class Column {\n    name: string;\n    dataType: string;\n    nullable: boolean;\n    constructor(name: string, dataType: string, nullable?: boolean);\n    private postInitilization;\n}\n/**\n * Cloud SQL shared connection pool\n *\n * Setup:\n * Install `@langchain/google-cloud-sql-pg`\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { Column, PostgresEngine, PostgresEngineArgs } from \"@langchain/google-cloud-sql-pg\";\n *\n * const pgArgs: PostgresEngineArgs = {\n *    user: \"db-user\",\n *    password: \"password\"\n *}\n *\n * const engine: PostgresEngine = await PostgresEngine.fromInstance(\n *  \"project-id\",\n *  \"region\",\n *  \"instance-name\",\n *  \"database-name\",\n *  pgArgs\n * );\n * ```\n * </details>\n *\n * <br />\n *\n */\nexport declare class PostgresEngine {\n    private static _createKey;\n    pool: knex.Knex;\n    static connector: Connector;\n    constructor(key: symbol, pool: knex.Knex);\n    /**\n     * @param projectId Required - GCP Project ID\n     * @param region Required - Postgres Instance Region\n     * @param instance Required - Postgres Instance name\n     * @param database Required - Database name\n     * @param ipType Optional - IP address type. Defaults to IPAddressType.PUBLIC\n     * @param user Optional - Postgres user name. Defaults to undefined\n     * @param password Optional - Postgres user password. Defaults to undefined\n     * @param iamAccountEmail Optional - IAM service account email. Defaults to undefined\n     * @returns PostgresEngine instance\n     */\n    static fromInstance(projectId: string, region: string, instance: string, database: string, { ipType, user, password, iamAccountEmail }?: PostgresEngineArgs): Promise<PostgresEngine>;\n    /**\n     * Create a PostgresEngine instance from an Knex instance.\n     *\n     * @param engine knex instance\n     * @returns PostgresEngine instance from a knex instance\n     */\n    static fromPool(engine: knex.Knex): Promise<PostgresEngine>;\n    /**\n     * Create a PostgresEngine instance from arguments.\n     *\n     * @param url URL use to connect to a database\n     * @param poolConfig Optional - Configuration pool to use in the Knex configuration\n     * @returns PostgresEngine instance\n     */\n    static fromConnectionString(url: string | knex.Knex.StaticConnectionConfig, poolConfig?: knex.Knex.PoolConfig): Promise<PostgresEngine>;\n    /**\n     * Create a table for saving of vectors to be used with PostgresVectorStore.\n     *\n     * @param tableName Postgres database table name. Parameter is not escaped. Do not use with end user input.\n     * @param vectorSize Vector size for the embedding model to be used.\n     * @param schemaName The schema name to store Postgres database table. Default: \"public\". Parameter is not escaped. Do not use with end user input.\n     * @param contentColumn Name of the column to store document content. Default: \"content\".\n     * @param embeddingColumn Name of the column to store vector embeddings. Default: \"embedding\".\n     * @param embeddingColumnType Type of the embedding column (\"vector\" | \"halfvec\" | \"bit\" | \"sparsevec\"). Default: \"vector\". More info on HNSW-supported types: https://github.com/pgvector/pgvector#hnsw\n     * @param metadataColumns Optional - A list of Columns to create for custom metadata. Default: [].\n     * @param metadataJsonColumn Optional - The column to store extra metadata in JSON format. Default: \"langchain_metadata\".\n     * @param idColumn Optional - Column to store ids. Default: \"langchain_id\" column name with data type UUID.\n     * @param overwriteExisting Whether to drop existing table. Default: False.\n     * @param storeMetadata Whether to store metadata in the table. Default: True.\n     */\n    initVectorstoreTable(tableName: string, vectorSize: number, { schemaName, contentColumn, embeddingColumn, embeddingColumnType, metadataColumns, metadataJsonColumn, idColumn, overwriteExisting, storeMetadata }?: VectorStoreTableArgs): Promise<void>;\n    /**\n     * Create a Cloud SQL table to store chat history.\n     *\n     * @param tableName Table name to store chat history\n     * @param schemaName Schema name to store chat history table\n     */\n    initChatHistoryTable(tableName: string, schemaName?: string): Promise<void>;\n    /**\n     *  Dispose of connection pool\n     */\n    closeConnection(): Promise<void>;\n    testConnection(): knex.Knex.Raw<any>;\n}\nexport default PostgresEngine;\n//# sourceMappingURL=engine.d.ts.map"],"mappings":";;;;UAEiBG,kBAAAA;WACJF;EADIE,IAAAA,CAAAA,EAAAA,MAAAA;EAMAC,QAAAA,CAAAA,EAAAA,MAAAA;EAWIC,eAAM,CAAA,EAAA,MAAA;AAqC3B;AAEeE,UAlDEH,oBAAAA,CAkDFG;EACOP,UAAAA,CAAAA,EAAAA,MAAAA;EACaE,aAAKK,CAAAA,EAAAA,MAAAA;EAYyDC,eAAAA,CAAAA,EAAAA,MAAAA;EAAQC,mBAAAA,CAAAA,EAAAA,QAAAA,GAAAA,SAAAA,GAAAA,KAAAA,GAAAA,WAAAA;EAAMC,eAAAA,CAAAA,EA3DzFL,MA2DyFK,EAAAA;EAAUC,kBAAAA,CAAAA,EAAAA,MAAAA;EAAoBR,QAAAA,CAAAA,EAAAA,MAAAA,GAzDrHE,MAyDqHF;EAA6BG,iBAAAA,CAAAA,EAAAA,OAAAA;EAARM,aAAAA,CAAAA,EAAAA,OAAAA;;AAOlHN,cA5D3BD,MAAAA,CA4D2BC;EAARM,IAAAA,EAAAA,MAAAA;EAQMV,QAAUW,EAAAA,MAAAA;EAAqCX,QAAUY,EAAAA,OAAAA;EAAqBR,WAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,MAAAA,EAAAA,QAAAA,CAAAA,EAAAA,OAAAA;EAARM,QAAAA,iBAAAA;;;;;;;;;;;;;;;AA4BjF;;;;;;;;;;;;;;;;;cA3DdN,cAAAA;;QAEXJ,IAAAA,CAAKK;oBACOP;iCACaE,IAAAA,CAAKK;;;;;;;;;;;;;;;;;MAYqGJ,qBAAqBS,QAAQN;;;;;;;0BAO9IJ,IAAAA,CAAKK,OAAOK,QAAQN;;;;;;;;4CAQFJ,IAAAA,CAAKK,IAAAA,CAAKM,qCAAqCX,IAAAA,CAAKK,IAAAA,CAAKO,aAAaF,QAAQN;;;;;;;;;;;;;;;;;;;;;;;;;;MAgB2FF,uBAAuBQ;;;;;;;gEAO5KA;;;;qBAI3CA;oBACDV,IAAAA,CAAKK,IAAAA,CAAKiB"}

package/dist/indexes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexes.d.cts","names":["StrategyMixin","DistanceStrategy","DEFAULT_DISTANCE_STRATEGY","DEFAULT_INDEX_NAME_SUFFIX","BaseIndexArgs","BaseIndex","ExactNearestNeighbor","HNSWIndex","IVFFlatIndex","QueryOptions","HNSWQueryOptions","IVFFlatQueryOptions"],"sources":["../src/indexes.d.ts"],"sourcesContent":["declare class StrategyMixin {\n    operator: string;\n    searchFunction: string;\n    indexFunction: string;\n    constructor(operator: string, searchFunction: string, indexFunction: string);\n}\n/**\n * Enumerator of the Distance strategies.\n */\nexport declare class DistanceStrategy extends StrategyMixin {\n    static EUCLIDEAN: StrategyMixin;\n    static COSINE_DISTANCE: StrategyMixin;\n    static INNER_PRODUCT: StrategyMixin;\n}\nexport declare const DEFAULT_DISTANCE_STRATEGY: StrategyMixin;\nexport declare const DEFAULT_INDEX_NAME_SUFFIX: string;\nexport interface BaseIndexArgs {\n    name?: string;\n    distanceStrategy?: DistanceStrategy;\n    partialIndexes?: string[];\n}\nexport declare abstract class BaseIndex {\n    name?: string;\n    indexType: string;\n    distanceStrategy: DistanceStrategy;\n    partialIndexes?: string[];\n    constructor(name?: string, indexType?: string, distanceStrategy?: DistanceStrategy, partialIndexes?: string[]);\n    /**\n     * Set index query options for vector store initialization.\n     */\n    abstract indexOptions(): string;\n}\nexport declare class ExactNearestNeighbor extends BaseIndex {\n    constructor(baseArgs?: BaseIndexArgs);\n    indexOptions(): string;\n}\nexport declare class HNSWIndex extends BaseIndex {\n    m: number;\n    efConstruction: number;\n    constructor(baseArgs?: BaseIndexArgs, m?: number, efConstruction?: number);\n    indexOptions(): string;\n}\nexport declare class IVFFlatIndex extends BaseIndex {\n    lists: number;\n    constructor(baseArgs: BaseIndexArgs, lists?: number);\n    indexOptions(): string;\n}\n/**\n * Convert index attributes to string.\n * Must be implemented by subclasses.\n */\nexport declare abstract class QueryOptions {\n    abstract to_string(): string;\n}\nexport declare class HNSWQueryOptions extends QueryOptions {\n    efSearch: number;\n    constructor(efSearch?: number);\n    to_string(): string;\n}\nexport declare class IVFFlatQueryOptions extends QueryOptions {\n    readonly probes: number;\n    constructor(probes?: number);\n    to_string(): string;\n}\nexport {};\n//# sourceMappingURL=indexes.d.ts.map"],"mappings":";cAAcA,aAAAA;EAAAA,QAAAA,EAAAA,MAAa;EASNC,cAAAA,EAAAA,MAAgB;EACfD,aAAAA,EAAAA,MAAAA;EACMA,WAAAA,CAAAA,QAAAA,EAAAA,MAAAA,EAAAA,cAAAA,EAAAA,MAAAA,EAAAA,aAAAA,EAAAA,MAAAA;;;AAF+B;AAK3D;AACqBG,cANAF,gBAAAA,SAAyBD,aAAAA,CAMQ;EACrCI,OAAAA,SAAa,EANRJ,aAQCC;EAGOI,OAAAA,eAAS,EAVXL,aAaNC;EAQDK,OAAAA,aAAAA,EApBKN,aAqBCI;AAG3B;AAMqBI,cA5BAN,yBA4BqBG,EA5BML,aA4BG;AASrBS,cApCTN,yBAoCqB,EAAA,MAAA;AAGrBO,UAtCJN,aAAAA,CAsCoB;EAKhBO,IAAAA,CAAAA,EAAAA,MAAAA;qBAzCEV;;;uBAGOI,SAAAA;;;oBAGRJ;;oEAEgDA;;;;;;cAMjDK,oBAAAA,SAA6BD,SAAS;yBAChCD;;;cAGNG,SAAAA,SAAkBF,SAAS;;;yBAGrBD;;;cAGNI,YAAAA,SAAqBH,SAAS;;wBAEzBD;;;;;;;uBAOIK,YAAAA;;;cAGTC,gBAAAA,SAAyBD,YAAY;;;;;cAKrCE,mBAAAA,SAA4BF,YAAY"}

package/dist/indexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexes.d.ts","names":["StrategyMixin","DistanceStrategy","DEFAULT_DISTANCE_STRATEGY","DEFAULT_INDEX_NAME_SUFFIX","BaseIndexArgs","BaseIndex","ExactNearestNeighbor","HNSWIndex","IVFFlatIndex","QueryOptions","HNSWQueryOptions","IVFFlatQueryOptions"],"sources":["../src/indexes.d.ts"],"sourcesContent":["declare class StrategyMixin {\n    operator: string;\n    searchFunction: string;\n    indexFunction: string;\n    constructor(operator: string, searchFunction: string, indexFunction: string);\n}\n/**\n * Enumerator of the Distance strategies.\n */\nexport declare class DistanceStrategy extends StrategyMixin {\n    static EUCLIDEAN: StrategyMixin;\n    static COSINE_DISTANCE: StrategyMixin;\n    static INNER_PRODUCT: StrategyMixin;\n}\nexport declare const DEFAULT_DISTANCE_STRATEGY: StrategyMixin;\nexport declare const DEFAULT_INDEX_NAME_SUFFIX: string;\nexport interface BaseIndexArgs {\n    name?: string;\n    distanceStrategy?: DistanceStrategy;\n    partialIndexes?: string[];\n}\nexport declare abstract class BaseIndex {\n    name?: string;\n    indexType: string;\n    distanceStrategy: DistanceStrategy;\n    partialIndexes?: string[];\n    constructor(name?: string, indexType?: string, distanceStrategy?: DistanceStrategy, partialIndexes?: string[]);\n    /**\n     * Set index query options for vector store initialization.\n     */\n    abstract indexOptions(): string;\n}\nexport declare class ExactNearestNeighbor extends BaseIndex {\n    constructor(baseArgs?: BaseIndexArgs);\n    indexOptions(): string;\n}\nexport declare class HNSWIndex extends BaseIndex {\n    m: number;\n    efConstruction: number;\n    constructor(baseArgs?: BaseIndexArgs, m?: number, efConstruction?: number);\n    indexOptions(): string;\n}\nexport declare class IVFFlatIndex extends BaseIndex {\n    lists: number;\n    constructor(baseArgs: BaseIndexArgs, lists?: number);\n    indexOptions(): string;\n}\n/**\n * Convert index attributes to string.\n * Must be implemented by subclasses.\n */\nexport declare abstract class QueryOptions {\n    abstract to_string(): string;\n}\nexport declare class HNSWQueryOptions extends QueryOptions {\n    efSearch: number;\n    constructor(efSearch?: number);\n    to_string(): string;\n}\nexport declare class IVFFlatQueryOptions extends QueryOptions {\n    readonly probes: number;\n    constructor(probes?: number);\n    to_string(): string;\n}\nexport {};\n//# sourceMappingURL=indexes.d.ts.map"],"mappings":";cAAcA,aAAAA;EAAAA,QAAAA,EAAAA,MAAa;EASNC,cAAAA,EAAAA,MAAgB;EACfD,aAAAA,EAAAA,MAAAA;EACMA,WAAAA,CAAAA,QAAAA,EAAAA,MAAAA,EAAAA,cAAAA,EAAAA,MAAAA,EAAAA,aAAAA,EAAAA,MAAAA;;;AAF+B;AAK3D;AACqBG,cANAF,gBAAAA,SAAyBD,aAAAA,CAMQ;EACrCI,OAAAA,SAAa,EANRJ,aAQCC;EAGOI,OAAAA,eAAS,EAVXL,aAaNC;EAQDK,OAAAA,aAAAA,EApBKN,aAqBCI;AAG3B;AAMqBI,cA5BAN,yBA4BqBG,EA5BML,aA4BG;AASrBS,cApCTN,yBAoCqB,EAAA,MAAA;AAGrBO,UAtCJN,aAAAA,CAsCoB;EAKhBO,IAAAA,CAAAA,EAAAA,MAAAA;qBAzCEV;;;uBAGOI,SAAAA;;;oBAGRJ;;oEAEgDA;;;;;;cAMjDK,oBAAAA,SAA6BD,SAAS;yBAChCD;;;cAGNG,SAAAA,SAAkBF,SAAS;;;yBAGrBD;;;cAGNI,YAAAA,SAAqBH,SAAS;;wBAEzBD;;;;;;;uBAOIK,YAAAA;;;cAGTC,gBAAAA,SAAyBD,YAAY;;;;;cAKrCE,mBAAAA,SAA4BF,YAAY"}

package/dist/loader.d.cts

@@ -6,7 +6,6 @@ import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
 type Row = {
   [key: string]: string;
 };
-// Options for PostgresLoader
 interface PostgresLoaderOptions {
   tableName?: string;
   schemaName?: string;

package/dist/loader.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.cts","names":["Document","BaseDocumentLoader","PostgresEngine","Row","PostgresLoaderOptions","PostgresLoader","schemaName","tableName","contentColumns","metadataColumns","format","query","formatter","metadataJsonColumn","Promise","AsyncGenerator"],"sources":["../src/loader.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport PostgresEngine from \"./engine.js\";\ntype Row = {\n    [key: string]: string;\n};\nexport interface PostgresLoaderOptions {\n    tableName?: string;\n    schemaName?: string;\n    contentColumns?: string[];\n    metadataColumns?: string[];\n    format?: \"text\" | \"json\" | \"yaml\" | \"csv\";\n    formatter?: (row: Row, contentColumns: string[]) => string;\n    query?: string;\n    metadataJsonColumn?: string | null;\n}\n/**\n * Google Cloud SQL for PostgreSQL vector store integration.\n *\n * Setup:\n * Install`@langchain/google-cloud-sql-pg`\n *\n * ```bash\n * npm install @langchain/google-cloud-sql-pg\n * ```\n *\n * <details open >\n * <summary><strong>Use with Table Name < /strong></summary >\n *\n * ```typescript\n * import { PostgresEngine, PostgresLoader } from \"@langchain/google-cloud-sql-pg\";\n *\n * const documentLoaderArgs: PostgresLoaderOptions = {\n *   tableName: \"test_table_custom\",\n *   contentColumns: [ \"fruit_name\", \"variety\"],\n *   metadataColumns: [\"fruit_id\", \"quantity_in_stock\", \"price_per_unit\", \"organic\"],\n *   format: \"text\"\n * };\n *\n * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);\n *\n * const documents = await documentLoaderInstance.load();\n * ```\n * </details>\n *\n * <br />\n *\n * <details open >\n * <summary><strong>Use with Query < /strong></summary >\n *\n * ```typescript\n * import { PostgresEngine, PostgresLoader } from \"@langchain/google-cloud-sql-pg\";\n *\n * const documentLoaderArgs: PostgresLoaderOptions = {\n *   query: \"SELECT * FROM my_table WHERE organic = true;\",\n *   contentColumns: [ \"fruit_name\", \"variety\"],\n *   metadataColumns: [\"fruit_id\", \"quantity_in_stock\", \"price_per_unit\", \"organic\"],\n *   format: \"text\"\n * };\n *\n * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);\n *\n * for await (const doc of documentLoaderInstance.lazyLoad()) {\n *   console.log(doc);\n *   break; // break based on required condition\n * }\n * ```\n * </details>\n *\n * <br />\n */\nexport declare class PostgresLoader extends BaseDocumentLoader {\n    private engine;\n    tableName?: string;\n    schemaName?: string;\n    contentColumns?: string[];\n    metadataColumns?: string[];\n    format?: \"text\" | \"json\" | \"yaml\" | \"csv\";\n    formatter?: (row: Row, contentColumns: string[]) => string;\n    query?: string;\n    metadataJsonColumn?: string | null;\n    constructor(engine: PostgresEngine, options: PostgresLoaderOptions);\n    static initialize(engine: PostgresEngine, { schemaName, tableName, contentColumns, metadataColumns, format, query, formatter, metadataJsonColumn }: PostgresLoaderOptions): Promise<PostgresLoader>;\n    load(): Promise<Document[]>;\n    lazyLoad(): AsyncGenerator<Document>;\n}\nexport {};\n//# sourceMappingURL=loader.d.ts.map"],"mappings":";;;;;KAGKG,GAAAA;;AADoC,CAAA;AAIxBC,UAAAA,qBAAAA,CAAqB;EAiEjBC,SAAAA,CAAAA,EAAAA,MAAc;EAObF,UAAAA,CAAAA,EAAAA,MAAAA;EAGED,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAyBE,eAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EACnBF,MAAAA,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,KAAAA;EAAkBI,SAAAA,CAAAA,EAAAA,CAAAA,GAAAA,EAtE1BH,GAsE0BG,EAAAA,cAAAA,EAAAA,MAAAA,EAAAA,EAAAA,GAAAA,MAAAA;EAAYC,KAAAA,CAAAA,EAAAA,MAAAA;EAAWC,kBAAAA,CAAAA,EAAAA,MAAAA,GAAAA,IAAAA;;;;;;;;;;;;;;AAXT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAzCH,cAAAA,SAAuBJ,kBAAAA;;;;;;;oBAOtBE;;;sBAGED,yBAAyBE;4BACnBF;;;;;;;;;KAA0HE,wBAAwBU,QAAQT;UAC5KS,QAAQd;cACJe,eAAef"}

package/dist/loader.d.ts

@@ -6,7 +6,6 @@ import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
 type Row = {
   [key: string]: string;
 };
-// Options for PostgresLoader
 interface PostgresLoaderOptions {
   tableName?: string;
   schemaName?: string;

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","names":["Document","BaseDocumentLoader","PostgresEngine","Row","PostgresLoaderOptions","PostgresLoader","schemaName","tableName","contentColumns","metadataColumns","format","query","formatter","metadataJsonColumn","Promise","AsyncGenerator"],"sources":["../src/loader.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport PostgresEngine from \"./engine.js\";\ntype Row = {\n    [key: string]: string;\n};\nexport interface PostgresLoaderOptions {\n    tableName?: string;\n    schemaName?: string;\n    contentColumns?: string[];\n    metadataColumns?: string[];\n    format?: \"text\" | \"json\" | \"yaml\" | \"csv\";\n    formatter?: (row: Row, contentColumns: string[]) => string;\n    query?: string;\n    metadataJsonColumn?: string | null;\n}\n/**\n * Google Cloud SQL for PostgreSQL vector store integration.\n *\n * Setup:\n * Install`@langchain/google-cloud-sql-pg`\n *\n * ```bash\n * npm install @langchain/google-cloud-sql-pg\n * ```\n *\n * <details open >\n * <summary><strong>Use with Table Name < /strong></summary >\n *\n * ```typescript\n * import { PostgresEngine, PostgresLoader } from \"@langchain/google-cloud-sql-pg\";\n *\n * const documentLoaderArgs: PostgresLoaderOptions = {\n *   tableName: \"test_table_custom\",\n *   contentColumns: [ \"fruit_name\", \"variety\"],\n *   metadataColumns: [\"fruit_id\", \"quantity_in_stock\", \"price_per_unit\", \"organic\"],\n *   format: \"text\"\n * };\n *\n * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);\n *\n * const documents = await documentLoaderInstance.load();\n * ```\n * </details>\n *\n * <br />\n *\n * <details open >\n * <summary><strong>Use with Query < /strong></summary >\n *\n * ```typescript\n * import { PostgresEngine, PostgresLoader } from \"@langchain/google-cloud-sql-pg\";\n *\n * const documentLoaderArgs: PostgresLoaderOptions = {\n *   query: \"SELECT * FROM my_table WHERE organic = true;\",\n *   contentColumns: [ \"fruit_name\", \"variety\"],\n *   metadataColumns: [\"fruit_id\", \"quantity_in_stock\", \"price_per_unit\", \"organic\"],\n *   format: \"text\"\n * };\n *\n * const documentLoaderInstance = await PostgresLoader.initialize(PEInstance, documentLoaderArgs);\n *\n * for await (const doc of documentLoaderInstance.lazyLoad()) {\n *   console.log(doc);\n *   break; // break based on required condition\n * }\n * ```\n * </details>\n *\n * <br />\n */\nexport declare class PostgresLoader extends BaseDocumentLoader {\n    private engine;\n    tableName?: string;\n    schemaName?: string;\n    contentColumns?: string[];\n    metadataColumns?: string[];\n    format?: \"text\" | \"json\" | \"yaml\" | \"csv\";\n    formatter?: (row: Row, contentColumns: string[]) => string;\n    query?: string;\n    metadataJsonColumn?: string | null;\n    constructor(engine: PostgresEngine, options: PostgresLoaderOptions);\n    static initialize(engine: PostgresEngine, { schemaName, tableName, contentColumns, metadataColumns, format, query, formatter, metadataJsonColumn }: PostgresLoaderOptions): Promise<PostgresLoader>;\n    load(): Promise<Document[]>;\n    lazyLoad(): AsyncGenerator<Document>;\n}\nexport {};\n//# sourceMappingURL=loader.d.ts.map"],"mappings":";;;;;KAGKG,GAAAA;;AADoC,CAAA;AAIxBC,UAAAA,qBAAAA,CAAqB;EAiEjBC,SAAAA,CAAAA,EAAAA,MAAc;EAObF,UAAAA,CAAAA,EAAAA,MAAAA;EAGED,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAyBE,eAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EACnBF,MAAAA,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,GAAAA,KAAAA;EAAkBI,SAAAA,CAAAA,EAAAA,CAAAA,GAAAA,EAtE1BH,GAsE0BG,EAAAA,cAAAA,EAAAA,MAAAA,EAAAA,EAAAA,GAAAA,MAAAA;EAAYC,KAAAA,CAAAA,EAAAA,MAAAA;EAAWC,kBAAAA,CAAAA,EAAAA,MAAAA,GAAAA,IAAAA;;;;;;;;;;;;;;AAXT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAzCH,cAAAA,SAAuBJ,kBAAAA;;;;;;;oBAOtBE;;;sBAGED,yBAAyBE;4BACnBF;;;;;;;;;KAA0HE,wBAAwBU,QAAQT;UAC5KS,QAAQd;cACJe,eAAef"}

package/dist/vectorstore.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectorstore.d.cts","names":["EmbeddingsInterface","MaxMarginalRelevanceSearchOptions","VectorStore","Document","BaseIndex","DistanceStrategy","QueryOptions","PostgresEngine","PostgresVectorStoreArgs","Array","dbConfigArgs","VSArgs","PostgresVectorStore","schemaName","contentColumn","embeddingColumn","metadataColumns","ignoreMetadataColumns","idColumn","metadataJsonColumn","distanceStrategy","k","fetchK","lambdaMult","indexQueryOptions","Promise","default"],"sources":["../src/vectorstore.d.ts"],"sourcesContent":["import { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { MaxMarginalRelevanceSearchOptions, VectorStore } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseIndex, DistanceStrategy, QueryOptions } from \"./indexes.js\";\nimport PostgresEngine from \"./engine.js\";\nexport interface PostgresVectorStoreArgs {\n    schemaName?: string;\n    contentColumn?: string;\n    embeddingColumn?: string;\n    metadataColumns?: Array<string>;\n    idColumn?: string;\n    distanceStrategy?: DistanceStrategy;\n    k?: number;\n    fetchK?: number;\n    lambdaMult?: number;\n    ignoreMetadataColumns?: Array<string>;\n    metadataJsonColumn?: string;\n    indexQueryOptions?: QueryOptions;\n}\nexport interface dbConfigArgs {\n    engine: PostgresEngine;\n    tableName: string;\n    dbConfig?: PostgresVectorStoreArgs;\n}\ninterface VSArgs {\n    engine: PostgresEngine;\n    tableName: string;\n    schemaName: string;\n    contentColumn: string;\n    embeddingColumn: string;\n    metadataColumns: Array<string>;\n    idColumn: string;\n    distanceStrategy: DistanceStrategy;\n    k: number;\n    fetchK: number;\n    lambdaMult: number;\n    metadataJsonColumn: string;\n    indexQueryOptions?: QueryOptions;\n}\n/**\n * Google Cloud SQL for PostgreSQL vector store integration.\n *\n * Setup:\n * Install `@langchain/google-cloud-sql-pg`\n *\n * ```bash\n * npm install @langchain/google-cloud-sql-pg\n * ```\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { Column, PostgresEngine, PostgresEngineArgs, PostgresVectorStore, VectorStoreTableArgs } from \"@langchain/google-cloud-sql-pg\";\n * // Or other embeddings\n * import { OpenAIEmbeddings } from '@langchain/openai';\n *\n *\n * const embeddings = new OpenAIEmbeddings({\n *   model: \"text-embedding-3-small\",\n * });\n *\n * const pgArgs: PostgresEngineArgs = {\n *     user: \"db-user\",\n *     password: \"password\"\n * }\n * // Create a shared connection pool\n * const engine: PostgresEngine = await PostgresEngine.fromInstance(\n *  \"project-id\",\n *  \"region\",\n *  \"instance-name\",\n *  \"database-name\",\n *  pgArgs\n * );\n * // (Optional) Specify metadata columns for filtering\n * // All other metadata will be added to JSON\n * const vectorStoreTableArgs: VectorStoreTableArgs = {\n *   metadataColumns: [new Column(\"baz\", \"TEXT\")],\n * };\n * // Create a vector store table\n * await engine.initVectorstoreTable(\"my-table\", 768, vectorStoreTableArgs);\n * // Customize the vector store\n * const pvectorArgs: PostgresVectorStoreArgs = {\n *     idColumn: \"ID_COLUMN\",\n *     contentColumn: \"CONTENT_COLUMN\",\n *     embeddingColumn: \"EMBEDDING_COLUMN\",\n *     metadataColumns: [\"baz\"]\n * }\n *\n * const vectorStore = await PostgresVectorStore.initialize(engine, embeddingService, \"my-table\", pvectorArgs);\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Add documents</strong></summary>\n *\n * ```typescript\n * import type { Document } from '@langchain/core/documents';\n *\n * const document1 = { pageContent: \"foo\", metadata: { baz: \"bar\" } };\n * const document2 = { pageContent: \"thud\", metadata: { bar: \"baz\" } };\n * const document3 = { pageContent: \"i will be deleted :(\", metadata: {} };\n *\n * const documents: Document[] = [document1, document2, document3];\n * const ids = [\"1\", \"2\", \"3\"];\n * await vectorStore.addDocuments(documents, { ids });\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Delete documents</strong></summary>\n *\n * ```typescript\n * await vectorStore.delete({ ids: [\"3\"] });\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Similarity search</strong></summary>\n *\n * ```typescript\n * const results = await vectorStore.similaritySearch(\"thud\", 1);\n * for (const doc of results) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output:thud [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with filter</strong></summary>\n *\n * ```typescript\n * const resultsWithFilter = await vectorStore.similaritySearch(\"thud\", 1, \"baz = 'bar'\");\n *\n * for (const doc of resultsWithFilter) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output:foo [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with score</strong></summary>\n *\n * ```typescript\n * const resultsWithScore = await vectorStore.similaritySearchWithScore(\"qux\", 1);\n * for (const [doc, score] of resultsWithScore) {\n *   console.log(`* [SIM=${score.toFixed(6)}] ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output:[SIM=0.000000] qux [{\"bar\":\"baz\",\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>As a retriever</strong></summary>\n *\n * ```typescript\n * const retriever = vectorStore.asRetriever({\n *   searchType: \"mmr\", // Leave blank for standard similarity search\n *   k: 1,\n * });\n * const resultAsRetriever = await retriever.invoke(\"thud\");\n * console.log(resultAsRetriever);\n *\n * // Output: [Document({ metadata: { \"baz\":\"bar\" }, pageContent: \"thud\" })]\n * ```\n * </details>\n *\n * <br />\n */\nexport declare class PostgresVectorStore extends VectorStore {\n    FilterType: string;\n    engine: PostgresEngine;\n    embeddings: EmbeddingsInterface;\n    tableName: string;\n    schemaName: string;\n    contentColumn: string;\n    embeddingColumn: string;\n    metadataColumns: Array<string>;\n    idColumn: string;\n    metadataJsonColumn: string;\n    distanceStrategy: DistanceStrategy;\n    k: number;\n    fetchK: number;\n    lambdaMult: number;\n    indexQueryOptions: QueryOptions | undefined;\n    /**\n     * Initializes a new vector store with embeddings and database configuration.\n     *\n     * @param embeddings - Instance of `EmbeddingsInterface` used to embed queries.\n     * @param dbConfig - Configuration settings for the database or storage system.\n     */\n    constructor(embeddings: EmbeddingsInterface, dbConfig: VSArgs);\n    /**\n     * Create a new PostgresVectorStore instance.\n     * @param {PostgresEngine} engine Required - Connection pool engine for managing connections to Cloud SQL for PostgreSQL database.\n     * @param {Embeddings} embeddings Required - Text embedding model to use.\n     * @param {string} tableName Required - Name of an existing table or table to be created.\n     * @param {string} schemaName Database schema name of the table. Defaults to \"public\".\n     * @param {string} contentColumn Column that represent a Document's page_content. Defaults to \"content\".\n     * @param {string} embeddingColumn Column for embedding vectors. The embedding is generated from the document value. Defaults to \"embedding\".\n     * @param {Array<string>} metadataColumns Column(s) that represent a document's metadata.\n     * @param {Array<string>} ignoreMetadataColumns Optional - Column(s) to ignore in pre-existing tables for a document's metadata. Can not be used with metadata_columns.\n     * @param {string} idColumn Column that represents the Document's id. Defaults to \"langchain_id\".\n     * @param {string} metadataJsonColumn Optional - Column to store metadata as JSON. Defaults to \"langchain_metadata\".\n     * @param {DistanceStrategy} distanceStrategy Distance strategy to use for vector similarity search. Defaults to COSINE_DISTANCE.\n     * @param {number} k Number of Documents to return from search. Defaults to 4.\n     * @param {number} fetchK Number of Documents to fetch to pass to MMR algorithm.\n     * @param {number} lambdaMult Number between 0 and 1 that determines the degree of diversity among the results with 0 corresponding to maximum diversity and 1 to minimum diversity. Defaults to 0.5.\n     * @param {QueryOptions} indexQueryOptions Optional - Index query option.\n     * @returns PostgresVectorStore instance.\n     */\n    static initialize(engine: PostgresEngine, embeddings: EmbeddingsInterface, tableName: string, { schemaName, contentColumn, embeddingColumn, metadataColumns, ignoreMetadataColumns, idColumn, metadataJsonColumn, distanceStrategy, k, fetchK, lambdaMult, indexQueryOptions }?: PostgresVectorStoreArgs): Promise<PostgresVectorStore>;\n    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: EmbeddingsInterface, dbConfig: dbConfigArgs): Promise<VectorStore>;\n    static fromDocuments(docs: Document[], embeddings: EmbeddingsInterface, dbConfig: dbConfigArgs): Promise<VectorStore>;\n    addVectors(vectors: number[][], documents: Document[], options?: {\n        ids?: string[];\n    }): Promise<string[] | void>;\n    _vectorstoreType(): string;\n    /**\n     * Adds documents to the vector store, embedding them first through the\n     * `embeddings` instance.\n     *\n     * @param documents - Array of documents to embed and add.\n     * @param options - Optional configuration for embedding and storing documents.\n     * @returns A promise resolving to an array of document IDs or void, based on implementation.\n     * @abstract\n     */\n    addDocuments(documents: Document[], options?: {\n        ids?: string[];\n    }): Promise<string[] | void>;\n    /**\n     * Deletes documents from the vector store based on the specified ids.\n     *\n     * @param params - Flexible key-value pairs defining conditions for document deletion.\n     * @param ids -  Optional: Property of {params} that contains the array of ids to be deleted\n     * @returns A promise that resolves once the deletion is complete.\n     */\n    delete(params: {\n        ids?: string[];\n    }): Promise<void>;\n    similaritySearchVectorWithScore(embedding: number[], k: number, filter?: this[\"FilterType\"]): Promise<[Document, number][]>;\n    private queryCollection;\n    maxMarginalRelevanceSearch(query: string, options: MaxMarginalRelevanceSearchOptions<this[\"FilterType\"]>): Promise<Document[]>;\n    /**\n     * Create an index on the vector store table\n     * @param {BaseIndex} index\n     * @param {string} name Optional\n     * @param {boolean} concurrently Optional\n     */\n    applyVectorIndex(index: BaseIndex, name?: string, concurrently?: boolean): Promise<void>;\n    /**\n     * Check if index exists in the table.\n     * @param {string} indexName Optional - index name\n     */\n    isValidIndex(indexName?: string): Promise<boolean>;\n    /**\n     * Drop the vector index\n     * @param {string} indexName Optional - index name\n     */\n    dropVectorIndex(indexName?: string): Promise<void>;\n    /**\n     * Re-index the vector store table\n     * @param {string} indexName Optional - index name\n     */\n    reIndex(indexName?: string): Promise<void>;\n}\nexport default PostgresVectorStore;\n//# sourceMappingURL=vectorstore.d.ts.map"],"mappings":";;;;;;;UAKiBQ,uBAAAA;;EAAAA,aAAAA,CAAAA,EAAAA,MAAAA;EAIKC,eAAAA,CAAAA,EAAAA,MAAAA;EAECJ,eAAAA,CAAAA,EAFDI,KAECJ,CAAAA,MAAAA,CAAAA;EAIKI,QAAAA,CAAAA,EAAAA,MAAAA;EAEJH,gBAAAA,CAAAA,EANDD,gBAMCC;EAAY,CAAA,CAAA,EAAA,MAAA;EAEnBI,MAAAA,CAAAA,EAAAA,MAAY;EAKnBC,UAAM,CAAA,EAAA,MAAA;EACJJ,qBAAAA,CAAAA,EAVgBE,KAUhBF,CAAAA,MAAAA,CAAAA;EAKSE,kBAAAA,CAAAA,EAAAA,MAAAA;EAECJ,iBAAAA,CAAAA,EAfEC,YAeFD;;AAKc,UAlBnBK,YAAAA,CAkBmB;EAoJfE,MAAAA,EArKTL,cAqK4B;EAE5BA,SAAAA,EAAAA,MAAAA;EACIP,QAAAA,CAAAA,EAtKDQ,uBAsKCR;;UApKNW,MAAAA,CA4KYN;EAICC,MAAAA,EA/KXC,cA+KWD;EAOKN,SAAAA,EAAAA,MAAAA;EAA+BW,UAAAA,EAAAA,MAAAA;EAoB7BJ,aAAAA,EAAAA,MAAAA;EAA4BP,eAAAA,EAAAA,MAAAA;EAA0Ca,eAAAA,EArM/EJ,KAqM+EI,CAAAA,MAAAA,CAAAA;EAAYC,QAAAA,EAAAA,MAAAA;EAAeC,gBAAAA,EAnMzGV,gBAmMyGU;EAAiBC,CAAAA,EAAAA,MAAAA;EAAiBC,MAAAA,EAAAA,MAAAA;EAAuBC,UAAAA,EAAAA,MAAAA;EAAUC,kBAAAA,EAAAA,MAAAA;EAAoBC,iBAAAA,CAAAA,EA9L9Ld,YA8L8Lc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA1C1J;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAvCR,mBAAAA,SAA4BV,WAAAA;;UAErCK;cACIP;;;;;mBAKKS;;;oBAGCJ;;;;qBAICC;;;;;;;0BAOKN,+BAA+BW;;;;;;;;;;;;;;;;;;;;4BAoB7BJ,4BAA4BP;;;;;;;;;;;;;MAA2NQ,0BAA0BiB,QAAQb;8EACvOZ,+BAA+BU,eAAee,QAAQvB;6BACvGC,wBAAwBH,+BAA+BU,eAAee,QAAQvB;6CAC9DC;;MAEvCsB;;;;;;;;;;;0BAWoBtB;;MAEpBsB;;;;;;;;;;MAUAA;gGAC0FA,SAAStB;;qDAEpDF,wDAAwDwB,QAAQtB;;;;;;;0BAO3FC,mDAAmDqB;;;;;oCAKzCA;;;;;uCAKGA;;;;;+BAKRA"}

package/dist/vectorstore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectorstore.d.ts","names":["EmbeddingsInterface","MaxMarginalRelevanceSearchOptions","VectorStore","Document","BaseIndex","DistanceStrategy","QueryOptions","PostgresEngine","PostgresVectorStoreArgs","Array","dbConfigArgs","VSArgs","PostgresVectorStore","schemaName","contentColumn","embeddingColumn","metadataColumns","ignoreMetadataColumns","idColumn","metadataJsonColumn","distanceStrategy","k","fetchK","lambdaMult","indexQueryOptions","Promise","default"],"sources":["../src/vectorstore.d.ts"],"sourcesContent":["import { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { MaxMarginalRelevanceSearchOptions, VectorStore } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseIndex, DistanceStrategy, QueryOptions } from \"./indexes.js\";\nimport PostgresEngine from \"./engine.js\";\nexport interface PostgresVectorStoreArgs {\n    schemaName?: string;\n    contentColumn?: string;\n    embeddingColumn?: string;\n    metadataColumns?: Array<string>;\n    idColumn?: string;\n    distanceStrategy?: DistanceStrategy;\n    k?: number;\n    fetchK?: number;\n    lambdaMult?: number;\n    ignoreMetadataColumns?: Array<string>;\n    metadataJsonColumn?: string;\n    indexQueryOptions?: QueryOptions;\n}\nexport interface dbConfigArgs {\n    engine: PostgresEngine;\n    tableName: string;\n    dbConfig?: PostgresVectorStoreArgs;\n}\ninterface VSArgs {\n    engine: PostgresEngine;\n    tableName: string;\n    schemaName: string;\n    contentColumn: string;\n    embeddingColumn: string;\n    metadataColumns: Array<string>;\n    idColumn: string;\n    distanceStrategy: DistanceStrategy;\n    k: number;\n    fetchK: number;\n    lambdaMult: number;\n    metadataJsonColumn: string;\n    indexQueryOptions?: QueryOptions;\n}\n/**\n * Google Cloud SQL for PostgreSQL vector store integration.\n *\n * Setup:\n * Install `@langchain/google-cloud-sql-pg`\n *\n * ```bash\n * npm install @langchain/google-cloud-sql-pg\n * ```\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { Column, PostgresEngine, PostgresEngineArgs, PostgresVectorStore, VectorStoreTableArgs } from \"@langchain/google-cloud-sql-pg\";\n * // Or other embeddings\n * import { OpenAIEmbeddings } from '@langchain/openai';\n *\n *\n * const embeddings = new OpenAIEmbeddings({\n *   model: \"text-embedding-3-small\",\n * });\n *\n * const pgArgs: PostgresEngineArgs = {\n *     user: \"db-user\",\n *     password: \"password\"\n * }\n * // Create a shared connection pool\n * const engine: PostgresEngine = await PostgresEngine.fromInstance(\n *  \"project-id\",\n *  \"region\",\n *  \"instance-name\",\n *  \"database-name\",\n *  pgArgs\n * );\n * // (Optional) Specify metadata columns for filtering\n * // All other metadata will be added to JSON\n * const vectorStoreTableArgs: VectorStoreTableArgs = {\n *   metadataColumns: [new Column(\"baz\", \"TEXT\")],\n * };\n * // Create a vector store table\n * await engine.initVectorstoreTable(\"my-table\", 768, vectorStoreTableArgs);\n * // Customize the vector store\n * const pvectorArgs: PostgresVectorStoreArgs = {\n *     idColumn: \"ID_COLUMN\",\n *     contentColumn: \"CONTENT_COLUMN\",\n *     embeddingColumn: \"EMBEDDING_COLUMN\",\n *     metadataColumns: [\"baz\"]\n * }\n *\n * const vectorStore = await PostgresVectorStore.initialize(engine, embeddingService, \"my-table\", pvectorArgs);\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Add documents</strong></summary>\n *\n * ```typescript\n * import type { Document } from '@langchain/core/documents';\n *\n * const document1 = { pageContent: \"foo\", metadata: { baz: \"bar\" } };\n * const document2 = { pageContent: \"thud\", metadata: { bar: \"baz\" } };\n * const document3 = { pageContent: \"i will be deleted :(\", metadata: {} };\n *\n * const documents: Document[] = [document1, document2, document3];\n * const ids = [\"1\", \"2\", \"3\"];\n * await vectorStore.addDocuments(documents, { ids });\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Delete documents</strong></summary>\n *\n * ```typescript\n * await vectorStore.delete({ ids: [\"3\"] });\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Similarity search</strong></summary>\n *\n * ```typescript\n * const results = await vectorStore.similaritySearch(\"thud\", 1);\n * for (const doc of results) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output:thud [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with filter</strong></summary>\n *\n * ```typescript\n * const resultsWithFilter = await vectorStore.similaritySearch(\"thud\", 1, \"baz = 'bar'\");\n *\n * for (const doc of resultsWithFilter) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output:foo [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with score</strong></summary>\n *\n * ```typescript\n * const resultsWithScore = await vectorStore.similaritySearchWithScore(\"qux\", 1);\n * for (const [doc, score] of resultsWithScore) {\n *   console.log(`* [SIM=${score.toFixed(6)}] ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output:[SIM=0.000000] qux [{\"bar\":\"baz\",\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>As a retriever</strong></summary>\n *\n * ```typescript\n * const retriever = vectorStore.asRetriever({\n *   searchType: \"mmr\", // Leave blank for standard similarity search\n *   k: 1,\n * });\n * const resultAsRetriever = await retriever.invoke(\"thud\");\n * console.log(resultAsRetriever);\n *\n * // Output: [Document({ metadata: { \"baz\":\"bar\" }, pageContent: \"thud\" })]\n * ```\n * </details>\n *\n * <br />\n */\nexport declare class PostgresVectorStore extends VectorStore {\n    FilterType: string;\n    engine: PostgresEngine;\n    embeddings: EmbeddingsInterface;\n    tableName: string;\n    schemaName: string;\n    contentColumn: string;\n    embeddingColumn: string;\n    metadataColumns: Array<string>;\n    idColumn: string;\n    metadataJsonColumn: string;\n    distanceStrategy: DistanceStrategy;\n    k: number;\n    fetchK: number;\n    lambdaMult: number;\n    indexQueryOptions: QueryOptions | undefined;\n    /**\n     * Initializes a new vector store with embeddings and database configuration.\n     *\n     * @param embeddings - Instance of `EmbeddingsInterface` used to embed queries.\n     * @param dbConfig - Configuration settings for the database or storage system.\n     */\n    constructor(embeddings: EmbeddingsInterface, dbConfig: VSArgs);\n    /**\n     * Create a new PostgresVectorStore instance.\n     * @param {PostgresEngine} engine Required - Connection pool engine for managing connections to Cloud SQL for PostgreSQL database.\n     * @param {Embeddings} embeddings Required - Text embedding model to use.\n     * @param {string} tableName Required - Name of an existing table or table to be created.\n     * @param {string} schemaName Database schema name of the table. Defaults to \"public\".\n     * @param {string} contentColumn Column that represent a Document's page_content. Defaults to \"content\".\n     * @param {string} embeddingColumn Column for embedding vectors. The embedding is generated from the document value. Defaults to \"embedding\".\n     * @param {Array<string>} metadataColumns Column(s) that represent a document's metadata.\n     * @param {Array<string>} ignoreMetadataColumns Optional - Column(s) to ignore in pre-existing tables for a document's metadata. Can not be used with metadata_columns.\n     * @param {string} idColumn Column that represents the Document's id. Defaults to \"langchain_id\".\n     * @param {string} metadataJsonColumn Optional - Column to store metadata as JSON. Defaults to \"langchain_metadata\".\n     * @param {DistanceStrategy} distanceStrategy Distance strategy to use for vector similarity search. Defaults to COSINE_DISTANCE.\n     * @param {number} k Number of Documents to return from search. Defaults to 4.\n     * @param {number} fetchK Number of Documents to fetch to pass to MMR algorithm.\n     * @param {number} lambdaMult Number between 0 and 1 that determines the degree of diversity among the results with 0 corresponding to maximum diversity and 1 to minimum diversity. Defaults to 0.5.\n     * @param {QueryOptions} indexQueryOptions Optional - Index query option.\n     * @returns PostgresVectorStore instance.\n     */\n    static initialize(engine: PostgresEngine, embeddings: EmbeddingsInterface, tableName: string, { schemaName, contentColumn, embeddingColumn, metadataColumns, ignoreMetadataColumns, idColumn, metadataJsonColumn, distanceStrategy, k, fetchK, lambdaMult, indexQueryOptions }?: PostgresVectorStoreArgs): Promise<PostgresVectorStore>;\n    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: EmbeddingsInterface, dbConfig: dbConfigArgs): Promise<VectorStore>;\n    static fromDocuments(docs: Document[], embeddings: EmbeddingsInterface, dbConfig: dbConfigArgs): Promise<VectorStore>;\n    addVectors(vectors: number[][], documents: Document[], options?: {\n        ids?: string[];\n    }): Promise<string[] | void>;\n    _vectorstoreType(): string;\n    /**\n     * Adds documents to the vector store, embedding them first through the\n     * `embeddings` instance.\n     *\n     * @param documents - Array of documents to embed and add.\n     * @param options - Optional configuration for embedding and storing documents.\n     * @returns A promise resolving to an array of document IDs or void, based on implementation.\n     * @abstract\n     */\n    addDocuments(documents: Document[], options?: {\n        ids?: string[];\n    }): Promise<string[] | void>;\n    /**\n     * Deletes documents from the vector store based on the specified ids.\n     *\n     * @param params - Flexible key-value pairs defining conditions for document deletion.\n     * @param ids -  Optional: Property of {params} that contains the array of ids to be deleted\n     * @returns A promise that resolves once the deletion is complete.\n     */\n    delete(params: {\n        ids?: string[];\n    }): Promise<void>;\n    similaritySearchVectorWithScore(embedding: number[], k: number, filter?: this[\"FilterType\"]): Promise<[Document, number][]>;\n    private queryCollection;\n    maxMarginalRelevanceSearch(query: string, options: MaxMarginalRelevanceSearchOptions<this[\"FilterType\"]>): Promise<Document[]>;\n    /**\n     * Create an index on the vector store table\n     * @param {BaseIndex} index\n     * @param {string} name Optional\n     * @param {boolean} concurrently Optional\n     */\n    applyVectorIndex(index: BaseIndex, name?: string, concurrently?: boolean): Promise<void>;\n    /**\n     * Check if index exists in the table.\n     * @param {string} indexName Optional - index name\n     */\n    isValidIndex(indexName?: string): Promise<boolean>;\n    /**\n     * Drop the vector index\n     * @param {string} indexName Optional - index name\n     */\n    dropVectorIndex(indexName?: string): Promise<void>;\n    /**\n     * Re-index the vector store table\n     * @param {string} indexName Optional - index name\n     */\n    reIndex(indexName?: string): Promise<void>;\n}\nexport default PostgresVectorStore;\n//# sourceMappingURL=vectorstore.d.ts.map"],"mappings":";;;;;;;UAKiBQ,uBAAAA;;EAAAA,aAAAA,CAAAA,EAAAA,MAAAA;EAIKC,eAAAA,CAAAA,EAAAA,MAAAA;EAECJ,eAAAA,CAAAA,EAFDI,KAECJ,CAAAA,MAAAA,CAAAA;EAIKI,QAAAA,CAAAA,EAAAA,MAAAA;EAEJH,gBAAAA,CAAAA,EANDD,gBAMCC;EAAY,CAAA,CAAA,EAAA,MAAA;EAEnBI,MAAAA,CAAAA,EAAAA,MAAY;EAKnBC,UAAM,CAAA,EAAA,MAAA;EACJJ,qBAAAA,CAAAA,EAVgBE,KAUhBF,CAAAA,MAAAA,CAAAA;EAKSE,kBAAAA,CAAAA,EAAAA,MAAAA;EAECJ,iBAAAA,CAAAA,EAfEC,YAeFD;;AAKc,UAlBnBK,YAAAA,CAkBmB;EAoJfE,MAAAA,EArKTL,cAqK4B;EAE5BA,SAAAA,EAAAA,MAAAA;EACIP,QAAAA,CAAAA,EAtKDQ,uBAsKCR;;UApKNW,MAAAA,CA4KYN;EAICC,MAAAA,EA/KXC,cA+KWD;EAOKN,SAAAA,EAAAA,MAAAA;EAA+BW,UAAAA,EAAAA,MAAAA;EAoB7BJ,aAAAA,EAAAA,MAAAA;EAA4BP,eAAAA,EAAAA,MAAAA;EAA0Ca,eAAAA,EArM/EJ,KAqM+EI,CAAAA,MAAAA,CAAAA;EAAYC,QAAAA,EAAAA,MAAAA;EAAeC,gBAAAA,EAnMzGV,gBAmMyGU;EAAiBC,CAAAA,EAAAA,MAAAA;EAAiBC,MAAAA,EAAAA,MAAAA;EAAuBC,UAAAA,EAAAA,MAAAA;EAAUC,kBAAAA,EAAAA,MAAAA;EAAoBC,iBAAAA,CAAAA,EA9L9Ld,YA8L8Lc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA1C1J;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAvCR,mBAAAA,SAA4BV,WAAAA;;UAErCK;cACIP;;;;;mBAKKS;;;oBAGCJ;;;;qBAICC;;;;;;;0BAOKN,+BAA+BW;;;;;;;;;;;;;;;;;;;;4BAoB7BJ,4BAA4BP;;;;;;;;;;;;;MAA2NQ,0BAA0BiB,QAAQb;8EACvOZ,+BAA+BU,eAAee,QAAQvB;6BACvGC,wBAAwBH,+BAA+BU,eAAee,QAAQvB;6CAC9DC;;MAEvCsB;;;;;;;;;;;0BAWoBtB;;MAEpBsB;;;;;;;;;;MAUAA;gGAC0FA,SAAStB;;qDAEpDF,wDAAwDwB,QAAQtB;;;;;;;0BAO3FC,mDAAmDqB;;;;;oCAKzCA;;;;;uCAKGA;;;;;+BAKRA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-cloud-sql-pg",
-  "version": "1.0.5",
+  "version": "1.0.6-dev-1765432861398",
   "description": "LangChain.js integrations for Google Cloud SQL for PostgreSQL",
   "author": "Google LLC",
   "license": "MIT",
@@ -18,7 +18,7 @@
     "google-auth-library": "^9.15.0",
     "knex": "^3.1.0",
     "uuid": "^11.0.5",
-    "@langchain/core": "1.1.4"
+    "@langchain/core": "1.1.5-dev-1765432861398"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
@@ -38,8 +38,9 @@
     "testcontainers": "^10.23.0",
     "ts-jest": "^29.1.0",
     "typescript": "~5.8.3",
-    "@langchain/core": "1.1.4",
-    "@langchain/eslint": "0.1.1"
+    "@langchain/core": "1.1.5-dev-1765432861398",
+    "@langchain/eslint": "0.1.1",
+    "@langchain/tsconfig": "0.0.1"
   },
   "publishConfig": {
     "access": "public"
@@ -79,7 +80,7 @@
     "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
     "test:single": "NODE_OPTIONS=--experimental-vm-modules pnpm run jest --config jest.config.cjs --testTimeout 100000",
     "test:int": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.int\\.test.ts --testTimeout 100000 --maxWorkers=50%",
-    "format": "prettier --config .prettierrc --write \"src\"",
-    "format:check": "prettier --config .prettierrc --check \"src\""
+    "format": "prettier --write \"src\"",
+    "format:check": "prettier --check \"src\""
   }
 }