@paean-ai/adk 0.2.19 → 0.2.20

package/dist/web/agents/loop_agent.js

@@ -0,0 +1,71 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseAgent } from "./base_agent.js";
+class LoopAgent extends BaseAgent {
+  constructor(config) {
+    var _a;
+    super(config);
+    this.maxIterations = (_a = config.maxIterations) != null ? _a : Number.MAX_SAFE_INTEGER;
+  }
+  runAsyncImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      let iteration = 0;
+      while (iteration < this.maxIterations) {
+        for (const subAgent of this.subAgents) {
+          let shouldExit = false;
+          try {
+            for (var iter = __forAwait(subAgent.runAsync(context)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+              const event = temp.value;
+              yield event;
+              if (event.actions.escalate) {
+                shouldExit = true;
+              }
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+            } finally {
+              if (error)
+                throw error[0];
+            }
+          }
+          if (shouldExit) {
+            return;
+          }
+        }
+        iteration++;
+      }
+      return;
+    });
+  }
+  runLiveImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      throw new Error("This is not supported yet for LoopAgent.");
+    });
+  }
+}
+export {
+  LoopAgent
+};

package/dist/web/agents/parallel_agent.js

@@ -0,0 +1,83 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseAgent } from "./base_agent.js";
+import { InvocationContext } from "./invocation_context.js";
+class ParallelAgent extends BaseAgent {
+  runAsyncImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      const agentRuns = this.subAgents.map(
+        (subAgent) => subAgent.runAsync(
+          createBranchCtxForSubAgent(this, subAgent, context)
+        )
+      );
+      try {
+        for (var iter = __forAwait(mergeAgentRuns(agentRuns)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const event = temp.value;
+          yield event;
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+  runLiveImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      throw new Error("This is not supported yet for ParallelAgent.");
+    });
+  }
+}
+function createBranchCtxForSubAgent(agent, subAgent, originalContext) {
+  const invocationContext = new InvocationContext(originalContext);
+  const branchSuffix = "".concat(agent.name, ".").concat(subAgent.name);
+  invocationContext.branch = invocationContext.branch ? "".concat(invocationContext.branch, ".").concat(branchSuffix) : branchSuffix;
+  return invocationContext;
+}
+function mergeAgentRuns(agentRuns) {
+  return __asyncGenerator(this, null, function* () {
+    const pendingPromises = /* @__PURE__ */ new Map();
+    for (const [index, generator] of agentRuns.entries()) {
+      const promise = generator.next().then((result) => ({ result, index }));
+      pendingPromises.set(index, promise);
+    }
+    while (pendingPromises.size > 0) {
+      const { result, index } = yield new __await(Promise.race(pendingPromises.values()));
+      if (result.done) {
+        pendingPromises.delete(index);
+        continue;
+      }
+      yield result.value;
+      const nextPromise = agentRuns[index].next().then((result2) => ({ result: result2, index }));
+      pendingPromises.set(index, nextPromise);
+    }
+  });
+}
+export {
+  ParallelAgent
+};

package/dist/web/agents/readonly_context.js

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { State } from "../sessions/state.js";
+class ReadonlyContext {
+  constructor(invocationContext) {
+    this.invocationContext = invocationContext;
+  }
+  /**
+   * The user content that started this invocation.
+   */
+  get userContent() {
+    return this.invocationContext.userContent;
+  }
+  /**
+   * The current invocation id.
+   */
+  get invocationId() {
+    return this.invocationContext.invocationId;
+  }
+  /**
+   * The current agent name.
+   */
+  get agentName() {
+    return this.invocationContext.agent.name;
+  }
+  /**
+   * The state of the current session.
+   */
+  get state() {
+    return new State(this.invocationContext.session.state, {});
+  }
+}
+export {
+  ReadonlyContext
+};

package/dist/web/agents/run_config.js

@@ -0,0 +1,54 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from "../utils/logger.js";
+var StreamingMode = /* @__PURE__ */ ((StreamingMode2) => {
+  StreamingMode2["NONE"] = "none";
+  StreamingMode2["SSE"] = "sse";
+  StreamingMode2["BIDI"] = "bidi";
+  return StreamingMode2;
+})(StreamingMode || {});
+function createRunConfig(params = {}) {
+  return __spreadValues({
+    saveInputBlobsAsArtifacts: false,
+    supportCfc: false,
+    enableAffectiveDialog: false,
+    streamingMode: "none" /* NONE */,
+    maxLlmCalls: validateMaxLlmCalls(params.maxLlmCalls || 500)
+  }, params);
+}
+function validateMaxLlmCalls(value) {
+  if (value > Number.MAX_SAFE_INTEGER) {
+    throw new Error(
+      "maxLlmCalls should be less than ".concat(Number.MAX_SAFE_INTEGER, ".")
+    );
+  }
+  if (value <= 0) {
+    logger.warn(
+      "maxLlmCalls is less than or equal to 0. This will result in no enforcement on total number of llm calls that will be made for a run. This may not be ideal, as this could result in a never ending communication between the model and the agent in certain cases."
+    );
+  }
+  return value;
+}
+export {
+  StreamingMode,
+  createRunConfig
+};

package/dist/web/agents/sequential_agent.js

@@ -0,0 +1,99 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionTool } from "../tools/function_tool.js";
+import { BaseAgent } from "./base_agent.js";
+import { LlmAgent } from "./llm_agent.js";
+import { ReadonlyContext } from "./readonly_context.js";
+const TASK_COMPLETED_TOOL_NAME = "task_completed";
+class SequentialAgent extends BaseAgent {
+  runAsyncImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      for (const subAgent of this.subAgents) {
+        try {
+          for (var iter = __forAwait(subAgent.runAsync(context)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const event = temp.value;
+            yield event;
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+      }
+    });
+  }
+  /**
+   * Implementation for live SequentialAgent.
+   *
+   * Compared to the non-live case, live agents process a continuous stream of
+   * audio or video, so there is no way to tell if it's finished and should pass
+   * to the next agent or not. So we introduce a task_completed() function so
+   * the model can call this function to signal that it's finished the task and
+   * we can move on to the next agent.
+   *
+   * @param context: The invocation context of the agent.
+   */
+  runLiveImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      for (const subAgent of this.subAgents) {
+        if (subAgent instanceof LlmAgent) {
+          const agentTools = yield new __await(subAgent.canonicalTools(new ReadonlyContext(context)));
+          const taskCompletedToolAlreadyAdded = agentTools.some((tool) => tool.name === TASK_COMPLETED_TOOL_NAME);
+          if (!taskCompletedToolAlreadyAdded) {
+            subAgent.tools.push(new FunctionTool({
+              name: TASK_COMPLETED_TOOL_NAME,
+              description: "Signals that the model has successfully completed the user's question or task.",
+              execute: () => "Task completion signaled."
+            }));
+            subAgent.instruction += "If you finished the user's request according to its description, call the ".concat(TASK_COMPLETED_TOOL_NAME, " function to exit so the next agents can take over. When calling this function, do not generate any text other than the function call.");
+          }
+        }
+      }
+      for (const subAgent of this.subAgents) {
+        try {
+          for (var iter = __forAwait(subAgent.runLive(context)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const event = temp.value;
+            yield event;
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+      }
+    });
+  }
+}
+export {
+  SequentialAgent
+};

package/dist/web/agents/transcription_entry.js

@@ -0,0 +1,5 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/web/artifacts/base_artifact_service.js

@@ -0,0 +1,5 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/web/artifacts/gcs_artifact_service.js

@@ -0,0 +1,126 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Storage } from "@google-cloud/storage";
+import { createPartFromBase64, createPartFromText } from "@google/genai";
+class GcsArtifactService {
+  constructor(bucket) {
+    this.bucket = new Storage().bucket(bucket);
+  }
+  async saveArtifact(request) {
+    const versions = await this.listVersions(request);
+    const version = versions.length > 0 ? Math.max(...versions) + 1 : 0;
+    const file = this.bucket.file(getFileName(__spreadProps(__spreadValues({}, request), {
+      version
+    })));
+    if (request.artifact.inlineData) {
+      await file.save(JSON.stringify(request.artifact.inlineData.data), {
+        contentType: request.artifact.inlineData.mimeType
+      });
+      return version;
+    }
+    if (request.artifact.text) {
+      await file.save(request.artifact.text, {
+        contentType: "text/plain"
+      });
+      return version;
+    }
+    throw new Error("Artifact must have either inlineData or text.");
+  }
+  async loadArtifact(request) {
+    let version = request.version;
+    if (version === void 0) {
+      const versions = await this.listVersions(request);
+      if (versions.length === 0) {
+        return void 0;
+      }
+      version = Math.max(...versions);
+    }
+    const file = this.bucket.file(getFileName(__spreadProps(__spreadValues({}, request), {
+      version
+    })));
+    const [[metadata], [rawDataBuffer]] = await Promise.all([file.getMetadata(), file.download()]);
+    if (metadata.contentType === "text/plain") {
+      return createPartFromText(rawDataBuffer.toString("utf-8"));
+    }
+    return createPartFromBase64(
+      rawDataBuffer.toString("base64"),
+      metadata.contentType
+    );
+  }
+  async listArtifactKeys(request) {
+    const fileNames = [];
+    const sessionPrefix = "".concat(request.appName, "/").concat(request.userId, "/").concat(request.sessionId, "/");
+    const usernamePrefix = "".concat(request.appName, "/").concat(request.userId, "/user/");
+    const [
+      [sessionFiles],
+      [userSessionFiles]
+    ] = await Promise.all([
+      this.bucket.getFiles({ prefix: sessionPrefix }),
+      this.bucket.getFiles({ prefix: usernamePrefix })
+    ]);
+    for (const file of sessionFiles) {
+      fileNames.push(file.name.split("/").pop());
+    }
+    for (const file of userSessionFiles) {
+      fileNames.push(file.name.split("/").pop());
+    }
+    return fileNames.sort((a, b) => a.localeCompare(b));
+  }
+  async deleteArtifact(request) {
+    const versions = await this.listVersions(request);
+    await Promise.all(versions.map((version) => {
+      const file = this.bucket.file(getFileName(__spreadProps(__spreadValues({}, request), {
+        version
+      })));
+      return file.delete();
+    }));
+    return;
+  }
+  async listVersions(request) {
+    const prefix = getFileName(request);
+    const [files] = await this.bucket.getFiles({ prefix });
+    const versions = [];
+    for (const file of files) {
+      const version = file.name.split("/").pop();
+      versions.push(parseInt(version, 10));
+    }
+    return versions;
+  }
+}
+function getFileName({
+  appName,
+  userId,
+  sessionId,
+  filename,
+  version
+}) {
+  if (filename.startsWith("user:")) {
+    return "".concat(appName, "/").concat(userId, "/user/").concat(filename, "/").concat(version);
+  }
+  return "".concat(appName, "/").concat(userId, "/").concat(sessionId, "/").concat(filename, "/").concat(version);
+}
+export {
+  GcsArtifactService
+};

package/dist/web/artifacts/in_memory_artifact_service.js

@@ -0,0 +1,89 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class InMemoryArtifactService {
+  constructor() {
+    this.artifacts = {};
+  }
+  saveArtifact({
+    appName,
+    userId,
+    sessionId,
+    filename,
+    artifact
+  }) {
+    const path = artifactPath(appName, userId, sessionId, filename);
+    if (!this.artifacts[path]) {
+      this.artifacts[path] = [];
+    }
+    const version = this.artifacts[path].length;
+    this.artifacts[path].push(artifact);
+    return Promise.resolve(version);
+  }
+  loadArtifact({
+    appName,
+    userId,
+    sessionId,
+    filename,
+    version
+  }) {
+    const path = artifactPath(appName, userId, sessionId, filename);
+    const versions = this.artifacts[path];
+    if (!versions) {
+      return Promise.resolve(void 0);
+    }
+    if (version === void 0) {
+      version = versions.length - 1;
+    }
+    return Promise.resolve(versions[version]);
+  }
+  listArtifactKeys({ appName, userId, sessionId }) {
+    const sessionPrefix = "".concat(appName, "/").concat(userId, "/").concat(sessionId, "/");
+    const usernamespacePrefix = "".concat(appName, "/").concat(userId, "/user/");
+    const filenames = [];
+    for (const path in this.artifacts) {
+      if (path.startsWith(sessionPrefix)) {
+        const filename = path.replace(sessionPrefix, "");
+        filenames.push(filename);
+      } else if (path.startsWith(usernamespacePrefix)) {
+        const filename = path.replace(usernamespacePrefix, "");
+        filenames.push(filename);
+      }
+    }
+    return Promise.resolve(filenames.sort());
+  }
+  deleteArtifact({ appName, userId, sessionId, filename }) {
+    const path = artifactPath(appName, userId, sessionId, filename);
+    if (!this.artifacts[path]) {
+      return Promise.resolve();
+    }
+    delete this.artifacts[path];
+    return Promise.resolve();
+  }
+  listVersions({ appName, userId, sessionId, filename }) {
+    const path = artifactPath(appName, userId, sessionId, filename);
+    const artifacts = this.artifacts[path];
+    if (!artifacts) {
+      return Promise.resolve([]);
+    }
+    let versions = [];
+    for (let i = 0; i < artifacts.length; i++) {
+      versions.push(i);
+    }
+    return Promise.resolve(versions);
+  }
+}
+function artifactPath(appName, userId, sessionId, filename) {
+  if (fileHasUserNamespace(filename)) {
+    return "".concat(appName, "/").concat(userId, "/user/").concat(filename);
+  }
+  return "".concat(appName, "/").concat(userId, "/").concat(sessionId, "/").concat(filename);
+}
+function fileHasUserNamespace(filename) {
+  return filename.startsWith("user:");
+}
+export {
+  InMemoryArtifactService
+};

package/dist/web/auth/auth_credential.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var AuthCredentialTypes = /* @__PURE__ */ ((AuthCredentialTypes2) => {
+  AuthCredentialTypes2["API_KEY"] = "apiKey";
+  AuthCredentialTypes2["HTTP"] = "http";
+  AuthCredentialTypes2["OAUTH2"] = "oauth2";
+  AuthCredentialTypes2["OPEN_ID_CONNECT"] = "openIdConnect";
+  AuthCredentialTypes2["SERVICE_ACCOUNT"] = "serviceAccount";
+  return AuthCredentialTypes2;
+})(AuthCredentialTypes || {});
+export {
+  AuthCredentialTypes
+};

package/dist/web/auth/auth_handler.js

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class AuthHandler {
+  constructor(authConfig) {
+    this.authConfig = authConfig;
+  }
+  getAuthResponse(state) {
+    const credentialKey = "temp:" + this.authConfig.credentialKey;
+    return state.get(credentialKey);
+  }
+  generateAuthRequest() {
+    var _a, _b;
+    const authSchemeType = this.authConfig.authScheme.type;
+    if (!["oauth2", "openIdConnect"].includes(authSchemeType)) {
+      return this.authConfig;
+    }
+    if ((_b = (_a = this.authConfig.exchangedAuthCredential) == null ? void 0 : _a.oauth2) == null ? void 0 : _b.authUri) {
+      return this.authConfig;
+    }
+    if (!this.authConfig.rawAuthCredential) {
+      throw new Error("Auth Scheme ".concat(authSchemeType, " requires authCredential."));
+    }
+    if (!this.authConfig.rawAuthCredential.oauth2) {
+      throw new Error(
+        "Auth Scheme ".concat(authSchemeType, " requires oauth2 in authCredential.")
+      );
+    }
+    if (this.authConfig.rawAuthCredential.oauth2.authUri) {
+      return {
+        credentialKey: this.authConfig.credentialKey,
+        authScheme: this.authConfig.authScheme,
+        rawAuthCredential: this.authConfig.rawAuthCredential,
+        exchangedAuthCredential: this.authConfig.rawAuthCredential
+      };
+    }
+    if (!this.authConfig.rawAuthCredential.oauth2.clientId || !this.authConfig.rawAuthCredential.oauth2.clientSecret) {
+      throw new Error("Auth Scheme ".concat(authSchemeType, " requires both clientId and clientSecret in authCredential.oauth2."));
+    }
+    return {
+      credentialKey: this.authConfig.credentialKey,
+      authScheme: this.authConfig.authScheme,
+      rawAuthCredential: this.authConfig.rawAuthCredential,
+      exchangedAuthCredential: this.generateAuthUri()
+    };
+  }
+  /**
+   * Generates an response containing the auth uri for user to sign in.
+   *
+   * @return An AuthCredential object containing the auth URI and state.
+   * @throws Error: If the authorization endpoint is not configured in the
+   *     auth scheme.
+   */
+  generateAuthUri() {
+    return this.authConfig.rawAuthCredential;
+  }
+}
+export {
+  AuthHandler
+};

package/dist/web/auth/auth_schemes.js

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var OAuthGrantType = /* @__PURE__ */ ((OAuthGrantType2) => {
+  OAuthGrantType2["CLIENT_CREDENTIALS"] = "client_credentials";
+  OAuthGrantType2["AUTHORIZATION_CODE"] = "authorization_code";
+  OAuthGrantType2["IMPLICIT"] = "implicit";
+  OAuthGrantType2["PASSWORD"] = "password";
+  return OAuthGrantType2;
+})(OAuthGrantType || {});
+function getOAuthGrantTypeFromFlow(flow) {
+  if (flow.clientCredentials) {
+    return "client_credentials" /* CLIENT_CREDENTIALS */;
+  }
+  if (flow.authorizationCode) {
+    return "authorization_code" /* AUTHORIZATION_CODE */;
+  }
+  if (flow.implicit) {
+    return "implicit" /* IMPLICIT */;
+  }
+  if (flow.password) {
+    return "password" /* PASSWORD */;
+  }
+  return void 0;
+}
+export {
+  OAuthGrantType,
+  getOAuthGrantTypeFromFlow
+};