@intuned/browser-dev 2.2.3-unify-sdks.20

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { sanitizeHtml } from "./helpers/sanitizeHtml";
+export { downloadFile } from "./helpers/downloadFile";
+export { saveFileToS3 } from "./helpers/saveFileToS3";
+export { filterEmptyValues } from "./helpers/filterEmptyValues";
+export { goToUrl } from "./helpers/gotoUrl";
+export { processDate } from "./helpers/processDate";
+export { resolveUrl } from "./helpers/resolveUrl";
+export { uploadFileToS3 } from "./helpers/uploadFileToS3";
+export { validateDataUsingSchema } from "./helpers/validateDataUsingSchema";
+export { waitForDomSettled } from "./helpers/waitForDomSettled";
+export { waitForNetworkIdle } from "./helpers/waitForNetworkIdle";

package/dist/index.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "downloadFile", {
+  enumerable: true,
+  get: function () {
+    return _helpers.downloadFile;
+  }
+});
+Object.defineProperty(exports, "extractMarkdown", {
+  enumerable: true,
+  get: function () {
+    return _helpers.extractMarkdown;
+  }
+});
+Object.defineProperty(exports, "filterEmptyValues", {
+  enumerable: true,
+  get: function () {
+    return _helpers.filterEmptyValues;
+  }
+});
+Object.defineProperty(exports, "goToUrl", {
+  enumerable: true,
+  get: function () {
+    return _helpers.goToUrl;
+  }
+});
+Object.defineProperty(exports, "processDate", {
+  enumerable: true,
+  get: function () {
+    return _helpers.processDate;
+  }
+});
+Object.defineProperty(exports, "resolveUrl", {
+  enumerable: true,
+  get: function () {
+    return _helpers.resolveUrl;
+  }
+});
+Object.defineProperty(exports, "sanitizeHtml", {
+  enumerable: true,
+  get: function () {
+    return _helpers.sanitizeHtml;
+  }
+});
+Object.defineProperty(exports, "saveFileToS3", {
+  enumerable: true,
+  get: function () {
+    return _helpers.saveFileToS3;
+  }
+});
+Object.defineProperty(exports, "scrollToLoadContent", {
+  enumerable: true,
+  get: function () {
+    return _helpers.scrollToLoadContent;
+  }
+});
+Object.defineProperty(exports, "uploadFileToS3", {
+  enumerable: true,
+  get: function () {
+    return _helpers.uploadFileToS3;
+  }
+});
+Object.defineProperty(exports, "validateDataUsingSchema", {
+  enumerable: true,
+  get: function () {
+    return _helpers.validateDataUsingSchema;
+  }
+});
+Object.defineProperty(exports, "waitForDomSettled", {
+  enumerable: true,
+  get: function () {
+    return _helpers.waitForDomSettled;
+  }
+});
+Object.defineProperty(exports, "waitForNetworkIdle", {
+  enumerable: true,
+  get: function () {
+    return _helpers.waitForNetworkIdle;
+  }
+});
+var _helpers = require("./helpers");

package/dist/intunedServices/ApiGateway/aiApiGateway.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.APIGateway = void 0;
+var _getModelProvider = require("../../common/getModelProvider");
+var _Anthropic = require("./providers/Anthropic");
+var _OpenAI = require("./providers/OpenAI");
+var _Gemini = require("./providers/Gemini");
+class APIGateway {
+  constructor() {
+    this.config = this.getDefaultConfig();
+    this.validateConfig(this.config);
+  }
+  validateConfig(config) {
+    if (!config.functionsDomain || !config.workspaceId || !config.integrationId) {
+      throw new Error("Gateway configuration is incomplete. " + "Please provide functionsDomain, workspaceId, and integrationId");
+    }
+  }
+  getDefaultConfig() {
+    return {
+      functionsDomain: process.env.FUNCTIONS_DOMAIN,
+      workspaceId: process.env.INTUNED_WORKSPACE_ID,
+      integrationId: process.env.INTUNED_INTEGRATION_ID
+    };
+  }
+  detectProvider(model) {
+    const modelLower = model.toLowerCase();
+    return (0, _getModelProvider.getModelProvider)(modelLower);
+  }
+  buildGatewayUrl(provider) {
+    var _this$config;
+    const baseDomain = (_this$config = this.config) === null || _this$config === void 0 || (_this$config = _this$config.functionsDomain) === null || _this$config === void 0 ? void 0 : _this$config.replace(/\/$/, "");
+    return `${baseDomain}/api/${this.config.workspaceId}/functions/${this.config.integrationId}/${provider === "anthropic" ? "anthropic/v1" : provider === "google_vertexai" ? "google_vertexai/v1beta" : provider}`;
+  }
+  getModelConfig(model, options) {
+    const {
+      apiKey,
+      extraHeaders
+    } = options;
+    if (apiKey) {
+      return {
+        model,
+        apiKey,
+        extraHeaders,
+        baseUrl: undefined
+      };
+    }
+    const provider = this.detectProvider(model);
+    const baseUrl = this.buildGatewayUrl(provider);
+    return {
+      model,
+      apiKey: "--THI_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+      extraHeaders,
+      baseUrl
+    };
+  }
+  createProviderInstance(model, apiKey, extraHeaders) {
+    const config = this.getModelConfig(model, {
+      apiKey,
+      extraHeaders
+    });
+    const provider = this.detectProvider(model);
+    const input = {
+      apiKey: config.apiKey,
+      headers: config.extraHeaders,
+      model: config.model,
+      baseUrl: config.baseUrl
+    };
+    const providerFactories = {
+      anthropic: () => (0, _Anthropic.createAnthropicInstance)(input),
+      openai: () => (0, _OpenAI.createOpenAIInstance)(input),
+      google_vertexai: () => (0, _Gemini.createGoogleInstance)(input)
+    };
+    const factory = providerFactories[provider];
+    if (!factory) {
+      throw new Error(`Unsupported provider: ${provider}`);
+    }
+    return factory();
+  }
+  getModel(model, apiKey, extraHeaders) {
+    const providerInstance = this.createProviderInstance(model, apiKey, extraHeaders);
+    return providerInstance.chat(model);
+  }
+}
+exports.APIGateway = APIGateway;

package/dist/intunedServices/ApiGateway/factory.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GatewayFactory = void 0;
+var _aiApiGateway = require("./aiApiGateway");
+class GatewayFactory {
+  static createAIGateway() {
+    return new _aiApiGateway.APIGateway();
+  }
+}
+exports.GatewayFactory = GatewayFactory;

package/dist/intunedServices/ApiGateway/providers/Anthropic.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAnthropicInstance = void 0;
+var _anthropic = require("@ai-sdk/anthropic");
+var _jwtTokenManager = require("../../../common/jwtTokenManager");
+const createAnthropicInstance = input => {
+  const {
+    apiKey,
+    baseUrl
+  } = input;
+  if (apiKey && baseUrl === undefined) {
+    return (0, _anthropic.createAnthropic)({
+      apiKey
+    });
+  } else {
+    return (0, _anthropic.createAnthropic)({
+      apiKey: "--THI_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+      baseURL: baseUrl,
+      fetch: _jwtTokenManager.backendFunctionsTokenManager.fetchWithToken.bind(_jwtTokenManager.backendFunctionsTokenManager)
+    });
+  }
+};
+exports.createAnthropicInstance = createAnthropicInstance;

package/dist/intunedServices/ApiGateway/providers/Gemini.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGoogleInstance = void 0;
+var _google = require("@ai-sdk/google");
+var _jwtTokenManager = require("../../../common/jwtTokenManager");
+const createGoogleInstance = input => {
+  const {
+    apiKey,
+    headers,
+    baseUrl
+  } = input;
+  if (apiKey && baseUrl === undefined) {
+    return (0, _google.createGoogleGenerativeAI)({
+      apiKey,
+      headers
+    });
+  } else {
+    return (0, _google.createGoogleGenerativeAI)({
+      apiKey: "--THI_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+      headers,
+      baseURL: baseUrl,
+      fetch: _jwtTokenManager.backendFunctionsTokenManager.fetchWithToken.bind(_jwtTokenManager.backendFunctionsTokenManager)
+    });
+  }
+};
+exports.createGoogleInstance = createGoogleInstance;

package/dist/intunedServices/ApiGateway/providers/OpenAI.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createOpenAIInstance = void 0;
+var _openai = require("@ai-sdk/openai");
+var _jwtTokenManager = require("../../../common/jwtTokenManager");
+const createOpenAIInstance = input => {
+  const {
+    apiKey,
+    headers,
+    baseUrl
+  } = input;
+  if (apiKey && baseUrl === undefined) {
+    return (0, _openai.createOpenAI)({
+      apiKey,
+      headers
+    });
+  } else {
+    return (0, _openai.createOpenAI)({
+      apiKey: "--THI_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+      headers,
+      baseURL: baseUrl,
+      fetch: _jwtTokenManager.backendFunctionsTokenManager.fetchWithToken.bind(_jwtTokenManager.backendFunctionsTokenManager)
+    });
+  }
+};
+exports.createOpenAIInstance = createOpenAIInstance;

package/dist/intunedServices/ApiGateway/tests/testApiGateway.spec.js

@@ -0,0 +1,221 @@
+"use strict";
+
+var _extendedTest = require("../../../common/extendedTest");
+var _vitest = require("vitest");
+var _aiApiGateway = require("../aiApiGateway");
+var _getModelProvider = require("../../../common/getModelProvider");
+var _Anthropic = require("../providers/Anthropic");
+var _OpenAI = require("../providers/OpenAI");
+var _Gemini = require("../providers/Gemini");
+_vitest.vi.mock("../../../common/jwtTokenManager", () => ({
+  backendFunctionsTokenManager: {
+    fetchWithToken: _vitest.vi.fn()
+  }
+}));
+_vitest.vi.mock("../../../common/getModelProvider", () => ({
+  getModelProvider: _vitest.vi.fn()
+}));
+_vitest.vi.mock("../providers/Anthropic", () => ({
+  createAnthropicInstance: _vitest.vi.fn()
+}));
+_vitest.vi.mock("../providers/OpenAI", () => ({
+  createOpenAIInstance: _vitest.vi.fn()
+}));
+_vitest.vi.mock("../providers/Gemini", () => ({
+  createGoogleInstance: _vitest.vi.fn()
+}));
+const mockGetModelProvider = _vitest.vi.mocked(_getModelProvider.getModelProvider);
+const mockCreateAnthropicInstance = _vitest.vi.mocked(_Anthropic.createAnthropicInstance);
+const mockCreateOpenAIInstance = _vitest.vi.mocked(_OpenAI.createOpenAIInstance);
+const mockCreateGoogleInstance = _vitest.vi.mocked(_Gemini.createGoogleInstance);
+(0, _extendedTest.describe)("APIGateway", () => {
+  let originalEnv;
+  let gateway;
+  (0, _extendedTest.beforeEach)(() => {
+    originalEnv = process.env;
+    process.env = {
+      ...originalEnv,
+      FUNCTIONS_DOMAIN: "https://functions.example.com",
+      INTUNED_WORKSPACE_ID: "workspace123",
+      INTUNED_INTEGRATION_ID: "integration456"
+    };
+    gateway = new _aiApiGateway.APIGateway();
+    _vitest.vi.clearAllMocks();
+  });
+  (0, _extendedTest.afterEach)(() => {
+    process.env = originalEnv;
+  });
+  (0, _extendedTest.describe)("constructor and config", () => {
+    (0, _extendedTest.it)("should initialize with default config from environment", () => {
+      (0, _extendedTest.expect)(gateway["config"]).toEqual({
+        functionsDomain: "https://functions.example.com",
+        workspaceId: "workspace123",
+        integrationId: "integration456"
+      });
+    });
+  });
+  (0, _extendedTest.describe)("detectProvider", () => {
+    (0, _extendedTest.it)("should detect openai models", () => {
+      mockGetModelProvider.mockReturnValue("openai");
+      (0, _extendedTest.expect)(gateway["detectProvider"]("gpt-4")).toBe("openai");
+      (0, _extendedTest.expect)(mockGetModelProvider).toHaveBeenCalledWith("gpt-4");
+    });
+    (0, _extendedTest.it)("should detect anthropic models", () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
+      (0, _extendedTest.expect)(gateway["detectProvider"]("claude-3-sonnet")).toBe("anthropic");
+      (0, _extendedTest.expect)(mockGetModelProvider).toHaveBeenCalledWith("claude-3-sonnet");
+    });
+    (0, _extendedTest.it)("should handle case insensitive models", () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
+      (0, _extendedTest.expect)(gateway["detectProvider"]("CLAUDE-3-OPUS")).toBe("anthropic");
+      (0, _extendedTest.expect)(mockGetModelProvider).toHaveBeenCalledWith("claude-3-opus");
+    });
+    (0, _extendedTest.it)("should return unknown for unsupported models", () => {
+      mockGetModelProvider.mockReturnValue("unknown");
+      (0, _extendedTest.expect)(gateway["detectProvider"]("unknown-model")).toBe("unknown");
+    });
+  });
+  (0, _extendedTest.describe)("buildGatewayUrl", () => {
+    (0, _extendedTest.it)("should build correct URL for anthropic", () => {
+      const result = gateway["buildGatewayUrl"]("anthropic");
+      (0, _extendedTest.expect)(result).toBe("https://functions.example.com/api/workspace123/functions/integration456/anthropic/v1");
+    });
+    (0, _extendedTest.it)("should build correct URL for google_vertexai", () => {
+      const result = gateway["buildGatewayUrl"]("google_vertexai");
+      (0, _extendedTest.expect)(result).toBe("https://functions.example.com/api/workspace123/functions/integration456/google_vertexai/v1beta");
+    });
+    (0, _extendedTest.it)("should build correct URL for other providers", () => {
+      const result = gateway["buildGatewayUrl"]("openai");
+      (0, _extendedTest.expect)(result).toBe("https://functions.example.com/api/workspace123/functions/integration456/openai");
+    });
+    (0, _extendedTest.it)("should strip trailing slash from domain", () => {
+      process.env.FUNCTIONS_DOMAIN = "https://functions.example.com/";
+      const newGateway = new _aiApiGateway.APIGateway();
+      const result = newGateway["buildGatewayUrl"]("openai");
+      (0, _extendedTest.expect)(result).toBe("https://functions.example.com/api/workspace123/functions/integration456/openai");
+    });
+    (0, _extendedTest.it)("should throw error for incomplete config", () => {
+      delete process.env.FUNCTIONS_DOMAIN;
+      (0, _extendedTest.expect)(() => new _aiApiGateway.APIGateway()).toThrow("Gateway configuration is incomplete");
+    });
+  });
+  (0, _extendedTest.describe)("getModelConfig", () => {
+    (0, _extendedTest.it)("should return direct mode config when API key provided", () => {
+      const config = gateway.getModelConfig("claude-3-sonnet", {
+        apiKey: "sk-test123",
+        extraHeaders: {
+          "Custom-Header": "value"
+        }
+      });
+      (0, _extendedTest.expect)(config).toEqual({
+        model: "claude-3-sonnet",
+        apiKey: "sk-test123",
+        extraHeaders: {
+          "Custom-Header": "value"
+        },
+        baseUrl: undefined
+      });
+    });
+    (0, _extendedTest.it)("should return gateway mode config when no API key", () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
+      const config = gateway.getModelConfig("claude-3-sonnet", {
+        apiKey: undefined,
+        extraHeaders: {
+          "Custom-Header": "value"
+        }
+      });
+      (0, _extendedTest.expect)(config).toEqual({
+        model: "claude-3-sonnet",
+        apiKey: "--THI_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+        extraHeaders: {
+          "Custom-Header": "value"
+        },
+        baseUrl: "https://functions.example.com/api/workspace123/functions/integration456/anthropic/v1"
+      });
+    });
+  });
+  (0, _extendedTest.describe)("createProviderInstance", () => {
+    (0, _extendedTest.it)("should create anthropic instance", () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
+      const mockInstance = {
+        chat: _vitest.vi.fn()
+      };
+      mockCreateAnthropicInstance.mockReturnValue(mockInstance);
+      const result = gateway.createProviderInstance("claude-3-sonnet");
+      (0, _extendedTest.expect)(mockCreateAnthropicInstance).toHaveBeenCalledWith({
+        apiKey: "--THI_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+        headers: undefined,
+        model: "claude-3-sonnet",
+        baseUrl: "https://functions.example.com/api/workspace123/functions/integration456/anthropic/v1"
+      });
+      (0, _extendedTest.expect)(result).toBe(mockInstance);
+    });
+    (0, _extendedTest.it)("should create openai instance", () => {
+      mockGetModelProvider.mockReturnValue("openai");
+      const mockInstance = {
+        chat: _vitest.vi.fn()
+      };
+      mockCreateOpenAIInstance.mockReturnValue(mockInstance);
+      const result = gateway.createProviderInstance("gpt-4", "sk-test123");
+      (0, _extendedTest.expect)(mockCreateOpenAIInstance).toHaveBeenCalledWith({
+        apiKey: "sk-test123",
+        headers: undefined,
+        model: "gpt-4",
+        baseUrl: undefined
+      });
+      (0, _extendedTest.expect)(result).toBe(mockInstance);
+    });
+    (0, _extendedTest.it)("should create google instance", () => {
+      mockGetModelProvider.mockReturnValue("google_vertexai");
+      const mockInstance = {
+        chat: _vitest.vi.fn()
+      };
+      mockCreateGoogleInstance.mockReturnValue(mockInstance);
+      const result = gateway.createProviderInstance("gemini-pro");
+      (0, _extendedTest.expect)(mockCreateGoogleInstance).toHaveBeenCalled();
+      (0, _extendedTest.expect)(result).toBe(mockInstance);
+    });
+    (0, _extendedTest.it)("should throw error for unsupported provider", () => {
+      mockGetModelProvider.mockReturnValue("unknown");
+      (0, _extendedTest.expect)(() => gateway.createProviderInstance("unknown-model")).toThrow("Unsupported provider: unknown");
+    });
+  });
+  (0, _extendedTest.describe)("getModel", () => {
+    (0, _extendedTest.it)("should return language model from provider instance", () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
+      const mockModelInstance = {
+        generate: _vitest.vi.fn()
+      };
+      const mockProviderInstance = {
+        chat: _vitest.vi.fn().mockReturnValue(mockModelInstance)
+      };
+      mockCreateAnthropicInstance.mockReturnValue(mockProviderInstance);
+      const result = gateway.getModel("claude-3-sonnet");
+      (0, _extendedTest.expect)(mockProviderInstance.chat).toHaveBeenCalledWith("claude-3-sonnet");
+      (0, _extendedTest.expect)(result).toBe(mockModelInstance);
+    });
+    (0, _extendedTest.it)("should pass through API key and headers", () => {
+      mockGetModelProvider.mockReturnValue("openai");
+      const mockModelInstance = {
+        generate: _vitest.vi.fn()
+      };
+      const mockProviderInstance = {
+        chat: _vitest.vi.fn().mockReturnValue(mockModelInstance)
+      };
+      mockCreateOpenAIInstance.mockReturnValue(mockProviderInstance);
+      const result = gateway.getModel("gpt-4", "sk-test123", {
+        "Custom-Header": "value"
+      });
+      (0, _extendedTest.expect)(mockCreateOpenAIInstance).toHaveBeenCalledWith({
+        apiKey: "sk-test123",
+        headers: {
+          "Custom-Header": "value"
+        },
+        model: "gpt-4",
+        baseUrl: undefined
+      });
+      (0, _extendedTest.expect)(mockProviderInstance.chat).toHaveBeenCalledWith("gpt-4");
+      (0, _extendedTest.expect)(result).toBe(mockModelInstance);
+    });
+  });
+});

package/dist/intunedServices/ApiGateway/types.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GatewayMode = void 0;
+let GatewayMode = exports.GatewayMode = function (GatewayMode) {
+  GatewayMode["DIRECT"] = "direct";
+  GatewayMode["GATEWAY"] = "gateway";
+  return GatewayMode;
+}({});

package/dist/intunedServices/cache/cache.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cache = void 0;
+var _zod = require("zod");
+var _jwtTokenManager = require("../../common/jwtTokenManager");
+var _Logger = require("../../common/Logger");
+const forbiddenCharacters = /[:#]/g;
+const keySchema = _zod.z.string().min(1, "Key must be at least 1 character long").refine(key => {
+  var _key$match;
+  return (((_key$match = key.match(forbiddenCharacters)) === null || _key$match === void 0 ? void 0 : _key$match.length) ?? 0) === 0;
+}, 'Key cannot contain the following characters: ":" or "#"');
+class Cache {
+  async get(key) {
+    try {
+      const parsedKey = keySchema.parse(key);
+      const response = await (0, _jwtTokenManager.callBackendFunctionWithToken)(`cache/${parsedKey}`, {
+        method: "GET"
+      });
+      const contentType = response.headers.get("content-type");
+      if (!(contentType !== null && contentType !== void 0 && contentType.includes("application/json"))) {
+        const responseText = await response.text();
+        throw new Error(`Server returned ${contentType} instead of JSON. This usually indicates an authentication issue or wrong endpoint. Response: ${responseText.substring(0, 200)}...`);
+      }
+      const json = await response.json();
+      if (!response.ok) {
+        throw new Error(`Failed to get cache value for key ${parsedKey}: ${json.message}`);
+      }
+      return json.value;
+    } catch (error) {
+      throw new Error(`Failed to get cache value for key ${key}: ${error}`);
+    }
+  }
+  async set(key, value) {
+    try {
+      const keyResult = keySchema.parse(key);
+      const response = await (0, _jwtTokenManager.callBackendFunctionWithToken)(`cache/${keyResult}`, {
+        method: "PUT",
+        body: JSON.stringify(value),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      const contentType = response.headers.get("content-type");
+      if (!(contentType !== null && contentType !== void 0 && contentType.includes("application/json"))) {
+        const responseText = await response.text();
+        _Logger.logger.error(`Expected JSON but got content-type: ${contentType}`);
+        throw new Error(`Server returned ${contentType} instead of JSON. This usually indicates an authentication issue or wrong endpoint. Response: ${responseText.substring(0, 200)}...`);
+      }
+      const json = await response.json();
+      if (!response.ok) {
+        throw new Error(`Failed to set cache value for key ${keyResult}: ${json.message}`);
+      }
+    } catch (error) {
+      throw new Error(`Failed to set cache value for key ${key}: ${error}`);
+    }
+  }
+}
+const cache = exports.cache = new Cache();

package/dist/intunedServices/cache/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "cache", {
+  enumerable: true,
+  get: function () {
+    return _cache.cache;
+  }
+});
+var _cache = require("./cache");