@softactivate/adk 1.1.0

package/dist/web/artifacts/gcs_artifact_service.js

@@ -0,0 +1,213 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+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";
+import { logger } from "../utils/logger.js";
+class GcsArtifactService {
+  constructor(bucket) {
+    this.bucket = new Storage().bucket(bucket);
+  }
+  async saveArtifact(request) {
+    if (!request.artifact.inlineData && !request.artifact.text) {
+      throw new Error("Artifact must have either inlineData or text content.");
+    }
+    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
+      }))
+    );
+    const metadata = request.customMetadata || {};
+    if (request.artifact.inlineData) {
+      await file.save(
+        Buffer.from(request.artifact.inlineData.data || "", "base64"),
+        {
+          contentType: request.artifact.inlineData.mimeType,
+          metadata
+        }
+      );
+      return version;
+    }
+    await file.save(request.artifact.text, {
+      contentType: "text/plain",
+      metadata
+    });
+    return version;
+  }
+  async loadArtifact(request) {
+    try {
+      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
+      );
+    } catch (e) {
+      logger.warn(
+        "[GcsArtifactService] loadArtifact: Failed to load artifact ".concat(request.filename),
+        e
+      );
+      return void 0;
+    }
+  }
+  async listArtifactKeys(request) {
+    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 })
+    ]);
+    return [
+      ...extractArtifactKeys(sessionFiles, sessionPrefix),
+      ...extractArtifactKeys(userSessionFiles, usernamePrefix, "user:")
+    ].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 searchPrefix = prefix + "/";
+    const [files] = await this.bucket.getFiles({ prefix: searchPrefix });
+    const versions = [];
+    for (const file of files) {
+      const version = file.name.split("/").pop();
+      const v = parseInt(version, 10);
+      if (!isNaN(v)) {
+        versions.push(v);
+      }
+    }
+    return versions.sort((a, b) => a - b);
+  }
+  async listArtifactVersions(request) {
+    const versions = await this.listVersions(request);
+    const artifactVersions = [];
+    for (const version of versions) {
+      const artifactVersion = await this.getArtifactVersion(__spreadProps(__spreadValues({}, request), {
+        version
+      }));
+      if (artifactVersion) {
+        artifactVersions.push(artifactVersion);
+      }
+    }
+    return artifactVersions;
+  }
+  async getArtifactVersion(request) {
+    try {
+      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] = await file.getMetadata();
+      return {
+        version,
+        mimeType: metadata.contentType,
+        customMetadata: metadata.metadata,
+        canonicalUri: file.publicUrl()
+      };
+    } catch (e) {
+      logger.warn(
+        "[GcsArtifactService] getArtifactVersion: Failed to get artifact version for userId: ".concat(request.userId, " sessionId: ").concat(request.sessionId, " filename: ").concat(request.filename, " version: ").concat(request.version),
+        e
+      );
+      return void 0;
+    }
+  }
+}
+function getFileName({
+  appName,
+  userId,
+  sessionId,
+  filename,
+  version
+}) {
+  const isUser = filename.startsWith("user:");
+  const cleanFilename = isUser ? filename.substring(5) : filename;
+  const prefix = isUser ? "".concat(appName, "/").concat(userId, "/user/").concat(cleanFilename) : "".concat(appName, "/").concat(userId, "/").concat(sessionId, "/").concat(cleanFilename);
+  return version !== void 0 ? "".concat(prefix, "/").concat(version) : prefix;
+}
+function extractArtifactKeys(files, fileNamePrefix, keyPrefix = "") {
+  const keys = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (!file.name.startsWith(fileNamePrefix)) {
+      continue;
+    }
+    const relative = file.name.substring(fileNamePrefix.length);
+    const name = getFileNameFromPath(relative);
+    keys.add("".concat(keyPrefix).concat(name));
+  }
+  return [...keys];
+}
+function getFileNameFromPath(filePath) {
+  const parts = filePath.split("/");
+  if (parts.length < 2) {
+    return filePath;
+  }
+  return parts.slice(0, -1).join("/");
+}
+export {
+  GcsArtifactService
+};

package/dist/web/artifacts/in_memory_artifact_service.js

@@ -0,0 +1,152 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isInMemoryConnectionString(uri) {
+  return uri === "memory://";
+}
+class InMemoryArtifactService {
+  constructor() {
+    this.artifacts = {};
+  }
+  saveArtifact({
+    appName,
+    userId,
+    sessionId,
+    filename,
+    artifact,
+    customMetadata
+  }) {
+    if (!artifact.inlineData && !artifact.text) {
+      return Promise.reject(
+        new Error("Artifact must have either inlineData or text content.")
+      );
+    }
+    const path = artifactPath(appName, userId, sessionId, filename);
+    if (!this.artifacts[path]) {
+      this.artifacts[path] = [];
+    }
+    const version = this.artifacts[path].length;
+    const metadata = {
+      version,
+      customMetadata
+    };
+    this.artifacts[path].push({ part: artifact, metadata });
+    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].part);
+  }
+  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([]);
+    }
+    const versions = [];
+    for (let i = 0; i < artifacts.length; i++) {
+      versions.push(i);
+    }
+    return Promise.resolve(versions);
+  }
+  listArtifactVersions({
+    appName,
+    userId,
+    sessionId,
+    filename
+  }) {
+    const path = artifactPath(appName, userId, sessionId, filename);
+    const artifacts = this.artifacts[path];
+    if (!artifacts) {
+      return Promise.resolve([]);
+    }
+    return Promise.resolve(artifacts.map((a) => a.metadata));
+  }
+  getArtifactVersion({
+    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;
+    }
+    if (versions[version]) {
+      return Promise.resolve(versions[version].metadata);
+    }
+    return Promise.resolve(void 0);
+  }
+}
+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,
+  isInMemoryConnectionString
+};

package/dist/web/artifacts/registry.js

@@ -0,0 +1,30 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FileArtifactService } from "./file_artifact_service.js";
+import { GcsArtifactService } from "./gcs_artifact_service.js";
+import {
+  InMemoryArtifactService,
+  isInMemoryConnectionString
+} from "./in_memory_artifact_service.js";
+function getArtifactServiceFromUri(uri) {
+  if (isInMemoryConnectionString(uri)) {
+    return new InMemoryArtifactService();
+  }
+  if (uri.startsWith("gs://")) {
+    const bucket = uri.split("://")[1];
+    return new GcsArtifactService(bucket);
+  }
+  if (uri.startsWith("file://")) {
+    const rootDir = uri.split("://")[1];
+    return new FileArtifactService(rootDir);
+  }
+  throw new Error("Unsupported artifact service URI: ".concat(uri));
+}
+export {
+  getArtifactServiceFromUri
+};

package/dist/web/auth/auth_credential.js

@@ -0,0 +1,18 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @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,148 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+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 { randomUUID } from "../utils/env_aware_utils.js";
+import { OAuth2CredentialExchanger } from "./oauth2/oauth2_credential_exchanger.js";
+class AuthHandler {
+  constructor(authConfig) {
+    this.authConfig = authConfig;
+  }
+  getAuthResponse(state) {
+    const credentialKey = "temp:" + this.authConfig.credentialKey;
+    return state.get(credentialKey);
+  }
+  async parseAndStoreAuthResponse(state) {
+    const credentialKey = "temp:" + this.authConfig.credentialKey;
+    const authSchemeType = this.authConfig.authScheme.type;
+    if (!["oauth2", "openIdConnect"].includes(authSchemeType)) {
+      state.set(credentialKey, this.authConfig.exchangedAuthCredential);
+      return;
+    }
+    if (this.authConfig.exchangedAuthCredential) {
+      const exchanger = new OAuth2CredentialExchanger();
+      const exchangedCredential = await exchanger.exchange({
+        authCredential: this.authConfig.exchangedAuthCredential,
+        authScheme: this.authConfig.authScheme
+      });
+      state.set(credentialKey, exchangedCredential.credential);
+    }
+  }
+  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() {
+    const authScheme = this.authConfig.authScheme;
+    const authCredential = this.authConfig.rawAuthCredential;
+    if (!authCredential || !authCredential.oauth2) {
+      return authCredential;
+    }
+    let authorizationEndpoint = "";
+    let scopes = [];
+    if ("authorizationEndpoint" in authScheme) {
+      authorizationEndpoint = authScheme.authorizationEndpoint;
+      scopes = authScheme.scopes || [];
+    } else if (authScheme.type === "oauth2" && authScheme.flows) {
+      const flows = authScheme.flows;
+      const flow = flows.implicit || flows.authorizationCode || flows.clientCredentials || flows.password;
+      if (flow) {
+        if ("authorizationUrl" in flow && flow.authorizationUrl) {
+          authorizationEndpoint = flow.authorizationUrl;
+        } else if ("tokenUrl" in flow && flow.tokenUrl) {
+          authorizationEndpoint = flow.tokenUrl;
+        }
+        if (flow.scopes) {
+          scopes = Object.keys(flow.scopes);
+        }
+      }
+    }
+    if (!authorizationEndpoint) {
+      throw new Error("Authorization endpoint not configured in auth scheme.");
+    }
+    const state = randomUUID();
+    const url = new URL(authorizationEndpoint);
+    url.searchParams.set("client_id", authCredential.oauth2.clientId || "");
+    url.searchParams.set(
+      "redirect_uri",
+      authCredential.oauth2.redirectUri || ""
+    );
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("scope", scopes.join(" "));
+    url.searchParams.set("state", state);
+    url.searchParams.set("access_type", "offline");
+    url.searchParams.set("prompt", "consent");
+    const exchangedAuthCredential = __spreadProps(__spreadValues({}, authCredential), {
+      oauth2: __spreadProps(__spreadValues({}, authCredential.oauth2), {
+        authUri: url.toString(),
+        state
+      })
+    });
+    return exchangedAuthCredential;
+  }
+}
+export {
+  AuthHandler
+};