langchain 0.0.175 → 0.0.177

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

@@ -1,25 +1,94 @@
 import { BaseLanguageModelCallOptions } from "../base_language/index.js";
 import { AsyncCaller, AsyncCallerCallOptions } from "./async_caller.js";
-import type { GoogleVertexAIBaseLLMInput, GoogleVertexAIBasePrediction, GoogleVertexAIConnectionParams, GoogleVertexAILLMResponse, GoogleVertexAIModelParams, GoogleResponse, GoogleAbstractedClient } from "../types/googlevertexai-types.js";
+import type { GoogleVertexAIBaseLLMInput, GoogleVertexAIBasePrediction, GoogleVertexAIConnectionParams, GoogleVertexAILLMPredictions, GoogleVertexAIModelParams, GoogleResponse, GoogleAbstractedClient, GoogleAbstractedClientOpsMethod } from "../types/googlevertexai-types.js";
 export declare abstract class GoogleConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleResponse> {
     caller: AsyncCaller;
     client: GoogleAbstractedClient;
-    constructor(caller: AsyncCaller, client: GoogleAbstractedClient);
+    streaming: boolean;
+    constructor(caller: AsyncCaller, client: GoogleAbstractedClient, streaming?: boolean);
     abstract buildUrl(): Promise<string>;
-    abstract buildMethod(): string;
+    abstract buildMethod(): GoogleAbstractedClientOpsMethod;
     _request(data: unknown | undefined, options: CallOptions): Promise<ResponseType>;
 }
 export declare abstract class GoogleVertexAIConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleResponse, AuthOptions> extends GoogleConnection<CallOptions, ResponseType> implements GoogleVertexAIConnectionParams<AuthOptions> {
     endpoint: string;
     location: string;
     apiVersion: string;
-    constructor(fields: GoogleVertexAIConnectionParams<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient);
-    buildMethod(): string;
+    constructor(fields: GoogleVertexAIConnectionParams<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming?: boolean);
+    buildMethod(): GoogleAbstractedClientOpsMethod;
 }
-export declare class GoogleVertexAILLMConnection<CallOptions extends BaseLanguageModelCallOptions, InstanceType, PredictionType extends GoogleVertexAIBasePrediction, AuthOptions> extends GoogleVertexAIConnection<CallOptions, PredictionType, AuthOptions> implements GoogleVertexAIBaseLLMInput<AuthOptions> {
+export declare function complexValue(value: unknown): unknown;
+export declare function simpleValue(val: unknown): unknown;
+export declare class GoogleVertexAILLMConnection<CallOptions extends BaseLanguageModelCallOptions, InstanceType, PredictionType extends GoogleVertexAIBasePrediction, AuthOptions> extends GoogleVertexAIConnection<CallOptions, GoogleVertexAILLMResponse<PredictionType>, AuthOptions> implements GoogleVertexAIBaseLLMInput<AuthOptions> {
     model: string;
     client: GoogleAbstractedClient;
-    constructor(fields: GoogleVertexAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient);
+    constructor(fields: GoogleVertexAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming?: boolean);
     buildUrl(): Promise<string>;
+    formatStreamingData(inputs: InstanceType[], parameters: GoogleVertexAIModelParams): unknown;
+    formatStandardData(instances: InstanceType[], parameters: GoogleVertexAIModelParams): unknown;
+    formatData(instances: InstanceType[], parameters: GoogleVertexAIModelParams): unknown;
     request(instances: InstanceType[], parameters: GoogleVertexAIModelParams, options: CallOptions): Promise<GoogleVertexAILLMResponse<PredictionType>>;
 }
+export interface GoogleVertexAILLMResponse<PredictionType extends GoogleVertexAIBasePrediction> extends GoogleResponse {
+    data: GoogleVertexAIStream | GoogleVertexAILLMPredictions<PredictionType>;
+}
+export declare class GoogleVertexAIStream {
+    _buffer: string;
+    _bufferOpen: boolean;
+    _firstRun: boolean;
+    /**
+     * Add data to the buffer. This may cause chunks to be generated, if available.
+     * @param data
+     */
+    appendBuffer(data: string): void;
+    /**
+     * Indicate there is no more data that will be added to the text buffer.
+     * This should be called when all the data has been read and added to indicate
+     * that we should process everything remaining in the buffer.
+     */
+    closeBuffer(): void;
+    /**
+     * Skip characters in the buffer till we get to the start of an object.
+     * Then attempt to read a full object.
+     * If we do read a full object, turn it into a chunk and send it to the chunk handler.
+     * Repeat this for as much as we can.
+     */
+    _parseBuffer(): void;
+    /**
+     * If the string is present, move the start of the buffer to the first occurrence
+     * of that string. This is useful for skipping over elements or parts that we're not
+     * really interested in parsing. (ie - the opening characters, comma separators, etc.)
+     * @param start The string to start the buffer with
+     */
+    _skipTo(start: string): void;
+    /**
+     * Given what is in the buffer, parse a single object out of it.
+     * If a complete object isn't available, return null.
+     * Assumes that we are at the start of an object to parse.
+     */
+    _getFullObject(): object | null;
+    _simplifyObject(obj: unknown): object;
+    _chunkResolution: (chunk: any) => void;
+    _chunkPending: Promise<any> | null;
+    _chunkQueue: any[];
+    /**
+     * Register that we have another chunk available for consumption.
+     * If we are waiting for a chunk, resolve the promise waiting for it immediately.
+     * If not, then add it to the queue.
+     * @param chunk
+     */
+    _handleChunk(chunk: any): void;
+    /**
+     * Get the next chunk that is coming from the stream.
+     * This chunk may be null, usually indicating the last chunk in the stream.
+     */
+    nextChunk(): Promise<any>;
+    /**
+     * Is the stream done?
+     * A stream is only done if all of the following are true:
+     * - There is no more data to be added to the text buffer
+     * - There is no more data in the text buffer
+     * - There are no chunks that are waiting to be consumed
+     */
+    get streamDone(): boolean;
+}

package/dist/util/googlevertexai-connection.js

@@ -1,5 +1,5 @@
 export class GoogleConnection {
-    constructor(caller, client) {
+    constructor(caller, client, streaming) {
         Object.defineProperty(this, "caller", {
             enumerable: true,
             configurable: true,
@@ -12,13 +12,19 @@ export class GoogleConnection {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "streaming", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.caller = caller;
         this.client = client;
+        this.streaming = streaming ?? false;
     }
     async _request(data, options) {
         const url = await this.buildUrl();
         const method = this.buildMethod();
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const opts = {
             url,
             method,
@@ -26,6 +32,12 @@ export class GoogleConnection {
         if (data && method === "POST") {
             opts.data = data;
         }
+        if (this.streaming) {
+            opts.responseType = "stream";
+        }
+        else {
+            opts.responseType = "json";
+        }
         try {
             const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, async () => this.client.request(opts));
             const response = callResponse; // Done for typecast safety, I guess
@@ -38,8 +50,8 @@ export class GoogleConnection {
     }
 }
 export class GoogleVertexAIConnection extends GoogleConnection {
-    constructor(fields, caller, client) {
-        super(caller, client);
+    constructor(fields, caller, client, streaming) {
+        super(caller, client, streaming);
         Object.defineProperty(this, "endpoint", {
             enumerable: true,
             configurable: true,
@@ -68,9 +80,84 @@ export class GoogleVertexAIConnection extends GoogleConnection {
         return "POST";
     }
 }
+export function complexValue(value) {
+    if (value === null || typeof value === "undefined") {
+        // I dunno what to put here. An error, probably
+        return undefined;
+    }
+    else if (typeof value === "object") {
+        if (Array.isArray(value)) {
+            return {
+                list_val: value.map((avalue) => complexValue(avalue)),
+            };
+        }
+        else {
+            const ret = {};
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const v = value;
+            Object.keys(v).forEach((key) => {
+                ret[key] = complexValue(v[key]);
+            });
+            return { struct_val: ret };
+        }
+    }
+    else if (typeof value === "number") {
+        if (Number.isInteger(value)) {
+            return { int_val: value };
+        }
+        else {
+            return { float_val: value };
+        }
+    }
+    else {
+        return {
+            string_val: [value],
+        };
+    }
+}
+export function simpleValue(val) {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+        // eslint-disable-next-line no-prototype-builtins
+        if (val.hasOwnProperty("stringVal")) {
+            return val.stringVal[0];
+            // eslint-disable-next-line no-prototype-builtins
+        }
+        else if (val.hasOwnProperty("boolVal")) {
+            return val.boolVal[0];
+            // eslint-disable-next-line no-prototype-builtins
+        }
+        else if (val.hasOwnProperty("listVal")) {
+            const { listVal } = val;
+            return listVal.map((aval) => simpleValue(aval));
+            // eslint-disable-next-line no-prototype-builtins
+        }
+        else if (val.hasOwnProperty("structVal")) {
+            const ret = {};
+            const struct = val.structVal;
+            Object.keys(struct).forEach((key) => {
+                ret[key] = simpleValue(struct[key]);
+            });
+            return ret;
+        }
+        else {
+            const ret = {};
+            const struct = val;
+            Object.keys(struct).forEach((key) => {
+                ret[key] = simpleValue(struct[key]);
+            });
+            return ret;
+        }
+    }
+    else if (Array.isArray(val)) {
+        return val.map((aval) => simpleValue(aval));
+    }
+    else {
+        return val;
+    }
+}
 export class GoogleVertexAILLMConnection extends GoogleVertexAIConnection {
-    constructor(fields, caller, client) {
-        super(fields, caller, client);
+    constructor(fields, caller, client, streaming) {
+        super(fields, caller, client, streaming);
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
@@ -88,15 +175,213 @@ export class GoogleVertexAILLMConnection extends GoogleVertexAIConnection {
     }
     async buildUrl() {
         const projectId = await this.client.getProjectId();
-        const url = `https://${this.endpoint}/v1/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:predict`;
+        const method = this.streaming ? "serverStreamingPredict" : "predict";
+        const url = `https://${this.endpoint}/v1/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:${method}`;
         return url;
     }
-    async request(instances, parameters, options) {
-        const data = {
+    formatStreamingData(inputs, parameters) {
+        return {
+            inputs: [inputs.map((i) => complexValue(i))],
+            parameters: complexValue(parameters),
+        };
+    }
+    formatStandardData(instances, parameters) {
+        return {
             instances,
             parameters,
         };
+    }
+    formatData(instances, parameters) {
+        return this.streaming
+            ? this.formatStreamingData(instances, parameters)
+            : this.formatStandardData(instances, parameters);
+    }
+    async request(instances, parameters, options) {
+        const data = this.formatData(instances, parameters);
         const response = await this._request(data, options);
         return response;
     }
 }
+export class GoogleVertexAIStream {
+    constructor() {
+        Object.defineProperty(this, "_buffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        Object.defineProperty(this, "_bufferOpen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "_firstRun", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        // Set up a potential Promise that the handler can resolve.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "_chunkResolution", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // If there is no Promise (it is null), the handler must add it to the queue
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "_chunkPending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // A queue that will collect chunks while there is no Promise
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "_chunkQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    /**
+     * Add data to the buffer. This may cause chunks to be generated, if available.
+     * @param data
+     */
+    appendBuffer(data) {
+        this._buffer += data;
+        // Our first time, skip to the opening of the array
+        if (this._firstRun) {
+            this._skipTo("[");
+            this._firstRun = false;
+        }
+        this._parseBuffer();
+    }
+    /**
+     * Indicate there is no more data that will be added to the text buffer.
+     * This should be called when all the data has been read and added to indicate
+     * that we should process everything remaining in the buffer.
+     */
+    closeBuffer() {
+        this._bufferOpen = false;
+        this._parseBuffer();
+    }
+    /**
+     * Skip characters in the buffer till we get to the start of an object.
+     * Then attempt to read a full object.
+     * If we do read a full object, turn it into a chunk and send it to the chunk handler.
+     * Repeat this for as much as we can.
+     */
+    _parseBuffer() {
+        let obj = null;
+        do {
+            this._skipTo("{");
+            obj = this._getFullObject();
+            if (obj !== null) {
+                const chunk = this._simplifyObject(obj);
+                this._handleChunk(chunk);
+            }
+        } while (obj !== null);
+        if (!this._bufferOpen) {
+            // No more data will be added, and we have parsed everything we could,
+            // so everything else is garbage.
+            this._handleChunk(null);
+            this._buffer = "";
+        }
+    }
+    /**
+     * If the string is present, move the start of the buffer to the first occurrence
+     * of that string. This is useful for skipping over elements or parts that we're not
+     * really interested in parsing. (ie - the opening characters, comma separators, etc.)
+     * @param start The string to start the buffer with
+     */
+    _skipTo(start) {
+        const index = this._buffer.indexOf(start);
+        if (index > 0) {
+            this._buffer = this._buffer.slice(index);
+        }
+    }
+    /**
+     * Given what is in the buffer, parse a single object out of it.
+     * If a complete object isn't available, return null.
+     * Assumes that we are at the start of an object to parse.
+     */
+    _getFullObject() {
+        let ret = null;
+        // Loop while we don't have something to return AND we have something in the buffer
+        let index = 0;
+        while (ret === null && this._buffer.length > index) {
+            // Advance to the next close bracket after our current index
+            index = this._buffer.indexOf("}", index + 1);
+            // If we don't find one, exit with null
+            if (index === -1) {
+                return null;
+            }
+            // If we have one, try to turn it into an object to return
+            try {
+                const objStr = this._buffer.substring(0, index + 1);
+                ret = JSON.parse(objStr);
+                // We only get here if it parsed it ok
+                // If we did turn it into an object, remove it from the buffer
+                this._buffer = this._buffer.slice(index + 1);
+            }
+            catch (xx) {
+                // It didn't parse it correctly, so we swallow the exception and continue
+            }
+        }
+        return ret;
+    }
+    _simplifyObject(obj) {
+        return simpleValue(obj);
+    }
+    /**
+     * Register that we have another chunk available for consumption.
+     * If we are waiting for a chunk, resolve the promise waiting for it immediately.
+     * If not, then add it to the queue.
+     * @param chunk
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _handleChunk(chunk) {
+        if (this._chunkPending) {
+            this._chunkResolution(chunk);
+            this._chunkPending = null;
+        }
+        else {
+            this._chunkQueue.push(chunk);
+        }
+    }
+    /**
+     * Get the next chunk that is coming from the stream.
+     * This chunk may be null, usually indicating the last chunk in the stream.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async nextChunk() {
+        if (this._chunkQueue.length > 0) {
+            // If there is data in the queue, return the next queue chunk
+            return this._chunkQueue.shift();
+        }
+        else {
+            // Otherwise, set up a promise that handleChunk will cause to be resolved
+            this._chunkPending = new Promise((resolve) => {
+                this._chunkResolution = resolve;
+            });
+            return this._chunkPending;
+        }
+    }
+    /**
+     * Is the stream done?
+     * A stream is only done if all of the following are true:
+     * - There is no more data to be added to the text buffer
+     * - There is no more data in the text buffer
+     * - There are no chunks that are waiting to be consumed
+     */
+    get streamDone() {
+        return (!this._bufferOpen &&
+            this._buffer.length === 0 &&
+            this._chunkQueue.length === 0 &&
+            this._chunkPending === null);
+    }
+}

package/dist/util/googlevertexai-gauth.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GAuthClient = void 0;
+const google_auth_library_1 = require("google-auth-library");
+const googlevertexai_connection_js_1 = require("./googlevertexai-connection.cjs");
+class GoogleVertexAINodeStream extends googlevertexai_connection_js_1.GoogleVertexAIStream {
+    constructor(data) {
+        super();
+        data.on("data", (data) => this.appendBuffer(data.toString()));
+        data.on("end", () => this.closeBuffer());
+    }
+}
+class GAuthClient {
+    constructor(options) {
+        Object.defineProperty(this, "gauth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.gauth = new google_auth_library_1.GoogleAuth(options);
+    }
+    async getProjectId() {
+        return this.gauth.getProjectId();
+    }
+    async request(opts) {
+        const ret = await this.gauth.request(opts);
+        return opts.responseType !== "stream"
+            ? ret
+            : {
+                ...ret,
+                data: new GoogleVertexAINodeStream(ret.data),
+            };
+    }
+}
+exports.GAuthClient = GAuthClient;

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

@@ -0,0 +1,8 @@
+import { GoogleAuth, GoogleAuthOptions } from "google-auth-library";
+import { GoogleAbstractedClient, GoogleAbstractedClientOps } from "../types/googlevertexai-types.js";
+export declare class GAuthClient implements GoogleAbstractedClient {
+    gauth: GoogleAuth;
+    constructor(options?: GoogleAuthOptions);
+    getProjectId(): Promise<string>;
+    request(opts: GoogleAbstractedClientOps): Promise<unknown>;
+}

package/dist/util/googlevertexai-gauth.js

@@ -0,0 +1,32 @@
+import { GoogleAuth } from "google-auth-library";
+import { GoogleVertexAIStream } from "./googlevertexai-connection.js";
+class GoogleVertexAINodeStream extends GoogleVertexAIStream {
+    constructor(data) {
+        super();
+        data.on("data", (data) => this.appendBuffer(data.toString()));
+        data.on("end", () => this.closeBuffer());
+    }
+}
+export class GAuthClient {
+    constructor(options) {
+        Object.defineProperty(this, "gauth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.gauth = new GoogleAuth(options);
+    }
+    async getProjectId() {
+        return this.gauth.getProjectId();
+    }
+    async request(opts) {
+        const ret = await this.gauth.request(opts);
+        return opts.responseType !== "stream"
+            ? ret
+            : {
+                ...ret,
+                data: new GoogleVertexAINodeStream(ret.data),
+            };
+    }
+}

package/dist/util/googlevertexai-webauth.cjs

@@ -3,6 +3,40 @@ 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");
+const googlevertexai_connection_js_1 = require("./googlevertexai-connection.cjs");
+class GoogleVertexAIResponseStream extends googlevertexai_connection_js_1.GoogleVertexAIStream {
+    constructor(body) {
+        super();
+        Object.defineProperty(this, "decoder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.decoder = new TextDecoder();
+        if (body) {
+            void this.run(body);
+        }
+        else {
+            console.error("Unexpected empty body while streaming");
+        }
+    }
+    async run(body) {
+        const reader = body.getReader();
+        let isDone = false;
+        while (!isDone) {
+            const { value, done } = await reader.read();
+            if (!done) {
+                const svalue = this.decoder.decode(value);
+                this.appendBuffer(svalue);
+            }
+            else {
+                isDone = done;
+                this.closeBuffer();
+            }
+        }
+    }
+}
 class WebGoogleAuth {
     constructor(options) {
         Object.defineProperty(this, "options", {
@@ -15,7 +49,7 @@ class WebGoogleAuth {
         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".`);
+            throw new Error(`Credentials not found. Please set the GOOGLE_VERTEX_AI_WEB_CREDENTIALS environment variable or pass credentials into "authOptions.credentials".`);
         const scope = options?.scope ?? "https://www.googleapis.com/auth/cloud-platform";
         this.options = { ...options, accessToken, credentials, scope };
     }
@@ -48,7 +82,9 @@ class WebGoogleAuth {
             throw error;
         }
         return {
-            data: await res.json(),
+            data: opts.responseType === "json"
+                ? await res.json()
+                : new GoogleVertexAIResponseStream(res.body),
             config: {},
             status: res.status,
             statusText: res.statusText,

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

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

package/dist/util/googlevertexai-webauth.js

@@ -1,5 +1,39 @@
 import { getAccessToken, getCredentials, } from "web-auth-library/google";
 import { getEnvironmentVariable } from "./env.js";
+import { GoogleVertexAIStream } from "./googlevertexai-connection.js";
+class GoogleVertexAIResponseStream extends GoogleVertexAIStream {
+    constructor(body) {
+        super();
+        Object.defineProperty(this, "decoder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.decoder = new TextDecoder();
+        if (body) {
+            void this.run(body);
+        }
+        else {
+            console.error("Unexpected empty body while streaming");
+        }
+    }
+    async run(body) {
+        const reader = body.getReader();
+        let isDone = false;
+        while (!isDone) {
+            const { value, done } = await reader.read();
+            if (!done) {
+                const svalue = this.decoder.decode(value);
+                this.appendBuffer(svalue);
+            }
+            else {
+                isDone = done;
+                this.closeBuffer();
+            }
+        }
+    }
+}
 export class WebGoogleAuth {
     constructor(options) {
         Object.defineProperty(this, "options", {
@@ -12,7 +46,7 @@ export class WebGoogleAuth {
         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".`);
+            throw new Error(`Credentials not found. Please set the GOOGLE_VERTEX_AI_WEB_CREDENTIALS environment variable or pass credentials into "authOptions.credentials".`);
         const scope = options?.scope ?? "https://www.googleapis.com/auth/cloud-platform";
         this.options = { ...options, accessToken, credentials, scope };
     }
@@ -45,7 +79,9 @@ export class WebGoogleAuth {
             throw error;
         }
         return {
-            data: await res.json(),
+            data: opts.responseType === "json"
+                ? await res.json()
+                : new GoogleVertexAIResponseStream(res.body),
             config: {},
             status: res.status,
             statusText: res.statusText,