@intuned/browser-dev 0.1.4-dev.0

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

@@ -0,0 +1,355 @@
+"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");
+var _loadRuntime = require("../../../common/loadRuntime");
+_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()
+}));
+_vitest.vi.mock("../../../common/loadRuntime", () => ({
+  loadRuntime: _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);
+const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
+(0, _extendedTest.describe)("APIGateway", () => {
+  let originalEnv;
+  (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,
+      OPENAI_API_KEY: undefined,
+      GOOGLE_API_KEY: undefined
+    };
+    _vitest.vi.clearAllMocks();
+  });
+  (0, _extendedTest.afterEach)(() => {
+    process.env = originalEnv;
+  });
+  (0, _extendedTest.describe)("constructor", () => {
+    (0, _extendedTest.it)("should initialize with provided model and apiKey", () => {
+      const gateway = new _aiApiGateway.APIGateway({
+        apiKey: "sk-test123",
+        model: "gpt-4"
+      });
+      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-4");
+      (0, _extendedTest.expect)(gateway["apiKey"]).toBe("sk-test123");
+    });
+    (0, _extendedTest.it)("should use default model when not provided", () => {
+      const gateway = new _aiApiGateway.APIGateway({
+        apiKey: "sk-test123",
+        model: "gpt-4o-2024-08-06"
+      });
+      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-4o-2024-08-06");
+    });
+    (0, _extendedTest.it)("should allow no parameters", () => {
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4o-2024-08-06"
+      });
+      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-4o-2024-08-06");
+      (0, _extendedTest.expect)(gateway["apiKey"]).toBeUndefined();
+    });
+  });
+  (0, _extendedTest.describe)("detectProvider", () => {
+    (0, _extendedTest.it)("should detect openai models", () => {
+      mockGetModelProvider.mockReturnValue("openai");
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4"
+      });
+      (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");
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "claude-3-sonnet"
+      });
+      (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");
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "CLAUDE-3-OPUS"
+      });
+      (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");
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "unknown-model"
+      });
+      (0, _extendedTest.expect)(gateway["detectProvider"]("unknown-model")).toBe("unknown");
+    });
+  });
+  (0, _extendedTest.describe)("buildGatewayUrl", () => {
+    (0, _extendedTest.it)("should build correct URL for anthropic", async () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
+      mockLoadRuntime.mockResolvedValue(() => ({
+        runId: "test"
+      }));
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "claude-3-sonnet"
+      });
+      await gateway["ensureInitialized"]();
+      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", async () => {
+      mockGetModelProvider.mockReturnValue("google_vertexai");
+      mockLoadRuntime.mockResolvedValue(() => ({
+        runId: "test"
+      }));
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gemini-pro"
+      });
+      await gateway["ensureInitialized"]();
+      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", async () => {
+      mockGetModelProvider.mockReturnValue("openai");
+      mockLoadRuntime.mockResolvedValue(() => ({
+        runId: "test"
+      }));
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4"
+      });
+      await gateway["ensureInitialized"]();
+      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", async () => {
+      process.env.FUNCTIONS_DOMAIN = "https://functions.example.com/";
+      mockGetModelProvider.mockReturnValue("openai");
+      mockLoadRuntime.mockResolvedValue(() => ({
+        runId: "test"
+      }));
+      const newGateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4"
+      });
+      await newGateway["ensureInitialized"]();
+      const result = newGateway["buildGatewayUrl"]("openai");
+      (0, _extendedTest.expect)(result).toBe("https://functions.example.com/api/workspace123/functions/integration456/openai");
+    });
+  });
+  (0, _extendedTest.describe)("ensureInitialized", () => {
+    (0, _extendedTest.it)("should use direct mode when API key provided", async () => {
+      const gateway = new _aiApiGateway.APIGateway({
+        apiKey: "sk-test123",
+        model: "gpt-4"
+      });
+      await gateway["ensureInitialized"]();
+      (0, _extendedTest.expect)(gateway["useGateway"]).toBe(false);
+      (0, _extendedTest.expect)(gateway["apiKey"]).toBe("sk-test123");
+      (0, _extendedTest.expect)(gateway["isInitialized"]).toBe(true);
+    });
+    (0, _extendedTest.it)("should find API key in environment and use direct mode", async () => {
+      process.env.OPENAI_API_KEY = "sk-env-key";
+      mockGetModelProvider.mockReturnValue("openai");
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4"
+      });
+      await gateway["ensureInitialized"]();
+      (0, _extendedTest.expect)(gateway["useGateway"]).toBe(false);
+      (0, _extendedTest.expect)(gateway["apiKey"]).toBe("sk-env-key");
+      (0, _extendedTest.expect)(gateway["isInitialized"]).toBe(true);
+    });
+    (0, _extendedTest.it)("should use gateway mode when no API key and in intuned context", async () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
+      mockLoadRuntime.mockResolvedValue(() => ({
+        runId: "test"
+      }));
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "claude-3-sonnet"
+      });
+      await gateway["ensureInitialized"]();
+      (0, _extendedTest.expect)(gateway["useGateway"]).toBe(true);
+      (0, _extendedTest.expect)(gateway["isInitialized"]).toBe(true);
+      (0, _extendedTest.expect)(gateway["config"]).toEqual({
+        functionsDomain: "https://functions.example.com",
+        workspaceId: "workspace123",
+        integrationId: "integration456"
+      });
+    });
+    (0, _extendedTest.it)("should throw error when no API key and not in intuned context", async () => {
+      mockGetModelProvider.mockReturnValue("openai");
+      mockLoadRuntime.mockResolvedValue(() => null);
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4"
+      });
+      await (0, _extendedTest.expect)(gateway["ensureInitialized"]()).rejects.toThrow("No API key provided and not running in Intuned context");
+    });
+    (0, _extendedTest.it)("should throw error when in intuned context but missing env vars", async () => {
+      delete process.env.FUNCTIONS_DOMAIN;
+      mockGetModelProvider.mockReturnValue("openai");
+      mockLoadRuntime.mockResolvedValue(() => ({
+        runId: "test"
+      }));
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4"
+      });
+      await (0, _extendedTest.expect)(gateway["ensureInitialized"]()).rejects.toThrow("Gateway configuration is incomplete. Missing environment variables: FUNCTIONS_DOMAIN");
+    });
+  });
+  (0, _extendedTest.describe)("createProviderInstance", () => {
+    (0, _extendedTest.it)("should create anthropic instance with gateway mode", async () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
+      mockLoadRuntime.mockResolvedValue(() => ({
+        runId: "test"
+      }));
+      const mockInstance = {
+        chat: _vitest.vi.fn()
+      };
+      mockCreateAnthropicInstance.mockReturnValue(mockInstance);
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "claude-3-sonnet"
+      });
+      const result = await gateway.createProviderInstance();
+      (0, _extendedTest.expect)(mockCreateAnthropicInstance).toHaveBeenCalledWith({
+        apiKey: "--THIS_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 with direct API key", async () => {
+      mockGetModelProvider.mockReturnValue("openai");
+      const mockInstance = {
+        chat: _vitest.vi.fn()
+      };
+      mockCreateOpenAIInstance.mockReturnValue(mockInstance);
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4",
+        apiKey: "sk-test123"
+      });
+      const result = await gateway.createProviderInstance();
+      (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", async () => {
+      mockGetModelProvider.mockReturnValue("google_vertexai");
+      mockLoadRuntime.mockResolvedValue(() => ({
+        runId: "test"
+      }));
+      const mockInstance = {
+        chat: _vitest.vi.fn()
+      };
+      mockCreateGoogleInstance.mockReturnValue(mockInstance);
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gemini-pro"
+      });
+      const result = await gateway.createProviderInstance();
+      (0, _extendedTest.expect)(mockCreateGoogleInstance).toHaveBeenCalled();
+      (0, _extendedTest.expect)(result).toBe(mockInstance);
+    });
+    (0, _extendedTest.it)("should throw error for unsupported provider", async () => {
+      mockGetModelProvider.mockReturnValue("unknown");
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "unknown-model",
+        apiKey: "sk-test"
+      });
+      await (0, _extendedTest.expect)(gateway.createProviderInstance()).rejects.toThrow("Unsupported provider: unknown");
+    });
+    (0, _extendedTest.it)("should pass extra headers", async () => {
+      mockGetModelProvider.mockReturnValue("openai");
+      const mockInstance = {
+        chat: _vitest.vi.fn()
+      };
+      mockCreateOpenAIInstance.mockReturnValue(mockInstance);
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4",
+        apiKey: "sk-test123"
+      });
+      await gateway.createProviderInstance({
+        "Custom-Header": "value"
+      });
+      (0, _extendedTest.expect)(mockCreateOpenAIInstance).toHaveBeenCalledWith({
+        apiKey: "sk-test123",
+        headers: {
+          "Custom-Header": "value"
+        },
+        model: "gpt-4",
+        baseUrl: undefined
+      });
+    });
+  });
+  (0, _extendedTest.describe)("getModel", () => {
+    (0, _extendedTest.it)("should return language model from provider instance", async () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
+      const mockModelInstance = {
+        generate: _vitest.vi.fn()
+      };
+      const mockProviderInstance = {
+        chat: _vitest.vi.fn().mockReturnValue(mockModelInstance)
+      };
+      mockCreateAnthropicInstance.mockReturnValue(mockProviderInstance);
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "claude-3-sonnet",
+        apiKey: "sk-test"
+      });
+      const result = await gateway.getModel();
+      (0, _extendedTest.expect)(mockProviderInstance.chat).toHaveBeenCalledWith("claude-3-sonnet");
+      (0, _extendedTest.expect)(result).toBe(mockModelInstance);
+    });
+    (0, _extendedTest.it)("should pass through headers", async () => {
+      mockGetModelProvider.mockReturnValue("openai");
+      const mockModelInstance = {
+        generate: _vitest.vi.fn()
+      };
+      const mockProviderInstance = {
+        chat: _vitest.vi.fn().mockReturnValue(mockModelInstance)
+      };
+      mockCreateOpenAIInstance.mockReturnValue(mockProviderInstance);
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4",
+        apiKey: "sk-test123"
+      });
+      const result = await gateway.getModel({
+        "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");

package/dist/intunedServices/cache/tests/testCache.spec.js

@@ -0,0 +1,117 @@
+"use strict";
+
+var _extendedTest = require("../../../common/extendedTest");
+var _cache = require("../cache");
+var _vitest = require("vitest");
+var _jwtTokenManager = require("../../../common/jwtTokenManager");
+_vitest.vi.mock("../../../common/jwtTokenManager", () => ({
+  callBackendFunctionWithToken: _vitest.vi.fn()
+}));
+const mockCallBackendFunction = _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken);
+(0, _extendedTest.describe)("Cache", () => {
+  (0, _extendedTest.beforeEach)(() => {
+    _vitest.vi.clearAllMocks();
+  });
+  (0, _extendedTest.describe)("get", () => {
+    (0, _extendedTest.it)("should return value when successful", async () => {
+      const mockResponse = {
+        ok: true,
+        headers: {
+          get: _vitest.vi.fn().mockReturnValue("application/json")
+        },
+        json: _vitest.vi.fn().mockResolvedValue({
+          value: "cached_data"
+        })
+      };
+      mockCallBackendFunction.mockResolvedValue(mockResponse);
+      const result = await _cache.cache.get("test_key");
+      (0, _extendedTest.expect)(result).toBe("cached_data");
+      (0, _extendedTest.expect)(mockCallBackendFunction).toHaveBeenCalledWith("cache/test_key", {
+        method: "GET"
+      });
+      (0, _extendedTest.expect)(mockResponse.json).toHaveBeenCalled();
+    });
+    (0, _extendedTest.it)("should throw error when response is not ok", async () => {
+      const mockResponse = {
+        ok: false,
+        headers: {
+          get: _vitest.vi.fn().mockReturnValue("application/json")
+        },
+        json: _vitest.vi.fn().mockResolvedValue({
+          message: "Cache miss"
+        })
+      };
+      mockCallBackendFunction.mockResolvedValue(mockResponse);
+      await (0, _extendedTest.expect)(_cache.cache.get("test_key")).rejects.toThrow("Failed to get cache value for key test_key: Cache miss");
+    });
+    (0, _extendedTest.it)("should throw error for empty key", async () => {
+      await (0, _extendedTest.expect)(_cache.cache.get("")).rejects.toThrow("Failed to get cache value for key : [");
+    });
+    (0, _extendedTest.it)("should throw error for key with colon", async () => {
+      await (0, _extendedTest.expect)(_cache.cache.get("invalid:key")).rejects.toThrow("Failed to get cache value for key invalid:key: [");
+    });
+    (0, _extendedTest.it)("should throw error for key with hash", async () => {
+      await (0, _extendedTest.expect)(_cache.cache.get("invalid#key")).rejects.toThrow("Failed to get cache value for key invalid#key: [");
+    });
+  });
+  (0, _extendedTest.describe)("set", () => {
+    (0, _extendedTest.it)("should call backend correctly when successful", async () => {
+      const mockResponse = {
+        ok: true,
+        headers: {
+          get: _vitest.vi.fn().mockReturnValue("application/json")
+        },
+        json: _vitest.vi.fn().mockResolvedValue({})
+      };
+      mockCallBackendFunction.mockResolvedValue(mockResponse);
+      const testValue = {
+        data: "test"
+      };
+      await _cache.cache.set("test_key", testValue);
+      (0, _extendedTest.expect)(mockCallBackendFunction).toHaveBeenCalledWith("cache/test_key", {
+        method: "PUT",
+        body: JSON.stringify(testValue),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      (0, _extendedTest.expect)(mockResponse.json).toHaveBeenCalled();
+    });
+    (0, _extendedTest.it)("should throw error when response is not ok", async () => {
+      const mockResponse = {
+        ok: false,
+        headers: {
+          get: _vitest.vi.fn().mockReturnValue("application/json")
+        },
+        json: _vitest.vi.fn().mockResolvedValue({
+          message: "Set failed"
+        })
+      };
+      mockCallBackendFunction.mockResolvedValue(mockResponse);
+      await (0, _extendedTest.expect)(_cache.cache.set("test_key", "value")).rejects.toThrow("Failed to set cache value for key test_key: Set failed");
+    });
+    (0, _extendedTest.it)("should throw error for empty key", async () => {
+      await (0, _extendedTest.expect)(_cache.cache.set("", "value")).rejects.toThrow("Failed to set cache value for key : [");
+    });
+    (0, _extendedTest.it)("should throw error for key with forbidden characters", async () => {
+      await (0, _extendedTest.expect)(_cache.cache.set("invalid:key", "value")).rejects.toThrow("Failed to set cache value for key invalid:key: [");
+      await (0, _extendedTest.expect)(_cache.cache.set("invalid#key", "value")).rejects.toThrow("Failed to set cache value for key invalid#key: [");
+    });
+    (0, _extendedTest.it)("should handle different value types", async () => {
+      const mockResponse = {
+        ok: true,
+        headers: {
+          get: _vitest.vi.fn().mockReturnValue("application/json")
+        },
+        json: _vitest.vi.fn().mockResolvedValue({})
+      };
+      mockCallBackendFunction.mockResolvedValue(mockResponse);
+      await _cache.cache.set("key1", "string_value");
+      await _cache.cache.set("key2", {
+        object: "value"
+      });
+      await _cache.cache.set("key3", 123);
+      (0, _extendedTest.expect)(mockCallBackendFunction).toHaveBeenCalledTimes(3);
+    });
+  });
+});

package/dist/optimized-extractors/common/buildExamplesPrompt.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildExamplesPrompt = buildExamplesPrompt;
+function buildExamplesPrompt({
+  entityName,
+  examples
+}) {
+  return `Ensure your extraction of ` + entityName + ` matches these examples in format and content. Follow these guidelines:` + "\n" + `1. **String Data**: Match the formatting and any transformations applied in the examples. If strings were reformed or parts were removed in the examples, apply the same changes to your extraction,.` + "\n" + `2. **Numerical Data**: Keep numbers in the same format as the examples. Ensure consistency in units, rounding, and notation.` + "\n" + `3. **Date Data**: Align the date format with the examples provided. Maintain the same order, separators, and any additional formatting rules.` + "\n" + `Consistency with these examples is crucial for accurate data extraction:` + "\n" + examples.map((e, index) => `${index}. ` + JSON.stringify(e)).join("\n");
+}

package/dist/optimized-extractors/common/buildImagesFromPage.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildImagesFromPageOrHandle = buildImagesFromPageOrHandle;
+exports.captureFullPageImagesWithOverlap = captureFullPageImagesWithOverlap;
+var _neverthrow = require("neverthrow");
+var errors = _interopRequireWildcard(require("../types/errors"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+async function captureFullPageImagesWithOverlap(page, options = {
+  overlap: 200,
+  sliceHeight: 1000
+}) {
+  const totalHeight = await page.evaluate(() => document.body.scrollHeight);
+  let currentHeight = 0;
+  const buffers = [];
+  while (currentHeight < totalHeight) {
+    if (buffers.length > 10) {
+      console.info(`the page is too long, only first ${totalHeight} px of the page will be captured.`);
+      break;
+    }
+    await page.setViewportSize({
+      width: 1200,
+      height: options.sliceHeight
+    });
+    await page.evaluate(y => window.scrollTo(0, y), currentHeight - (currentHeight > 0 ? options.overlap : 0));
+    await page.waitForTimeout(500);
+    const buffer = await page.screenshot();
+    buffers.push(buffer);
+    currentHeight += options.sliceHeight - options.overlap;
+  }
+  return buffers;
+}
+async function buildImagesFromPageOrHandle(page, searchRegionHandler) {
+  const originalViewPortSize = page.viewportSize();
+  await page.setViewportSize({
+    width: 1200,
+    height: 800
+  });
+  if (searchRegionHandler) {
+    const size = await searchRegionHandler.boundingBox();
+    if (!size) {
+      return (0, _neverthrow.err)(errors.other("the provided search region is very large, image extraction support up to 5000px height."));
+    }
+    return (0, _neverthrow.ok)([await searchRegionHandler.screenshot({
+      type: "png"
+    })]);
+  }
+  const fullPageImages = await captureFullPageImagesWithOverlap(page);
+  if (originalViewPortSize) {
+    await page.setViewportSize(originalViewPortSize);
+  }
+  return (0, _neverthrow.ok)(fullPageImages);
+}