@intuned/browser-dev 2.2.3-test-build.0

package/dist/helpers/waitForDomSettled.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.waitForDomSettled = void 0;
+var _locatorHelpers = require("../common/locatorHelpers");
+var _Logger = require("../common/Logger");
+const waitForDomSettled = async options => {
+  const {
+    source,
+    settleDurationMs = 500,
+    timeoutInMs = 30000
+  } = options;
+  const settleDurationMsFloored = Math.floor(settleDurationMs);
+  const timeoutMs = Math.floor(timeoutInMs);
+  let pageObj;
+  let elementHandle;
+  if (!(0, _locatorHelpers.isPage)(source)) {
+    pageObj = source.page();
+    const handle = await source.elementHandle();
+    if (!handle) {
+      _Logger.logger.warn("Could not get element handle from locator");
+      return false;
+    }
+    elementHandle = handle;
+  } else if ((0, _locatorHelpers.isPage)(source)) {
+    pageObj = source;
+    elementHandle = await pageObj.evaluateHandle("document.documentElement");
+  } else {
+    throw new Error("Invalid state");
+  }
+  try {
+    const result = await pageObj.evaluate(({
+      target,
+      settleDurationMsFloored,
+      timeoutMs
+    }) => {
+      return new Promise((resolve, reject) => {
+        if (!target) {
+          reject(new Error("Target element not found"));
+          return;
+        }
+        let mutationTimer;
+        let settled = false;
+        const observer = new MutationObserver(() => {
+          if (settled) return;
+          clearTimeout(mutationTimer);
+          mutationTimer = window.setTimeout(() => {
+            settled = true;
+            observer.disconnect();
+            clearTimeout(timeoutTimer);
+            resolve(true);
+          }, settleDurationMsFloored);
+        });
+        const timeoutTimer = window.setTimeout(() => {
+          settled = true;
+          observer.disconnect();
+          clearTimeout(mutationTimer);
+          reject(new Error(`DOM timed out settling after ${timeoutMs} ms`));
+        }, timeoutMs);
+        observer.observe(target, {
+          childList: true,
+          subtree: true,
+          attributes: true,
+          characterData: true
+        });
+        mutationTimer = window.setTimeout(() => {
+          settled = true;
+          observer.disconnect();
+          clearTimeout(timeoutTimer);
+          resolve(true);
+        }, settleDurationMsFloored);
+      });
+    }, {
+      target: elementHandle,
+      settleDurationMsFloored,
+      timeoutMs
+    });
+    return result;
+  } catch (error) {
+    _Logger.logger.warn(`DOM settlement detection failed: ${error}`);
+    return false;
+  } finally {
+    if ((0, _locatorHelpers.isPage)(source) && elementHandle) {
+      await elementHandle.dispose();
+    }
+  }
+};
+exports.waitForDomSettled = waitForDomSettled;

package/dist/helpers/withNetworkSettledWait.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withNetworkSettledWait = void 0;
+var _Logger = require("../common/Logger");
+const withNetworkSettledWait = async (callback, options) => {
+  const {
+    page,
+    timeoutInMs = 30000,
+    maxInflightRequests = 0
+  } = options || {};
+  _Logger.logger.debug(`Page object: ${page}`);
+  let networkSettledResolve = null;
+  let networkSettledPromise = new Promise(resolve => {
+    networkSettledResolve = resolve;
+  });
+  let isTimeout = false;
+  let requestCounter = 0;
+  let actionDone = false;
+  const pendingRequests = new Set();
+  const maybeSettle = async () => {
+    if (actionDone && requestCounter <= maxInflightRequests) {
+      var _networkSettledResolv;
+      (_networkSettledResolv = networkSettledResolve) === null || _networkSettledResolv === void 0 || _networkSettledResolv();
+    }
+  };
+  const onRequest = request => {
+    requestCounter++;
+    pendingRequests.add(request);
+  };
+  const onRequestDone = async request => {
+    await new Promise(resolve => setTimeout(resolve, 0));
+    if (pendingRequests.has(request)) {
+      requestCounter--;
+      pendingRequests.delete(request);
+      await maybeSettle();
+    }
+  };
+  const handleRequestFinished = async req => {
+    await onRequestDone(req);
+  };
+  const handleRequestFailed = async req => {
+    await onRequestDone(req);
+  };
+  page === null || page === void 0 || page.on("request", onRequest);
+  page === null || page === void 0 || page.on("requestfinished", handleRequestFinished);
+  page === null || page === void 0 || page.on("requestfailed", handleRequestFailed);
+  const timeoutPromise = new Promise(resolve => {
+    setTimeout(() => {
+      var _networkSettledResolv2;
+      _Logger.logger.info("waiting for network to settle timed out");
+      isTimeout = true;
+      (_networkSettledResolv2 = networkSettledResolve) === null || _networkSettledResolv2 === void 0 || _networkSettledResolv2();
+      resolve();
+    }, timeoutInMs);
+  });
+  try {
+    const result = await callback(page);
+    actionDone = true;
+    await new Promise(resolve => setTimeout(resolve, 500));
+    await maybeSettle();
+    _Logger.logger.info("-- Start waiting for network to settle... --");
+    let shouldContinue = true;
+    while (shouldContinue) {
+      _Logger.logger.info(`waiting for network to settle, ${requestCounter} requests pending`);
+      await Promise.race([networkSettledPromise, timeoutPromise]);
+      await new Promise(resolve => setTimeout(resolve, 500));
+      if (actionDone && requestCounter <= maxInflightRequests || isTimeout) {
+        if (isTimeout) {
+          _Logger.logger.info("Exiting due to timeout, network did not settle");
+        } else {
+          _Logger.logger.info("network settled, no pending requests");
+        }
+        shouldContinue = false;
+      } else {
+        networkSettledPromise = new Promise(resolve => {
+          networkSettledResolve = resolve;
+        });
+      }
+    }
+    _Logger.logger.info("-- Finished waiting for network to settle --");
+    return result;
+  } finally {
+    page === null || page === void 0 || page.off("request", onRequest);
+    page === null || page === void 0 || page.off("requestfinished", handleRequestFinished);
+    page === null || page === void 0 || page.off("requestfailed", handleRequestFailed);
+  }
+};
+exports.withNetworkSettledWait = withNetworkSettledWait;

package/dist/index.d.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _export = require("./helpers/export");
+Object.keys(_export).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _export[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _export[key];
+    }
+  });
+});

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./helpers/export";
+
+export type {
+  Attachment,
+  Trigger,
+  S3Configs,
+  FileType,
+  AttachmentType,
+  SanitizeHtmlOptions,
+} from "./helpers/export";

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _helpers = require("./helpers");
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _helpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _helpers[key];
+    }
+  });
+});

package/dist/intunedServices/ApiGateway/aiApiGateway.js

@@ -0,0 +1,99 @@
+"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");
+var _dotenv = require("dotenv");
+(0, _dotenv.config)();
+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;
+    const provider = this.detectProvider(model);
+    let apiKeyToUse = apiKey;
+    if (apiKey === undefined) {
+      if (provider !== null && provider !== void 0 && provider.toLowerCase().includes("anthropic")) {
+        apiKeyToUse = process.env.ANTHROPIC_API_KEY;
+      } else if (provider !== null && provider !== void 0 && provider.toLowerCase().includes("openai")) {
+        apiKeyToUse = process.env.OPENAI_API_KEY;
+      } else if (provider !== null && provider !== void 0 && provider.toLowerCase().includes("google_vertexai")) {
+        apiKeyToUse = process.env.GOOGLE_API_KEY;
+      }
+    }
+    if (apiKeyToUse) {
+      return {
+        model,
+        apiKey: apiKeyToUse,
+        extraHeaders,
+        baseUrl: undefined
+      };
+    }
+    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,224 @@
+"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",
+      ANTHROPIC_API_KEY: undefined
+    };
+    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"
+        }
+      });
+      process.env.ANTHROPIC_API_KEY = undefined;
+      (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");
+      process.env.ANTHROPIC_API_KEY = undefined;
+      (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;
+}({});