langchain 0.0.147 → 0.0.149

package/dist/schema/runnable/passthrough.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnablePassthrough = void 0;
+const base_js_1 = require("./base.cjs");
+/**
+ * A runnable that passes through the input.
+ */
+class RunnablePassthrough extends base_js_1.Runnable {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "schema", "runnable"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+    }
+    static lc_name() {
+        return "RunnablePassthrough";
+    }
+    async invoke(input, options) {
+        return this._callWithConfig((input) => Promise.resolve(input), input, options);
+    }
+}
+exports.RunnablePassthrough = RunnablePassthrough;

package/dist/schema/runnable/passthrough.d.ts

@@ -0,0 +1,11 @@
+import { Runnable } from "./base.js";
+import type { RunnableConfig } from "./config.js";
+/**
+ * A runnable that passes through the input.
+ */
+export declare class RunnablePassthrough<RunInput> extends Runnable<RunInput, RunInput> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;
+}

package/dist/schema/runnable/passthrough.js

@@ -0,0 +1,27 @@
+import { Runnable } from "./base.js";
+/**
+ * A runnable that passes through the input.
+ */
+export class RunnablePassthrough extends Runnable {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "schema", "runnable"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+    }
+    static lc_name() {
+        return "RunnablePassthrough";
+    }
+    async invoke(input, options) {
+        return this._callWithConfig((input) => Promise.resolve(input), input, options);
+    }
+}

package/dist/schema/runnable/router.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterRunnable = void 0;
+const base_js_1 = require("./base.cjs");
+/**
+ * A runnable that routes to a set of runnables based on Input['key'].
+ * Returns the output of the selected runnable.
+ */
+class RouterRunnable extends base_js_1.Runnable {
+    static lc_name() {
+        return "RouterRunnable";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "schema", "runnable"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "runnables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.runnables = fields.runnables;
+    }
+    async invoke(input, options) {
+        const { key, input: actualInput } = input;
+        const runnable = this.runnables[key];
+        if (runnable === undefined) {
+            throw new Error(`No runnable associated with key "${key}".`);
+        }
+        return runnable.invoke(actualInput, options);
+    }
+    async batch(inputs, options, batchOptions) {
+        const keys = inputs.map((input) => input.key);
+        const actualInputs = inputs.map((input) => input.input);
+        const missingKey = keys.find((key) => this.runnables[key] === undefined);
+        if (missingKey !== undefined) {
+            throw new Error(`One or more keys do not have a corresponding runnable.`);
+        }
+        const runnables = keys.map((key) => this.runnables[key]);
+        const optionsList = this._getOptionsList(options ?? {}, inputs.length);
+        const batchSize = batchOptions?.maxConcurrency && batchOptions.maxConcurrency > 0
+            ? batchOptions?.maxConcurrency
+            : inputs.length;
+        const batchResults = [];
+        for (let i = 0; i < actualInputs.length; i += batchSize) {
+            const batchPromises = actualInputs
+                .slice(i, i + batchSize)
+                .map((actualInput, i) => runnables[i].invoke(actualInput, optionsList[i]));
+            const batchResult = await Promise.all(batchPromises);
+            batchResults.push(batchResult);
+        }
+        return batchResults.flat();
+    }
+    async stream(input, options) {
+        const { key, input: actualInput } = input;
+        const runnable = this.runnables[key];
+        if (runnable === undefined) {
+            throw new Error(`No runnable associated with key "${key}".`);
+        }
+        return runnable.stream(actualInput, options);
+    }
+}
+exports.RouterRunnable = RouterRunnable;

package/dist/schema/runnable/router.d.ts

@@ -0,0 +1,29 @@
+import { Runnable, type RunnableBatchOptions } from "./base.js";
+import { IterableReadableStream } from "../../util/stream.js";
+import type { RunnableConfig } from "./config.js";
+export type RouterInput = {
+    key: string;
+    input: any;
+};
+/**
+ * A runnable that routes to a set of runnables based on Input['key'].
+ * Returns the output of the selected runnable.
+ */
+export declare class RouterRunnable<RunInput extends RouterInput, RunnableInput, RunOutput> extends Runnable<RunInput, RunOutput> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;
+    constructor(fields: {
+        runnables: Record<string, Runnable<RunnableInput, RunOutput>>;
+    });
+    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;
+    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    stream(input: RunInput, options?: Partial<RunnableConfig>): Promise<IterableReadableStream<RunOutput>>;
+}

package/dist/schema/runnable/router.js

@@ -0,0 +1,70 @@
+import { Runnable } from "./base.js";
+/**
+ * A runnable that routes to a set of runnables based on Input['key'].
+ * Returns the output of the selected runnable.
+ */
+export class RouterRunnable extends Runnable {
+    static lc_name() {
+        return "RouterRunnable";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "schema", "runnable"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "runnables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.runnables = fields.runnables;
+    }
+    async invoke(input, options) {
+        const { key, input: actualInput } = input;
+        const runnable = this.runnables[key];
+        if (runnable === undefined) {
+            throw new Error(`No runnable associated with key "${key}".`);
+        }
+        return runnable.invoke(actualInput, options);
+    }
+    async batch(inputs, options, batchOptions) {
+        const keys = inputs.map((input) => input.key);
+        const actualInputs = inputs.map((input) => input.input);
+        const missingKey = keys.find((key) => this.runnables[key] === undefined);
+        if (missingKey !== undefined) {
+            throw new Error(`One or more keys do not have a corresponding runnable.`);
+        }
+        const runnables = keys.map((key) => this.runnables[key]);
+        const optionsList = this._getOptionsList(options ?? {}, inputs.length);
+        const batchSize = batchOptions?.maxConcurrency && batchOptions.maxConcurrency > 0
+            ? batchOptions?.maxConcurrency
+            : inputs.length;
+        const batchResults = [];
+        for (let i = 0; i < actualInputs.length; i += batchSize) {
+            const batchPromises = actualInputs
+                .slice(i, i + batchSize)
+                .map((actualInput, i) => runnables[i].invoke(actualInput, optionsList[i]));
+            const batchResult = await Promise.all(batchPromises);
+            batchResults.push(batchResult);
+        }
+        return batchResults.flat();
+    }
+    async stream(input, options) {
+        const { key, input: actualInput } = input;
+        const runnable = this.runnables[key];
+        if (runnable === undefined) {
+            throw new Error(`No runnable associated with key "${key}".`);
+        }
+        return runnable.stream(actualInput, options);
+    }
+}

package/dist/types/googlevertexai-types.d.ts

@@ -1,9 +1,8 @@
-import { GoogleAuthOptions } from "google-auth-library";
 import { BaseLLMParams } from "../llms/base.js";
-export interface GoogleVertexAIConnectionParams {
+export interface GoogleVertexAIConnectionParams<AuthOptions> {
     /** Hostname for the API call */
     endpoint?: string;
-    authOptions?: GoogleAuthOptions;
+    authOptions?: AuthOptions;
     /** Region where the LLM is stored */
     location?: string;
     /** The version of the API functions. Part of the path. */
@@ -39,7 +38,7 @@ export interface GoogleVertexAIModelParams {
      */
     topK?: number;
 }
-export interface GoogleVertexAIBaseLLMInput extends BaseLLMParams, GoogleVertexAIConnectionParams, GoogleVertexAIModelParams {
+export interface GoogleVertexAIBaseLLMInput<AuthOptions> extends BaseLLMParams, GoogleVertexAIConnectionParams<AuthOptions>, GoogleVertexAIModelParams {
 }
 export interface GoogleVertexAIResponse {
     data: any;
@@ -52,3 +51,11 @@ export interface GoogleVertexAILLMResponse<PredictionType extends GoogleVertexAI
         predictions: PredictionType[];
     };
 }
+export interface GoogleVertexAIAbstractedClient {
+    request: (opts: {
+        url?: string;
+        method?: "GET" | "POST";
+        data?: unknown;
+    }) => unknown;
+    getProjectId: () => Promise<string>;
+}

package/dist/util/googlevertexai-connection.cjs

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoogleVertexAILLMConnection = exports.GoogleVertexAIConnection = void 0;
-const google_auth_library_1 = require("google-auth-library");
 class GoogleVertexAIConnection {
-    constructor(fields, caller) {
+    constructor(fields, caller, client) {
         Object.defineProperty(this, "caller", {
             enumerable: true,
             configurable: true,
@@ -28,7 +27,7 @@ class GoogleVertexAIConnection {
             writable: true,
             value: "v1"
         });
-        Object.defineProperty(this, "auth", {
+        Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -38,16 +37,12 @@ class GoogleVertexAIConnection {
         this.endpoint = fields?.endpoint ?? this.endpoint;
         this.location = fields?.location ?? this.location;
         this.apiVersion = fields?.apiVersion ?? this.apiVersion;
-        this.auth = new google_auth_library_1.GoogleAuth({
-            scopes: "https://www.googleapis.com/auth/cloud-platform",
-            ...fields?.authOptions,
-        });
+        this.client = client;
     }
     buildMethod() {
         return "POST";
     }
     async _request(data, options) {
-        const client = await this.auth.getClient();
         const url = await this.buildUrl();
         const method = this.buildMethod();
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -58,11 +53,8 @@ class GoogleVertexAIConnection {
         if (data && method === "POST") {
             opts.data = data;
         }
-        async function _request() {
-            return client.request(opts);
-        }
         try {
-            const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, _request.bind(client));
+            const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, async () => this.client.request(opts));
             const response = callResponse; // Done for typecast safety, I guess
             return response;
         }
@@ -74,18 +66,25 @@ class GoogleVertexAIConnection {
 }
 exports.GoogleVertexAIConnection = GoogleVertexAIConnection;
 class GoogleVertexAILLMConnection extends GoogleVertexAIConnection {
-    constructor(fields, caller) {
-        super(fields, caller);
+    constructor(fields, caller, client) {
+        super(fields, caller, client);
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.client = client;
         this.model = fields?.model ?? this.model;
     }
     async buildUrl() {
-        const projectId = await this.auth.getProjectId();
+        const projectId = await this.client.getProjectId();
         const url = `https://${this.endpoint}/v1/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:predict`;
         return url;
     }

package/dist/util/googlevertexai-connection.d.ts

@@ -1,21 +1,21 @@
-import { GoogleAuth } from "google-auth-library";
 import { BaseLanguageModelCallOptions } from "../base_language/index.js";
 import { AsyncCaller, AsyncCallerCallOptions } from "./async_caller.js";
-import { GoogleVertexAIBaseLLMInput, GoogleVertexAIBasePrediction, GoogleVertexAIConnectionParams, GoogleVertexAILLMResponse, GoogleVertexAIModelParams, GoogleVertexAIResponse } from "../types/googlevertexai-types.js";
-export declare abstract class GoogleVertexAIConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleVertexAIResponse> implements GoogleVertexAIConnectionParams {
+import type { GoogleVertexAIBaseLLMInput, GoogleVertexAIBasePrediction, GoogleVertexAIConnectionParams, GoogleVertexAILLMResponse, GoogleVertexAIModelParams, GoogleVertexAIResponse, GoogleVertexAIAbstractedClient } from "../types/googlevertexai-types.js";
+export declare abstract class GoogleVertexAIConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleVertexAIResponse, AuthOptions> implements GoogleVertexAIConnectionParams<AuthOptions> {
     caller: AsyncCaller;
     endpoint: string;
     location: string;
     apiVersion: string;
-    auth: GoogleAuth;
-    constructor(fields: GoogleVertexAIConnectionParams | undefined, caller: AsyncCaller);
+    client: GoogleVertexAIAbstractedClient;
+    constructor(fields: GoogleVertexAIConnectionParams<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleVertexAIAbstractedClient);
     abstract buildUrl(): Promise<string>;
     buildMethod(): string;
     _request(data: unknown | undefined, options: CallOptions): Promise<ResponseType>;
 }
-export declare class GoogleVertexAILLMConnection<CallOptions extends BaseLanguageModelCallOptions, InstanceType, PredictionType extends GoogleVertexAIBasePrediction> extends GoogleVertexAIConnection<CallOptions, PredictionType> implements GoogleVertexAIBaseLLMInput {
+export declare class GoogleVertexAILLMConnection<CallOptions extends BaseLanguageModelCallOptions, InstanceType, PredictionType extends GoogleVertexAIBasePrediction, AuthOptions> extends GoogleVertexAIConnection<CallOptions, PredictionType, AuthOptions> implements GoogleVertexAIBaseLLMInput<AuthOptions> {
     model: string;
-    constructor(fields: GoogleVertexAIBaseLLMInput | undefined, caller: AsyncCaller);
+    client: GoogleVertexAIAbstractedClient;
+    constructor(fields: GoogleVertexAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleVertexAIAbstractedClient);
     buildUrl(): Promise<string>;
     request(instances: InstanceType[], parameters: GoogleVertexAIModelParams, options: CallOptions): Promise<GoogleVertexAILLMResponse<PredictionType>>;
 }

package/dist/util/googlevertexai-connection.js

@@ -1,6 +1,5 @@
-import { GoogleAuth } from "google-auth-library";
 export class GoogleVertexAIConnection {
-    constructor(fields, caller) {
+    constructor(fields, caller, client) {
         Object.defineProperty(this, "caller", {
             enumerable: true,
             configurable: true,
@@ -25,7 +24,7 @@ export class GoogleVertexAIConnection {
             writable: true,
             value: "v1"
         });
-        Object.defineProperty(this, "auth", {
+        Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -35,16 +34,12 @@ export class GoogleVertexAIConnection {
         this.endpoint = fields?.endpoint ?? this.endpoint;
         this.location = fields?.location ?? this.location;
         this.apiVersion = fields?.apiVersion ?? this.apiVersion;
-        this.auth = new GoogleAuth({
-            scopes: "https://www.googleapis.com/auth/cloud-platform",
-            ...fields?.authOptions,
-        });
+        this.client = client;
     }
     buildMethod() {
         return "POST";
     }
     async _request(data, options) {
-        const client = await this.auth.getClient();
         const url = await this.buildUrl();
         const method = this.buildMethod();
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -55,11 +50,8 @@ export class GoogleVertexAIConnection {
         if (data && method === "POST") {
             opts.data = data;
         }
-        async function _request() {
-            return client.request(opts);
-        }
         try {
-            const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, _request.bind(client));
+            const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, async () => this.client.request(opts));
             const response = callResponse; // Done for typecast safety, I guess
             return response;
         }
@@ -70,18 +62,25 @@ export class GoogleVertexAIConnection {
     }
 }
 export class GoogleVertexAILLMConnection extends GoogleVertexAIConnection {
-    constructor(fields, caller) {
-        super(fields, caller);
+    constructor(fields, caller, client) {
+        super(fields, caller, client);
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.client = client;
         this.model = fields?.model ?? this.model;
     }
     async buildUrl() {
-        const projectId = await this.auth.getProjectId();
+        const projectId = await this.client.getProjectId();
         const url = `https://${this.endpoint}/v1/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:predict`;
         return url;
     }

package/dist/util/googlevertexai-webauth.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebGoogleAuth = void 0;
+const google_1 = require("web-auth-library/google");
+const env_js_1 = require("./env.cjs");
+class WebGoogleAuth {
+    constructor(options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const credentials = options?.credentials ??
+            (0, env_js_1.getEnvironmentVariable)("GOOGLE_VERTEX_AI_WEB_CREDENTIALS");
+        if (credentials === undefined)
+            throw new Error(`Credentials not found. Please set the GOOGLE_VERTEX_AI_WEB_CREDENTIALS or pass credentials into "authOptions.credentials".`);
+        const scope = options?.scope ?? "https://www.googleapis.com/auth/cloud-platform";
+        this.options = { ...options, credentials, scope };
+    }
+    async getProjectId() {
+        const credentials = (0, google_1.getCredentials)(this.options.credentials);
+        return credentials.project_id;
+    }
+    async request(opts) {
+        const accessToken = await (0, google_1.getAccessToken)(this.options);
+        if (opts.url == null)
+            throw new Error("Missing URL");
+        const fetchOptions = {
+            method: opts.method,
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+            },
+        };
+        if (opts.data !== undefined) {
+            fetchOptions.body = JSON.stringify(opts.data);
+        }
+        const res = await fetch(opts.url, fetchOptions);
+        if (!res.ok) {
+            const error = new Error(`Could not get access token for Vertex AI with status code: ${res.status}`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error.response = res;
+            throw error;
+        }
+        return {
+            data: await res.json(),
+            config: {},
+            status: res.status,
+            statusText: res.statusText,
+            headers: res.headers,
+            request: { responseURL: res.url },
+        };
+    }
+}
+exports.WebGoogleAuth = WebGoogleAuth;

package/dist/util/googlevertexai-webauth.d.ts

@@ -0,0 +1,25 @@
+import { Credentials } from "web-auth-library/google";
+import type { GoogleVertexAIAbstractedClient } from "../types/googlevertexai-types.js";
+export type WebGoogleAuthOptions = {
+    credentials: string | Credentials;
+    scope?: string | string[];
+};
+export declare class WebGoogleAuth implements GoogleVertexAIAbstractedClient {
+    options: WebGoogleAuthOptions;
+    constructor(options?: WebGoogleAuthOptions);
+    getProjectId(): Promise<string>;
+    request(opts: {
+        url?: string;
+        method?: string;
+        data?: unknown;
+    }): Promise<{
+        data: any;
+        config: {};
+        status: number;
+        statusText: string;
+        headers: Headers;
+        request: {
+            responseURL: string;
+        };
+    }>;
+}

package/dist/util/googlevertexai-webauth.js

@@ -0,0 +1,52 @@
+import { getAccessToken, getCredentials, } from "web-auth-library/google";
+import { getEnvironmentVariable } from "./env.js";
+export class WebGoogleAuth {
+    constructor(options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const credentials = options?.credentials ??
+            getEnvironmentVariable("GOOGLE_VERTEX_AI_WEB_CREDENTIALS");
+        if (credentials === undefined)
+            throw new Error(`Credentials not found. Please set the GOOGLE_VERTEX_AI_WEB_CREDENTIALS or pass credentials into "authOptions.credentials".`);
+        const scope = options?.scope ?? "https://www.googleapis.com/auth/cloud-platform";
+        this.options = { ...options, credentials, scope };
+    }
+    async getProjectId() {
+        const credentials = getCredentials(this.options.credentials);
+        return credentials.project_id;
+    }
+    async request(opts) {
+        const accessToken = await getAccessToken(this.options);
+        if (opts.url == null)
+            throw new Error("Missing URL");
+        const fetchOptions = {
+            method: opts.method,
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+            },
+        };
+        if (opts.data !== undefined) {
+            fetchOptions.body = JSON.stringify(opts.data);
+        }
+        const res = await fetch(opts.url, fetchOptions);
+        if (!res.ok) {
+            const error = new Error(`Could not get access token for Vertex AI with status code: ${res.status}`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error.response = res;
+            throw error;
+        }
+        return {
+            data: await res.json(),
+            config: {},
+            status: res.status,
+            statusText: res.statusText,
+            headers: res.headers,
+            request: { responseURL: res.url },
+        };
+    }
+}