@langchain/google 0.1.0

package/dist/utils/gcp-auth.cjs

@@ -0,0 +1,188 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_misc = require('./misc.cjs');
+const require_errors = require('./errors.cjs');
+const jose = require_rolldown_runtime.__toESM(require("jose"));
+
+//#region src/utils/gcp-auth.ts
+const cache = /* @__PURE__ */ new Map();
+const CACHE_MAX_AGE = 3600;
+/**
+* Normalizes GCP credentials to a frozen GCPCredentials object.
+*
+* This function accepts credentials in either string (JSON) or object format
+* and ensures the returned value is a frozen (immutable) GCPCredentials object.
+* Freezing the credentials prevents accidental modification and ensures
+* consistency throughout the application lifecycle.
+*
+* @param credentials - The GCP service account credentials, either as a JSON string
+*                      or as a GCPCredentials object
+* @returns A frozen GCPCredentials object that cannot be modified
+*
+* @example
+* ```typescript
+* // From JSON string
+* const creds = normalizeGCPCredentials('{"type":"service_account",...}');
+*
+* // From object
+* const creds = normalizeGCPCredentials({
+*   type: "service_account",
+*   project_id: "my-project",
+*   // ... other fields
+* });
+* ```
+*/
+function normalizeGCPCredentials(credentials) {
+	return typeof credentials === "string" ? Object.freeze(JSON.parse(credentials)) : Object.isFrozen(credentials) ? credentials : Object.freeze(credentials);
+}
+/**
+* Imports and returns the private key from GCP credentials for JWT signing.
+*
+* This function extracts the RSA private key from the service account credentials
+* and imports it using the PKCS#8 format with the RS256 algorithm. The returned
+* key can be used to sign JWTs for authentication with Google Cloud services.
+*
+* @param credentials - The GCP service account credentials containing the private key
+* @returns A Promise that resolves to the imported private key suitable for JWT signing
+*
+* @throws {Error} If the private key format is invalid or cannot be imported
+*
+* @example
+* ```typescript
+* const credentials = normalizeGCPCredentials(credentialsJson);
+* const privateKey = await getGCPPrivateKey(credentials);
+* // Use privateKey for signing operations
+* ```
+*/
+function getGCPPrivateKey(credentials) {
+	return (0, jose.importPKCS8)(credentials.private_key, "RS256");
+}
+/**
+* Generates a custom JWT token for authenticating with Google Cloud services.
+*
+* This function creates a signed JWT (JSON Web Token) using the service account's
+* private key. The token includes standard claims such as issuer, audience, subject,
+* issued-at time, and expiration time. This custom token can be exchanged for an
+* access token or ID token through Google's OAuth2 token endpoint.
+*
+* The generated JWT is valid for 1 hour and follows the OAuth 2.0 JWT Bearer
+* Token flow as specified by RFC 7523.
+*
+* @param credentials - The GCP service account credentials used to sign the JWT
+* @returns A Promise that resolves to the signed JWT string
+*
+* @throws {Error} If the private key cannot be imported or the JWT cannot be signed
+*
+* @see https://datatracker.ietf.org/doc/html/rfc7523
+* @see https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials
+*
+* @example
+* ```typescript
+* const credentials = normalizeGCPCredentials(credentialsJson);
+* const customToken = await getGCPCustomToken(credentials);
+* // Use customToken to request an access token
+* ```
+*/
+async function getGCPCustomToken(credentials) {
+	const privateKey = await getGCPPrivateKey(credentials);
+	const customToken = await new jose.SignJWT().setIssuer(credentials.client_email).setAudience(credentials.token_uri).setSubject(credentials.client_email).setProtectedHeader({ alg: "RS256" }).setIssuedAt().setExpirationTime("1h").sign(privateKey);
+	return customToken;
+}
+/**
+* Retrieves an access token for authenticating with Google Cloud APIs.
+*
+* - Tokens are cached based on the token URI and private key ID
+* - Cache entries are valid for up to 1 hour
+* - Expired tokens trigger automatic refresh
+* - Multiple concurrent requests for the same token are deduplicated
+*
+* The function handles both access tokens and ID tokens, automatically detecting
+* which type is returned by the token endpoint and extracting the appropriate
+* expiration time.
+*
+* @param credentials - The GCP service account credentials used to request the token
+* @returns A Promise that resolves to the access token string
+*
+* @throws {AuthError} If the token request fails (e.g., invalid credentials,
+*                     network error, or API error)
+*
+* @see https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials
+* @see https://datatracker.ietf.org/doc/html/rfc7523
+*
+* @example
+* ```typescript
+* const credentials = normalizeGCPCredentials(credentialsJson);
+* const accessToken = await getGCPCredentialsAccessToken(credentials);
+*
+* // Use the access token in API requests
+* const response = await fetch('https://api.google.com/...', {
+*   headers: {
+*     'Authorization': `Bearer ${accessToken}`
+*   }
+* });
+* ```
+*
+* @remarks
+* The caching mechanism uses a two-level validation:
+* 1. Cache entry age (must be less than CACHE_MAX_AGE)
+* 2. Token expiration time (must not be expired)
+*
+* This ensures that even if a cache entry is fresh, an expired token
+* will trigger a refresh request.
+*/
+async function getGCPCredentialsAccessToken(credentials) {
+	const tokenUrl = credentials.token_uri;
+	const cacheKeyUrl = new URL(tokenUrl);
+	cacheKeyUrl.searchParams.set("key", credentials.private_key_id);
+	const cacheKey = cacheKeyUrl.toString();
+	const cacheValue = cache.get(cacheKey);
+	let now = Math.floor(Date.now() / 1e3);
+	if (cacheValue) if (cacheValue.created > now - CACHE_MAX_AGE) {
+		let token = await cacheValue.promise;
+		if (token.expires > now) return token.token;
+		else {
+			const nextValue = cache.get(cacheKey);
+			if (nextValue && nextValue !== cacheValue) {
+				token = await nextValue.promise;
+				if (token.expires > now) return token.token;
+				else cache.delete(cacheKey);
+			}
+		}
+	} else cache.delete(cacheKey);
+	const promise = require_misc.iife(async () => {
+		now = Math.floor(Date.now() / 1e3);
+		const jwt = await getGCPCustomToken(credentials);
+		const body = new URLSearchParams();
+		body.append("grant_type", "urn:ietf:params:oauth:grant-type:jwt-bearer");
+		body.append("assertion", jwt);
+		const res = await fetch(tokenUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body
+		});
+		if (!res.ok) throw await require_errors.AuthError.fromResponse(res);
+		const data = await res.json();
+		if ("id_token" in data) {
+			const claims = (0, jose.decodeJwt)(data.id_token);
+			return {
+				token: data.id_token,
+				expires: claims.exp
+			};
+		}
+		const lastModified = res.headers.get("last-modified");
+		const expires = lastModified ? Math.floor(new Date(lastModified).valueOf() / 1e3) + data.expires_in : now + data.expires_in;
+		return {
+			expires,
+			token: data.access_token
+		};
+	});
+	cache.set(cacheKey, {
+		created: now,
+		promise
+	});
+	return await promise.then((data) => data.token);
+}
+
+//#endregion
+exports.getGCPCredentialsAccessToken = getGCPCredentialsAccessToken;
+exports.normalizeGCPCredentials = normalizeGCPCredentials;
+//# sourceMappingURL=gcp-auth.cjs.map

package/dist/utils/gcp-auth.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcp-auth.cjs","names":["credentials: string | GCPCredentials","credentials: GCPCredentials","SignJWT","iife","AuthError"],"sources":["../../src/utils/gcp-auth.ts"],"sourcesContent":["/**\n * GCP authentication utilities.\n *\n * Adapted from: https://github.com/kriasoft/web-auth-library\n * Original source: web-auth-library by Kriasoft\n * License: MIT (https://github.com/kriasoft/web-auth-library/blob/main/LICENSE)\n */\n\nimport { decodeJwt, importPKCS8, SignJWT } from \"jose\";\nimport { AuthError } from \"../utils/errors.js\";\nimport { iife } from \"../utils/misc.js\";\n\n/**\n * Google Cloud Platform service account credentials interface.\n *\n * This interface represents the structure of a GCP service account key file,\n * which is used for authenticating with Google Cloud APIs. Service account\n * keys can be downloaded from the Google Cloud Console and contain all the\n * information needed to authenticate as a service account.\n *\n * @see https://cloud.google.com/iam/docs/creating-managing-service-account-keys\n */\nexport interface GCPCredentials {\n  /** The type of credential, typically \"service_account\" */\n  type: string;\n  /** The GCP project ID associated with this service account */\n  project_id: string;\n  /** The unique identifier for the private key */\n  private_key_id: string;\n  /** The RSA private key in PEM format used for signing JWTs */\n  private_key: string;\n  /** The unique client ID for this service account */\n  client_id: string;\n  /** The email address of the service account */\n  client_email: string;\n  /** The OAuth2 authorization endpoint URI */\n  auth_uri: string;\n  /** The OAuth2 token endpoint URI where access tokens are requested */\n  token_uri: string;\n  /** The URL for the OAuth2 provider's x509 certificate */\n  auth_provider_x509_cert_url: string;\n  /** The URL for this service account's x509 certificate */\n  client_x509_cert_url: string;\n}\n\ninterface CacheValue {\n  /** Unix timestamp (in seconds) when this cache entry was created */\n  created: number;\n  /** Promise that resolves to the token and its expiration time */\n  promise: Promise<{ token: string; expires: number }>;\n}\n\nconst cache = new Map<string, CacheValue>();\nconst CACHE_MAX_AGE = 60 * 60; // 1 hour\n\n/**\n * Normalizes GCP credentials to a frozen GCPCredentials object.\n *\n * This function accepts credentials in either string (JSON) or object format\n * and ensures the returned value is a frozen (immutable) GCPCredentials object.\n * Freezing the credentials prevents accidental modification and ensures\n * consistency throughout the application lifecycle.\n *\n * @param credentials - The GCP service account credentials, either as a JSON string\n *                      or as a GCPCredentials object\n * @returns A frozen GCPCredentials object that cannot be modified\n *\n * @example\n * ```typescript\n * // From JSON string\n * const creds = normalizeGCPCredentials('{\"type\":\"service_account\",...}');\n *\n * // From object\n * const creds = normalizeGCPCredentials({\n *   type: \"service_account\",\n *   project_id: \"my-project\",\n *   // ... other fields\n * });\n * ```\n */\nexport function normalizeGCPCredentials(\n  credentials: string | GCPCredentials\n): GCPCredentials {\n  return typeof credentials === \"string\"\n    ? Object.freeze(JSON.parse(credentials))\n    : Object.isFrozen(credentials)\n    ? credentials\n    : Object.freeze(credentials);\n}\n\n/**\n * Imports and returns the private key from GCP credentials for JWT signing.\n *\n * This function extracts the RSA private key from the service account credentials\n * and imports it using the PKCS#8 format with the RS256 algorithm. The returned\n * key can be used to sign JWTs for authentication with Google Cloud services.\n *\n * @param credentials - The GCP service account credentials containing the private key\n * @returns A Promise that resolves to the imported private key suitable for JWT signing\n *\n * @throws {Error} If the private key format is invalid or cannot be imported\n *\n * @example\n * ```typescript\n * const credentials = normalizeGCPCredentials(credentialsJson);\n * const privateKey = await getGCPPrivateKey(credentials);\n * // Use privateKey for signing operations\n * ```\n */\nexport function getGCPPrivateKey(credentials: GCPCredentials) {\n  return importPKCS8(credentials.private_key, \"RS256\");\n}\n\n/**\n * Generates a custom JWT token for authenticating with Google Cloud services.\n *\n * This function creates a signed JWT (JSON Web Token) using the service account's\n * private key. The token includes standard claims such as issuer, audience, subject,\n * issued-at time, and expiration time. This custom token can be exchanged for an\n * access token or ID token through Google's OAuth2 token endpoint.\n *\n * The generated JWT is valid for 1 hour and follows the OAuth 2.0 JWT Bearer\n * Token flow as specified by RFC 7523.\n *\n * @param credentials - The GCP service account credentials used to sign the JWT\n * @returns A Promise that resolves to the signed JWT string\n *\n * @throws {Error} If the private key cannot be imported or the JWT cannot be signed\n *\n * @see https://datatracker.ietf.org/doc/html/rfc7523\n * @see https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials\n *\n * @example\n * ```typescript\n * const credentials = normalizeGCPCredentials(credentialsJson);\n * const customToken = await getGCPCustomToken(credentials);\n * // Use customToken to request an access token\n * ```\n */\nexport async function getGCPCustomToken(credentials: GCPCredentials) {\n  const privateKey = await getGCPPrivateKey(credentials);\n  const customToken = await new SignJWT()\n    .setIssuer(credentials.client_email)\n    .setAudience(credentials.token_uri)\n    .setSubject(credentials.client_email)\n    .setProtectedHeader({ alg: \"RS256\" })\n    .setIssuedAt()\n    .setExpirationTime(\"1h\")\n    .sign(privateKey);\n  return customToken;\n}\n\n/**\n * Retrieves an access token for authenticating with Google Cloud APIs.\n *\n * - Tokens are cached based on the token URI and private key ID\n * - Cache entries are valid for up to 1 hour\n * - Expired tokens trigger automatic refresh\n * - Multiple concurrent requests for the same token are deduplicated\n *\n * The function handles both access tokens and ID tokens, automatically detecting\n * which type is returned by the token endpoint and extracting the appropriate\n * expiration time.\n *\n * @param credentials - The GCP service account credentials used to request the token\n * @returns A Promise that resolves to the access token string\n *\n * @throws {AuthError} If the token request fails (e.g., invalid credentials,\n *                     network error, or API error)\n *\n * @see https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials\n * @see https://datatracker.ietf.org/doc/html/rfc7523\n *\n * @example\n * ```typescript\n * const credentials = normalizeGCPCredentials(credentialsJson);\n * const accessToken = await getGCPCredentialsAccessToken(credentials);\n *\n * // Use the access token in API requests\n * const response = await fetch('https://api.google.com/...', {\n *   headers: {\n *     'Authorization': `Bearer ${accessToken}`\n *   }\n * });\n * ```\n *\n * @remarks\n * The caching mechanism uses a two-level validation:\n * 1. Cache entry age (must be less than CACHE_MAX_AGE)\n * 2. Token expiration time (must not be expired)\n *\n * This ensures that even if a cache entry is fresh, an expired token\n * will trigger a refresh request.\n */\nexport async function getGCPCredentialsAccessToken(\n  credentials: GCPCredentials\n): Promise<string> {\n  const tokenUrl = credentials.token_uri;\n\n  const cacheKeyUrl = new URL(tokenUrl);\n  cacheKeyUrl.searchParams.set(\"key\", credentials.private_key_id);\n  const cacheKey = cacheKeyUrl.toString();\n\n  // Attempt to retrieve the token from the cache\n  const cacheValue = cache.get(cacheKey);\n  let now = Math.floor(Date.now() / 1000);\n\n  if (cacheValue) {\n    if (cacheValue.created > now - CACHE_MAX_AGE) {\n      let token = await cacheValue.promise;\n\n      if (token.expires > now) {\n        return token.token;\n      } else {\n        const nextValue = cache.get(cacheKey);\n\n        if (nextValue && nextValue !== cacheValue) {\n          token = await nextValue.promise;\n          if (token.expires > now) {\n            return token.token;\n          } else {\n            cache.delete(cacheKey);\n          }\n        }\n      }\n    } else {\n      cache.delete(cacheKey);\n    }\n  }\n\n  const promise = iife(async () => {\n    now = Math.floor(Date.now() / 1000);\n\n    // Request a new token from the Google Cloud API\n    const jwt = await getGCPCustomToken(credentials);\n    const body = new URLSearchParams();\n    body.append(\"grant_type\", \"urn:ietf:params:oauth:grant-type:jwt-bearer\");\n    body.append(\"assertion\", jwt);\n    const res = await fetch(tokenUrl, {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n      body,\n    });\n\n    if (!res.ok) {\n      throw await AuthError.fromResponse(res);\n    }\n\n    const data = await res.json();\n\n    if (\"id_token\" in data) {\n      const claims = decodeJwt(data.id_token);\n      return { token: data.id_token, expires: claims.exp as number };\n    }\n\n    const lastModified = res.headers.get(\"last-modified\");\n    const expires = lastModified\n      ? Math.floor(new Date(lastModified).valueOf() / 1000) + data.expires_in\n      : now + data.expires_in;\n\n    return { expires, token: data.access_token };\n  });\n\n  cache.set(cacheKey, { created: now, promise });\n  return await promise.then((data) => data.token);\n}\n"],"mappings":";;;;;;AAoDA,MAAM,wBAAQ,IAAI;AAClB,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BtB,SAAgB,wBACdA,aACgB;AAChB,QAAO,OAAO,gBAAgB,WAC1B,OAAO,OAAO,KAAK,MAAM,YAAY,CAAC,GACtC,OAAO,SAAS,YAAY,GAC5B,cACA,OAAO,OAAO,YAAY;AAC/B;;;;;;;;;;;;;;;;;;;;AAqBD,SAAgB,iBAAiBC,aAA6B;AAC5D,8BAAmB,YAAY,aAAa,QAAQ;AACrD;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BD,eAAsB,kBAAkBA,aAA6B;CACnE,MAAM,aAAa,MAAM,iBAAiB,YAAY;CACtD,MAAM,cAAc,MAAM,IAAIC,eAC3B,UAAU,YAAY,aAAa,CACnC,YAAY,YAAY,UAAU,CAClC,WAAW,YAAY,aAAa,CACpC,mBAAmB,EAAE,KAAK,QAAS,EAAC,CACpC,aAAa,CACb,kBAAkB,KAAK,CACvB,KAAK,WAAW;AACnB,QAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CD,eAAsB,6BACpBD,aACiB;CACjB,MAAM,WAAW,YAAY;CAE7B,MAAM,cAAc,IAAI,IAAI;CAC5B,YAAY,aAAa,IAAI,OAAO,YAAY,eAAe;CAC/D,MAAM,WAAW,YAAY,UAAU;CAGvC,MAAM,aAAa,MAAM,IAAI,SAAS;CACtC,IAAI,MAAM,KAAK,MAAM,KAAK,KAAK,GAAG,IAAK;AAEvC,KAAI,WACF,KAAI,WAAW,UAAU,MAAM,eAAe;EAC5C,IAAI,QAAQ,MAAM,WAAW;AAE7B,MAAI,MAAM,UAAU,IAClB,QAAO,MAAM;OACR;GACL,MAAM,YAAY,MAAM,IAAI,SAAS;AAErC,OAAI,aAAa,cAAc,YAAY;IACzC,QAAQ,MAAM,UAAU;AACxB,QAAI,MAAM,UAAU,IAClB,QAAO,MAAM;SAEb,MAAM,OAAO,SAAS;GAEzB;EACF;CACF,OACC,MAAM,OAAO,SAAS;CAI1B,MAAM,UAAUE,kBAAK,YAAY;EAC/B,MAAM,KAAK,MAAM,KAAK,KAAK,GAAG,IAAK;EAGnC,MAAM,MAAM,MAAM,kBAAkB,YAAY;EAChD,MAAM,OAAO,IAAI;EACjB,KAAK,OAAO,cAAc,8CAA8C;EACxE,KAAK,OAAO,aAAa,IAAI;EAC7B,MAAM,MAAM,MAAM,MAAM,UAAU;GAChC,QAAQ;GACR,SAAS,EAAE,gBAAgB,oCAAqC;GAChE;EACD,EAAC;AAEF,MAAI,CAAC,IAAI,GACP,OAAM,MAAMC,yBAAU,aAAa,IAAI;EAGzC,MAAM,OAAO,MAAM,IAAI,MAAM;AAE7B,MAAI,cAAc,MAAM;GACtB,MAAM,6BAAmB,KAAK,SAAS;AACvC,UAAO;IAAE,OAAO,KAAK;IAAU,SAAS,OAAO;GAAe;EAC/D;EAED,MAAM,eAAe,IAAI,QAAQ,IAAI,gBAAgB;EACrD,MAAM,UAAU,eACZ,KAAK,MAAM,IAAI,KAAK,cAAc,SAAS,GAAG,IAAK,GAAG,KAAK,aAC3D,MAAM,KAAK;AAEf,SAAO;GAAE;GAAS,OAAO,KAAK;EAAc;CAC7C,EAAC;CAEF,MAAM,IAAI,UAAU;EAAE,SAAS;EAAK;CAAS,EAAC;AAC9C,QAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,KAAK,MAAM;AAChD"}

package/dist/utils/gcp-auth.d.cts

@@ -0,0 +1,43 @@
+//#region src/utils/gcp-auth.d.ts
+/**
+ * GCP authentication utilities.
+ *
+ * Adapted from: https://github.com/kriasoft/web-auth-library
+ * Original source: web-auth-library by Kriasoft
+ * License: MIT (https://github.com/kriasoft/web-auth-library/blob/main/LICENSE)
+ */
+/**
+ * Google Cloud Platform service account credentials interface.
+ *
+ * This interface represents the structure of a GCP service account key file,
+ * which is used for authenticating with Google Cloud APIs. Service account
+ * keys can be downloaded from the Google Cloud Console and contain all the
+ * information needed to authenticate as a service account.
+ *
+ * @see https://cloud.google.com/iam/docs/creating-managing-service-account-keys
+ */
+interface GCPCredentials {
+  /** The type of credential, typically "service_account" */
+  type: string;
+  /** The GCP project ID associated with this service account */
+  project_id: string;
+  /** The unique identifier for the private key */
+  private_key_id: string;
+  /** The RSA private key in PEM format used for signing JWTs */
+  private_key: string;
+  /** The unique client ID for this service account */
+  client_id: string;
+  /** The email address of the service account */
+  client_email: string;
+  /** The OAuth2 authorization endpoint URI */
+  auth_uri: string;
+  /** The OAuth2 token endpoint URI where access tokens are requested */
+  token_uri: string;
+  /** The URL for the OAuth2 provider's x509 certificate */
+  auth_provider_x509_cert_url: string;
+  /** The URL for this service account's x509 certificate */
+  client_x509_cert_url: string;
+}
+//#endregion
+export { GCPCredentials };
+//# sourceMappingURL=gcp-auth.d.cts.map

package/dist/utils/gcp-auth.d.ts

@@ -0,0 +1,43 @@
+//#region src/utils/gcp-auth.d.ts
+/**
+ * GCP authentication utilities.
+ *
+ * Adapted from: https://github.com/kriasoft/web-auth-library
+ * Original source: web-auth-library by Kriasoft
+ * License: MIT (https://github.com/kriasoft/web-auth-library/blob/main/LICENSE)
+ */
+/**
+ * Google Cloud Platform service account credentials interface.
+ *
+ * This interface represents the structure of a GCP service account key file,
+ * which is used for authenticating with Google Cloud APIs. Service account
+ * keys can be downloaded from the Google Cloud Console and contain all the
+ * information needed to authenticate as a service account.
+ *
+ * @see https://cloud.google.com/iam/docs/creating-managing-service-account-keys
+ */
+interface GCPCredentials {
+  /** The type of credential, typically "service_account" */
+  type: string;
+  /** The GCP project ID associated with this service account */
+  project_id: string;
+  /** The unique identifier for the private key */
+  private_key_id: string;
+  /** The RSA private key in PEM format used for signing JWTs */
+  private_key: string;
+  /** The unique client ID for this service account */
+  client_id: string;
+  /** The email address of the service account */
+  client_email: string;
+  /** The OAuth2 authorization endpoint URI */
+  auth_uri: string;
+  /** The OAuth2 token endpoint URI where access tokens are requested */
+  token_uri: string;
+  /** The URL for the OAuth2 provider's x509 certificate */
+  auth_provider_x509_cert_url: string;
+  /** The URL for this service account's x509 certificate */
+  client_x509_cert_url: string;
+}
+//#endregion
+export { GCPCredentials };
+//# sourceMappingURL=gcp-auth.d.ts.map

package/dist/utils/gcp-auth.js

@@ -0,0 +1,186 @@
+import { iife } from "./misc.js";
+import { AuthError } from "./errors.js";
+import { SignJWT, decodeJwt, importPKCS8 } from "jose";
+
+//#region src/utils/gcp-auth.ts
+const cache = /* @__PURE__ */ new Map();
+const CACHE_MAX_AGE = 3600;
+/**
+* Normalizes GCP credentials to a frozen GCPCredentials object.
+*
+* This function accepts credentials in either string (JSON) or object format
+* and ensures the returned value is a frozen (immutable) GCPCredentials object.
+* Freezing the credentials prevents accidental modification and ensures
+* consistency throughout the application lifecycle.
+*
+* @param credentials - The GCP service account credentials, either as a JSON string
+*                      or as a GCPCredentials object
+* @returns A frozen GCPCredentials object that cannot be modified
+*
+* @example
+* ```typescript
+* // From JSON string
+* const creds = normalizeGCPCredentials('{"type":"service_account",...}');
+*
+* // From object
+* const creds = normalizeGCPCredentials({
+*   type: "service_account",
+*   project_id: "my-project",
+*   // ... other fields
+* });
+* ```
+*/
+function normalizeGCPCredentials(credentials) {
+	return typeof credentials === "string" ? Object.freeze(JSON.parse(credentials)) : Object.isFrozen(credentials) ? credentials : Object.freeze(credentials);
+}
+/**
+* Imports and returns the private key from GCP credentials for JWT signing.
+*
+* This function extracts the RSA private key from the service account credentials
+* and imports it using the PKCS#8 format with the RS256 algorithm. The returned
+* key can be used to sign JWTs for authentication with Google Cloud services.
+*
+* @param credentials - The GCP service account credentials containing the private key
+* @returns A Promise that resolves to the imported private key suitable for JWT signing
+*
+* @throws {Error} If the private key format is invalid or cannot be imported
+*
+* @example
+* ```typescript
+* const credentials = normalizeGCPCredentials(credentialsJson);
+* const privateKey = await getGCPPrivateKey(credentials);
+* // Use privateKey for signing operations
+* ```
+*/
+function getGCPPrivateKey(credentials) {
+	return importPKCS8(credentials.private_key, "RS256");
+}
+/**
+* Generates a custom JWT token for authenticating with Google Cloud services.
+*
+* This function creates a signed JWT (JSON Web Token) using the service account's
+* private key. The token includes standard claims such as issuer, audience, subject,
+* issued-at time, and expiration time. This custom token can be exchanged for an
+* access token or ID token through Google's OAuth2 token endpoint.
+*
+* The generated JWT is valid for 1 hour and follows the OAuth 2.0 JWT Bearer
+* Token flow as specified by RFC 7523.
+*
+* @param credentials - The GCP service account credentials used to sign the JWT
+* @returns A Promise that resolves to the signed JWT string
+*
+* @throws {Error} If the private key cannot be imported or the JWT cannot be signed
+*
+* @see https://datatracker.ietf.org/doc/html/rfc7523
+* @see https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials
+*
+* @example
+* ```typescript
+* const credentials = normalizeGCPCredentials(credentialsJson);
+* const customToken = await getGCPCustomToken(credentials);
+* // Use customToken to request an access token
+* ```
+*/
+async function getGCPCustomToken(credentials) {
+	const privateKey = await getGCPPrivateKey(credentials);
+	const customToken = await new SignJWT().setIssuer(credentials.client_email).setAudience(credentials.token_uri).setSubject(credentials.client_email).setProtectedHeader({ alg: "RS256" }).setIssuedAt().setExpirationTime("1h").sign(privateKey);
+	return customToken;
+}
+/**
+* Retrieves an access token for authenticating with Google Cloud APIs.
+*
+* - Tokens are cached based on the token URI and private key ID
+* - Cache entries are valid for up to 1 hour
+* - Expired tokens trigger automatic refresh
+* - Multiple concurrent requests for the same token are deduplicated
+*
+* The function handles both access tokens and ID tokens, automatically detecting
+* which type is returned by the token endpoint and extracting the appropriate
+* expiration time.
+*
+* @param credentials - The GCP service account credentials used to request the token
+* @returns A Promise that resolves to the access token string
+*
+* @throws {AuthError} If the token request fails (e.g., invalid credentials,
+*                     network error, or API error)
+*
+* @see https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials
+* @see https://datatracker.ietf.org/doc/html/rfc7523
+*
+* @example
+* ```typescript
+* const credentials = normalizeGCPCredentials(credentialsJson);
+* const accessToken = await getGCPCredentialsAccessToken(credentials);
+*
+* // Use the access token in API requests
+* const response = await fetch('https://api.google.com/...', {
+*   headers: {
+*     'Authorization': `Bearer ${accessToken}`
+*   }
+* });
+* ```
+*
+* @remarks
+* The caching mechanism uses a two-level validation:
+* 1. Cache entry age (must be less than CACHE_MAX_AGE)
+* 2. Token expiration time (must not be expired)
+*
+* This ensures that even if a cache entry is fresh, an expired token
+* will trigger a refresh request.
+*/
+async function getGCPCredentialsAccessToken(credentials) {
+	const tokenUrl = credentials.token_uri;
+	const cacheKeyUrl = new URL(tokenUrl);
+	cacheKeyUrl.searchParams.set("key", credentials.private_key_id);
+	const cacheKey = cacheKeyUrl.toString();
+	const cacheValue = cache.get(cacheKey);
+	let now = Math.floor(Date.now() / 1e3);
+	if (cacheValue) if (cacheValue.created > now - CACHE_MAX_AGE) {
+		let token = await cacheValue.promise;
+		if (token.expires > now) return token.token;
+		else {
+			const nextValue = cache.get(cacheKey);
+			if (nextValue && nextValue !== cacheValue) {
+				token = await nextValue.promise;
+				if (token.expires > now) return token.token;
+				else cache.delete(cacheKey);
+			}
+		}
+	} else cache.delete(cacheKey);
+	const promise = iife(async () => {
+		now = Math.floor(Date.now() / 1e3);
+		const jwt = await getGCPCustomToken(credentials);
+		const body = new URLSearchParams();
+		body.append("grant_type", "urn:ietf:params:oauth:grant-type:jwt-bearer");
+		body.append("assertion", jwt);
+		const res = await fetch(tokenUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body
+		});
+		if (!res.ok) throw await AuthError.fromResponse(res);
+		const data = await res.json();
+		if ("id_token" in data) {
+			const claims = decodeJwt(data.id_token);
+			return {
+				token: data.id_token,
+				expires: claims.exp
+			};
+		}
+		const lastModified = res.headers.get("last-modified");
+		const expires = lastModified ? Math.floor(new Date(lastModified).valueOf() / 1e3) + data.expires_in : now + data.expires_in;
+		return {
+			expires,
+			token: data.access_token
+		};
+	});
+	cache.set(cacheKey, {
+		created: now,
+		promise
+	});
+	return await promise.then((data) => data.token);
+}
+
+//#endregion
+export { getGCPCredentialsAccessToken, normalizeGCPCredentials };
+//# sourceMappingURL=gcp-auth.js.map

package/dist/utils/gcp-auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcp-auth.js","names":["credentials: string | GCPCredentials","credentials: GCPCredentials"],"sources":["../../src/utils/gcp-auth.ts"],"sourcesContent":["/**\n * GCP authentication utilities.\n *\n * Adapted from: https://github.com/kriasoft/web-auth-library\n * Original source: web-auth-library by Kriasoft\n * License: MIT (https://github.com/kriasoft/web-auth-library/blob/main/LICENSE)\n */\n\nimport { decodeJwt, importPKCS8, SignJWT } from \"jose\";\nimport { AuthError } from \"../utils/errors.js\";\nimport { iife } from \"../utils/misc.js\";\n\n/**\n * Google Cloud Platform service account credentials interface.\n *\n * This interface represents the structure of a GCP service account key file,\n * which is used for authenticating with Google Cloud APIs. Service account\n * keys can be downloaded from the Google Cloud Console and contain all the\n * information needed to authenticate as a service account.\n *\n * @see https://cloud.google.com/iam/docs/creating-managing-service-account-keys\n */\nexport interface GCPCredentials {\n  /** The type of credential, typically \"service_account\" */\n  type: string;\n  /** The GCP project ID associated with this service account */\n  project_id: string;\n  /** The unique identifier for the private key */\n  private_key_id: string;\n  /** The RSA private key in PEM format used for signing JWTs */\n  private_key: string;\n  /** The unique client ID for this service account */\n  client_id: string;\n  /** The email address of the service account */\n  client_email: string;\n  /** The OAuth2 authorization endpoint URI */\n  auth_uri: string;\n  /** The OAuth2 token endpoint URI where access tokens are requested */\n  token_uri: string;\n  /** The URL for the OAuth2 provider's x509 certificate */\n  auth_provider_x509_cert_url: string;\n  /** The URL for this service account's x509 certificate */\n  client_x509_cert_url: string;\n}\n\ninterface CacheValue {\n  /** Unix timestamp (in seconds) when this cache entry was created */\n  created: number;\n  /** Promise that resolves to the token and its expiration time */\n  promise: Promise<{ token: string; expires: number }>;\n}\n\nconst cache = new Map<string, CacheValue>();\nconst CACHE_MAX_AGE = 60 * 60; // 1 hour\n\n/**\n * Normalizes GCP credentials to a frozen GCPCredentials object.\n *\n * This function accepts credentials in either string (JSON) or object format\n * and ensures the returned value is a frozen (immutable) GCPCredentials object.\n * Freezing the credentials prevents accidental modification and ensures\n * consistency throughout the application lifecycle.\n *\n * @param credentials - The GCP service account credentials, either as a JSON string\n *                      or as a GCPCredentials object\n * @returns A frozen GCPCredentials object that cannot be modified\n *\n * @example\n * ```typescript\n * // From JSON string\n * const creds = normalizeGCPCredentials('{\"type\":\"service_account\",...}');\n *\n * // From object\n * const creds = normalizeGCPCredentials({\n *   type: \"service_account\",\n *   project_id: \"my-project\",\n *   // ... other fields\n * });\n * ```\n */\nexport function normalizeGCPCredentials(\n  credentials: string | GCPCredentials\n): GCPCredentials {\n  return typeof credentials === \"string\"\n    ? Object.freeze(JSON.parse(credentials))\n    : Object.isFrozen(credentials)\n    ? credentials\n    : Object.freeze(credentials);\n}\n\n/**\n * Imports and returns the private key from GCP credentials for JWT signing.\n *\n * This function extracts the RSA private key from the service account credentials\n * and imports it using the PKCS#8 format with the RS256 algorithm. The returned\n * key can be used to sign JWTs for authentication with Google Cloud services.\n *\n * @param credentials - The GCP service account credentials containing the private key\n * @returns A Promise that resolves to the imported private key suitable for JWT signing\n *\n * @throws {Error} If the private key format is invalid or cannot be imported\n *\n * @example\n * ```typescript\n * const credentials = normalizeGCPCredentials(credentialsJson);\n * const privateKey = await getGCPPrivateKey(credentials);\n * // Use privateKey for signing operations\n * ```\n */\nexport function getGCPPrivateKey(credentials: GCPCredentials) {\n  return importPKCS8(credentials.private_key, \"RS256\");\n}\n\n/**\n * Generates a custom JWT token for authenticating with Google Cloud services.\n *\n * This function creates a signed JWT (JSON Web Token) using the service account's\n * private key. The token includes standard claims such as issuer, audience, subject,\n * issued-at time, and expiration time. This custom token can be exchanged for an\n * access token or ID token through Google's OAuth2 token endpoint.\n *\n * The generated JWT is valid for 1 hour and follows the OAuth 2.0 JWT Bearer\n * Token flow as specified by RFC 7523.\n *\n * @param credentials - The GCP service account credentials used to sign the JWT\n * @returns A Promise that resolves to the signed JWT string\n *\n * @throws {Error} If the private key cannot be imported or the JWT cannot be signed\n *\n * @see https://datatracker.ietf.org/doc/html/rfc7523\n * @see https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials\n *\n * @example\n * ```typescript\n * const credentials = normalizeGCPCredentials(credentialsJson);\n * const customToken = await getGCPCustomToken(credentials);\n * // Use customToken to request an access token\n * ```\n */\nexport async function getGCPCustomToken(credentials: GCPCredentials) {\n  const privateKey = await getGCPPrivateKey(credentials);\n  const customToken = await new SignJWT()\n    .setIssuer(credentials.client_email)\n    .setAudience(credentials.token_uri)\n    .setSubject(credentials.client_email)\n    .setProtectedHeader({ alg: \"RS256\" })\n    .setIssuedAt()\n    .setExpirationTime(\"1h\")\n    .sign(privateKey);\n  return customToken;\n}\n\n/**\n * Retrieves an access token for authenticating with Google Cloud APIs.\n *\n * - Tokens are cached based on the token URI and private key ID\n * - Cache entries are valid for up to 1 hour\n * - Expired tokens trigger automatic refresh\n * - Multiple concurrent requests for the same token are deduplicated\n *\n * The function handles both access tokens and ID tokens, automatically detecting\n * which type is returned by the token endpoint and extracting the appropriate\n * expiration time.\n *\n * @param credentials - The GCP service account credentials used to request the token\n * @returns A Promise that resolves to the access token string\n *\n * @throws {AuthError} If the token request fails (e.g., invalid credentials,\n *                     network error, or API error)\n *\n * @see https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials\n * @see https://datatracker.ietf.org/doc/html/rfc7523\n *\n * @example\n * ```typescript\n * const credentials = normalizeGCPCredentials(credentialsJson);\n * const accessToken = await getGCPCredentialsAccessToken(credentials);\n *\n * // Use the access token in API requests\n * const response = await fetch('https://api.google.com/...', {\n *   headers: {\n *     'Authorization': `Bearer ${accessToken}`\n *   }\n * });\n * ```\n *\n * @remarks\n * The caching mechanism uses a two-level validation:\n * 1. Cache entry age (must be less than CACHE_MAX_AGE)\n * 2. Token expiration time (must not be expired)\n *\n * This ensures that even if a cache entry is fresh, an expired token\n * will trigger a refresh request.\n */\nexport async function getGCPCredentialsAccessToken(\n  credentials: GCPCredentials\n): Promise<string> {\n  const tokenUrl = credentials.token_uri;\n\n  const cacheKeyUrl = new URL(tokenUrl);\n  cacheKeyUrl.searchParams.set(\"key\", credentials.private_key_id);\n  const cacheKey = cacheKeyUrl.toString();\n\n  // Attempt to retrieve the token from the cache\n  const cacheValue = cache.get(cacheKey);\n  let now = Math.floor(Date.now() / 1000);\n\n  if (cacheValue) {\n    if (cacheValue.created > now - CACHE_MAX_AGE) {\n      let token = await cacheValue.promise;\n\n      if (token.expires > now) {\n        return token.token;\n      } else {\n        const nextValue = cache.get(cacheKey);\n\n        if (nextValue && nextValue !== cacheValue) {\n          token = await nextValue.promise;\n          if (token.expires > now) {\n            return token.token;\n          } else {\n            cache.delete(cacheKey);\n          }\n        }\n      }\n    } else {\n      cache.delete(cacheKey);\n    }\n  }\n\n  const promise = iife(async () => {\n    now = Math.floor(Date.now() / 1000);\n\n    // Request a new token from the Google Cloud API\n    const jwt = await getGCPCustomToken(credentials);\n    const body = new URLSearchParams();\n    body.append(\"grant_type\", \"urn:ietf:params:oauth:grant-type:jwt-bearer\");\n    body.append(\"assertion\", jwt);\n    const res = await fetch(tokenUrl, {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n      body,\n    });\n\n    if (!res.ok) {\n      throw await AuthError.fromResponse(res);\n    }\n\n    const data = await res.json();\n\n    if (\"id_token\" in data) {\n      const claims = decodeJwt(data.id_token);\n      return { token: data.id_token, expires: claims.exp as number };\n    }\n\n    const lastModified = res.headers.get(\"last-modified\");\n    const expires = lastModified\n      ? Math.floor(new Date(lastModified).valueOf() / 1000) + data.expires_in\n      : now + data.expires_in;\n\n    return { expires, token: data.access_token };\n  });\n\n  cache.set(cacheKey, { created: now, promise });\n  return await promise.then((data) => data.token);\n}\n"],"mappings":";;;;;AAoDA,MAAM,wBAAQ,IAAI;AAClB,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BtB,SAAgB,wBACdA,aACgB;AAChB,QAAO,OAAO,gBAAgB,WAC1B,OAAO,OAAO,KAAK,MAAM,YAAY,CAAC,GACtC,OAAO,SAAS,YAAY,GAC5B,cACA,OAAO,OAAO,YAAY;AAC/B;;;;;;;;;;;;;;;;;;;;AAqBD,SAAgB,iBAAiBC,aAA6B;AAC5D,QAAO,YAAY,YAAY,aAAa,QAAQ;AACrD;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BD,eAAsB,kBAAkBA,aAA6B;CACnE,MAAM,aAAa,MAAM,iBAAiB,YAAY;CACtD,MAAM,cAAc,MAAM,IAAI,UAC3B,UAAU,YAAY,aAAa,CACnC,YAAY,YAAY,UAAU,CAClC,WAAW,YAAY,aAAa,CACpC,mBAAmB,EAAE,KAAK,QAAS,EAAC,CACpC,aAAa,CACb,kBAAkB,KAAK,CACvB,KAAK,WAAW;AACnB,QAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CD,eAAsB,6BACpBA,aACiB;CACjB,MAAM,WAAW,YAAY;CAE7B,MAAM,cAAc,IAAI,IAAI;CAC5B,YAAY,aAAa,IAAI,OAAO,YAAY,eAAe;CAC/D,MAAM,WAAW,YAAY,UAAU;CAGvC,MAAM,aAAa,MAAM,IAAI,SAAS;CACtC,IAAI,MAAM,KAAK,MAAM,KAAK,KAAK,GAAG,IAAK;AAEvC,KAAI,WACF,KAAI,WAAW,UAAU,MAAM,eAAe;EAC5C,IAAI,QAAQ,MAAM,WAAW;AAE7B,MAAI,MAAM,UAAU,IAClB,QAAO,MAAM;OACR;GACL,MAAM,YAAY,MAAM,IAAI,SAAS;AAErC,OAAI,aAAa,cAAc,YAAY;IACzC,QAAQ,MAAM,UAAU;AACxB,QAAI,MAAM,UAAU,IAClB,QAAO,MAAM;SAEb,MAAM,OAAO,SAAS;GAEzB;EACF;CACF,OACC,MAAM,OAAO,SAAS;CAI1B,MAAM,UAAU,KAAK,YAAY;EAC/B,MAAM,KAAK,MAAM,KAAK,KAAK,GAAG,IAAK;EAGnC,MAAM,MAAM,MAAM,kBAAkB,YAAY;EAChD,MAAM,OAAO,IAAI;EACjB,KAAK,OAAO,cAAc,8CAA8C;EACxE,KAAK,OAAO,aAAa,IAAI;EAC7B,MAAM,MAAM,MAAM,MAAM,UAAU;GAChC,QAAQ;GACR,SAAS,EAAE,gBAAgB,oCAAqC;GAChE;EACD,EAAC;AAEF,MAAI,CAAC,IAAI,GACP,OAAM,MAAM,UAAU,aAAa,IAAI;EAGzC,MAAM,OAAO,MAAM,IAAI,MAAM;AAE7B,MAAI,cAAc,MAAM;GACtB,MAAM,SAAS,UAAU,KAAK,SAAS;AACvC,UAAO;IAAE,OAAO,KAAK;IAAU,SAAS,OAAO;GAAe;EAC/D;EAED,MAAM,eAAe,IAAI,QAAQ,IAAI,gBAAgB;EACrD,MAAM,UAAU,eACZ,KAAK,MAAM,IAAI,KAAK,cAAc,SAAS,GAAG,IAAK,GAAG,KAAK,aAC3D,MAAM,KAAK;AAEf,SAAO;GAAE;GAAS,OAAO,KAAK;EAAc;CAC7C,EAAC;CAEF,MAAM,IAAI,UAAU;EAAE,SAAS;EAAK;CAAS,EAAC;AAC9C,QAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,KAAK,MAAM;AAChD"}

package/dist/utils/handler.cjs

@@ -0,0 +1,67 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const __langchain_core_callbacks_base = require_rolldown_runtime.__toESM(require("@langchain/core/callbacks/base"));
+
+//#region src/utils/handler.ts
+var GoogleRequestCallbackHandler = class extends __langchain_core_callbacks_base.BaseCallbackHandler {
+	customEventInfo(eventName) {
+		const names = eventName.split("-");
+		return {
+			subEvent: names[1],
+			module: names[2]
+		};
+	}
+	handleCustomEvent(eventName, data, runId, tags, metadata) {
+		if (!eventName) return void 0;
+		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)}`);
+		}
+	}
+};
+var GoogleRequestLogger = class extends GoogleRequestCallbackHandler {
+	name = "GoogleRequestLogger";
+	shortenStringLength = 40;
+	log(eventName, data, tags) {
+		const splitLen = this.shortenStringLength;
+		const half = splitLen / 2;
+		const replacer = (_key, value) => {
+			if (typeof value === "string" && splitLen > 0 && value.length > splitLen) return `${value.substring(0, half)}...${value.substring(value.length - half)}`;
+			return value;
+		};
+		const tagStr = tags ? `[${tags}]` : "[]";
+		console.log(`${eventName} ${tagStr} ${JSON.stringify(data, replacer, 1)}`);
+	}
+	handleCustomRequestEvent(eventName, _eventInfo, data, _runId, tags, _metadata) {
+		this.log(eventName, data, tags);
+	}
+	handleCustomResponseEvent(eventName, _eventInfo, data, _runId, tags, _metadata) {
+		this.log(eventName, data, tags);
+	}
+	handleCustomChunkEvent(eventName, _eventInfo, data, _runId, tags, _metadata) {
+		this.log(eventName, data, tags);
+	}
+};
+var GoogleRequestRecorder = class extends GoogleRequestCallbackHandler {
+	name = "GoogleRequestRecorder";
+	request = {};
+	response = {};
+	chunk = [];
+	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);
+	}
+};
+
+//#endregion
+exports.GoogleRequestCallbackHandler = GoogleRequestCallbackHandler;
+exports.GoogleRequestLogger = GoogleRequestLogger;
+exports.GoogleRequestRecorder = GoogleRequestRecorder;
+//# sourceMappingURL=handler.cjs.map

package/dist/utils/handler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.cjs","names":["BaseCallbackHandler","eventName: string","data: any","runId: string","tags?: string[]","metadata?: Record<string, any>","_key: string","value: any","_eventInfo: GoogleCustomEventInfo","_runId: string","_metadata?: Record<string, any>","_eventName: string","_tags?: string[]"],"sources":["../../src/utils/handler.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { BaseCallbackHandler } from \"@langchain/core/callbacks/base\";\n\nexport interface GoogleCustomEventInfo {\n  subEvent: string;\n  module: string;\n}\n\nexport abstract class GoogleRequestCallbackHandler extends BaseCallbackHandler {\n  customEventInfo(eventName: string): GoogleCustomEventInfo {\n    const names = eventName.split(\"-\");\n    return {\n      subEvent: names[1],\n      module: names[2],\n    };\n  }\n\n  abstract handleCustomRequestEvent(\n    eventName: string,\n    eventInfo: GoogleCustomEventInfo,\n    data: any,\n    runId: string,\n    tags?: string[],\n    metadata?: Record<string, any>\n  ): any;\n\n  abstract handleCustomResponseEvent(\n    eventName: string,\n    eventInfo: GoogleCustomEventInfo,\n    data: any,\n    runId: string,\n    tags?: string[],\n    metadata?: Record<string, any>\n  ): any;\n\n  abstract handleCustomChunkEvent(\n    eventName: string,\n    eventInfo: GoogleCustomEventInfo,\n    data: any,\n    runId: string,\n    tags?: string[],\n    metadata?: Record<string, any>\n  ): any;\n\n  handleCustomEvent(\n    eventName: string,\n    data: any,\n    runId: string,\n    tags?: string[],\n    metadata?: Record<string, any>\n  ): any {\n    if (!eventName) {\n      return undefined;\n    }\n    const eventInfo = this.customEventInfo(eventName);\n    switch (eventInfo.subEvent) {\n      case \"request\":\n        return this.handleCustomRequestEvent(\n          eventName,\n          eventInfo,\n          data,\n          runId,\n          tags,\n          metadata\n        );\n      case \"response\":\n        return this.handleCustomResponseEvent(\n          eventName,\n          eventInfo,\n          data,\n          runId,\n          tags,\n          metadata\n        );\n      case \"chunk\":\n        return this.handleCustomChunkEvent(\n          eventName,\n          eventInfo,\n          data,\n          runId,\n          tags,\n          metadata\n        );\n      default:\n        console.error(\n          `Unexpected eventInfo for ${eventName} ${JSON.stringify(\n            eventInfo,\n            null,\n            1\n          )}`\n        );\n    }\n  }\n}\n\nexport class GoogleRequestLogger extends GoogleRequestCallbackHandler {\n  name: string = \"GoogleRequestLogger\";\n\n  shortenStringLength = 40;\n\n  log(eventName: string, data: any, tags?: string[]): undefined {\n    const splitLen = this.shortenStringLength;\n    const half = splitLen / 2;\n    const replacer = (_key: string, value: any) => {\n      if (\n        typeof value === \"string\" &&\n        splitLen > 0 &&\n        value.length > splitLen\n      ) {\n        return `${value.substring(0, half)}...${value.substring(\n          value.length - half\n        )}`;\n      }\n      return value;\n    };\n    const tagStr = tags ? `[${tags}]` : \"[]\";\n    console.log(`${eventName} ${tagStr} ${JSON.stringify(data, replacer, 1)}`);\n  }\n\n  handleCustomRequestEvent(\n    eventName: string,\n    _eventInfo: GoogleCustomEventInfo,\n    data: any,\n    _runId: string,\n    tags?: string[],\n    _metadata?: Record<string, any>\n  ): any {\n    this.log(eventName, data, tags);\n  }\n\n  handleCustomResponseEvent(\n    eventName: string,\n    _eventInfo: GoogleCustomEventInfo,\n    data: any,\n    _runId: string,\n    tags?: string[],\n    _metadata?: Record<string, any>\n  ): any {\n    this.log(eventName, data, tags);\n  }\n\n  handleCustomChunkEvent(\n    eventName: string,\n    _eventInfo: GoogleCustomEventInfo,\n    data: any,\n    _runId: string,\n    tags?: string[],\n    _metadata?: Record<string, any>\n  ): any {\n    this.log(eventName, data, tags);\n  }\n}\n\nexport class GoogleRequestRecorder extends GoogleRequestCallbackHandler {\n  name = \"GoogleRequestRecorder\";\n\n  request: any = {};\n\n  response: any = {};\n\n  chunk: any[] = [];\n\n  handleCustomRequestEvent(\n    _eventName: string,\n    _eventInfo: GoogleCustomEventInfo,\n    data: any,\n    _runId: string,\n    _tags?: string[],\n    _metadata?: Record<string, any>\n  ): any {\n    this.request = data;\n  }\n\n  handleCustomResponseEvent(\n    _eventName: string,\n    _eventInfo: GoogleCustomEventInfo,\n    data: any,\n    _runId: string,\n    _tags?: string[],\n    _metadata?: Record<string, any>\n  ): any {\n    this.response = data;\n  }\n\n  handleCustomChunkEvent(\n    _eventName: string,\n    _eventInfo: GoogleCustomEventInfo,\n    data: any,\n    _runId: string,\n    _tags?: string[],\n    _metadata?: Record<string, any>\n  ): any {\n    this.chunk.push(data);\n  }\n}\n"],"mappings":";;;;AAQA,IAAsB,+BAAtB,cAA2DA,oDAAoB;CAC7E,gBAAgBC,WAA0C;EACxD,MAAM,QAAQ,UAAU,MAAM,IAAI;AAClC,SAAO;GACL,UAAU,MAAM;GAChB,QAAQ,MAAM;EACf;CACF;CA6BD,kBACEA,WACAC,MACAC,OACAC,MACAC,UACK;AACL,MAAI,CAAC,UACH,QAAO;EAET,MAAM,YAAY,KAAK,gBAAgB,UAAU;AACjD,UAAQ,UAAU,UAAlB;GACE,KAAK,UACH,QAAO,KAAK,yBACV,WACA,WACA,MACA,OACA,MACA,SACD;GACH,KAAK,WACH,QAAO,KAAK,0BACV,WACA,WACA,MACA,OACA,MACA,SACD;GACH,KAAK,QACH,QAAO,KAAK,uBACV,WACA,WACA,MACA,OACA,MACA,SACD;GACH,SACE,QAAQ,MACN,CAAC,yBAAyB,EAAE,UAAU,CAAC,EAAE,KAAK,UAC5C,WACA,MACA,EACD,EAAE,CACJ;EACJ;CACF;AACF;AAED,IAAa,sBAAb,cAAyC,6BAA6B;CACpE,OAAe;CAEf,sBAAsB;CAEtB,IAAIJ,WAAmBC,MAAWE,MAA4B;EAC5D,MAAM,WAAW,KAAK;EACtB,MAAM,OAAO,WAAW;EACxB,MAAM,WAAW,CAACE,MAAcC,UAAe;AAC7C,OACE,OAAO,UAAU,YACjB,WAAW,KACX,MAAM,SAAS,SAEf,QAAO,GAAG,MAAM,UAAU,GAAG,KAAK,CAAC,GAAG,EAAE,MAAM,UAC5C,MAAM,SAAS,KAChB,EAAE;AAEL,UAAO;EACR;EACD,MAAM,SAAS,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG;EACpC,QAAQ,IAAI,GAAG,UAAU,CAAC,EAAE,OAAO,CAAC,EAAE,KAAK,UAAU,MAAM,UAAU,EAAE,EAAE,CAAC;CAC3E;CAED,yBACEN,WACAO,YACAN,MACAO,QACAL,MACAM,WACK;EACL,KAAK,IAAI,WAAW,MAAM,KAAK;CAChC;CAED,0BACET,WACAO,YACAN,MACAO,QACAL,MACAM,WACK;EACL,KAAK,IAAI,WAAW,MAAM,KAAK;CAChC;CAED,uBACET,WACAO,YACAN,MACAO,QACAL,MACAM,WACK;EACL,KAAK,IAAI,WAAW,MAAM,KAAK;CAChC;AACF;AAED,IAAa,wBAAb,cAA2C,6BAA6B;CACtE,OAAO;CAEP,UAAe,CAAE;CAEjB,WAAgB,CAAE;CAElB,QAAe,CAAE;CAEjB,yBACEC,YACAH,YACAN,MACAO,QACAG,OACAF,WACK;EACL,KAAK,UAAU;CAChB;CAED,0BACEC,YACAH,YACAN,MACAO,QACAG,OACAF,WACK;EACL,KAAK,WAAW;CACjB;CAED,uBACEC,YACAH,YACAN,MACAO,QACAG,OACAF,WACK;EACL,KAAK,MAAM,KAAK,KAAK;CACtB;AACF"}

package/dist/utils/handler.d.cts

@@ -0,0 +1,34 @@
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+
+//#region src/utils/handler.d.ts
+interface GoogleCustomEventInfo {
+  subEvent: string;
+  module: string;
+}
+declare abstract class GoogleRequestCallbackHandler extends BaseCallbackHandler {
+  customEventInfo(eventName: string): GoogleCustomEventInfo;
+  abstract handleCustomRequestEvent(eventName: string, eventInfo: GoogleCustomEventInfo, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): any;
+  abstract handleCustomResponseEvent(eventName: string, eventInfo: GoogleCustomEventInfo, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): any;
+  abstract handleCustomChunkEvent(eventName: string, eventInfo: GoogleCustomEventInfo, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): any;
+  handleCustomEvent(eventName: string, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): any;
+}
+declare class GoogleRequestLogger extends GoogleRequestCallbackHandler {
+  name: string;
+  shortenStringLength: number;
+  log(eventName: string, data: any, tags?: string[]): undefined;
+  handleCustomRequestEvent(eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, tags?: string[], _metadata?: Record<string, any>): any;
+  handleCustomResponseEvent(eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, tags?: string[], _metadata?: Record<string, any>): any;
+  handleCustomChunkEvent(eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, tags?: string[], _metadata?: Record<string, any>): any;
+}
+declare class GoogleRequestRecorder extends GoogleRequestCallbackHandler {
+  name: string;
+  request: any;
+  response: any;
+  chunk: any[];
+  handleCustomRequestEvent(_eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, _tags?: string[], _metadata?: Record<string, any>): any;
+  handleCustomResponseEvent(_eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, _tags?: string[], _metadata?: Record<string, any>): any;
+  handleCustomChunkEvent(_eventName: string, _eventInfo: GoogleCustomEventInfo, data: any, _runId: string, _tags?: string[], _metadata?: Record<string, any>): any;
+}
+//#endregion
+export { GoogleCustomEventInfo, GoogleRequestCallbackHandler, GoogleRequestLogger, GoogleRequestRecorder };
+//# sourceMappingURL=handler.d.cts.map