@intuned/browser-dev 0.1.10-dev.0 → 0.1.13-dev.0

package/dist/helpers/export.d.ts

@@ -1044,11 +1044,11 @@ export interface Attachment {
   /** The S3 object key/path */
   key: string;
 
-  /** The S3 bucket name where the file is stored */
-  bucket: string;
+  /** The S3 bucket name where the file is stored. Only present when using custom S3 storage. */
+  bucket?: string;
 
-  /** The AWS region where the S3 bucket is located */
-  region: string;
+  /** The AWS region where the S3 bucket is located. Only present when using custom S3 storage. */
+  region?: string;
 
   /** Optional custom S3 endpoint URL. Defaults to undefined for standard AWS S3 */
   endpoint?: string | null;
@@ -1069,7 +1069,7 @@ export interface Attachment {
   /**
    * Converts the file metadata to a record.
    *
-   * @returns `Record<string, string>` - Record with fileName, key, bucket, region, endpoint, suggestedFileName, and fileType
+   * @returns `Record<string, string>` - Record with fileName, key, suggestedFileName, fileType, and optionally bucket, region, endpoint, signedUrl
    */
   toDict(): Record<string, string>;
 
@@ -1080,13 +1080,6 @@ export interface Attachment {
    */
   getS3Key(): string;
 
-  /**
-   * Returns the file path/key within the S3 bucket.
-   *
-   * @returns `string` - The fileName property (S3 object key)
-   */
-  getFilePath(): string;
-
   /**
    * Generates a presigned URL for secure, temporary access to the file.
    *

package/dist/helpers/index.d.ts

@@ -1044,11 +1044,11 @@ export interface Attachment {
   /** The S3 object key/path */
   key: string;
 
-  /** The S3 bucket name where the file is stored */
-  bucket: string;
+  /** The S3 bucket name where the file is stored. Only present when using custom S3 storage. */
+  bucket?: string;
 
-  /** The AWS region where the S3 bucket is located */
-  region: string;
+  /** The AWS region where the S3 bucket is located. Only present when using custom S3 storage. */
+  region?: string;
 
   /** Optional custom S3 endpoint URL. Defaults to undefined for standard AWS S3 */
   endpoint?: string | null;
@@ -1069,7 +1069,7 @@ export interface Attachment {
   /**
    * Converts the file metadata to a record.
    *
-   * @returns `Record<string, string>` - Record with fileName, key, bucket, region, endpoint, suggestedFileName, and fileType
+   * @returns `Record<string, string>` - Record with fileName, key, suggestedFileName, fileType, and optionally bucket, region, endpoint, signedUrl
    */
   toDict(): Record<string, string>;
 
@@ -1080,13 +1080,6 @@ export interface Attachment {
    */
   getS3Key(): string;
 
-  /**
-   * Returns the file path/key within the S3 bucket.
-   *
-   * @returns `string` - The fileName property (S3 object key)
-   */
-  getFilePath(): string;
-
   /**
    * Generates a presigned URL for secure, temporary access to the file.
    *

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

@@ -224,6 +224,47 @@ _extendedTest.describe.skip("TestNotInGeneration", () => {
     (0, _extendedTest.expect)(uploadedFile.bucket).toBe("testing_bucket");
     (0, _extendedTest.expect)(uploadedFile.region).toBe("testing_region");
   });
+  (0, _extendedTest.test)("should upload Buffer to s3 in generate mode", async () => {
+    const buffer = Buffer.from("hello world");
+    const uploadedFile = await (0, _.uploadFileToS3)({
+      file: buffer,
+      fileNameOverride: "test-file.txt"
+    });
+    (0, _extendedTest.expect)(uploadedFile).toBeDefined();
+    (0, _extendedTest.expect)(uploadedFile.suggestedFileName).toBeDefined();
+    (0, _extendedTest.expect)(uploadedFile.bucket).toBe("testing_bucket");
+    (0, _extendedTest.expect)(uploadedFile.region).toBe("testing_region");
+  });
+  (0, _extendedTest.test)("uploaded attachment toDict has no null fields", async () => {
+    await page.setContent(content);
+    const download = await (0, _.downloadFile)({
+      page,
+      trigger: "https://intuned-docs-public-images.s3.amazonaws.com/32UP83A_ENG_US.pdf"
+    });
+    const uploadedFile = await (0, _.uploadFileToS3)({
+      file: download
+    });
+    const dict = uploadedFile.toDict();
+    for (const [key, value] of Object.entries(dict)) {
+      (0, _extendedTest.expect)(value).not.toBeNull();
+      (0, _extendedTest.expect)(value).not.toBeUndefined();
+    }
+    (0, _extendedTest.expect)(dict.fileName).toBeDefined();
+    (0, _extendedTest.expect)(dict.key).toBeDefined();
+    (0, _extendedTest.expect)(dict.suggestedFileName).toBeDefined();
+  });
+  (0, _extendedTest.test)("getSignedUrl returns mock URL in generate_code mode", async () => {
+    await page.setContent(content);
+    const download = await (0, _.downloadFile)({
+      page,
+      trigger: "https://intuned-docs-public-images.s3.amazonaws.com/32UP83A_ENG_US.pdf"
+    });
+    const uploadedFile = await (0, _.uploadFileToS3)({
+      file: download
+    });
+    const signedUrl = await uploadedFile.getSignedUrl();
+    (0, _extendedTest.expect)(signedUrl).toBe("https://not.real.com");
+  });
   (0, _extendedTest.test)("should download from print dialog", async () => {
     await page.setContent(content);
     const printButton = page.locator("#print-button");

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

@@ -19,7 +19,8 @@ var _validateDataUsingSchema = require("../validateDataUsingSchema");
       const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
       (0, _extendedTest.expect)(result.$defs).toBeDefined();
       (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
-      (0, _extendedTest.expect)(result.$defs.attachment.type).toBe("object");
+      (0, _extendedTest.expect)(result.$defs.attachment.anyOf).toBeDefined();
+      (0, _extendedTest.expect)(result.$defs.attachment.anyOf.length).toBe(2);
       (0, _extendedTest.expect)(result.properties.file).toEqual({
         $ref: "#/$defs/attachment"
       });
@@ -463,20 +464,28 @@ var _validateDataUsingSchema = require("../validateDataUsingSchema");
       };
       const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
       (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
-      (0, _extendedTest.expect)(result.$defs.attachment.type).toBe("object");
-      const attachmentProps = result.$defs.attachment.properties;
+      (0, _extendedTest.expect)(result.$defs.attachment.anyOf).toBeDefined();
+      (0, _extendedTest.expect)(result.$defs.attachment.anyOf.length).toBe(2);
+      const baseSchema = result.$defs.attachment.anyOf[1];
+      (0, _extendedTest.expect)(baseSchema.type).toBe("object");
+      const attachmentProps = baseSchema.properties;
       (0, _extendedTest.expect)(attachmentProps).toBeDefined();
       (0, _extendedTest.expect)(attachmentProps.fileName).toBeDefined();
       (0, _extendedTest.expect)(attachmentProps.bucket).toBeDefined();
       (0, _extendedTest.expect)(attachmentProps.region).toBeDefined();
       (0, _extendedTest.expect)(attachmentProps.key).toBeDefined();
       (0, _extendedTest.expect)(attachmentProps.suggestedFileName).toBeDefined();
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toBeDefined();
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("fileName");
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("bucket");
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("region");
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("key");
-      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("suggestedFileName");
+      (0, _extendedTest.expect)(baseSchema.required).toBeDefined();
+      (0, _extendedTest.expect)(baseSchema.required).toContain("fileName");
+      (0, _extendedTest.expect)(baseSchema.required).not.toContain("bucket");
+      (0, _extendedTest.expect)(baseSchema.required).not.toContain("region");
+      (0, _extendedTest.expect)(baseSchema.required).toContain("key");
+      (0, _extendedTest.expect)(baseSchema.required).toContain("suggestedFileName");
+      (0, _extendedTest.expect)(attachmentProps.bucket).toBeDefined();
+      (0, _extendedTest.expect)(attachmentProps.region).toBeDefined();
+      const signedUrlSchema = result.$defs.attachment.anyOf[0];
+      (0, _extendedTest.expect)(signedUrlSchema.type).toBe("object");
+      (0, _extendedTest.expect)(signedUrlSchema.properties.signedUrl).toBeDefined();
     });
   });
 });

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

@@ -1297,6 +1297,117 @@ var _extendedTest = require("../../common/extendedTest");
         schema
       })).not.toThrow();
     });
+    (0, _extendedTest.test)("should validate SignedUrlAttachment instance", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: "Attachment"
+          },
+          name: {
+            type: "string"
+          }
+        },
+        required: ["file", "name"]
+      };
+      const signed = new _Attachment.SignedUrlAttachment("report.pdf", "https://my-bucket.s3.us-east-1.amazonaws.com/files/report.pdf?X-Amz-Signature=abc123", "Monthly Report.pdf");
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: {
+          file: signed,
+          name: "Signed URL file"
+        },
+        schema
+      })).not.toThrow();
+      const dict = signed.toDict();
+      (0, _extendedTest.expect)(dict).toHaveProperty("signedUrl");
+      (0, _extendedTest.expect)(dict.signedUrl).toBe("https://my-bucket.s3.us-east-1.amazonaws.com/files/report.pdf?X-Amz-Signature=abc123");
+      (0, _extendedTest.expect)(dict.bucket).toBeUndefined();
+      (0, _extendedTest.expect)(dict.region).toBeUndefined();
+    });
+    (0, _extendedTest.test)("should validate array of SignedUrlAttachment instances", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          title: {
+            type: "string"
+          },
+          documents: {
+            type: "array",
+            items: {
+              type: "Attachment"
+            }
+          }
+        },
+        required: ["title", "documents"]
+      };
+      const data = {
+        title: "Project Files",
+        documents: [new _Attachment.SignedUrlAttachment("doc1.pdf", "https://bucket.r2.cloudflarestorage.com/doc1.pdf?sig=aaa", "Document 1.pdf"), new _Attachment.SignedUrlAttachment("doc2.pdf", "https://bucket.r2.cloudflarestorage.com/doc2.pdf?sig=bbb", "Document 2.pdf")]
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate mixed Attachment and SignedUrlAttachment instances", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: {
+            type: "string"
+          },
+          s3File: {
+            type: "Attachment"
+          },
+          intunedFile: {
+            type: "Attachment"
+          },
+          optionalFile: {
+            type: ["Attachment", "null"]
+          }
+        },
+        required: ["name", "s3File", "intunedFile", "optionalFile"]
+      };
+      const data = {
+        name: "Mixed storage",
+        s3File: new _Attachment.Attachment("report.pdf", "files/report.pdf", "my-bucket", "us-east-1", "Report.pdf", null, "document"),
+        intunedFile: new _Attachment.SignedUrlAttachment("invoice.pdf", "https://bucket.r2.cloudflarestorage.com/invoice.pdf?sig=xyz", "Invoice.pdf"),
+        optionalFile: null
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate nullable SignedUrlAttachment", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: ["Attachment", "null"]
+          },
+          name: {
+            type: "string"
+          }
+        },
+        required: ["file", "name"]
+      };
+      const signed = new _Attachment.SignedUrlAttachment("report.pdf", "https://bucket.r2.cloudflarestorage.com/report.pdf?sig=abc", "Report.pdf");
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: {
+          file: signed,
+          name: "With file"
+        },
+        schema
+      })).not.toThrow();
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: {
+          file: null,
+          name: "Without file"
+        },
+        schema
+      })).not.toThrow();
+    });
     (0, _extendedTest.test)("should format error messages with multiple errors correctly", async () => {
       const schema = {
         type: "object",

package/dist/helpers/types/Attachment.js

@@ -13,8 +13,8 @@ const AttachmentTypeSchema = exports.AttachmentTypeSchema = _zod.z.literal("docu
 const AttachmentSchema = exports.AttachmentSchema = _zod.z.object({
   fileName: _zod.z.string(),
   key: _zod.z.string(),
-  bucket: _zod.z.string(),
-  region: _zod.z.string(),
+  bucket: _zod.z.string().optional(),
+  region: _zod.z.string().optional(),
   suggestedFileName: _zod.z.string(),
   endpoint: _zod.z.string().nullable().optional(),
   fileType: AttachmentTypeSchema.optional().nullable()
@@ -34,7 +34,6 @@ class Attachment {
     this.key = validatedData.key;
     this.bucket = validatedData.bucket;
     this.region = validatedData.region;
-    this.key = validatedData.key;
     this.suggestedFileName = validatedData.suggestedFileName;
     this.endpoint = validatedData.endpoint;
     this.fileType = validatedData.fileType;
@@ -46,9 +45,13 @@ class Attachment {
     return {
       fileName: this.fileName,
       key: this.key,
-      bucket: this.bucket,
-      region: this.region,
       suggestedFileName: this.suggestedFileName,
+      ...(this.bucket ? {
+        bucket: this.bucket
+      } : {}),
+      ...(this.region ? {
+        region: this.region
+      } : {}),
       ...(this.endpoint ? {
         endpoint: this.endpoint
       } : {}),
@@ -65,6 +68,9 @@ class Attachment {
     if ((0, _utils.isGenerateCodeMode)()) {
       return "https://not.real.com";
     }
+    if (!this.bucket || !this.region) {
+      throw new Error("bucket and region are required to generate a signed URL");
+    }
     const s3Client = (0, _getS3Client.getS3Client)(this.endpoint ?? undefined, this.region);
     try {
       const response = await (0, _s3RequestPresigner.getSignedUrl)(s3Client, new _clientS.GetObjectCommand({
@@ -80,41 +86,36 @@ class Attachment {
     }
   }
   getS3Key() {
+    if (!this.bucket || !this.region) {
+      throw new Error("bucket and region are required to get the S3 key");
+    }
     return `https://${this.bucket}.s3.${this.region}.amazonaws.com/${this.fileName}`;
   }
-  getFilePath() {
-    return this.fileName;
-  }
   getFileType() {
     return this.fileType || "";
   }
 }
 exports.Attachment = Attachment;
 const SignedUrlAttachmentSchema = exports.SignedUrlAttachmentSchema = AttachmentSchema.extend({
-  downloadSignedUrl: _zod.z.string().url()
+  signedUrl: _zod.z.string().url()
 });
 class SignedUrlAttachment extends Attachment {
-  constructor(fileName, downloadSignedUrl, suggestedFileName) {
-    const url = new URL(downloadSignedUrl);
-    const bucket = url.hostname.split(".")[0];
-    const key = url.pathname.substring(1);
-    const validatedUrl = _zod.z.string().url().parse(downloadSignedUrl);
-    super(fileName, key, bucket, "", suggestedFileName ?? fileName);
-    this.downloadSignedUrl = validatedUrl;
-  }
-  async getSignedUrl() {
-    return this.downloadSignedUrl;
+  constructor(fileName, signedUrl, suggestedFileName) {
+    super(fileName, fileName, undefined, undefined, suggestedFileName ?? fileName);
+    this.signedUrl = _zod.z.string().url().parse(signedUrl);
   }
   toDict() {
     return {
       ...super.toDict(),
-      downloadSignedUrl: this.downloadSignedUrl
+      signedUrl: this.signedUrl
     };
   }
+  async getSignedUrl() {
+    return this.signedUrl;
+  }
   static fromDict(data) {
     const validatedData = SignedUrlAttachmentSchema.parse(data);
-    const attachment = new SignedUrlAttachment(validatedData.fileName, validatedData.downloadSignedUrl, validatedData.suggestedFileName);
-    return attachment;
+    return new SignedUrlAttachment(validatedData.fileName, validatedData.signedUrl, validatedData.suggestedFileName);
   }
 }
 exports.SignedUrlAttachment = SignedUrlAttachment;

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

@@ -0,0 +1,130 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _Attachment = require("../Attachment");
+const SIGNED_URL = "https://bucket.r2.cloudflarestorage.com/file.pdf?X-Amz-Signature=abc";
+(0, _vitest.describe)("Attachment", () => {
+  (0, _vitest.test)("stores required fields", () => {
+    const a = new _Attachment.Attachment("files/report.pdf", "files/report.pdf", "my-bucket", "us-east-1", "Report.pdf");
+    (0, _vitest.expect)(a.fileName).toBe("files/report.pdf");
+    (0, _vitest.expect)(a.key).toBe("files/report.pdf");
+    (0, _vitest.expect)(a.bucket).toBe("my-bucket");
+    (0, _vitest.expect)(a.region).toBe("us-east-1");
+    (0, _vitest.expect)(a.suggestedFileName).toBe("Report.pdf");
+  });
+  (0, _vitest.test)("endpoint defaults to undefined", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s");
+    (0, _vitest.expect)(a.endpoint).toBeUndefined();
+  });
+  (0, _vitest.test)("toDict includes s3 fields", () => {
+    const a = new _Attachment.Attachment("files/report.pdf", "files/report.pdf", "my-bucket", "us-east-1", "Report.pdf");
+    const d = a.toDict();
+    (0, _vitest.expect)(d.bucket).toBe("my-bucket");
+    (0, _vitest.expect)(d.region).toBe("us-east-1");
+    (0, _vitest.expect)(d.fileName).toBe("files/report.pdf");
+    (0, _vitest.expect)(d.suggestedFileName).toBe("Report.pdf");
+  });
+  (0, _vitest.test)("toDict omits endpoint when not set", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s");
+    (0, _vitest.expect)(a.toDict().endpoint).toBeUndefined();
+  });
+  (0, _vitest.test)("toDict includes endpoint when set", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s", "https://custom.s3.com");
+    (0, _vitest.expect)(a.toDict().endpoint).toBe("https://custom.s3.com");
+  });
+  (0, _vitest.test)("toJSON matches toDict", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s");
+    (0, _vitest.expect)(a.toJSON()).toEqual(a.toDict());
+  });
+  (0, _vitest.test)("fromDict round-trips", () => {
+    const a = new _Attachment.Attachment("files/report.pdf", "files/report.pdf", "my-bucket", "us-east-1", "Report.pdf");
+    const restored = _Attachment.Attachment.fromDict(a.toDict());
+    (0, _vitest.expect)(restored.bucket).toBe(a.bucket);
+    (0, _vitest.expect)(restored.region).toBe(a.region);
+    (0, _vitest.expect)(restored.fileName).toBe(a.fileName);
+  });
+  (0, _vitest.test)("getS3Key builds correct URL", () => {
+    const a = new _Attachment.Attachment("x.pdf", "x.pdf", "my-bucket", "us-east-1", "x.pdf");
+    (0, _vitest.expect)(a.getS3Key()).toBe("https://my-bucket.s3.us-east-1.amazonaws.com/x.pdf");
+  });
+  (0, _vitest.test)("getS3Key throws when bucket or region missing", () => {
+    const a = new _Attachment.Attachment("f", "f", undefined, undefined, "s");
+    (0, _vitest.expect)(() => a.getS3Key()).toThrow();
+  });
+  (0, _vitest.test)("does not have signedUrl field", () => {
+    const a = new _Attachment.Attachment("f", "f", "b", "r", "s");
+    (0, _vitest.expect)(a.signedUrl).toBeUndefined();
+  });
+});
+(0, _vitest.describe)("SignedUrlAttachment", () => {
+  (0, _vitest.test)("stores fields correctly", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    (0, _vitest.expect)(s.fileName).toBe("report.pdf");
+    (0, _vitest.expect)(s.suggestedFileName).toBe("Report.pdf");
+    (0, _vitest.expect)(s.signedUrl).toBe(SIGNED_URL);
+  });
+  (0, _vitest.test)("suggestedFileName falls back to fileName", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL);
+    (0, _vitest.expect)(s.suggestedFileName).toBe("report.pdf");
+  });
+  (0, _vitest.test)("toDict exposes signedUrl", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    (0, _vitest.expect)(s.toDict().signedUrl).toBe(SIGNED_URL);
+  });
+  (0, _vitest.test)("toDict does not include bucket or region", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    const d = s.toDict();
+    (0, _vitest.expect)(d.bucket).toBeUndefined();
+    (0, _vitest.expect)(d.region).toBeUndefined();
+  });
+  (0, _vitest.test)("toJSON matches toDict", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    (0, _vitest.expect)(s.toJSON()).toEqual(s.toDict());
+  });
+  (0, _vitest.test)("getSignedUrl returns the signed URL", async () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    (0, _vitest.expect)(await s.getSignedUrl()).toBe(SIGNED_URL);
+  });
+  (0, _vitest.test)("fromDict round-trips", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL, "Report.pdf");
+    const restored = _Attachment.SignedUrlAttachment.fromDict(s.toDict());
+    (0, _vitest.expect)(restored.signedUrl).toBe(SIGNED_URL);
+    (0, _vitest.expect)(restored.fileName).toBe("report.pdf");
+    (0, _vitest.expect)(restored.suggestedFileName).toBe("Report.pdf");
+  });
+  (0, _vitest.test)("is instance of Attachment", () => {
+    const s = new _Attachment.SignedUrlAttachment("report.pdf", SIGNED_URL);
+    (0, _vitest.expect)(s instanceof _Attachment.Attachment).toBe(true);
+  });
+  (0, _vitest.test)("rejects invalid signed URL", () => {
+    (0, _vitest.expect)(() => new _Attachment.SignedUrlAttachment("f", "not-a-url")).toThrow();
+  });
+});
+(0, _vitest.describe)("toDict null/undefined exclusion", () => {
+  (0, _vitest.test)("Attachment with S3 fields includes bucket and region", () => {
+    const a = new _Attachment.Attachment("f.pdf", "f.pdf", "my-bucket", "us-east-1", "f.pdf");
+    const d = a.toDict();
+    (0, _vitest.expect)(d.bucket).toBe("my-bucket");
+    (0, _vitest.expect)(d.region).toBe("us-east-1");
+    (0, _vitest.expect)(d.endpoint).toBeUndefined();
+  });
+  (0, _vitest.test)("Attachment without S3 fields omits bucket and region", () => {
+    const a = new _Attachment.Attachment("f.pdf", "f.pdf", undefined, undefined, "f.pdf");
+    const d = a.toDict();
+    (0, _vitest.expect)(d.bucket).toBeUndefined();
+    (0, _vitest.expect)(d.region).toBeUndefined();
+    (0, _vitest.expect)(d.endpoint).toBeUndefined();
+  });
+  (0, _vitest.test)("SignedUrlAttachment omits bucket and region, exposes signedUrl", () => {
+    const s = new _Attachment.SignedUrlAttachment("f.pdf", SIGNED_URL, "f.pdf");
+    const d = s.toDict();
+    (0, _vitest.expect)(d.bucket).toBeUndefined();
+    (0, _vitest.expect)(d.region).toBeUndefined();
+    (0, _vitest.expect)(d.endpoint).toBeUndefined();
+    (0, _vitest.expect)(d.signedUrl).toBe(SIGNED_URL);
+  });
+  (0, _vitest.test)("toJSON matches toDict for SignedUrlAttachment", () => {
+    const s = new _Attachment.SignedUrlAttachment("f.pdf", SIGNED_URL, "f.pdf");
+    (0, _vitest.expect)(s.toJSON()).toEqual(s.toDict());
+  });
+});

package/dist/helpers/validateDataUsingSchema.js

@@ -21,11 +21,15 @@ function injectAttachmentType(schema) {
   const attachmentJsonSchema = (0, _zodToJsonSchema.zodToJsonSchema)(_Attachment.AttachmentSchema, {
     $refStrategy: "none"
   });
-  const attachmentDefinition = typeof attachmentJsonSchema === "object" && attachmentJsonSchema !== null ? attachmentJsonSchema : {};
+  const signedUrlAttachmentJsonSchema = (0, _zodToJsonSchema.zodToJsonSchema)(_Attachment.SignedUrlAttachmentSchema, {
+    $refStrategy: "none"
+  });
   if (!schemaCopy.$defs) {
     schemaCopy.$defs = {};
   }
-  schemaCopy.$defs.attachment = attachmentDefinition;
+  schemaCopy.$defs.attachment = {
+    anyOf: [signedUrlAttachmentJsonSchema, attachmentJsonSchema]
+  };
   function replaceAttachmentType(node) {
     if (typeof node !== "object" || node === null) {
       return node;

package/dist/intunedServices/ApiGateway/aiApiGateway.js

@@ -88,16 +88,15 @@ class APIGateway {
     const modelLower = model.toLowerCase();
     return (0, _getModelProvider.getModelProvider)(modelLower);
   }
-  buildGatewayUrl(provider) {
+  buildGatewayUrl() {
     var _this$config$function;
     if (!this.config) {
       throw new Error("Gateway configuration not initialized");
     }
     const baseDomain = (_this$config$function = this.config.functionsDomain) === null || _this$config$function === void 0 ? void 0 : _this$config$function.replace(/\/$/, "");
-    return `${baseDomain}/api/${this.config.workspaceId}/functions/${this.config.integrationId}/${provider === "anthropic" ? "anthropic/v1" : provider === "google_vertexai" ? "google_vertexai/v1beta" : provider}`;
+    return `${baseDomain}/api/${this.config.workspaceId}/functions/${this.config.integrationId}/intuned-ai-gateway`;
   }
   getModelConfig(extraHeaders) {
-    const provider = this.detectProvider(this.model);
     if (!this.useGateway && this.apiKey) {
       return {
         model: this.model,
@@ -106,7 +105,7 @@ class APIGateway {
         baseUrl: undefined
       };
     }
-    const baseUrl = this.buildGatewayUrl(provider);
+    const baseUrl = this.buildGatewayUrl();
     return {
       model: this.model,
       apiKey: "--THIS_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",

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

@@ -118,8 +118,8 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
         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");
+      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");
@@ -130,8 +130,8 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
         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");
+      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");
@@ -142,8 +142,8 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
         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");
+      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/";
@@ -155,8 +155,8 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
         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");
+      const result = newGateway["buildGatewayUrl"]();
+      (0, _extendedTest.expect)(result).toBe("https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway");
     });
   });
   (0, _extendedTest.describe)("ensureInitialized", () => {
@@ -236,7 +236,7 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
         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"
+        baseUrl: "https://functions.example.com/api/workspace123/functions/integration456/intuned-ai-gateway"
       });
       (0, _extendedTest.expect)(result).toBe(mockInstance);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intuned/browser-dev",
-  "version": "0.1.10-dev.0",
+  "version": "0.1.13-dev.0",
   "description": "runner package for intuned functions",
   "types": "./dist/index.d.ts",
   "typesVersions": {