@ethisyscore/extension-runtime 1.34.0 → 1.35.0

package/dist/mock-host/cli.js

@@ -54,6 +54,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;
@@ -241,6 +248,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 {
@@ -279,6 +290,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;
@@ -308,10 +325,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 {
@@ -329,7 +373,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,
@@ -358,7 +402,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,
@@ -371,6 +415,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 });
@@ -691,6 +765,17 @@ window.__MOCK_HOST_REGISTRY__ = registry;
 }
 var defaultMockMcpClient = {
   fetch: async (req) => {
+    if (req.kind === "uploadDocument") {
+      return {
+        ok: true,
+        data: {
+          storedDocumentId: `mock-${req.meta.entityName}-${req.meta.fileName}`,
+          fileName: req.meta.fileName,
+          contentType: req.meta.contentType,
+          sizeBytes: req.buffer.byteLength
+        }
+      };
+    }
     const echo = req.kind === "invokeTool" ? { tool: req.name, args: req.args } : { resource: req.uri };
     return { ok: true, data: { mockHost: true, ...echo } };
   }