@langchain/google-common 0.1.1 → 0.1.3

package/dist/chat_models.cjs

@@ -53,49 +53,20 @@ class ChatConnection extends connection_js_1.AbstractGoogleLLMConnection {
         }
         return true;
     }
-    async formatContents(input, _parameters) {
-        const inputPromises = input.map((msg, i) => this.api.baseMessageToContent(msg, input[i - 1], this.useSystemInstruction));
-        const inputs = await Promise.all(inputPromises);
-        return inputs.reduce((acc, cur) => {
-            // Filter out the system content
-            if (cur.every((content) => content.role === "system")) {
-                return acc;
-            }
-            // Combine adjacent function messages
-            if (cur[0]?.role === "function" &&
-                acc.length > 0 &&
-                acc[acc.length - 1].role === "function") {
-                acc[acc.length - 1].parts = [
-                    ...acc[acc.length - 1].parts,
-                    ...cur[0].parts,
-                ];
-            }
-            else {
-                acc.push(...cur);
-            }
-            return acc;
-        }, []);
+    buildGeminiAPI() {
+        const geminiConfig = {
+            useSystemInstruction: this.useSystemInstruction,
+            ...this.apiConfig,
+        };
+        return (0, gemini_js_1.getGeminiAPI)(geminiConfig);
     }
-    async formatSystemInstruction(input, _parameters) {
-        if (!this.useSystemInstruction) {
-            return {};
+    get api() {
+        switch (this.apiName) {
+            case "google":
+                return this.buildGeminiAPI();
+            default:
+                return super.api;
         }
-        let ret = {};
-        for (let index = 0; index < input.length; index += 1) {
-            const message = input[index];
-            if (message._getType() === "system") {
-                // For system types, we only want it if it is the first message,
-                // if it appears anywhere else, it should be an error.
-                if (index === 0) {
-                    // eslint-disable-next-line prefer-destructuring
-                    ret = (await this.api.baseMessageToContent(message, undefined, true))[0];
-                }
-                else {
-                    throw new Error("System messages are only permitted as the first passed message.");
-                }
-            }
-        }
-        return ret;
     }
 }
 exports.ChatConnection = ChatConnection;
@@ -274,15 +245,18 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
                 generations: [finalChunk],
             };
         }
-        const response = await this.connection.request(messages, parameters, options);
-        const ret = this.connection.api.safeResponseToChatResult(response, this.safetyHandler);
-        await runManager?.handleLLMNewToken(ret.generations[0].text);
+        const response = await this.connection.request(messages, parameters, options, runManager);
+        const ret = this.connection.api.responseToChatResult(response);
+        const chunk = ret?.generations?.[0];
+        if (chunk) {
+            await runManager?.handleLLMNewToken(chunk.text || "");
+        }
         return ret;
     }
     async *_streamResponseChunks(_messages, options, runManager) {
         // Make the call as a streaming request
         const parameters = this.invocationParams(options);
-        const response = await this.streamedConnection.request(_messages, parameters, options);
+        const response = await this.streamedConnection.request(_messages, parameters, options, runManager);
         // Get the streaming parser of the response
         const stream = response.data;
         let usageMetadata;
@@ -291,6 +265,9 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
         // that is either available or added to the queue
         while (!stream.streamDone) {
             const output = await stream.nextChunk();
+            await runManager?.handleCustomEvent(`google-chunk-${this.constructor.name}`, {
+                output,
+            });
             if (output &&
                 output.usageMetadata &&
                 this.streamUsage !== false &&
@@ -302,7 +279,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
                 };
             }
             const chunk = output !== null
-                ? this.connection.api.safeResponseToChatGeneration({ data: output }, this.safetyHandler)
+                ? this.connection.api.responseToChatGeneration({ data: output })
                 : new outputs_1.ChatGenerationChunk({
                     text: "",
                     generationInfo: { finishReason: "stop" },
@@ -311,8 +288,10 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
                         usage_metadata: usageMetadata,
                     }),
                 });
-            yield chunk;
-            await runManager?.handleLLMNewToken(chunk.text);
+            if (chunk) {
+                yield chunk;
+                await runManager?.handleLLMNewToken(chunk.text ?? "", undefined, undefined, undefined, undefined, { chunk });
+            }
         }
     }
     /** @ignore */

package/dist/chat_models.d.ts

@@ -7,22 +7,22 @@ import { BaseLanguageModelInput, StructuredOutputMethodOptions } from "@langchai
 import type { z } from "zod";
 import { Runnable } from "@langchain/core/runnables";
 import { AsyncCaller } from "@langchain/core/utils/async_caller";
-import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GoogleConnectionParams, GooglePlatformType, GeminiContent, GoogleAIBaseLanguageModelCallOptions } from "./types.js";
+import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GoogleConnectionParams, GooglePlatformType, GoogleAIBaseLanguageModelCallOptions, GoogleAIAPI, GoogleAIAPIParams } from "./types.js";
 import { AbstractGoogleLLMConnection } from "./connection.js";
 import { GoogleAbstractedClient } from "./auth.js";
-import type { GoogleBaseLLMInput, GoogleAISafetyHandler, GoogleAISafetyParams, GoogleAIToolType, GeminiAPIConfig } from "./types.js";
+import type { GoogleBaseLLMInput, GoogleAISafetyHandler, GoogleAISafetyParams, GoogleAIToolType } from "./types.js";
 export declare class ChatConnection<AuthOptions> extends AbstractGoogleLLMConnection<BaseMessage[], AuthOptions> {
     convertSystemMessageToHumanContent: boolean | undefined;
     constructor(fields: GoogleAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming: boolean);
     get useSystemInstruction(): boolean;
     get computeUseSystemInstruction(): boolean;
-    formatContents(input: BaseMessage[], _parameters: GoogleAIModelParams): Promise<GeminiContent[]>;
-    formatSystemInstruction(input: BaseMessage[], _parameters: GoogleAIModelParams): Promise<GeminiContent>;
+    buildGeminiAPI(): GoogleAIAPI;
+    get api(): GoogleAIAPI;
 }
 /**
  * Input to chat model class.
  */
-export interface ChatGoogleBaseInput<AuthOptions> extends BaseChatModelParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams, GoogleAISafetyParams, GeminiAPIConfig, Pick<GoogleAIBaseLanguageModelCallOptions, "streamUsage"> {
+export interface ChatGoogleBaseInput<AuthOptions> extends BaseChatModelParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams, GoogleAISafetyParams, GoogleAIAPIParams, Pick<GoogleAIBaseLanguageModelCallOptions, "streamUsage"> {
 }
 /**
  * Integration with a Google chat model.

package/dist/chat_models.js

@@ -7,7 +7,7 @@ import { JsonOutputKeyToolsParser } from "@langchain/core/output_parsers/openai_
 import { concat } from "@langchain/core/utils/stream";
 import { convertToGeminiTools, copyAIModelParams, copyAndValidateModelParamsInto, } from "./utils/common.js";
 import { AbstractGoogleLLMConnection } from "./connection.js";
-import { DefaultGeminiSafetyHandler } from "./utils/gemini.js";
+import { DefaultGeminiSafetyHandler, getGeminiAPI } from "./utils/gemini.js";
 import { ApiKeyGoogleAuth } from "./auth.js";
 import { ensureParams } from "./utils/failed_handler.js";
 import { zodToGeminiParameters } from "./utils/zod_to_gemini_parameters.js";
@@ -50,49 +50,20 @@ export class ChatConnection extends AbstractGoogleLLMConnection {
         }
         return true;
     }
-    async formatContents(input, _parameters) {
-        const inputPromises = input.map((msg, i) => this.api.baseMessageToContent(msg, input[i - 1], this.useSystemInstruction));
-        const inputs = await Promise.all(inputPromises);
-        return inputs.reduce((acc, cur) => {
-            // Filter out the system content
-            if (cur.every((content) => content.role === "system")) {
-                return acc;
-            }
-            // Combine adjacent function messages
-            if (cur[0]?.role === "function" &&
-                acc.length > 0 &&
-                acc[acc.length - 1].role === "function") {
-                acc[acc.length - 1].parts = [
-                    ...acc[acc.length - 1].parts,
-                    ...cur[0].parts,
-                ];
-            }
-            else {
-                acc.push(...cur);
-            }
-            return acc;
-        }, []);
+    buildGeminiAPI() {
+        const geminiConfig = {
+            useSystemInstruction: this.useSystemInstruction,
+            ...this.apiConfig,
+        };
+        return getGeminiAPI(geminiConfig);
     }
-    async formatSystemInstruction(input, _parameters) {
-        if (!this.useSystemInstruction) {
-            return {};
+    get api() {
+        switch (this.apiName) {
+            case "google":
+                return this.buildGeminiAPI();
+            default:
+                return super.api;
         }
-        let ret = {};
-        for (let index = 0; index < input.length; index += 1) {
-            const message = input[index];
-            if (message._getType() === "system") {
-                // For system types, we only want it if it is the first message,
-                // if it appears anywhere else, it should be an error.
-                if (index === 0) {
-                    // eslint-disable-next-line prefer-destructuring
-                    ret = (await this.api.baseMessageToContent(message, undefined, true))[0];
-                }
-                else {
-                    throw new Error("System messages are only permitted as the first passed message.");
-                }
-            }
-        }
-        return ret;
     }
 }
 /**
@@ -270,15 +241,18 @@ export class ChatGoogleBase extends BaseChatModel {
                 generations: [finalChunk],
             };
         }
-        const response = await this.connection.request(messages, parameters, options);
-        const ret = this.connection.api.safeResponseToChatResult(response, this.safetyHandler);
-        await runManager?.handleLLMNewToken(ret.generations[0].text);
+        const response = await this.connection.request(messages, parameters, options, runManager);
+        const ret = this.connection.api.responseToChatResult(response);
+        const chunk = ret?.generations?.[0];
+        if (chunk) {
+            await runManager?.handleLLMNewToken(chunk.text || "");
+        }
         return ret;
     }
     async *_streamResponseChunks(_messages, options, runManager) {
         // Make the call as a streaming request
         const parameters = this.invocationParams(options);
-        const response = await this.streamedConnection.request(_messages, parameters, options);
+        const response = await this.streamedConnection.request(_messages, parameters, options, runManager);
         // Get the streaming parser of the response
         const stream = response.data;
         let usageMetadata;
@@ -287,6 +261,9 @@ export class ChatGoogleBase extends BaseChatModel {
         // that is either available or added to the queue
         while (!stream.streamDone) {
             const output = await stream.nextChunk();
+            await runManager?.handleCustomEvent(`google-chunk-${this.constructor.name}`, {
+                output,
+            });
             if (output &&
                 output.usageMetadata &&
                 this.streamUsage !== false &&
@@ -298,7 +275,7 @@ export class ChatGoogleBase extends BaseChatModel {
                 };
             }
             const chunk = output !== null
-                ? this.connection.api.safeResponseToChatGeneration({ data: output }, this.safetyHandler)
+                ? this.connection.api.responseToChatGeneration({ data: output })
                 : new ChatGenerationChunk({
                     text: "",
                     generationInfo: { finishReason: "stop" },
@@ -307,8 +284,10 @@ export class ChatGoogleBase extends BaseChatModel {
                         usage_metadata: usageMetadata,
                     }),
                 });
-            yield chunk;
-            await runManager?.handleLLMNewToken(chunk.text);
+            if (chunk) {
+                yield chunk;
+                await runManager?.handleLLMNewToken(chunk.text ?? "", undefined, undefined, undefined, undefined, { chunk });
+            }
         }
     }
     /** @ignore */

package/dist/connection.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractGoogleLLMConnection = exports.GoogleAIConnection = exports.GoogleRawConnection = exports.GoogleHostConnection = exports.GoogleConnection = void 0;
+exports.GoogleRequestRecorder = exports.GoogleRequestLogger = exports.GoogleRequestCallbackHandler = exports.AbstractGoogleLLMConnection = exports.GoogleAIConnection = exports.GoogleRawConnection = exports.GoogleHostConnection = exports.GoogleConnection = void 0;
 const env_1 = require("@langchain/core/utils/env");
-const function_calling_1 = require("@langchain/core/utils/function_calling");
-const zod_to_gemini_parameters_js_1 = require("./utils/zod_to_gemini_parameters.cjs");
+const base_1 = require("@langchain/core/callbacks/base");
 const index_js_1 = require("./utils/index.cjs");
+const anthropic_js_1 = require("./utils/anthropic.cjs");
 class GoogleConnection {
     constructor(caller, client, streaming) {
         Object.defineProperty(this, "caller", {
@@ -102,17 +102,17 @@ class GoogleHostConnection extends GoogleConnection {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "endpoint", {
+        Object.defineProperty(this, "_endpoint", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "us-central1-aiplatform.googleapis.com"
+            value: void 0
         });
-        Object.defineProperty(this, "location", {
+        Object.defineProperty(this, "_location", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "us-central1"
+            value: void 0
         });
         Object.defineProperty(this, "apiVersion", {
             enumerable: true,
@@ -122,8 +122,8 @@ class GoogleHostConnection extends GoogleConnection {
         });
         this.caller = caller;
         this.platformType = fields?.platformType;
-        this.endpoint = fields?.endpoint ?? this.endpoint;
-        this.location = fields?.location ?? this.location;
+        this._endpoint = fields?.endpoint;
+        this._location = fields?.location;
         this.apiVersion = fields?.apiVersion ?? this.apiVersion;
         this.client = client;
     }
@@ -133,6 +133,18 @@ class GoogleHostConnection extends GoogleConnection {
     get computedPlatformType() {
         return "gcp";
     }
+    get location() {
+        return this._location ?? this.computedLocation;
+    }
+    get computedLocation() {
+        return "us-central1";
+    }
+    get endpoint() {
+        return this._endpoint ?? this.computedEndpoint;
+    }
+    get computedEndpoint() {
+        return `${this.location}-aiplatform.googleapis.com`;
+    }
     buildMethod() {
         return "POST";
     }
@@ -167,24 +179,48 @@ class GoogleAIConnection extends GoogleHostConnection {
             writable: true,
             value: void 0
         });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Object.defineProperty(this, "api", {
+        Object.defineProperty(this, "_apiName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "apiConfig", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
-        }); // FIXME: Make this a real type
+        });
         this.client = client;
         this.modelName = fields?.model ?? fields?.modelName ?? this.model;
         this.model = this.modelName;
-        this.api = (0, index_js_1.getGeminiAPI)(fields);
+        this._apiName = fields?.apiName;
+        this.apiConfig = {
+            safetyHandler: fields?.safetyHandler,
+            ...fields?.apiConfig,
+        };
     }
     get modelFamily() {
-        if (this.model.startsWith("gemini")) {
-            return "gemini";
-        }
-        else {
-            return null;
+        return (0, index_js_1.modelToFamily)(this.model);
+    }
+    get modelPublisher() {
+        return (0, index_js_1.modelToPublisher)(this.model);
+    }
+    get computedAPIName() {
+        // At least at the moment, model publishers and APIs map the same
+        return this.modelPublisher;
+    }
+    get apiName() {
+        return this._apiName ?? this.computedAPIName;
+    }
+    get api() {
+        switch (this.apiName) {
+            case "google":
+                return (0, index_js_1.getGeminiAPI)(this.apiConfig);
+            case "anthropic":
+                return (0, anthropic_js_1.getAnthropicAPI)(this.apiConfig);
+            default:
+                throw new Error(`Unknown API: ${this.apiName}`);
         }
     }
     get computedPlatformType() {
@@ -195,6 +231,16 @@ class GoogleAIConnection extends GoogleHostConnection {
             return "gcp";
         }
     }
+    get computedLocation() {
+        switch (this.apiName) {
+            case "google":
+                return super.computedLocation;
+            case "anthropic":
+                return "us-east5";
+            default:
+                throw new Error(`Unknown apiName: ${this.apiName}. Can't get location.`);
+        }
+    }
     async buildUrlGenerativeLanguage() {
         const method = await this.buildUrlMethod();
         const url = `https://generativelanguage.googleapis.com/${this.apiVersion}/models/${this.model}:${method}`;
@@ -203,7 +249,8 @@ class GoogleAIConnection extends GoogleHostConnection {
     async buildUrlVertex() {
         const projectId = await this.client.getProjectId();
         const method = await this.buildUrlMethod();
-        const url = `https://${this.endpoint}/${this.apiVersion}/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:${method}`;
+        const publisher = this.modelPublisher;
+        const url = `https://${this.endpoint}/${this.apiVersion}/projects/${projectId}/locations/${this.location}/publishers/${publisher}/models/${this.model}:${method}`;
         return url;
     }
     async buildUrl() {
@@ -214,9 +261,30 @@ class GoogleAIConnection extends GoogleHostConnection {
                 return this.buildUrlVertex();
         }
     }
-    async request(input, parameters, options) {
-        const data = await this.formatData(input, parameters);
+    async request(input, parameters, options, runManager) {
+        const moduleName = this.constructor.name;
+        const streamingParameters = {
+            ...parameters,
+            streaming: this.streaming,
+        };
+        const data = await this.formatData(input, streamingParameters);
+        await runManager?.handleCustomEvent(`google-request-${moduleName}`, {
+            data,
+            parameters: streamingParameters,
+            options,
+            connection: {
+                ...this,
+                url: await this.buildUrl(),
+                urlMethod: await this.buildUrlMethod(),
+                modelFamily: this.modelFamily,
+                modelPublisher: this.modelPublisher,
+                computedPlatformType: this.computedPlatformType,
+            },
+        });
         const response = await this._request(data, options);
+        await runManager?.handleCustomEvent(`google-response-${moduleName}`, {
+            response,
+        });
         return response;
     }
 }
@@ -225,99 +293,111 @@ class AbstractGoogleLLMConnection extends GoogleAIConnection {
     async buildUrlMethodGemini() {
         return this.streaming ? "streamGenerateContent" : "generateContent";
     }
+    async buildUrlMethodClaude() {
+        return this.streaming ? "streamRawPredict" : "rawPredict";
+    }
     async buildUrlMethod() {
         switch (this.modelFamily) {
             case "gemini":
                 return this.buildUrlMethodGemini();
+            case "claude":
+                return this.buildUrlMethodClaude();
             default:
                 throw new Error(`Unknown model family: ${this.modelFamily}`);
         }
     }
-    formatGenerationConfig(_input, parameters) {
+    async formatData(input, parameters) {
+        return this.api.formatData(input, parameters);
+    }
+}
+exports.AbstractGoogleLLMConnection = AbstractGoogleLLMConnection;
+class GoogleRequestCallbackHandler extends base_1.BaseCallbackHandler {
+    customEventInfo(eventName) {
+        const names = eventName.split("-");
         return {
-            temperature: parameters.temperature,
-            topK: parameters.topK,
-            topP: parameters.topP,
-            maxOutputTokens: parameters.maxOutputTokens,
-            stopSequences: parameters.stopSequences,
-            responseMimeType: parameters.responseMimeType,
+            subEvent: names[1],
+            module: names[2],
         };
     }
-    formatSafetySettings(_input, parameters) {
-        return parameters.safetySettings ?? [];
+    handleCustomEvent(eventName, data, runId, tags, metadata) {
+        if (!eventName) {
+            return undefined;
+        }
+        const eventInfo = this.customEventInfo(eventName);
+        switch (eventInfo.subEvent) {
+            case "request":
+                return this.handleCustomRequestEvent(eventName, eventInfo, data, runId, tags, metadata);
+            case "response":
+                return this.handleCustomResponseEvent(eventName, eventInfo, data, runId, tags, metadata);
+            case "chunk":
+                return this.handleCustomChunkEvent(eventName, eventInfo, data, runId, tags, metadata);
+            default:
+                console.error(`Unexpected eventInfo for ${eventName} ${JSON.stringify(eventInfo, null, 1)}`);
+        }
     }
-    async formatSystemInstruction(_input, _parameters) {
-        return {};
+}
+exports.GoogleRequestCallbackHandler = GoogleRequestCallbackHandler;
+class GoogleRequestLogger extends GoogleRequestCallbackHandler {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "GoogleRequestLogger"
+        });
     }
-    structuredToolToFunctionDeclaration(tool) {
-        const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
-        return {
-            name: tool.name,
-            description: tool.description ?? `A function available to call.`,
-            parameters: jsonSchema,
-        };
+    log(eventName, data, tags) {
+        const tagStr = tags ? `[${tags}]` : "[]";
+        console.log(`${eventName} ${tagStr} ${JSON.stringify(data, null, 1)}`);
     }
-    structuredToolsToGeminiTools(tools) {
-        return [
-            {
-                functionDeclarations: tools.map(this.structuredToolToFunctionDeclaration),
-            },
-        ];
+    handleCustomRequestEvent(eventName, _eventInfo, data, _runId, tags, _metadata) {
+        this.log(eventName, data, tags);
     }
-    formatTools(_input, parameters) {
-        const tools = parameters?.tools;
-        if (!tools || tools.length === 0) {
-            return [];
-        }
-        if (tools.every(function_calling_1.isLangChainTool)) {
-            return this.structuredToolsToGeminiTools(tools);
-        }
-        else {
-            if (tools.length === 1 &&
-                (!("functionDeclarations" in tools[0]) ||
-                    !tools[0].functionDeclarations?.length)) {
-                return [];
-            }
-            return tools;
-        }
+    handleCustomResponseEvent(eventName, _eventInfo, data, _runId, tags, _metadata) {
+        this.log(eventName, data, tags);
     }
-    formatToolConfig(parameters) {
-        if (!parameters.tool_choice || typeof parameters.tool_choice !== "string") {
-            return undefined;
-        }
-        return {
-            functionCallingConfig: {
-                mode: parameters.tool_choice,
-                allowedFunctionNames: parameters.allowed_function_names,
-            },
-        };
+    handleCustomChunkEvent(eventName, _eventInfo, data, _runId, tags, _metadata) {
+        this.log(eventName, data, tags);
     }
-    async formatData(input, parameters) {
-        const contents = await this.formatContents(input, parameters);
-        const generationConfig = this.formatGenerationConfig(input, parameters);
-        const tools = this.formatTools(input, parameters);
-        const toolConfig = this.formatToolConfig(parameters);
-        const safetySettings = this.formatSafetySettings(input, parameters);
-        const systemInstruction = await this.formatSystemInstruction(input, parameters);
-        const ret = {
-            contents,
-            generationConfig,
-        };
-        if (tools && tools.length) {
-            ret.tools = tools;
-        }
-        if (toolConfig) {
-            ret.toolConfig = toolConfig;
-        }
-        if (safetySettings && safetySettings.length) {
-            ret.safetySettings = safetySettings;
-        }
-        if (systemInstruction?.role &&
-            systemInstruction?.parts &&
-            systemInstruction?.parts?.length) {
-            ret.systemInstruction = systemInstruction;
-        }
-        return ret;
+}
+exports.GoogleRequestLogger = GoogleRequestLogger;
+class GoogleRequestRecorder extends GoogleRequestCallbackHandler {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "GoogleRequestRecorder"
+        });
+        Object.defineProperty(this, "request", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "response", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "chunk", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    handleCustomRequestEvent(_eventName, _eventInfo, data, _runId, _tags, _metadata) {
+        this.request = data;
+    }
+    handleCustomResponseEvent(_eventName, _eventInfo, data, _runId, _tags, _metadata) {
+        this.response = data;
+    }
+    handleCustomChunkEvent(_eventName, _eventInfo, data, _runId, _tags, _metadata) {
+        this.chunk.push(data);
     }
 }
-exports.AbstractGoogleLLMConnection = AbstractGoogleLLMConnection;
+exports.GoogleRequestRecorder = GoogleRequestRecorder;