@ethisyscore/extension-runtime 1.33.0 → 1.35.0

package/dist/{bridge-client-UK3qcGoi.d.ts → bridge-client-DD99netz.d.ts}

@@ -1,35 +1,4 @@
-import { d as BridgePushThemeEnvelope, c as BridgePushLocaleEnvelope, b as BridgePushDensityEnvelope, a as BridgePushA11yEnvelope, B as BridgeNavPushEnvelope, e as BridgeSessionTokenPushEnvelope } from './bridge-envelopes-BRKGSiSC.js';
-
-/**
- * Transport contract used by the plugin-side React hooks
- * (`useMcpResource`, `useMcpTool`) to talk to the host.
- *
- * The hooks are deliberately transport-agnostic: the concrete implementation
- * (postMessage bridge, in-process direct call, fetch-based, …) is injected
- * via {@link ExtensionRuntimeProvider} or the per-hook `transport` option.
- * This keeps the React surface stable across Contract A (host-rendered) and
- * Contract B (worker remote-runtime) execution modes.
- *
- * Implementations must honour the supplied {@link AbortSignal} for
- * cancellation — hooks rely on it to tear down in-flight calls on unmount
- * or argument changes.
- */
-interface McpTransport {
-    /**
-     * Fetch a resource by URI. Implementations should reject with an `Error`
-     * when the host returns a failure, and should observe `signal` to abort
-     * any in-flight work.
-     */
-    getResource<T>(uri: string, signal?: AbortSignal): Promise<{
-        uri: string;
-        data: T;
-    }>;
-    /**
-     * Invoke a tool by name. The request object is opaque to the transport.
-     * Implementations should observe `signal` to abort in-flight work.
-     */
-    invokeTool<TReq, TRes>(name: string, args: TReq, signal?: AbortSignal): Promise<TRes>;
-}
+import { d as BridgePushThemeEnvelope, c as BridgePushLocaleEnvelope, b as BridgePushDensityEnvelope, a as BridgePushA11yEnvelope, B as BridgeNavPushEnvelope, e as BridgeSessionTokenPushEnvelope } from './bridge-envelopes-DA6vxbyb.js';
 
 /**
  * Plugin-side bridge client for the host ↔ plugin platform contract
@@ -99,4 +68,4 @@ interface PortBridgeClient {
  */
 declare function createPortBridgeClient(port: BridgePortShim): PortBridgeClient;
 
-export { type A11yPayload as A, type BridgePortShim as B, type DensityPayload as D, type LocalePayload as L, type McpTransport as M, type NavPayload as N, type PortBridgeClient as P, type SessionTokenPayload as S, type ThemePayload as T, createPortBridgeClient as c };
+export { type A11yPayload as A, type BridgePortShim as B, type DensityPayload as D, type LocalePayload as L, type NavPayload as N, type PortBridgeClient as P, type SessionTokenPayload as S, type ThemePayload as T, createPortBridgeClient as c };

package/dist/{bridge-client-CIThO7jZ.d.cts → bridge-client-DzRcKIJT.d.cts}

@@ -1,35 +1,4 @@
-import { d as BridgePushThemeEnvelope, c as BridgePushLocaleEnvelope, b as BridgePushDensityEnvelope, a as BridgePushA11yEnvelope, B as BridgeNavPushEnvelope, e as BridgeSessionTokenPushEnvelope } from './bridge-envelopes-BRKGSiSC.cjs';
-
-/**
- * Transport contract used by the plugin-side React hooks
- * (`useMcpResource`, `useMcpTool`) to talk to the host.
- *
- * The hooks are deliberately transport-agnostic: the concrete implementation
- * (postMessage bridge, in-process direct call, fetch-based, …) is injected
- * via {@link ExtensionRuntimeProvider} or the per-hook `transport` option.
- * This keeps the React surface stable across Contract A (host-rendered) and
- * Contract B (worker remote-runtime) execution modes.
- *
- * Implementations must honour the supplied {@link AbortSignal} for
- * cancellation — hooks rely on it to tear down in-flight calls on unmount
- * or argument changes.
- */
-interface McpTransport {
-    /**
-     * Fetch a resource by URI. Implementations should reject with an `Error`
-     * when the host returns a failure, and should observe `signal` to abort
-     * any in-flight work.
-     */
-    getResource<T>(uri: string, signal?: AbortSignal): Promise<{
-        uri: string;
-        data: T;
-    }>;
-    /**
-     * Invoke a tool by name. The request object is opaque to the transport.
-     * Implementations should observe `signal` to abort in-flight work.
-     */
-    invokeTool<TReq, TRes>(name: string, args: TReq, signal?: AbortSignal): Promise<TRes>;
-}
+import { d as BridgePushThemeEnvelope, c as BridgePushLocaleEnvelope, b as BridgePushDensityEnvelope, a as BridgePushA11yEnvelope, B as BridgeNavPushEnvelope, e as BridgeSessionTokenPushEnvelope } from './bridge-envelopes-DA6vxbyb.cjs';
 
 /**
  * Plugin-side bridge client for the host ↔ plugin platform contract
@@ -99,4 +68,4 @@ interface PortBridgeClient {
  */
 declare function createPortBridgeClient(port: BridgePortShim): PortBridgeClient;
 
-export { type A11yPayload as A, type BridgePortShim as B, type DensityPayload as D, type LocalePayload as L, type McpTransport as M, type NavPayload as N, type PortBridgeClient as P, type SessionTokenPayload as S, type ThemePayload as T, createPortBridgeClient as c };
+export { type A11yPayload as A, type BridgePortShim as B, type DensityPayload as D, type LocalePayload as L, type NavPayload as N, type PortBridgeClient as P, type SessionTokenPayload as S, type ThemePayload as T, createPortBridgeClient as c };

package/dist/bridge-envelopes-DA6vxbyb.d.cts

@@ -0,0 +1,151 @@
+/**
+ * Transport contract used by the plugin-side React hooks
+ * (`useMcpResource`, `useMcpTool`) to talk to the host.
+ *
+ * The hooks are deliberately transport-agnostic: the concrete implementation
+ * (postMessage bridge, in-process direct call, fetch-based, …) is injected
+ * via {@link ExtensionRuntimeProvider} or the per-hook `transport` option.
+ * This keeps the React surface stable across Contract A (host-rendered) and
+ * Contract B (worker remote-runtime) execution modes.
+ *
+ * Implementations must honour the supplied {@link AbortSignal} for
+ * cancellation — hooks rely on it to tear down in-flight calls on unmount
+ * or argument changes.
+ */
+interface McpTransport {
+    /**
+     * Fetch a resource by URI. Implementations should reject with an `Error`
+     * when the host returns a failure, and should observe `signal` to abort
+     * any in-flight work.
+     */
+    getResource<T>(uri: string, signal?: AbortSignal): Promise<{
+        uri: string;
+        data: T;
+    }>;
+    /**
+     * Invoke a tool by name. The request object is opaque to the transport.
+     * Implementations should observe `signal` to abort in-flight work.
+     */
+    invokeTool<TReq, TRes>(name: string, args: TReq, signal?: AbortSignal): Promise<TRes>;
+    /**
+     * Upload a binary document to CORE storage via the host shell and resolve
+     * the resulting {@link UploadDocumentResult} (a `StoredDocumentId` plus the
+     * server-validated file metadata).
+     *
+     * **Optional capability.** A transport that does not support binary upload
+     * simply omits this member; {@link "../../plugin-ui" useMcpUpload} throws a
+     * clear runtime error when invoked against such a transport. Keeping it
+     * optional makes adding the upload seam a **non-breaking, additive** change
+     * for existing custom transport implementations (which only provided
+     * `getResource` + `invokeTool`).
+     *
+     * The bytes are handed off as an {@link ArrayBuffer} — the transport is
+     * expected to move it as a **transferable** (zero-copy) across the
+     * worker↔host port. The plugin (worker) never sees the capability token or
+     * the kernel URL: the host shell mints the token, streams the octet-stream
+     * to the kernel document-upload route, and returns only the result.
+     *
+     * When provided, implementations MUST observe `signal` so an unmount /
+     * cancel aborts the in-flight upload rather than streaming bytes to
+     * completion.
+     */
+    uploadDocument?(meta: UploadDocumentMeta, buffer: ArrayBuffer, signal?: AbortSignal): Promise<UploadDocumentResult>;
+}
+/**
+ * Metadata accompanying an {@link McpTransport.uploadDocument} call. All fields
+ * are advisory hints to the host/kernel: the kernel derives the organisation
+ * from the authenticated capability token (never from this payload), binds the
+ * effective module key to the caller's plugin identity via a kernel allowlist,
+ * and re-validates / sanitises `fileName` + `contentType` server-side.
+ */
+interface UploadDocumentMeta {
+    /** Requested storage module key (e.g. "hr"). Validated against the caller's kernel allowlist. */
+    moduleKey: string;
+    /** Owning entity name (e.g. "Candidates", "CompanyDocuments"). */
+    entityName: string;
+    /** Optional owning entity id. */
+    entityId?: string;
+    /** Logical sub-folder / category (e.g. "cvs"). */
+    category: string;
+    /** Client-supplied file name (server sanitises + caps length). */
+    fileName: string;
+    /** Client-supplied MIME type (server re-parses; falls back to application/octet-stream). */
+    contentType: string;
+    /** Byte length of the buffer (advisory; the kernel size cap is authoritative). */
+    sizeBytes: number;
+}
+/**
+ * Result of a successful {@link McpTransport.uploadDocument} call — the id of
+ * the registered `StoredDocument` plus the metadata the kernel actually stored.
+ * The plugin only ever holds the id; it never receives the bytes back.
+ */
+interface UploadDocumentResult {
+    storedDocumentId: string;
+    fileName: string;
+    contentType: string;
+    sizeBytes: number;
+}
+
+/**
+ * Wire-shape constants and type guards for host→plugin bridge push messages
+ * (WI 4858 sub-plan 2). These types ride the existing MessagePort channel
+ * alongside the `ethisys:mcp:*` and `ethisys:remotedom` envelopes — the
+ * `type` discriminant keeps them fully separate at the dispatch site.
+ *
+ * The host posts bridge pushes through `WorkerRemoteDomTransport.hostPort`;
+ * the plugin side reads them in `createPortBridgeClient` (plugin-ui package).
+ * In-realm (Tier T) plugins use `InMemoryBridgeTransport` which calls the
+ * subscriber callbacks directly — no serialisation needed.
+ */
+declare const BRIDGE_PUSH_THEME: "ethisys:bridge:theme";
+declare const BRIDGE_PUSH_LOCALE: "ethisys:bridge:locale";
+declare const BRIDGE_PUSH_DENSITY: "ethisys:bridge:density";
+declare const BRIDGE_PUSH_A11Y: "ethisys:bridge:a11y";
+declare const BRIDGE_NAV_PUSH: "ethisys:bridge:nav";
+declare const BRIDGE_SESSION_TOKEN_PUSH: "ethisys:bridge:token";
+/** Theme push: host → plugin whenever the host theme changes. */
+interface BridgePushThemeEnvelope {
+    readonly type: typeof BRIDGE_PUSH_THEME;
+    /** "light" | "dark" | "high-contrast" */
+    readonly mode: string;
+    /** Flat design-token map (CSS-variable-name → value). May be empty. */
+    readonly tokens: Readonly<Record<string, string>>;
+}
+/** Locale push: host → plugin whenever the active locale changes. */
+interface BridgePushLocaleEnvelope {
+    readonly type: typeof BRIDGE_PUSH_LOCALE;
+    /** BCP 47 tag, e.g. "en-GB". */
+    readonly locale: string;
+    /** "ltr" | "rtl" */
+    readonly dir: "ltr" | "rtl";
+}
+/** Density push: host → plugin when the UI density preference changes. */
+interface BridgePushDensityEnvelope {
+    readonly type: typeof BRIDGE_PUSH_DENSITY;
+    /** "comfortable" | "compact" */
+    readonly density: string;
+}
+/** A11y push: host → plugin when accessibility prefs change. */
+interface BridgePushA11yEnvelope {
+    readonly type: typeof BRIDGE_PUSH_A11Y;
+    readonly reducedMotion: boolean;
+    readonly highContrast: boolean;
+}
+/** Nav push: host → plugin when the SPA location changes. */
+interface BridgeNavPushEnvelope {
+    readonly type: typeof BRIDGE_NAV_PUSH;
+    /** Current SPA path (pathname + search). */
+    readonly path: string;
+    /** `window.history.length` at the time of push. */
+    readonly historyLength: number;
+}
+/** Host → plugin: push a short-lived frontend-session token. */
+interface BridgeSessionTokenPushEnvelope {
+    readonly type: typeof BRIDGE_SESSION_TOKEN_PUSH;
+    /** Opaque JWT string — audience-restricted to the plugin's own backend. */
+    readonly token: string;
+    /** Absolute epoch-ms at which the token expires. Refresh fires 30 s before. */
+    readonly expiresAtMs: number;
+}
+
+export type { BridgeNavPushEnvelope as B, McpTransport as M, UploadDocumentMeta as U, BridgePushA11yEnvelope as a, BridgePushDensityEnvelope as b, BridgePushLocaleEnvelope as c, BridgePushThemeEnvelope as d, BridgeSessionTokenPushEnvelope as e, UploadDocumentResult as f };

package/dist/bridge-envelopes-DA6vxbyb.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Transport contract used by the plugin-side React hooks
+ * (`useMcpResource`, `useMcpTool`) to talk to the host.
+ *
+ * The hooks are deliberately transport-agnostic: the concrete implementation
+ * (postMessage bridge, in-process direct call, fetch-based, …) is injected
+ * via {@link ExtensionRuntimeProvider} or the per-hook `transport` option.
+ * This keeps the React surface stable across Contract A (host-rendered) and
+ * Contract B (worker remote-runtime) execution modes.
+ *
+ * Implementations must honour the supplied {@link AbortSignal} for
+ * cancellation — hooks rely on it to tear down in-flight calls on unmount
+ * or argument changes.
+ */
+interface McpTransport {
+    /**
+     * Fetch a resource by URI. Implementations should reject with an `Error`
+     * when the host returns a failure, and should observe `signal` to abort
+     * any in-flight work.
+     */
+    getResource<T>(uri: string, signal?: AbortSignal): Promise<{
+        uri: string;
+        data: T;
+    }>;
+    /**
+     * Invoke a tool by name. The request object is opaque to the transport.
+     * Implementations should observe `signal` to abort in-flight work.
+     */
+    invokeTool<TReq, TRes>(name: string, args: TReq, signal?: AbortSignal): Promise<TRes>;
+    /**
+     * Upload a binary document to CORE storage via the host shell and resolve
+     * the resulting {@link UploadDocumentResult} (a `StoredDocumentId` plus the
+     * server-validated file metadata).
+     *
+     * **Optional capability.** A transport that does not support binary upload
+     * simply omits this member; {@link "../../plugin-ui" useMcpUpload} throws a
+     * clear runtime error when invoked against such a transport. Keeping it
+     * optional makes adding the upload seam a **non-breaking, additive** change
+     * for existing custom transport implementations (which only provided
+     * `getResource` + `invokeTool`).
+     *
+     * The bytes are handed off as an {@link ArrayBuffer} — the transport is
+     * expected to move it as a **transferable** (zero-copy) across the
+     * worker↔host port. The plugin (worker) never sees the capability token or
+     * the kernel URL: the host shell mints the token, streams the octet-stream
+     * to the kernel document-upload route, and returns only the result.
+     *
+     * When provided, implementations MUST observe `signal` so an unmount /
+     * cancel aborts the in-flight upload rather than streaming bytes to
+     * completion.
+     */
+    uploadDocument?(meta: UploadDocumentMeta, buffer: ArrayBuffer, signal?: AbortSignal): Promise<UploadDocumentResult>;
+}
+/**
+ * Metadata accompanying an {@link McpTransport.uploadDocument} call. All fields
+ * are advisory hints to the host/kernel: the kernel derives the organisation
+ * from the authenticated capability token (never from this payload), binds the
+ * effective module key to the caller's plugin identity via a kernel allowlist,
+ * and re-validates / sanitises `fileName` + `contentType` server-side.
+ */
+interface UploadDocumentMeta {
+    /** Requested storage module key (e.g. "hr"). Validated against the caller's kernel allowlist. */
+    moduleKey: string;
+    /** Owning entity name (e.g. "Candidates", "CompanyDocuments"). */
+    entityName: string;
+    /** Optional owning entity id. */
+    entityId?: string;
+    /** Logical sub-folder / category (e.g. "cvs"). */
+    category: string;
+    /** Client-supplied file name (server sanitises + caps length). */
+    fileName: string;
+    /** Client-supplied MIME type (server re-parses; falls back to application/octet-stream). */
+    contentType: string;
+    /** Byte length of the buffer (advisory; the kernel size cap is authoritative). */
+    sizeBytes: number;
+}
+/**
+ * Result of a successful {@link McpTransport.uploadDocument} call — the id of
+ * the registered `StoredDocument` plus the metadata the kernel actually stored.
+ * The plugin only ever holds the id; it never receives the bytes back.
+ */
+interface UploadDocumentResult {
+    storedDocumentId: string;
+    fileName: string;
+    contentType: string;
+    sizeBytes: number;
+}
+
+/**
+ * Wire-shape constants and type guards for host→plugin bridge push messages
+ * (WI 4858 sub-plan 2). These types ride the existing MessagePort channel
+ * alongside the `ethisys:mcp:*` and `ethisys:remotedom` envelopes — the
+ * `type` discriminant keeps them fully separate at the dispatch site.
+ *
+ * The host posts bridge pushes through `WorkerRemoteDomTransport.hostPort`;
+ * the plugin side reads them in `createPortBridgeClient` (plugin-ui package).
+ * In-realm (Tier T) plugins use `InMemoryBridgeTransport` which calls the
+ * subscriber callbacks directly — no serialisation needed.
+ */
+declare const BRIDGE_PUSH_THEME: "ethisys:bridge:theme";
+declare const BRIDGE_PUSH_LOCALE: "ethisys:bridge:locale";
+declare const BRIDGE_PUSH_DENSITY: "ethisys:bridge:density";
+declare const BRIDGE_PUSH_A11Y: "ethisys:bridge:a11y";
+declare const BRIDGE_NAV_PUSH: "ethisys:bridge:nav";
+declare const BRIDGE_SESSION_TOKEN_PUSH: "ethisys:bridge:token";
+/** Theme push: host → plugin whenever the host theme changes. */
+interface BridgePushThemeEnvelope {
+    readonly type: typeof BRIDGE_PUSH_THEME;
+    /** "light" | "dark" | "high-contrast" */
+    readonly mode: string;
+    /** Flat design-token map (CSS-variable-name → value). May be empty. */
+    readonly tokens: Readonly<Record<string, string>>;
+}
+/** Locale push: host → plugin whenever the active locale changes. */
+interface BridgePushLocaleEnvelope {
+    readonly type: typeof BRIDGE_PUSH_LOCALE;
+    /** BCP 47 tag, e.g. "en-GB". */
+    readonly locale: string;
+    /** "ltr" | "rtl" */
+    readonly dir: "ltr" | "rtl";
+}
+/** Density push: host → plugin when the UI density preference changes. */
+interface BridgePushDensityEnvelope {
+    readonly type: typeof BRIDGE_PUSH_DENSITY;
+    /** "comfortable" | "compact" */
+    readonly density: string;
+}
+/** A11y push: host → plugin when accessibility prefs change. */
+interface BridgePushA11yEnvelope {
+    readonly type: typeof BRIDGE_PUSH_A11Y;
+    readonly reducedMotion: boolean;
+    readonly highContrast: boolean;
+}
+/** Nav push: host → plugin when the SPA location changes. */
+interface BridgeNavPushEnvelope {
+    readonly type: typeof BRIDGE_NAV_PUSH;
+    /** Current SPA path (pathname + search). */
+    readonly path: string;
+    /** `window.history.length` at the time of push. */
+    readonly historyLength: number;
+}
+/** Host → plugin: push a short-lived frontend-session token. */
+interface BridgeSessionTokenPushEnvelope {
+    readonly type: typeof BRIDGE_SESSION_TOKEN_PUSH;
+    /** Opaque JWT string — audience-restricted to the plugin's own backend. */
+    readonly token: string;
+    /** Absolute epoch-ms at which the token expires. Refresh fires 30 s before. */
+    readonly expiresAtMs: number;
+}
+
+export type { BridgeNavPushEnvelope as B, McpTransport as M, UploadDocumentMeta as U, BridgePushA11yEnvelope as a, BridgePushDensityEnvelope as b, BridgePushLocaleEnvelope as c, BridgePushThemeEnvelope as d, BridgeSessionTokenPushEnvelope as e, UploadDocumentResult as f };

package/dist/host/index.cjs

@@ -309,6 +309,13 @@ var WorkerRemoteDomTransport = class {
   coalesceMs;
   maxConcurrentMcpRequests;
   abortController;
+  // Per-request AbortControllers keyed by request id. An inbound
+  // `ethisys:mcp:abort` envelope (the worker posts one when a hook's
+  // AbortSignal fires on unmount / arg change) aborts just that request;
+  // dispose() fans out to every registered controller. Without this a
+  // cancelled call — most costly for uploadDocument — keeps streaming to the
+  // kernel even though the plugin promise already rejected.
+  inFlightAborts = /* @__PURE__ */ new Map();
   inFlightMcpRequests = 0;
   remoteDomConsumer;
   bridgeMessageConsumer;
@@ -496,6 +503,10 @@ var WorkerRemoteDomTransport = class {
     this.disposed = true;
     try {
       this.abortController.abort();
+      for (const controller of this.inFlightAborts.values()) {
+        controller.abort();
+      }
+      this.inFlightAborts.clear();
     } catch {
     }
     try {
@@ -534,6 +545,12 @@ var WorkerRemoteDomTransport = class {
       case "ethisys:mcp:getResource":
         this.dispatchMcp(message, "ethisys:mcp:getResource:result", (m) => this.handleGetResource(m));
         return;
+      case "ethisys:mcp:uploadDocument":
+        this.dispatchMcp(message, "ethisys:mcp:uploadDocument:result", (m) => this.handleUploadDocument(m));
+        return;
+      case "ethisys:mcp:abort":
+        this.inFlightAborts.get(message.id ?? "")?.abort();
+        return;
       case "ethisys:remotedom":
         this.remoteDomConsumer?.(message.payload);
         return;
@@ -563,10 +580,37 @@ var WorkerRemoteDomTransport = class {
       return;
     }
     this.inFlightMcpRequests++;
+    this.registerRequestAbort(message.id);
     handler(message).finally(() => {
+      this.releaseRequestAbort(message.id);
       this.inFlightMcpRequests = Math.max(0, this.inFlightMcpRequests - 1);
     });
   }
+  /**
+   * Create a per-request AbortController and register it under the request id
+   * so an inbound `ethisys:mcp:abort` can cancel just this call. If the
+   * transport is already disposed the controller starts aborted so the
+   * handler's `mcpClient.fetch` short-circuits immediately.
+   */
+  registerRequestAbort(id) {
+    const controller = new AbortController();
+    if (this.abortController.signal.aborted) {
+      controller.abort();
+    }
+    this.inFlightAborts.set(id, controller);
+  }
+  /** Drop a settled request's AbortController. */
+  releaseRequestAbort(id) {
+    this.inFlightAborts.delete(id);
+  }
+  /**
+   * The signal to hand to `mcpClient.fetch` for a given request: the
+   * per-request controller when registered (client cancel path), falling back
+   * to the dispose-level controller.
+   */
+  requestSignal(id) {
+    return this.inFlightAborts.get(id)?.signal ?? this.abortController.signal;
+  }
   async handleInvokeTool(message) {
     let token;
     try {
@@ -584,7 +628,7 @@ var WorkerRemoteDomTransport = class {
         name: message.name,
         args: message.args,
         capabilityToken: token,
-        signal: this.abortController.signal
+        signal: this.requestSignal(message.id)
       });
       this.safePostMessage({
         id: message.id,
@@ -613,7 +657,7 @@ var WorkerRemoteDomTransport = class {
         kind: "getResource",
         uri: message.uri,
         capabilityToken: token,
-        signal: this.abortController.signal
+        signal: this.requestSignal(message.id)
       });
       this.safePostMessage({
         id: message.id,
@@ -626,6 +670,36 @@ var WorkerRemoteDomTransport = class {
       this.replyError(message.id, "ethisys:mcp:getResource:result", err);
     }
   }
+  async handleUploadDocument(message) {
+    let token;
+    try {
+      token = await this.capabilityTokenProvider();
+    } catch (err) {
+      this.replyError(message.id, "ethisys:mcp:uploadDocument:result", err);
+      return;
+    }
+    if (this.disposed) {
+      return;
+    }
+    try {
+      const result = await this.mcpClient.fetch({
+        kind: "uploadDocument",
+        meta: message.meta,
+        buffer: message.buffer,
+        capabilityToken: token,
+        signal: this.requestSignal(message.id)
+      });
+      this.safePostMessage({
+        id: message.id,
+        type: "ethisys:mcp:uploadDocument:result",
+        ok: result.ok,
+        data: result.data,
+        error: result.error
+      });
+    } catch (err) {
+      this.replyError(message.id, "ethisys:mcp:uploadDocument:result", err);
+    }
+  }
   replyError(id, type, err) {
     const message = err instanceof Error ? err.message : "MCP request failed";
     this.safePostMessage({ id, type, ok: false, error: message });