@intuned/browser-dev 0.1.14-dev.3 → 0.1.15-dev.0

package/dist/helpers/tests/testDownloadFile.spec.js

@@ -4,6 +4,7 @@ var _extendedTest = require("../../common/extendedTest");
 var _playwright = require("playwright");
 var _fs = _interopRequireDefault(require("fs"));
 var _ = require("..");
+var _Attachment = require("../types/Attachment");
 var _promises = require("fs/promises");
 var _os = require("os");
 var _path = require("path");
@@ -278,4 +279,55 @@ _extendedTest.describe.skip("TestNotInGeneration", () => {
       (0, _extendedTest.expect)(cancelled).toContain("canceled");
     }
   });
+});
+const SIGNED_URL = "https://bucket.r2.cloudflarestorage.com/img.jpg?X-Amz-Signature=abc";
+(0, _extendedTest.describe)("SignedUrlAttachmentInTypedArray", () => {
+  (0, _extendedTest.test)("toDict() on SignedUrlAttachment stored in Attachment[] includes signedUrl", async () => {
+    const images = [];
+    images.push(new _Attachment.SignedUrlAttachment("img.jpg", SIGNED_URL, "img.jpg"));
+    const dict = images[0].toDict();
+    (0, _extendedTest.expect)(dict.signedUrl).toBe(SIGNED_URL);
+  });
+  (0, _extendedTest.test)("toDict() on SignedUrlAttachment stored in Attachment[] has no null/undefined fields", async () => {
+    const images = [];
+    images.push(new _Attachment.SignedUrlAttachment("img.jpg", SIGNED_URL, "img.jpg"));
+    const dict = images[0].toDict();
+    for (const [, value] of Object.entries(dict)) {
+      (0, _extendedTest.expect)(value).not.toBeNull();
+      (0, _extendedTest.expect)(value).not.toBeUndefined();
+    }
+    (0, _extendedTest.expect)(dict.bucket).toBeUndefined();
+    (0, _extendedTest.expect)(dict.region).toBeUndefined();
+    (0, _extendedTest.expect)(dict.endpoint).toBeUndefined();
+  });
+  (0, _extendedTest.test)("JSON.stringify on Attachment[] containing SignedUrlAttachment includes signedUrl", async () => {
+    const images = [new _Attachment.SignedUrlAttachment("img.jpg", SIGNED_URL, "img.jpg")];
+    const serialized = JSON.parse(JSON.stringify(images));
+    (0, _extendedTest.expect)(serialized[0].signedUrl).toBe(SIGNED_URL);
+    (0, _extendedTest.expect)(serialized[0].bucket).toBeUndefined();
+    (0, _extendedTest.expect)(serialized[0].region).toBeUndefined();
+  });
+  (0, _extendedTest.test)("JSON.stringify on plain object with imageAttachments: Attachment[] serializes signedUrl", async () => {
+    const product = {
+      name: "My Product",
+      imageAttachments: [new _Attachment.SignedUrlAttachment("img.jpg", SIGNED_URL, "img.jpg")]
+    };
+    const serialized = JSON.parse(JSON.stringify(product));
+    const item = serialized.imageAttachments[0];
+    (0, _extendedTest.expect)(item.signedUrl).toBe(SIGNED_URL);
+    (0, _extendedTest.expect)(item.bucket).toBeUndefined();
+    (0, _extendedTest.expect)(item.region).toBeUndefined();
+    (0, _extendedTest.expect)(item.endpoint).toBeUndefined();
+  });
+  (0, _extendedTest.test)("mixed Attachment and SignedUrlAttachment in Attachment[] both serialize correctly", async () => {
+    const images = [new _Attachment.Attachment("s3.jpg", "s3.jpg", "my-bucket", "us-east-1", "s3.jpg"), new _Attachment.SignedUrlAttachment("intuned.jpg", SIGNED_URL, "intuned.jpg")];
+    const s3Dict = images[0].toDict();
+    (0, _extendedTest.expect)(s3Dict.bucket).toBe("my-bucket");
+    (0, _extendedTest.expect)(s3Dict.region).toBe("us-east-1");
+    (0, _extendedTest.expect)(s3Dict.signedUrl).toBeUndefined();
+    const intunedDict = images[1].toDict();
+    (0, _extendedTest.expect)(intunedDict.signedUrl).toBe(SIGNED_URL);
+    (0, _extendedTest.expect)(intunedDict.bucket).toBeUndefined();
+    (0, _extendedTest.expect)(intunedDict.region).toBeUndefined();
+  });
 });

package/dist/helpers/types/Attachment.js

@@ -89,6 +89,9 @@ class Attachment {
     if (!this.bucket || !this.region) {
       throw new Error("bucket and region are required to get the S3 key");
     }
+    if (this.endpoint) {
+      throw new Error("getS3Key is not supported when using a custom endpoint, use getSignedUrl instead");
+    }
     return `https://${this.bucket}.s3.${this.region}.amazonaws.com/${this.fileName}`;
   }
   getFileType() {
@@ -110,6 +113,9 @@ class SignedUrlAttachment extends Attachment {
       signedUrl: this.signedUrl
     };
   }
+  getS3Key() {
+    throw new Error("SignedUrlAttachment does not support getS3Key, use getSignedUrl() instead");
+  }
   async getSignedUrl() {
     return this.signedUrl;
   }

package/dist/helpers/types/__tests__/Attachment.test.js

@@ -51,6 +51,10 @@ const SIGNED_URL = "https://bucket.r2.cloudflarestorage.com/file.pdf?X-Amz-Signa
     const a = new _Attachment.Attachment("f", "f", undefined, undefined, "s");
     (0, _vitest.expect)(() => a.getS3Key()).toThrow();
   });
+  (0, _vitest.test)("getS3Key throws when custom endpoint is set", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s", "https://r2.example.com");
+    (0, _vitest.expect)(() => a.getS3Key()).toThrow(/custom endpoint/);
+  });
   (0, _vitest.test)("does not have signedUrl field", () => {
     const a = new _Attachment.Attachment("f", "f", "b", "r", "s");
     (0, _vitest.expect)(a.signedUrl).toBeUndefined();
@@ -99,6 +103,10 @@ const SIGNED_URL = "https://bucket.r2.cloudflarestorage.com/file.pdf?X-Amz-Signa
   (0, _vitest.test)("rejects invalid signed URL", () => {
     (0, _vitest.expect)(() => new _Attachment.SignedUrlAttachment("f", "not-a-url")).toThrow();
   });
+  (0, _vitest.test)("getS3Key throws with descriptive message pointing to getSignedUrl", () => {
+    const s = new _Attachment.SignedUrlAttachment("f", SIGNED_URL, "f");
+    (0, _vitest.expect)(() => s.getS3Key()).toThrow(/getSignedUrl/);
+  });
 });
 (0, _vitest.describe)("toDict null/undefined exclusion", () => {
   (0, _vitest.test)("Attachment with S3 fields includes bucket and region", () => {

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

@@ -16,9 +16,10 @@ const createAnthropicInstance = input => {
       apiKey
     });
   } else {
+    const baseURLWithV1 = baseUrl ? `${baseUrl}/v1` : undefined;
     return (0, _anthropic.createAnthropic)({
       apiKey,
-      baseURL: baseUrl,
+      baseURL: baseURLWithV1,
       fetch: _jwtTokenManager.backendFunctionsTokenManager.fetchWithToken.bind(_jwtTokenManager.backendFunctionsTokenManager)
     });
   }

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

@@ -26,13 +26,15 @@ _vitest.vi.mock("../providers/Gemini", () => ({
   createGoogleInstance: _vitest.vi.fn()
 }));
 _vitest.vi.mock("../../../common/loadRuntime", () => ({
-  loadRuntime: _vitest.vi.fn()
+  loadRuntime: _vitest.vi.fn(),
+  loadGetAiGatewayConfig: _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);
+const mockLoadGetAiGatewayConfig = _vitest.vi.mocked(_loadRuntime.loadGetAiGatewayConfig);
 (0, _extendedTest.describe)("APIGateway", () => {
   let originalEnv;
   (0, _extendedTest.beforeEach)(() => {
@@ -108,57 +110,6 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
       (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"]();
-      (0, _extendedTest.expect)(result).toBe("https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway");
-    });
-    (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"]();
-      (0, _extendedTest.expect)(result).toBe("https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway");
-    });
-    (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"]();
-      (0, _extendedTest.expect)(result).toBe("https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway");
-    });
-    (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"]();
-      (0, _extendedTest.expect)(result).toBe("https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway");
-    });
-  });
   (0, _extendedTest.describe)("ensureInitialized", () => {
     (0, _extendedTest.it)("should use direct mode when API key provided", async () => {
       const gateway = new _aiApiGateway.APIGateway({
@@ -192,11 +143,6 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
       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");
@@ -206,16 +152,54 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
       });
       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");
+  });
+  (0, _extendedTest.describe)("getModelConfig", () => {
+    (0, _extendedTest.it)("should return direct config when apiKey is set", async () => {
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "gpt-4",
+        apiKey: "sk-direct"
+      });
+      await gateway["ensureInitialized"]();
+      const result = await gateway["getModelConfig"]();
+      (0, _extendedTest.expect)(result).toEqual({
+        model: "gpt-4",
+        apiKey: "sk-direct",
+        extraHeaders: undefined,
+        baseUrl: undefined
+      });
+    });
+    (0, _extendedTest.it)("should resolve base URL and API key from runtime in gateway mode", async () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
       mockLoadRuntime.mockResolvedValue(() => ({
         runId: "test"
       }));
+      mockLoadGetAiGatewayConfig.mockResolvedValue(() => ({
+        baseUrl: "https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway",
+        apiKey: "resolved-token"
+      }));
       const gateway = new _aiApiGateway.APIGateway({
-        model: "gpt-4"
+        model: "claude-3-sonnet"
+      });
+      await gateway["ensureInitialized"]();
+      const result = await gateway["getModelConfig"]();
+      (0, _extendedTest.expect)(result).toEqual({
+        model: "claude-3-sonnet",
+        apiKey: "resolved-token",
+        extraHeaders: undefined,
+        baseUrl: "https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway"
+      });
+    });
+    (0, _extendedTest.it)("should throw when runtime does not export getAiGatewayConfig", async () => {
+      mockGetModelProvider.mockReturnValue("anthropic");
+      mockLoadRuntime.mockResolvedValue(() => ({
+        runId: "test"
+      }));
+      mockLoadGetAiGatewayConfig.mockRejectedValue(new Error("@intuned/runtime does not export getAiGatewayConfig. Please upgrade to a newer version."));
+      const gateway = new _aiApiGateway.APIGateway({
+        model: "claude-3-sonnet"
       });
-      await (0, _extendedTest.expect)(gateway["ensureInitialized"]()).rejects.toThrow("Gateway configuration is incomplete. Missing environment variables: FUNCTIONS_DOMAIN");
+      await gateway["ensureInitialized"]();
+      await (0, _extendedTest.expect)(gateway["getModelConfig"]()).rejects.toThrow("Failed to load gateway configuration from @intuned/runtime");
     });
   });
   (0, _extendedTest.describe)("createProviderInstance", () => {
@@ -224,6 +208,10 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
       mockLoadRuntime.mockResolvedValue(() => ({
         runId: "test"
       }));
+      mockLoadGetAiGatewayConfig.mockResolvedValue(() => ({
+        baseUrl: "https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway",
+        apiKey: "resolved-token"
+      }));
       const mockInstance = {
         chat: _vitest.vi.fn()
       };
@@ -233,7 +221,7 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
       });
       const result = await gateway.createProviderInstance();
       (0, _extendedTest.expect)(mockCreateAnthropicInstance).toHaveBeenCalledWith({
-        apiKey: "--THIS_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+        apiKey: "resolved-token",
         headers: undefined,
         model: "claude-3-sonnet",
         baseUrl: "https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway"
@@ -264,6 +252,10 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
       mockLoadRuntime.mockResolvedValue(() => ({
         runId: "test"
       }));
+      mockLoadGetAiGatewayConfig.mockResolvedValue(() => ({
+        baseUrl: "https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway",
+        apiKey: "resolved-token"
+      }));
       const mockInstance = {
         chat: _vitest.vi.fn()
       };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intuned/browser-dev",
-  "version": "0.1.14-dev.3",
+  "version": "0.1.15-dev.0",
   "description": "runner package for intuned functions",
   "types": "./dist/index.d.ts",
   "typesVersions": {
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@ai-sdk/anthropic": "2.0.1",
-    "@ai-sdk/google": "1.0.12",
+    "@ai-sdk/google": "2.0.68",
     "@ai-sdk/openai": "2.0.4",
     "@ai-sdk/provider": "2.0.0",
     "@anthropic-ai/sdk": "0.22.0",