@slates/provider 1.0.0-rc.20 → 1.0.0-rc.22

package/dist/index.cjs

@@ -1051,6 +1051,91 @@ var SlateActionBuilder = class {
 // src/action/getFileUrlTool.ts
 var import_zod = require("zod");
 
+// src/auth/redact.ts
+var AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX = "$$MT$secret$authConfig$";
+var AuthConfigSecretRedactor = class {
+  secretToPlaceholder = /* @__PURE__ */ new Map();
+  constructor(authConfig) {
+    if (authConfig) this.buildSecretMap(authConfig);
+  }
+  redact(value) {
+    return this.transform(value, (stringValue) => {
+      return this.secretToPlaceholder.get(stringValue) ?? stringValue;
+    });
+  }
+  redactEmbedded(value) {
+    if (this.secretToPlaceholder.size === 0) return value;
+    let pattern = new RegExp(
+      [...this.secretToPlaceholder.keys()].sort((a, b) => b.length - a.length).map((secret) => secret.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"),
+      "g"
+    );
+    return this.transform(value, (stringValue) => {
+      let exactPlaceholder = this.secretToPlaceholder.get(stringValue);
+      if (exactPlaceholder) return exactPlaceholder;
+      return stringValue.replace(
+        pattern,
+        (secret) => `${this.secretToPlaceholder.get(secret)}$$`
+      );
+    });
+  }
+  buildSecretMap(value, path = []) {
+    if (typeof value === "string") {
+      if (value.length === 0) return;
+      this.secretToPlaceholder.set(
+        value,
+        `${AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX}${path.join(".")}`
+      );
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        this.buildSecretMap(item, [...path, String(index)]);
+      });
+      return;
+    }
+    if (this.isPlainObject(value)) {
+      Object.entries(value).forEach(([key, nestedValue]) => {
+        this.buildSecretMap(nestedValue, [...path, key]);
+      });
+    }
+  }
+  transform(value, transformString) {
+    if (typeof value === "string") {
+      return transformString(value);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.transform(item, transformString));
+    }
+    if (this.isPlainObject(value)) {
+      let result = {};
+      Object.entries(value).forEach(([key, nestedValue]) => {
+        result[key] = this.transform(nestedValue, transformString);
+      });
+      return result;
+    }
+    return value;
+  }
+  isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+};
+var redactUrlAttachmentSecrets = (attachments, authConfig) => {
+  if (!authConfig || !attachments) return attachments;
+  let redactor = new AuthConfigSecretRedactor(authConfig);
+  return attachments.map((attachment) => {
+    if (attachment.content.type !== "url") return attachment;
+    if (!attachment.content.headers && !attachment.content.query) return attachment;
+    return {
+      ...attachment,
+      content: {
+        ...attachment.content,
+        headers: attachment.content.headers ? redactor.redactEmbedded(attachment.content.headers) : void 0,
+        query: attachment.content.query ? redactor.redactEmbedded(attachment.content.query) : void 0
+      }
+    };
+  });
+};
+
 // src/action/tool.ts
 var SlateTool = class _SlateTool extends SlateAction {
   #handleInvocation;
@@ -1089,10 +1174,18 @@ var getFileUrlTool = (spec2, handleGetFileUrl) => tool(spec2, {
   key: GET_FILE_URL_TOOL_ID,
   name: "Get File URL",
   description: "Reserved: refreshes an expiring attachment download URL. Hub-internal only."
-}).input(getFileUrlToolInputSchema).output(getFileUrlToolOutputSchema).handleInvocation(async (ctx) => ({
-  output: await handleGetFileUrl(ctx),
-  message: "ok"
-})).build();
+}).input(getFileUrlToolInputSchema).output(getFileUrlToolOutputSchema).handleInvocation(async (ctx) => {
+  let output = await handleGetFileUrl(ctx);
+  let redactor = new AuthConfigSecretRedactor(ctx._getAuthConfigForRedaction());
+  return {
+    output: {
+      ...output,
+      ...output.headers ? { headers: redactor.redactEmbedded(output.headers) } : {},
+      ...output.query ? { query: redactor.redactEmbedded(output.query) } : {}
+    },
+    message: "ok"
+  };
+}).build();
 
 // src/action/publicTool.ts
 var SlatePublicTool = class {
@@ -1210,8 +1303,41 @@ var createTextAttachment = (content, mimeType, attachmentHash) => ({
 });
 
 // src/action/directUpload.ts
+var bufferAttachmentBody = async (body, maxSizeBytes) => {
+  if (body instanceof Uint8Array) {
+    if (body.byteLength > maxSizeBytes) {
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    let buffered2 = new ArrayBuffer(body.byteLength);
+    new Uint8Array(buffered2).set(body);
+    return buffered2;
+  }
+  let reader = body.getReader();
+  let chunks = [];
+  let sizeBytes = 0;
+  while (true) {
+    let { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    sizeBytes += value.byteLength;
+    if (sizeBytes > maxSizeBytes) {
+      await reader.cancel();
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    chunks.push(value);
+  }
+  let buffered = new ArrayBuffer(sizeBytes);
+  let bufferedView = new Uint8Array(buffered);
+  let offset = 0;
+  for (let chunk of chunks) {
+    bufferedView.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return buffered;
+};
 var uploadAttachmentDirect = async (d) => {
   let baseUrl = d.live.baseUrl.replace(/\/$/, "");
+  let body = await bufferAttachmentBody(d.body, d.live.maxAttachmentSizeBytes);
   let registerRes = await fetch(`${baseUrl}/slates-hub/live-invocation/attachments`, {
     method: "POST",
     headers: {
@@ -1219,7 +1345,13 @@ var uploadAttachmentDirect = async (d) => {
       authorization: `Bearer ${d.live.token}`
     },
     body: JSON.stringify({
-      attachments: [{ mimeType: d.mimeType, filename: d.filename }]
+      attachments: [
+        {
+          mimeType: d.mimeType,
+          filename: d.filename,
+          sizeBytes: body.byteLength || void 0
+        }
+      ]
     })
   });
   if (!registerRes.ok) {
@@ -1234,9 +1366,11 @@ var uploadAttachmentDirect = async (d) => {
   }
   let putRes = await fetch(registration.uploadUrl, {
     method: "PUT",
-    ...d.body instanceof Uint8Array ? {} : { duplex: "half" },
-    headers: d.mimeType ? { "content-type": d.mimeType } : void 0,
-    body: d.body
+    headers: {
+      ...d.mimeType ? { "content-type": d.mimeType } : {},
+      "content-length": String(body.byteLength)
+    },
+    body
   });
   if (!putRes.ok) {
     throw new Error(`Failed to upload attachment content (status ${putRes.status})`);
@@ -1517,76 +1651,6 @@ var normalizeOAuthTokenResponse = (data, options = {}) => {
   };
 };
 
-// src/auth/redact.ts
-var AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX = "$$MT$secret$authConfig$";
-var AuthConfigSecretRedactor = class {
-  secretToPlaceholder = /* @__PURE__ */ new Map();
-  constructor(authConfig) {
-    if (authConfig) this.buildSecretMap(authConfig);
-  }
-  redact(value) {
-    return this.transform(value, (stringValue) => {
-      return this.secretToPlaceholder.get(stringValue) ?? stringValue;
-    });
-  }
-  buildSecretMap(value, path = []) {
-    if (typeof value === "string") {
-      if (value.length === 0) return;
-      this.secretToPlaceholder.set(
-        value,
-        `${AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX}${path.join(".")}`
-      );
-      return;
-    }
-    if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        this.buildSecretMap(item, [...path, String(index)]);
-      });
-      return;
-    }
-    if (this.isPlainObject(value)) {
-      Object.entries(value).forEach(([key, nestedValue]) => {
-        this.buildSecretMap(nestedValue, [...path, key]);
-      });
-    }
-  }
-  transform(value, transformString) {
-    if (typeof value === "string") {
-      return transformString(value);
-    }
-    if (Array.isArray(value)) {
-      return value.map((item) => this.transform(item, transformString));
-    }
-    if (this.isPlainObject(value)) {
-      let result = {};
-      Object.entries(value).forEach(([key, nestedValue]) => {
-        result[key] = this.transform(nestedValue, transformString);
-      });
-      return result;
-    }
-    return value;
-  }
-  isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-  }
-};
-var redactUrlAttachmentSecrets = (attachments, authConfig) => {
-  if (!authConfig || !attachments) return attachments;
-  let redactor = new AuthConfigSecretRedactor(authConfig);
-  return attachments.map((attachment) => {
-    if (attachment.content.type !== "url") return attachment;
-    if (!attachment.content.headers && !attachment.content.query) return attachment;
-    return {
-      ...attachment,
-      content: {
-        ...attachment.content,
-        headers: attachment.content.headers ? redactor.redact(attachment.content.headers) : void 0,
-        query: attachment.content.query ? redactor.redact(attachment.content.query) : void 0
-      }
-    };
-  });
-};
-
 // src/axios/index.ts
 var import_axios3 = __toESM(require("axios"), 1);
 

package/dist/index.d.cts

@@ -42,15 +42,15 @@ declare let createTextAttachment: (content: string, mimeType?: string, attachmen
  */
 declare let AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX: string;
 /**
- * Walks an auth config object and replaces any string value that exactly matches one of its
- * leaf values with a `$$MT$secret$authConfig$<path>` placeholder. Literal, whole-value
- * substitution only -- not a substring scan, and not a heuristic key-name/value-shape guess
- * like the http trace redactor in '../axios/trace'.
+ * Maps auth-config string leaves to `$$MT$secret$authConfig$<path>` placeholders.
+ * `redact` preserves whole-value substitution for HTTP traces; `redactEmbedded` also
+ * replaces embedded values in attachment credentials, terminating those placeholders with `$$`.
  */
 declare class AuthConfigSecretRedactor {
     private readonly secretToPlaceholder;
     constructor(authConfig: Record<string, unknown> | undefined);
     redact<T>(value: T): T;
+    redactEmbedded<T>(value: T): T;
     private buildSecretMap;
     private transform;
     private isPlainObject;

package/dist/index.d.ts

@@ -42,15 +42,15 @@ declare let createTextAttachment: (content: string, mimeType?: string, attachmen
  */
 declare let AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX: string;
 /**
- * Walks an auth config object and replaces any string value that exactly matches one of its
- * leaf values with a `$$MT$secret$authConfig$<path>` placeholder. Literal, whole-value
- * substitution only -- not a substring scan, and not a heuristic key-name/value-shape guess
- * like the http trace redactor in '../axios/trace'.
+ * Maps auth-config string leaves to `$$MT$secret$authConfig$<path>` placeholders.
+ * `redact` preserves whole-value substitution for HTTP traces; `redactEmbedded` also
+ * replaces embedded values in attachment credentials, terminating those placeholders with `$$`.
  */
 declare class AuthConfigSecretRedactor {
     private readonly secretToPlaceholder;
     constructor(authConfig: Record<string, unknown> | undefined);
     redact<T>(value: T): T;
+    redactEmbedded<T>(value: T): T;
     private buildSecretMap;
     private transform;
     private isPlainObject;

package/dist/index.module.js

@@ -942,6 +942,91 @@ var SlateActionBuilder = class {
 // src/action/getFileUrlTool.ts
 import { z } from "zod";
 
+// src/auth/redact.ts
+var AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX = "$$MT$secret$authConfig$";
+var AuthConfigSecretRedactor = class {
+  secretToPlaceholder = /* @__PURE__ */ new Map();
+  constructor(authConfig) {
+    if (authConfig) this.buildSecretMap(authConfig);
+  }
+  redact(value) {
+    return this.transform(value, (stringValue) => {
+      return this.secretToPlaceholder.get(stringValue) ?? stringValue;
+    });
+  }
+  redactEmbedded(value) {
+    if (this.secretToPlaceholder.size === 0) return value;
+    let pattern = new RegExp(
+      [...this.secretToPlaceholder.keys()].sort((a, b) => b.length - a.length).map((secret) => secret.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"),
+      "g"
+    );
+    return this.transform(value, (stringValue) => {
+      let exactPlaceholder = this.secretToPlaceholder.get(stringValue);
+      if (exactPlaceholder) return exactPlaceholder;
+      return stringValue.replace(
+        pattern,
+        (secret) => `${this.secretToPlaceholder.get(secret)}$$`
+      );
+    });
+  }
+  buildSecretMap(value, path = []) {
+    if (typeof value === "string") {
+      if (value.length === 0) return;
+      this.secretToPlaceholder.set(
+        value,
+        `${AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX}${path.join(".")}`
+      );
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        this.buildSecretMap(item, [...path, String(index)]);
+      });
+      return;
+    }
+    if (this.isPlainObject(value)) {
+      Object.entries(value).forEach(([key, nestedValue]) => {
+        this.buildSecretMap(nestedValue, [...path, key]);
+      });
+    }
+  }
+  transform(value, transformString) {
+    if (typeof value === "string") {
+      return transformString(value);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.transform(item, transformString));
+    }
+    if (this.isPlainObject(value)) {
+      let result = {};
+      Object.entries(value).forEach(([key, nestedValue]) => {
+        result[key] = this.transform(nestedValue, transformString);
+      });
+      return result;
+    }
+    return value;
+  }
+  isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+};
+var redactUrlAttachmentSecrets = (attachments, authConfig) => {
+  if (!authConfig || !attachments) return attachments;
+  let redactor = new AuthConfigSecretRedactor(authConfig);
+  return attachments.map((attachment) => {
+    if (attachment.content.type !== "url") return attachment;
+    if (!attachment.content.headers && !attachment.content.query) return attachment;
+    return {
+      ...attachment,
+      content: {
+        ...attachment.content,
+        headers: attachment.content.headers ? redactor.redactEmbedded(attachment.content.headers) : void 0,
+        query: attachment.content.query ? redactor.redactEmbedded(attachment.content.query) : void 0
+      }
+    };
+  });
+};
+
 // src/action/tool.ts
 var SlateTool = class _SlateTool extends SlateAction {
   #handleInvocation;
@@ -980,10 +1065,18 @@ var getFileUrlTool = (spec2, handleGetFileUrl) => tool(spec2, {
   key: GET_FILE_URL_TOOL_ID,
   name: "Get File URL",
   description: "Reserved: refreshes an expiring attachment download URL. Hub-internal only."
-}).input(getFileUrlToolInputSchema).output(getFileUrlToolOutputSchema).handleInvocation(async (ctx) => ({
-  output: await handleGetFileUrl(ctx),
-  message: "ok"
-})).build();
+}).input(getFileUrlToolInputSchema).output(getFileUrlToolOutputSchema).handleInvocation(async (ctx) => {
+  let output = await handleGetFileUrl(ctx);
+  let redactor = new AuthConfigSecretRedactor(ctx._getAuthConfigForRedaction());
+  return {
+    output: {
+      ...output,
+      ...output.headers ? { headers: redactor.redactEmbedded(output.headers) } : {},
+      ...output.query ? { query: redactor.redactEmbedded(output.query) } : {}
+    },
+    message: "ok"
+  };
+}).build();
 
 // src/action/publicTool.ts
 var SlatePublicTool = class {
@@ -1101,8 +1194,41 @@ var createTextAttachment = (content, mimeType, attachmentHash) => ({
 });
 
 // src/action/directUpload.ts
+var bufferAttachmentBody = async (body, maxSizeBytes) => {
+  if (body instanceof Uint8Array) {
+    if (body.byteLength > maxSizeBytes) {
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    let buffered2 = new ArrayBuffer(body.byteLength);
+    new Uint8Array(buffered2).set(body);
+    return buffered2;
+  }
+  let reader = body.getReader();
+  let chunks = [];
+  let sizeBytes = 0;
+  while (true) {
+    let { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    sizeBytes += value.byteLength;
+    if (sizeBytes > maxSizeBytes) {
+      await reader.cancel();
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    chunks.push(value);
+  }
+  let buffered = new ArrayBuffer(sizeBytes);
+  let bufferedView = new Uint8Array(buffered);
+  let offset = 0;
+  for (let chunk of chunks) {
+    bufferedView.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return buffered;
+};
 var uploadAttachmentDirect = async (d) => {
   let baseUrl = d.live.baseUrl.replace(/\/$/, "");
+  let body = await bufferAttachmentBody(d.body, d.live.maxAttachmentSizeBytes);
   let registerRes = await fetch(`${baseUrl}/slates-hub/live-invocation/attachments`, {
     method: "POST",
     headers: {
@@ -1110,7 +1236,13 @@ var uploadAttachmentDirect = async (d) => {
       authorization: `Bearer ${d.live.token}`
     },
     body: JSON.stringify({
-      attachments: [{ mimeType: d.mimeType, filename: d.filename }]
+      attachments: [
+        {
+          mimeType: d.mimeType,
+          filename: d.filename,
+          sizeBytes: body.byteLength || void 0
+        }
+      ]
     })
   });
   if (!registerRes.ok) {
@@ -1125,9 +1257,11 @@ var uploadAttachmentDirect = async (d) => {
   }
   let putRes = await fetch(registration.uploadUrl, {
     method: "PUT",
-    ...d.body instanceof Uint8Array ? {} : { duplex: "half" },
-    headers: d.mimeType ? { "content-type": d.mimeType } : void 0,
-    body: d.body
+    headers: {
+      ...d.mimeType ? { "content-type": d.mimeType } : {},
+      "content-length": String(body.byteLength)
+    },
+    body
   });
   if (!putRes.ok) {
     throw new Error(`Failed to upload attachment content (status ${putRes.status})`);
@@ -1408,76 +1542,6 @@ var normalizeOAuthTokenResponse = (data, options = {}) => {
   };
 };
 
-// src/auth/redact.ts
-var AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX = "$$MT$secret$authConfig$";
-var AuthConfigSecretRedactor = class {
-  secretToPlaceholder = /* @__PURE__ */ new Map();
-  constructor(authConfig) {
-    if (authConfig) this.buildSecretMap(authConfig);
-  }
-  redact(value) {
-    return this.transform(value, (stringValue) => {
-      return this.secretToPlaceholder.get(stringValue) ?? stringValue;
-    });
-  }
-  buildSecretMap(value, path = []) {
-    if (typeof value === "string") {
-      if (value.length === 0) return;
-      this.secretToPlaceholder.set(
-        value,
-        `${AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX}${path.join(".")}`
-      );
-      return;
-    }
-    if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        this.buildSecretMap(item, [...path, String(index)]);
-      });
-      return;
-    }
-    if (this.isPlainObject(value)) {
-      Object.entries(value).forEach(([key, nestedValue]) => {
-        this.buildSecretMap(nestedValue, [...path, key]);
-      });
-    }
-  }
-  transform(value, transformString) {
-    if (typeof value === "string") {
-      return transformString(value);
-    }
-    if (Array.isArray(value)) {
-      return value.map((item) => this.transform(item, transformString));
-    }
-    if (this.isPlainObject(value)) {
-      let result = {};
-      Object.entries(value).forEach(([key, nestedValue]) => {
-        result[key] = this.transform(nestedValue, transformString);
-      });
-      return result;
-    }
-    return value;
-  }
-  isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-  }
-};
-var redactUrlAttachmentSecrets = (attachments, authConfig) => {
-  if (!authConfig || !attachments) return attachments;
-  let redactor = new AuthConfigSecretRedactor(authConfig);
-  return attachments.map((attachment) => {
-    if (attachment.content.type !== "url") return attachment;
-    if (!attachment.content.headers && !attachment.content.query) return attachment;
-    return {
-      ...attachment,
-      content: {
-        ...attachment.content,
-        headers: attachment.content.headers ? redactor.redact(attachment.content.headers) : void 0,
-        query: attachment.content.query ? redactor.redact(attachment.content.query) : void 0
-      }
-    };
-  });
-};
-
 // src/axios/index.ts
 import baseAxios, { getAdapter, isAxiosError as isAxiosError2 } from "axios";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider",
-  "version": "1.0.0-rc.20",
+  "version": "1.0.0-rc.22",
   "publishConfig": {
     "access": "public"
   },
@@ -43,4 +43,4 @@
     "typescript": "5.8.2",
     "vitest": "^3.1.2"
   }
-}
+}

package/src/action/directUpload.test.ts

@@ -0,0 +1,72 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { uploadAttachmentDirect } from './directUpload';
+
+let live = {
+  token: 'live-token',
+  baseUrl: 'https://hub.example/',
+  maxAttachmentSizeBytes: 10
+};
+
+describe('uploadAttachmentDirect', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('buffers streams and uploads them with their exact content length', async () => {
+    let fetchSpy = vi
+      .spyOn(globalThis, 'fetch')
+      .mockResolvedValueOnce(
+        Response.json({
+          attachments: [
+            { referenceId: 'attachment-reference', uploadUrl: 'https://s3.example/upload' }
+          ]
+        })
+      )
+      .mockResolvedValueOnce(new Response(null, { status: 200 }));
+    let body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new Uint8Array([1, 2]));
+        controller.enqueue(new Uint8Array([3, 4, 5]));
+        controller.close();
+      }
+    });
+
+    await expect(
+      uploadAttachmentDirect({ live, body, mimeType: 'application/octet-stream' })
+    ).resolves.toEqual({
+      mimeType: 'application/octet-stream',
+      content: { type: 'upload_reference', referenceId: 'attachment-reference' }
+    });
+
+    expect(JSON.parse(fetchSpy.mock.calls[0]![1]!.body as string)).toEqual({
+      attachments: [{ mimeType: 'application/octet-stream', sizeBytes: 5 }]
+    });
+    let upload = fetchSpy.mock.calls[1]!;
+    expect(upload[0]).toBe('https://s3.example/upload');
+    expect(upload[1]).toMatchObject({
+      method: 'PUT',
+      headers: {
+        'content-type': 'application/octet-stream',
+        'content-length': '5'
+      }
+    });
+    expect(new Uint8Array(upload[1]!.body as ArrayBuffer)).toEqual(
+      new Uint8Array([1, 2, 3, 4, 5])
+    );
+    expect(upload[1]).not.toHaveProperty('duplex');
+  });
+
+  it('rejects an oversized stream before registering an upload', async () => {
+    let fetchSpy = vi.spyOn(globalThis, 'fetch');
+    let body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new Uint8Array(11));
+      }
+    });
+
+    await expect(uploadAttachmentDirect({ live, body })).rejects.toThrow(
+      'Attachment exceeds the maximum size of 10 bytes'
+    );
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+});

package/src/action/directUpload.ts

@@ -13,10 +13,52 @@ export interface SlateDirectUploadInput {
   body: ReadableStream<Uint8Array> | Uint8Array;
 }
 
+let bufferAttachmentBody = async (
+  body: SlateDirectUploadInput['body'],
+  maxSizeBytes: number
+): Promise<ArrayBuffer> => {
+  if (body instanceof Uint8Array) {
+    if (body.byteLength > maxSizeBytes) {
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+
+    let buffered = new ArrayBuffer(body.byteLength);
+    new Uint8Array(buffered).set(body);
+    return buffered;
+  }
+
+  let reader = body.getReader();
+  let chunks: Uint8Array[] = [];
+  let sizeBytes = 0;
+
+  while (true) {
+    let { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+
+    sizeBytes += value.byteLength;
+    if (sizeBytes > maxSizeBytes) {
+      await reader.cancel();
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    chunks.push(value);
+  }
+
+  let buffered = new ArrayBuffer(sizeBytes);
+  let bufferedView = new Uint8Array(buffered);
+  let offset = 0;
+  for (let chunk of chunks) {
+    bufferedView.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return buffered;
+};
+
 export let uploadAttachmentDirect = async (
   d: SlateDirectUploadInput
 ): Promise<SlateAttachment> => {
   let baseUrl = d.live.baseUrl.replace(/\/$/, '');
+  let body = await bufferAttachmentBody(d.body, d.live.maxAttachmentSizeBytes);
 
   let registerRes = await fetch(`${baseUrl}/slates-hub/live-invocation/attachments`, {
     method: 'POST',
@@ -25,7 +67,13 @@ export let uploadAttachmentDirect = async (
       authorization: `Bearer ${d.live.token}`
     },
     body: JSON.stringify({
-      attachments: [{ mimeType: d.mimeType, filename: d.filename }]
+      attachments: [
+        {
+          mimeType: d.mimeType,
+          filename: d.filename,
+          sizeBytes: body.byteLength || undefined
+        }
+      ]
     })
   });
   if (!registerRes.ok) {
@@ -44,9 +92,11 @@ export let uploadAttachmentDirect = async (
 
   let putRes = await fetch(registration.uploadUrl, {
     method: 'PUT',
-    ...(d.body instanceof Uint8Array ? {} : ({ duplex: 'half' } as any)),
-    headers: d.mimeType ? { 'content-type': d.mimeType } : undefined,
-    body: d.body
+    headers: {
+      ...(d.mimeType ? { 'content-type': d.mimeType } : {}),
+      'content-length': String(body.byteLength)
+    },
+    body
   });
   if (!putRes.ok) {
     throw new Error(`Failed to upload attachment content (status ${putRes.status})`);

package/src/action/getFileUrlTool.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { AuthConfigSecretRedactor } from '../auth/redact';
 import type { SlateContext } from '../context/context';
 import type { SlateSpecification } from '../specification/specification';
 import { tool } from './tool';
@@ -34,8 +35,17 @@ export let getFileUrlTool = <ConfigType extends {}, AuthType extends {}>(
   })
     .input(getFileUrlToolInputSchema)
     .output(getFileUrlToolOutputSchema)
-    .handleInvocation(async ctx => ({
-      output: await handleGetFileUrl(ctx),
-      message: 'ok'
-    }))
+    .handleInvocation(async ctx => {
+      let output = await handleGetFileUrl(ctx);
+      let redactor = new AuthConfigSecretRedactor(ctx._getAuthConfigForRedaction());
+
+      return {
+        output: {
+          ...output,
+          ...(output.headers ? { headers: redactor.redactEmbedded(output.headers) } : {}),
+          ...(output.query ? { query: redactor.redactEmbedded(output.query) } : {})
+        },
+        message: 'ok'
+      };
+    })
     .build();

package/src/auth/redact.test.ts

@@ -49,6 +49,98 @@ describe('AuthConfigSecretRedactor', () => {
   });
 });
 
+describe('AuthConfigSecretRedactor.redactEmbedded', () => {
+  it('preserves the legacy placeholder format for whole-value matches', () => {
+    let redactor = new AuthConfigSecretRedactor({
+      token: 'ABC',
+      nested: { tokens: ['XYZ'] }
+    });
+
+    expect(redactor.redactEmbedded({ values: ['ABC', 'XYZ', 'plain', 42, null] })).toEqual({
+      values: [
+        '$$MT$secret$authConfig$token',
+        '$$MT$secret$authConfig$nested.tokens.0',
+        'plain',
+        42,
+        null
+      ]
+    });
+  });
+
+  it('terminates embedded placeholders before prefixes, suffixes, and adjacent literals', () => {
+    let redactor = new AuthConfigSecretRedactor({ token: 'ABC', token2: 'XYZ' });
+
+    expect(
+      redactor.redactEmbedded({
+        bearer: 'Bearer ABC',
+        suffix: 'ABC2',
+        multiple: 'ABC:XYZ:ABC',
+        adjacent: 'ABCXYZ'
+      })
+    ).toEqual({
+      bearer: 'Bearer $$MT$secret$authConfig$token$$',
+      suffix: '$$MT$secret$authConfig$token$$2',
+      multiple:
+        '$$MT$secret$authConfig$token$$:$$MT$secret$authConfig$token2$$:$$MT$secret$authConfig$token$$',
+      adjacent: '$$MT$secret$authConfig$token$$$$MT$secret$authConfig$token2$$'
+    });
+  });
+
+  it('matches overlapping secrets longest-first', () => {
+    let redactor = new AuthConfigSecretRedactor({ token: 'ABC', longer: 'ABC2' });
+
+    expect(redactor.redactEmbedded('ABC2 ABC')).toBe(
+      '$$MT$secret$authConfig$longer$$ $$MT$secret$authConfig$token$$'
+    );
+    expect(redactor.redactEmbedded('ABC2')).toBe('$$MT$secret$authConfig$longer');
+  });
+
+  it('does not scan emitted placeholders again', () => {
+    let redactor = new AuthConfigSecretRedactor({ token: 'ABC', other: 'token' });
+
+    expect(redactor.redactEmbedded('Bearer ABC token')).toBe(
+      'Bearer $$MT$secret$authConfig$token$$ $$MT$secret$authConfig$other$$'
+    );
+  });
+
+  it.each([
+    '.',
+    '*',
+    '+',
+    '?',
+    '^',
+    '$',
+    '{',
+    '}',
+    '(',
+    ')',
+    '|',
+    '[',
+    ']',
+    '\\'
+  ])('treats %s literally in secret values', character => {
+    let secret = `${character}secret`;
+    let redactor = new AuthConfigSecretRedactor({ token: secret });
+
+    expect(redactor.redactEmbedded(`prefix ${secret} suffix`)).toBe(
+      'prefix $$MT$secret$authConfig$token$$ suffix'
+    );
+    expect(redactor.redactEmbedded('prefix secret suffix')).toBe('prefix secret suffix');
+  });
+
+  it('ignores empty secrets and leaves unrelated values unchanged', () => {
+    let redactor = new AuthConfigSecretRedactor({ empty: '', token: 'ABC' });
+
+    expect(redactor.redactEmbedded({ empty: '', plain: 'plain', token: 'ABC' })).toEqual({
+      empty: '',
+      plain: 'plain',
+      token: '$$MT$secret$authConfig$token'
+    });
+    expect(new AuthConfigSecretRedactor({ empty: '' }).redactEmbedded('plain')).toBe('plain');
+    expect(new AuthConfigSecretRedactor(undefined).redactEmbedded('plain')).toBe('plain');
+  });
+});
+
 describe('redactUrlAttachmentSecrets', () => {
   let authConfig = { token: '123SECRET', nested: { token2: 'also_secret' } };
 
@@ -69,12 +161,40 @@ describe('redactUrlAttachmentSecrets', () => {
 
     expect(redactUrlAttachmentSecrets(attachments, authConfig)).toEqual([
       urlAttachment({
-        headers: { Authorization: 'Bearer 123SECRET' },
+        headers: { Authorization: 'Bearer $$MT$secret$authConfig$token$$' },
         query: { key: '$$MT$secret$authConfig$nested.token2' }
       })
     ]);
   });
 
+  it('only changes header and query values, preserving metadata and the original attachment', () => {
+    let attachment: SlateAttachment = {
+      mimeType: 'application/pdf',
+      attachmentHash: 'file-hash',
+      content: {
+        type: 'url',
+        url: 'https://example.com/123SECRET/file.pdf',
+        headers: { Authorization: 'Bearer 123SECRET' },
+        query: { key: 'also_secret-suffix' },
+        refreshReference: { id: 'file-1' },
+        refreshAt: '2026-09-10T00:00:00Z'
+      }
+    };
+    let original = structuredClone(attachment);
+
+    expect(redactUrlAttachmentSecrets([attachment], authConfig)).toEqual([
+      {
+        ...original,
+        content: {
+          ...original.content,
+          headers: { Authorization: 'Bearer $$MT$secret$authConfig$token$$' },
+          query: { key: '$$MT$secret$authConfig$nested.token2$$-suffix' }
+        }
+      }
+    ]);
+    expect(attachment).toEqual(original);
+  });
+
   it('leaves url attachments with no headers/query untouched', () => {
     let attachments = [urlAttachment()];
     expect(redactUrlAttachmentSecrets(attachments, authConfig)).toEqual(attachments);

package/src/auth/redact.ts

@@ -8,10 +8,9 @@ import type { SlateAttachment } from '../action/attachment';
 export let AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX = '$$MT$secret$authConfig$';
 
 /**
- * Walks an auth config object and replaces any string value that exactly matches one of its
- * leaf values with a `$$MT$secret$authConfig$<path>` placeholder. Literal, whole-value
- * substitution only -- not a substring scan, and not a heuristic key-name/value-shape guess
- * like the http trace redactor in '../axios/trace'.
+ * Maps auth-config string leaves to `$$MT$secret$authConfig$<path>` placeholders.
+ * `redact` preserves whole-value substitution for HTTP traces; `redactEmbedded` also
+ * replaces embedded values in attachment credentials, terminating those placeholders with `$$`.
  */
 export class AuthConfigSecretRedactor {
   private readonly secretToPlaceholder = new Map<string, string>();
@@ -26,6 +25,29 @@ export class AuthConfigSecretRedactor {
     });
   }
 
+  public redactEmbedded<T>(value: T): T {
+    if (this.secretToPlaceholder.size === 0) return value;
+
+    let pattern = new RegExp(
+      [...this.secretToPlaceholder.keys()]
+        .sort((a, b) => b.length - a.length)
+        // Escape regex metacharacters so values match literally; $& inserts the matched character.
+        .map(secret => secret.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+        .join('|'),
+      'g'
+    );
+
+    return this.transform(value, stringValue => {
+      let exactPlaceholder = this.secretToPlaceholder.get(stringValue);
+      if (exactPlaceholder) return exactPlaceholder;
+
+      return stringValue.replace(
+        pattern,
+        secret => `${this.secretToPlaceholder.get(secret)}$$`
+      );
+    });
+  }
+
   private buildSecretMap(value: unknown, path: string[] = []): void {
     if (typeof value === 'string') {
       // Never register "" -- it would replace every empty header/query value with a placeholder.
@@ -102,9 +124,11 @@ export let redactUrlAttachmentSecrets = (
       content: {
         ...attachment.content,
         headers: attachment.content.headers
-          ? redactor.redact(attachment.content.headers)
+          ? redactor.redactEmbedded(attachment.content.headers)
           : undefined,
-        query: attachment.content.query ? redactor.redact(attachment.content.query) : undefined
+        query: attachment.content.query
+          ? redactor.redactEmbedded(attachment.content.query)
+          : undefined
       }
     };
   });