@finalai/agent-provider 0.1.0

package/dist/modules/sandbox/frame-channel.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/sandbox/frame-channel.ts"],
+  "sourcesContent": ["// An ordered, bidirectional frame transport: a WebSocket or any message\n// stream. Text frames are JSON-RPC, binary frames are stream chunks.\n\nexport type WireFrame = string | Uint8Array;\n\nexport interface FrameChannelCloseIface {\n  code: number;\n  reason: string;\n}\n\nexport interface FrameChannelHandlersIface {\n  frame: (frame: WireFrame) => void;\n  close: (info: FrameChannelCloseIface) => void;\n}\n\nexport interface FrameChannelIface {\n  send(frame: WireFrame): void;\n  close(code?: number, reason?: string): void;\n  // Registers the single consumer; frames received earlier are delivered first.\n  listen(handlers: FrameChannelHandlersIface): void;\n}\n\nconst ABNORMAL_CLOSE = 1006;\n\nconst createBufferedListener = () => {\n  const pending: WireFrame[] = [];\n  let closed: FrameChannelCloseIface | null = null;\n  let handlers: FrameChannelHandlersIface | null = null;\n  return {\n    frame: (frame: WireFrame) => {\n      if (handlers == null) pending.push(frame);\n      else handlers.frame(frame);\n    },\n    close: (info: FrameChannelCloseIface) => {\n      if (closed != null) return;\n      closed = info;\n      handlers?.close(info);\n    },\n    listen: (next: FrameChannelHandlersIface) => {\n      handlers = next;\n      for (const frame of pending.splice(0)) next.frame(frame);\n      if (closed != null) next.close(closed);\n    },\n    isClosed: () => closed != null,\n  };\n};\n\n// The subset of the WHATWG WebSocket API the adapters need (browsers, Workers,\n// Node's global WebSocket and the `ws` package all satisfy it).\n// What WebSocket implementations deliver: text, or binary as ArrayBuffer,\n// a view, a Blob (when binaryType was ignored) or `ws`'s fragment arrays.\nexport type WebSocketMessageData = string | ArrayBuffer | ArrayBufferView | Blob | Uint8Array[];\n\nexport interface WebSocketMessageEventLikeIface {\n  readonly data: WebSocketMessageData;\n}\n\nexport interface WebSocketEventLikeIface {\n  readonly type: string;\n}\n\nexport interface WebSocketCloseEventLikeIface {\n  readonly code: number;\n  readonly reason: string;\n}\n\nexport interface WebSocketLikeIface {\n  readonly readyState: number;\n  binaryType: string;\n  send(data: string | Uint8Array<ArrayBuffer>): void;\n  close(code?: number, reason?: string): void;\n  addEventListener(\n    type: 'message',\n    listener: (event: WebSocketMessageEventLikeIface) => void,\n  ): void;\n  addEventListener(type: 'close', listener: (event: WebSocketCloseEventLikeIface) => void): void;\n  addEventListener(type: 'open', listener: (event: WebSocketEventLikeIface) => void): void;\n  addEventListener(type: 'error', listener: (event: WebSocketEventLikeIface) => void): void;\n}\n\nexport type WebSocketConstructorIface = new (\n  url: string,\n  protocols?: string | string[],\n) => WebSocketLikeIface;\n\nconst WS_OPEN = 1;\n\nconst toWireFrame = (data: WebSocketMessageData): WireFrame | null => {\n  if (data instanceof Uint8Array) return data;\n  if (data instanceof ArrayBuffer) return new Uint8Array(data);\n  if (ArrayBuffer.isView(data))\n    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n  if (data instanceof Blob) return null;\n  // `ws` may deliver fragmented binary messages as an array of buffers.\n  if (Array.isArray(data)) {\n    let total = 0;\n    for (const part of data) total += part.byteLength;\n    const out = new Uint8Array(total);\n    let offset = 0;\n    for (const part of data) {\n      out.set(part, offset);\n      offset += part.byteLength;\n    }\n    return out;\n  }\n  return data;\n};\n\n// Wraps a WebSocket. `opened` resolves once the socket is open (immediately\n// for an already open server-side socket) and rejects if it closes first.\nexport interface WebSocketFrameChannelIface {\n  channel: FrameChannelIface;\n  opened: Promise<void>;\n}\n\nexport const frameChannelFromWebSocket = (\n  socket: WebSocketLikeIface,\n): WebSocketFrameChannelIface => {\n  socket.binaryType = 'arraybuffer';\n  const listener = createBufferedListener();\n  let resolveOpen: () => void = () => undefined;\n  let rejectOpen: (error: Error) => void = () => undefined;\n  const opened = new Promise<void>((resolve, reject) => {\n    resolveOpen = resolve;\n    rejectOpen = reject;\n  });\n  // Avoid an unhandled rejection when nobody awaits `opened`.\n  opened.catch(() => undefined);\n  if (socket.readyState === WS_OPEN) resolveOpen();\n  socket.addEventListener('open', () => resolveOpen());\n  socket.addEventListener('message', (event) => {\n    const frame = toWireFrame(event.data);\n    if (frame != null) listener.frame(frame);\n  });\n  socket.addEventListener('close', (event) => {\n    rejectOpen(new Error(`websocket closed before opening (${event.code})`));\n    listener.close({ code: event.code, reason: event.reason });\n  });\n  socket.addEventListener('error', () => {\n    rejectOpen(new Error('websocket failed to open'));\n  });\n  const channel: FrameChannelIface = {\n    send: (frame) => {\n      if (socket.readyState !== WS_OPEN) return;\n      if (!(frame instanceof Uint8Array)) socket.send(frame);\n      else if (frame.buffer instanceof ArrayBuffer)\n        socket.send(new Uint8Array(frame.buffer, frame.byteOffset, frame.byteLength));\n      else socket.send(new Uint8Array(frame));\n    },\n    close: (code, reason) => {\n      try {\n        socket.close(code, reason);\n      } catch {\n        socket.close();\n      }\n      listener.close({ code: code ?? 1000, reason: reason ?? '' });\n    },\n    listen: (handlers) => listener.listen(handlers),\n  };\n  return { channel, opened };\n};\n\nexport interface FrameStreamIface {\n  readable: ReadableStream<WireFrame>;\n  writable: WritableStream<WireFrame>;\n}\n\n// Wraps an ordered message stream (a MessagePort bridge, a relay, a test pair).\n// Close codes are not transmitted: the far side sees 1000 on a clean end.\nexport const frameChannelFromStream = (stream: FrameStreamIface): FrameChannelIface => {\n  const listener = createBufferedListener();\n  const writer = stream.writable.getWriter();\n  const reader = stream.readable.getReader();\n  const pump = async () => {\n    try {\n      for (;;) {\n        const { done, value } = await reader.read();\n        if (done) break;\n        listener.frame(value);\n      }\n      listener.close({ code: 1000, reason: '' });\n    } catch (error) {\n      listener.close({\n        code: ABNORMAL_CLOSE,\n        reason: error instanceof Error ? error.message : 'stream error',\n      });\n    }\n  };\n  void pump();\n  return {\n    send: (frame) => {\n      if (listener.isClosed()) return;\n      writer\n        .write(frame)\n        .catch(() => listener.close({ code: ABNORMAL_CLOSE, reason: 'write failed' }));\n    },\n    close: (code, reason) => {\n      if (listener.isClosed()) return;\n      listener.close({ code: code ?? 1000, reason: reason ?? '' });\n      writer.close().catch(() => undefined);\n      reader.cancel().catch(() => undefined);\n    },\n    listen: (handlers) => listener.listen(handlers),\n  };\n};\n\n// Two connected in-memory channels with asynchronous delivery, like a socket.\n// Close codes and reasons propagate to the far side.\nexport const createFrameChannelPair = (): [FrameChannelIface, FrameChannelIface] => {\n  const left = createBufferedListener();\n  const right = createBufferedListener();\n  const deliver = (target: ReturnType<typeof createBufferedListener>, frame: WireFrame) => {\n    queueMicrotask(() => target.frame(frame));\n  };\n  const closeBoth = (info: FrameChannelCloseIface) => {\n    queueMicrotask(() => {\n      left.close(info);\n      right.close(info);\n    });\n  };\n  let closed = false;\n  const make = (\n    peer: ReturnType<typeof createBufferedListener>,\n    self: ReturnType<typeof createBufferedListener>,\n  ) => ({\n    send: (frame: WireFrame) => {\n      if (closed) return;\n      // Copy binary frames so senders may reuse buffers.\n      deliver(peer, frame instanceof Uint8Array ? frame.slice() : frame);\n    },\n    close: (code?: number, reason?: string) => {\n      if (closed) return;\n      closed = true;\n      closeBoth({ code: code ?? 1000, reason: reason ?? '' });\n    },\n    listen: (handlers: FrameChannelHandlersIface) => self.listen(handlers),\n  });\n  return [make(right, left), make(left, right)];\n};\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/sandbox/index.d.mts

@@ -0,0 +1,18 @@
+export { ProcessInspectionOperation, inspectedProcessSchema, processInspectionDetailSchema, processInspectionPageSchema, processInspectionRequestSchema, processInspectionResultSchema, type InspectedProcessIface, type ProcessInspectionDetailIface, type ProcessInspectionPageIface, type ProcessInspectionRequestIface, type ProcessInspectionResultIface, } from '@finalai/agent-protocol/process-inspection';
+export { decodeSandboxText, encodeSandboxText } from "./bytes.mjs";
+export * from "./client.mjs";
+export { createConfinedFileReader } from "./confined-files.mjs";
+export * from "./convenience.mjs";
+export * from "./mcp.mjs";
+export * from "./mcp-testing.mjs";
+export * from "./memory-sandbox.mjs";
+export * from "./open-scope.mjs";
+export { MAX_SANDBOX_SEED_BYTES, SANDBOX_SEED_MARKER, SANDBOX_SEED_PROTOCOL, materializeSandboxSeeds, sandboxPreparationInputs, sandboxSeedArtifact, sandboxSeedArtifactSchema, sandboxSeedFiles, sandboxSeedFilesForStart, sandboxSeedFilesSchema, sandboxSeedIdentity, } from "./seeds.mjs";
+export * from "./server.mjs";
+export * from "./testing.mjs";
+export * from "./types.mjs";
+export * from "./wire.mjs";
+export { mapSessionPath, withSessionWorkspaceRoot } from "./workspace-root.mjs";
+export type { MapSessionPathArgsIface } from "./workspace-root.mjs";
+export * from "./snapshots.mjs";
+export { SandboxEditorOperation, sandboxEditorRequestSchema, sandboxEditorResultSchema, sandboxEditorSessionSchema, type SandboxEditorRequestIface, type SandboxEditorResultIface, type SandboxEditorSessionIface, } from "./editor.mjs";

package/dist/modules/sandbox/index.mjs

@@ -0,0 +1,70 @@
+import {
+  ProcessInspectionOperation,
+  inspectedProcessSchema,
+  processInspectionDetailSchema,
+  processInspectionPageSchema,
+  processInspectionRequestSchema,
+  processInspectionResultSchema
+} from "@finalai/agent-protocol/process-inspection";
+import { decodeSandboxText, encodeSandboxText } from "./bytes.mjs";
+export * from "./client.mjs";
+import { createConfinedFileReader } from "./confined-files.mjs";
+export * from "./convenience.mjs";
+export * from "./mcp.mjs";
+export * from "./mcp-testing.mjs";
+export * from "./memory-sandbox.mjs";
+export * from "./open-scope.mjs";
+import {
+  MAX_SANDBOX_SEED_BYTES,
+  SANDBOX_SEED_MARKER,
+  SANDBOX_SEED_PROTOCOL,
+  materializeSandboxSeeds,
+  sandboxPreparationInputs,
+  sandboxSeedArtifact,
+  sandboxSeedArtifactSchema,
+  sandboxSeedFiles,
+  sandboxSeedFilesForStart,
+  sandboxSeedFilesSchema,
+  sandboxSeedIdentity
+} from "./seeds.mjs";
+export * from "./server.mjs";
+export * from "./testing.mjs";
+export * from "./types.mjs";
+export * from "./wire.mjs";
+import { mapSessionPath, withSessionWorkspaceRoot } from "./workspace-root.mjs";
+export * from "./snapshots.mjs";
+import {
+  SandboxEditorOperation,
+  sandboxEditorRequestSchema,
+  sandboxEditorResultSchema,
+  sandboxEditorSessionSchema
+} from "./editor.mjs";
+export {
+  MAX_SANDBOX_SEED_BYTES,
+  ProcessInspectionOperation,
+  SANDBOX_SEED_MARKER,
+  SANDBOX_SEED_PROTOCOL,
+  SandboxEditorOperation,
+  createConfinedFileReader,
+  decodeSandboxText,
+  encodeSandboxText,
+  inspectedProcessSchema,
+  mapSessionPath,
+  materializeSandboxSeeds,
+  processInspectionDetailSchema,
+  processInspectionPageSchema,
+  processInspectionRequestSchema,
+  processInspectionResultSchema,
+  sandboxEditorRequestSchema,
+  sandboxEditorResultSchema,
+  sandboxEditorSessionSchema,
+  sandboxPreparationInputs,
+  sandboxSeedArtifact,
+  sandboxSeedArtifactSchema,
+  sandboxSeedFiles,
+  sandboxSeedFilesForStart,
+  sandboxSeedFilesSchema,
+  sandboxSeedIdentity,
+  withSessionWorkspaceRoot
+};
+//# sourceMappingURL=index.mjs.map

package/dist/modules/sandbox/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/sandbox/index.ts"],
+  "sourcesContent": ["export {\n  ProcessInspectionOperation,\n  inspectedProcessSchema,\n  processInspectionDetailSchema,\n  processInspectionPageSchema,\n  processInspectionRequestSchema,\n  processInspectionResultSchema,\n  type InspectedProcessIface,\n  type ProcessInspectionDetailIface,\n  type ProcessInspectionPageIface,\n  type ProcessInspectionRequestIface,\n  type ProcessInspectionResultIface,\n} from '@finalai/agent-protocol/process-inspection';\nexport { decodeSandboxText, encodeSandboxText } from \"./bytes.mjs\";\nexport * from \"./client.mjs\";\nexport { createConfinedFileReader } from \"./confined-files.mjs\";\nexport * from \"./convenience.mjs\";\nexport * from \"./mcp.mjs\";\nexport * from \"./mcp-testing.mjs\";\nexport * from \"./memory-sandbox.mjs\";\nexport * from \"./open-scope.mjs\";\nexport {\n  MAX_SANDBOX_SEED_BYTES,\n  SANDBOX_SEED_MARKER,\n  SANDBOX_SEED_PROTOCOL,\n  materializeSandboxSeeds,\n  sandboxPreparationInputs,\n  sandboxSeedArtifact,\n  sandboxSeedArtifactSchema,\n  sandboxSeedFiles,\n  sandboxSeedFilesForStart,\n  sandboxSeedFilesSchema,\n  sandboxSeedIdentity,\n} from \"./seeds.mjs\";\nexport * from \"./server.mjs\";\nexport * from \"./testing.mjs\";\nexport * from \"./types.mjs\";\nexport * from \"./wire.mjs\";\nexport { mapSessionPath, withSessionWorkspaceRoot } from \"./workspace-root.mjs\";\nexport type { MapSessionPathArgsIface } from \"./workspace-root.mjs\";\n\nexport * from \"./snapshots.mjs\";\n\nexport {\n  SandboxEditorOperation,\n  sandboxEditorRequestSchema,\n  sandboxEditorResultSchema,\n  sandboxEditorSessionSchema,\n  type SandboxEditorRequestIface,\n  type SandboxEditorResultIface,\n  type SandboxEditorSessionIface,\n} from \"./editor.mjs\";\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAMK;AACP,SAAS,mBAAmB,yBAAyB;AACrD,cAAc;AACd,SAAS,gCAAgC;AACzC,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAAS,gBAAgB,gCAAgC;AAGzD,cAAc;AAEd;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAIK;",
+  "names": []
+}

package/dist/modules/sandbox/mcp-channel.d.mts

@@ -0,0 +1,9 @@
+import { type Transport } from '@modelcontextprotocol/client';
+import type { McpChannelIface } from "./types.mjs";
+export interface McpChannelTransportArgsIface {
+    channel: McpChannelIface;
+    sleep?: (ms: number) => Promise<void>;
+    pollMinMs?: number;
+    pollMaxMs?: number;
+}
+export declare const createMcpChannelTransport: (args: McpChannelTransportArgsIface) => Transport;

package/dist/modules/sandbox/mcp-channel.mjs

@@ -0,0 +1,77 @@
+import {
+  isJSONRPCRequest,
+  isJSONRPCResponse,
+  parseJSONRPCMessage
+} from "@modelcontextprotocol/client";
+import { jsonValueSchema } from "../json.mjs";
+const POLL_MIN_MS = 25;
+const POLL_MAX_MS = 1e3;
+const INTERNAL_ERROR = -32603;
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const createMcpChannelTransport = (args) => {
+  const sleep = args.sleep ?? defaultSleep;
+  const pollMinMs = args.pollMinMs ?? POLL_MIN_MS;
+  const pollMaxMs = args.pollMaxMs ?? POLL_MAX_MS;
+  const pending = /* @__PURE__ */ new Set();
+  let polling = null;
+  let closed = false;
+  const transport = {
+    start: async () => void 0,
+    send: async (message) => {
+      if (closed) throw new Error("the MCP channel is closed");
+      await args.channel.send(jsonValueSchema.parse(JSON.parse(JSON.stringify(message))));
+      if (isJSONRPCRequest(message)) {
+        pending.add(message.id);
+        polling ??= poll().finally(() => {
+          polling = null;
+        });
+      }
+    },
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      pending.clear();
+      await args.channel.close().catch(() => void 0);
+      transport.onclose?.();
+    }
+  };
+  const deliver = (message) => {
+    if (isJSONRPCResponse(message) && message.id != null) pending.delete(message.id);
+    transport.onmessage?.(message);
+  };
+  const failPending = (error) => {
+    transport.onerror?.(error);
+    for (const id of [...pending]) {
+      deliver({ jsonrpc: "2.0", id, error: { code: INTERNAL_ERROR, message: error.message } });
+    }
+  };
+  const poll = async () => {
+    let delay = pollMinMs;
+    while (!closed && pending.size > 0) {
+      let messages;
+      try {
+        messages = await args.channel.receive();
+      } catch (error) {
+        failPending(error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+      for (const raw of messages) {
+        try {
+          deliver(parseJSONRPCMessage(raw));
+        } catch {
+        }
+      }
+      if (messages.length > 0) {
+        delay = pollMinMs;
+        continue;
+      }
+      await sleep(delay);
+      delay = Math.min(delay * 2, pollMaxMs);
+    }
+  };
+  return transport;
+};
+export {
+  createMcpChannelTransport
+};
+//# sourceMappingURL=mcp-channel.mjs.map

package/dist/modules/sandbox/mcp-channel.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/sandbox/mcp-channel.ts"],
+  "sourcesContent": ["import {\n  isJSONRPCRequest,\n  isJSONRPCResponse,\n  parseJSONRPCMessage,\n  type JSONRPCMessage,\n  type Transport,\n} from '@modelcontextprotocol/client';\nimport { jsonValueSchema } from \"../json.mjs\";\nimport type { McpChannelIface } from \"./types.mjs\";\n\n// An MCP client transport over a sandbox's MCP channel (types.ts\n// McpChannelIface). The channel only answers `receive` with what has arrived,\n// so the transport polls it while requests are outstanding, quickly at first\n// and backing off while the server is busy; an idle channel is not polled.\n\nconst POLL_MIN_MS = 25;\nconst POLL_MAX_MS = 1_000;\nconst INTERNAL_ERROR = -32603;\n\nexport interface McpChannelTransportArgsIface {\n  channel: McpChannelIface;\n  sleep?: (ms: number) => Promise<void>;\n  pollMinMs?: number;\n  pollMaxMs?: number;\n}\n\nconst defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));\n\nexport const createMcpChannelTransport = (args: McpChannelTransportArgsIface): Transport => {\n  const sleep = args.sleep ?? defaultSleep;\n  const pollMinMs = args.pollMinMs ?? POLL_MIN_MS;\n  const pollMaxMs = args.pollMaxMs ?? POLL_MAX_MS;\n  // Ids of our requests still waiting for a response.\n  const pending = new Set<string | number>();\n  let polling: Promise<void> | null = null;\n  let closed = false;\n\n  const transport: Transport = {\n    start: async () => undefined,\n    send: async (message) => {\n      if (closed) throw new Error('the MCP channel is closed');\n      await args.channel.send(jsonValueSchema.parse(JSON.parse(JSON.stringify(message))));\n      if (isJSONRPCRequest(message)) {\n        pending.add(message.id);\n        polling ??= poll().finally(() => {\n          polling = null;\n        });\n      }\n    },\n    close: async () => {\n      if (closed) return;\n      closed = true;\n      pending.clear();\n      await args.channel.close().catch(() => undefined);\n      transport.onclose?.();\n    },\n  };\n\n  const deliver = (message: JSONRPCMessage) => {\n    if (isJSONRPCResponse(message) && message.id != null) pending.delete(message.id);\n    transport.onmessage?.(message);\n  };\n\n  // A channel that failed answers every outstanding request with the error, so\n  // callers fail at once instead of at their request timeout.\n  const failPending = (error: Error) => {\n    transport.onerror?.(error);\n    for (const id of [...pending]) {\n      deliver({ jsonrpc: '2.0', id, error: { code: INTERNAL_ERROR, message: error.message } });\n    }\n  };\n\n  const poll = async (): Promise<void> => {\n    let delay = pollMinMs;\n    while (!closed && pending.size > 0) {\n      let messages;\n      try {\n        messages = await args.channel.receive();\n      } catch (error) {\n        failPending(error instanceof Error ? error : new Error(String(error)));\n        return;\n      }\n      for (const raw of messages) {\n        try {\n          deliver(parseJSONRPCMessage(raw));\n        } catch {\n          // Not JSON-RPC; dropped.\n        }\n      }\n      if (messages.length > 0) {\n        delay = pollMinMs;\n        continue;\n      }\n      await sleep(delay);\n      delay = Math.min(delay * 2, pollMaxMs);\n    }\n  };\n\n  return transport;\n};\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AACP,SAAS,uBAAuB;AAQhC,MAAM,cAAc;AACpB,MAAM,cAAc;AACpB,MAAM,iBAAiB;AASvB,MAAM,eAAe,CAAC,OAAe,IAAI,QAAc,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AAEpF,MAAM,4BAA4B,CAAC,SAAkD;AAC1F,QAAM,QAAQ,KAAK,SAAS;AAC5B,QAAM,YAAY,KAAK,aAAa;AACpC,QAAM,YAAY,KAAK,aAAa;AAEpC,QAAM,UAAU,oBAAI,IAAqB;AACzC,MAAI,UAAgC;AACpC,MAAI,SAAS;AAEb,QAAM,YAAuB;AAAA,IAC3B,OAAO,YAAY;AAAA,IACnB,MAAM,OAAO,YAAY;AACvB,UAAI,OAAQ,OAAM,IAAI,MAAM,2BAA2B;AACvD,YAAM,KAAK,QAAQ,KAAK,gBAAgB,MAAM,KAAK,MAAM,KAAK,UAAU,OAAO,CAAC,CAAC,CAAC;AAClF,UAAI,iBAAiB,OAAO,GAAG;AAC7B,gBAAQ,IAAI,QAAQ,EAAE;AACtB,oBAAY,KAAK,EAAE,QAAQ,MAAM;AAC/B,oBAAU;AAAA,QACZ,CAAC;AAAA,MACH;AAAA,IACF;AAAA,IACA,OAAO,YAAY;AACjB,UAAI,OAAQ;AACZ,eAAS;AACT,cAAQ,MAAM;AACd,YAAM,KAAK,QAAQ,MAAM,EAAE,MAAM,MAAM,MAAS;AAChD,gBAAU,UAAU;AAAA,IACtB;AAAA,EACF;AAEA,QAAM,UAAU,CAAC,YAA4B;AAC3C,QAAI,kBAAkB,OAAO,KAAK,QAAQ,MAAM,KAAM,SAAQ,OAAO,QAAQ,EAAE;AAC/E,cAAU,YAAY,OAAO;AAAA,EAC/B;AAIA,QAAM,cAAc,CAAC,UAAiB;AACpC,cAAU,UAAU,KAAK;AACzB,eAAW,MAAM,CAAC,GAAG,OAAO,GAAG;AAC7B,cAAQ,EAAE,SAAS,OAAO,IAAI,OAAO,EAAE,MAAM,gBAAgB,SAAS,MAAM,QAAQ,EAAE,CAAC;AAAA,IACzF;AAAA,EACF;AAEA,QAAM,OAAO,YAA2B;AACtC,QAAI,QAAQ;AACZ,WAAO,CAAC,UAAU,QAAQ,OAAO,GAAG;AAClC,UAAI;AACJ,UAAI;AACF,mBAAW,MAAM,KAAK,QAAQ,QAAQ;AAAA,MACxC,SAAS,OAAO;AACd,oBAAY,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;AACrE;AAAA,MACF;AACA,iBAAW,OAAO,UAAU;AAC1B,YAAI;AACF,kBAAQ,oBAAoB,GAAG,CAAC;AAAA,QAClC,QAAQ;AAAA,QAER;AAAA,MACF;AACA,UAAI,SAAS,SAAS,GAAG;AACvB,gBAAQ;AACR;AAAA,MACF;AACA,YAAM,MAAM,KAAK;AACjB,cAAQ,KAAK,IAAI,QAAQ,GAAG,SAAS;AAAA,IACvC;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/modules/sandbox/mcp-hosted.d.mts

@@ -0,0 +1,46 @@
+import { type FetchLike } from '@modelcontextprotocol/client';
+import type { CallToolResult } from '@modelcontextprotocol/server';
+import type { JsonObject } from "../json.mjs";
+import { type ToolDescriptorIface } from "../manifest.mjs";
+import { type McpEndpointIface, type NetworkSandboxSessionIface, type SandboxMcpCatalogIface } from "./types.mjs";
+export declare enum SandboxHostedServerKind {
+    ComputerUse = "computerUse",
+    Local = "local"
+}
+export type SandboxHostedServer = {
+    kind: SandboxHostedServerKind.ComputerUse;
+} | {
+    kind: SandboxHostedServerKind.Local;
+    name: string;
+};
+export declare const COMPUTER_USE_SERVER_NAME = "computer-use";
+export declare const EMPTY_MCP_CATALOG: SandboxMcpCatalogIface;
+export interface HostedToolIface {
+    name: string;
+    server: SandboxHostedServer;
+    tool: ToolDescriptorIface;
+    policyKeys: string[];
+}
+export declare const hostedTools: (args: {
+    catalog: SandboxMcpCatalogIface;
+    computerUse: boolean;
+    localMcp: boolean;
+    localServer?: string;
+    taken: ReadonlySet<string>;
+}) => HostedToolIface[];
+export interface HostedMcpConnectionsIface {
+    call(server: SandboxHostedServer, tool: string, input: JsonObject): Promise<CallToolResult>;
+    tools(server: SandboxHostedServer): Promise<ToolDescriptorIface[]>;
+    learn(sandbox: NetworkSandboxSessionIface, needed: {
+        computerUse: boolean;
+        localMcp: boolean;
+    }): Promise<Partial<SandboxMcpCatalogIface>>;
+    close(): Promise<void>;
+}
+export declare const createHostedMcpConnections: (args: {
+    getSandbox: () => Promise<NetworkSandboxSessionIface>;
+    fetch?: FetchLike;
+    name?: string;
+    version?: string;
+}) => HostedMcpConnectionsIface;
+export declare const withHostedMcpEndpoints: <S extends NetworkSandboxSessionIface>(sandbox: S, endpointFor: (server: SandboxHostedServer) => McpEndpointIface) => S;

package/dist/modules/sandbox/mcp-hosted.mjs

@@ -0,0 +1,221 @@
+import {
+  Client,
+  ProtocolError,
+  StreamableHTTPClientTransport
+} from "@modelcontextprotocol/client";
+import { toolDescriptorSchema } from "../manifest.mjs";
+import { createMcpChannelTransport } from "./mcp-channel.mjs";
+import {
+  isMcpChannelEndpoint,
+  SandboxCapability
+} from "./types.mjs";
+var SandboxHostedServerKind = /* @__PURE__ */ ((SandboxHostedServerKind2) => {
+  SandboxHostedServerKind2["ComputerUse"] = "computerUse";
+  SandboxHostedServerKind2["Local"] = "local";
+  return SandboxHostedServerKind2;
+})(SandboxHostedServerKind || {});
+const COMPUTER_USE_SERVER_NAME = "computer-use";
+const EMPTY_MCP_CATALOG = { computerUse: null, localMcp: null };
+const toolNameSafe = (value) => value.replace(/[^A-Za-z0-9_-]/g, "_");
+const hostedTools = (args) => {
+  const taken = new Set(args.taken);
+  const tools = [];
+  const claim = (preferred, fallback) => {
+    const name = taken.has(preferred) ? fallback : preferred;
+    if (taken.has(name)) return null;
+    taken.add(name);
+    return name;
+  };
+  if (args.computerUse) {
+    for (const tool of args.catalog.computerUse ?? []) {
+      const name = claim(tool.name, `computer_use_${tool.name}`);
+      if (name == null) continue;
+      tools.push({
+        name,
+        server: { kind: "computerUse" /* ComputerUse */ },
+        tool,
+        policyKeys: [SandboxCapability.ComputerUse]
+      });
+    }
+  }
+  if (args.localMcp) {
+    const servers = Object.entries(args.catalog.localMcp ?? {}).filter(
+      ([server]) => args.localServer == null || server === args.localServer
+    );
+    const counts = /* @__PURE__ */ new Map();
+    for (const [, serverTools] of servers) {
+      for (const tool of serverTools) counts.set(tool.name, (counts.get(tool.name) ?? 0) + 1);
+    }
+    for (const [server, serverTools] of servers) {
+      for (const tool of serverTools) {
+        const prefixed = `${toolNameSafe(server)}_${tool.name}`;
+        const name = (counts.get(tool.name) ?? 0) > 1 ? claim(prefixed, prefixed) : claim(tool.name, prefixed);
+        if (name == null) continue;
+        tools.push({
+          name,
+          server: { kind: "local" /* Local */, name: server },
+          tool,
+          policyKeys: [`${server}/${tool.name}`, SandboxCapability.LocalMcp]
+        });
+      }
+    }
+  }
+  return tools;
+};
+const serverKeyOf = (server) => server.kind === "computerUse" /* ComputerUse */ ? "computer-use" : `local\0${server.name}`;
+const createHostedMcpConnections = (args) => {
+  const clients = /* @__PURE__ */ new Map();
+  const connect = async (endpoint) => {
+    const client = new Client({ name: args.name ?? "final-sandbox", version: args.version ?? "1" });
+    if (isMcpChannelEndpoint(endpoint)) {
+      await client.connect(createMcpChannelTransport({ channel: await endpoint.connect() }));
+      return client;
+    }
+    await client.connect(
+      new StreamableHTTPClientTransport(new URL(endpoint.url), {
+        requestInit: { headers: endpoint.headers },
+        fetch: args.fetch
+      })
+    );
+    return client;
+  };
+  const endpointOf = async (sandbox, server) => {
+    if (server.kind === "computerUse" /* ComputerUse */) {
+      if (sandbox.computerUse == null) throw new Error("this sandbox has no computer use");
+      return sandbox.computerUse();
+    }
+    if (sandbox.localMcp == null) throw new Error("this sandbox has no local MCP servers");
+    const found = (await sandbox.localMcp()).find((endpoint) => endpoint.name === server.name);
+    if (found == null) throw new Error(`this sandbox has no local MCP server ${server.name}`);
+    return found;
+  };
+  const forget = (key) => {
+    const client = clients.get(key);
+    clients.delete(key);
+    void client?.then((connected) => connected.close()).catch(() => void 0);
+  };
+  const clientFor = (key, endpoint) => {
+    const existing = clients.get(key);
+    if (existing != null) return existing;
+    const connecting = endpoint().then(connect);
+    clients.set(key, connecting);
+    connecting.catch(() => {
+      if (clients.get(key) === connecting) clients.delete(key);
+    });
+    return connecting;
+  };
+  const withClient = async (key, endpoint, work, retry = true) => {
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await work(await clientFor(key, endpoint));
+      } catch (error) {
+        if (error instanceof ProtocolError) throw error;
+        forget(key);
+        if (!retry || attempt > 0) throw error;
+      }
+    }
+  };
+  const toolsOf = async (client) => {
+    const tools = [];
+    let cursor;
+    do {
+      const page = await client.listTools(cursor == null ? void 0 : { cursor });
+      for (const tool of page.tools) {
+        const parsed = toolDescriptorSchema.safeParse(
+          JSON.parse(
+            JSON.stringify({
+              name: tool.name,
+              description: tool.description ?? tool.title ?? tool.name,
+              inputSchema: tool.inputSchema,
+              outputSchema: tool.outputSchema,
+              annotations: tool.annotations
+            })
+          )
+        );
+        if (parsed.success) tools.push(parsed.data);
+      }
+      cursor = page.nextCursor;
+    } while (cursor != null);
+    return tools;
+  };
+  return {
+    call: async (server, tool, input) => withClient(
+      serverKeyOf(server),
+      async () => endpointOf(await args.getSandbox(), server),
+      async (client) => {
+        const result = await client.callTool({ name: tool, arguments: input });
+        const proxied = { content: result.content };
+        if (result.structuredContent != null)
+          proxied.structuredContent = result.structuredContent;
+        if (result.isError === true) proxied.isError = true;
+        return proxied;
+      },
+      false
+    ),
+    tools: async (server) => withClient(
+      serverKeyOf(server),
+      async () => endpointOf(await args.getSandbox(), server),
+      toolsOf
+    ),
+    learn: async (sandbox, needed) => {
+      const learned = {};
+      if (needed.computerUse && sandbox.computerUse != null) {
+        const server = { kind: "computerUse" /* ComputerUse */ };
+        learned.computerUse = await withClient(
+          serverKeyOf(server),
+          () => endpointOf(sandbox, server),
+          toolsOf
+        );
+      }
+      if (needed.localMcp && sandbox.localMcp != null) {
+        const local = {};
+        for (const endpoint of await sandbox.localMcp()) {
+          const server = {
+            kind: "local" /* Local */,
+            name: endpoint.name
+          };
+          try {
+            local[endpoint.name] = await withClient(
+              serverKeyOf(server),
+              async () => endpoint,
+              toolsOf
+            );
+          } catch {
+            local[endpoint.name] = [];
+          }
+        }
+        learned.localMcp = local;
+      }
+      return learned;
+    },
+    close: async () => {
+      const open = [...clients.values()];
+      clients.clear();
+      await Promise.all(
+        open.map((client) => client.then((connected) => connected.close()).catch(() => void 0))
+      );
+    }
+  };
+};
+const withHostedMcpEndpoints = (sandbox, endpointFor) => {
+  const addressed = { ...sandbox };
+  if (sandbox.computerUse != null) {
+    addressed.computerUse = async () => endpointFor({ kind: "computerUse" /* ComputerUse */ });
+  }
+  const localMcp = sandbox.localMcp;
+  if (localMcp != null) {
+    addressed.localMcp = async () => (await localMcp()).map(
+      (endpoint) => endpointFor({ kind: "local" /* Local */, name: endpoint.name })
+    );
+  }
+  return addressed;
+};
+export {
+  COMPUTER_USE_SERVER_NAME,
+  EMPTY_MCP_CATALOG,
+  SandboxHostedServerKind,
+  createHostedMcpConnections,
+  hostedTools,
+  withHostedMcpEndpoints
+};
+//# sourceMappingURL=mcp-hosted.mjs.map

package/dist/modules/sandbox/mcp-hosted.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/sandbox/mcp-hosted.ts"],
+  "sourcesContent": ["import {\n  Client,\n  ProtocolError,\n  StreamableHTTPClientTransport,\n  type FetchLike,\n} from '@modelcontextprotocol/client';\nimport type { CallToolResult } from '@modelcontextprotocol/server';\nimport type { JsonObject } from \"../json.mjs\";\nimport { toolDescriptorSchema, type ToolDescriptorIface } from \"../manifest.mjs\";\nimport { createMcpChannelTransport } from \"./mcp-channel.mjs\";\nimport {\n  isMcpChannelEndpoint,\n  SandboxCapability,\n  type McpEndpointIface,\n  type NetworkSandboxSessionIface,\n  type SandboxMcpCatalogIface,\n  type SandboxMcpEndpoint,\n} from \"./types.mjs\";\n\n// A sandbox's hosted MCP servers (its computer-use server and local MCP\n// servers) as the MCP projection serves them: their own tools, by their own\n// names, proxied through the handle's `computerUse()` / `localMcp()`. Catalogs\n// come from the provider before anything starts when it can give them, and\n// are otherwise learned from the servers once the sandbox is attached.\n\nexport enum SandboxHostedServerKind {\n  ComputerUse = 'computerUse',\n  Local = 'local',\n}\n\nexport type SandboxHostedServer =\n  | { kind: SandboxHostedServerKind.ComputerUse }\n  | { kind: SandboxHostedServerKind.Local; name: string };\n\nexport const COMPUTER_USE_SERVER_NAME = 'computer-use';\n\nexport const EMPTY_MCP_CATALOG: SandboxMcpCatalogIface = { computerUse: null, localMcp: null };\n\n// One projected tool of a hosted server.\nexport interface HostedToolIface {\n  // The name the projection lists: the tool's own, prefixed only on a collision.\n  name: string;\n  server: SandboxHostedServer;\n  tool: ToolDescriptorIface;\n  // toolPolicy keys after `name`, most specific first.\n  policyKeys: string[];\n}\n\nconst toolNameSafe = (value: string): string => value.replace(/[^A-Za-z0-9_-]/g, '_');\n\n// Hosted tools under the names the projection lists. Computer-use tools keep\n// their names unless a built-in tool has it (`computer_use_<name>`); a local\n// tool keeps its name unless something else has it or another local server\n// has the same tool (`<server>_<name>`).\nexport const hostedTools = (args: {\n  catalog: SandboxMcpCatalogIface;\n  computerUse: boolean;\n  localMcp: boolean;\n  // Only this local server (a per-server endpoint).\n  localServer?: string;\n  taken: ReadonlySet<string>;\n}): HostedToolIface[] => {\n  const taken = new Set(args.taken);\n  const tools: HostedToolIface[] = [];\n  const claim = (preferred: string, fallback: string): string | null => {\n    const name = taken.has(preferred) ? fallback : preferred;\n    if (taken.has(name)) return null;\n    taken.add(name);\n    return name;\n  };\n  if (args.computerUse) {\n    for (const tool of args.catalog.computerUse ?? []) {\n      const name = claim(tool.name, `computer_use_${tool.name}`);\n      if (name == null) continue;\n      tools.push({\n        name,\n        server: { kind: SandboxHostedServerKind.ComputerUse },\n        tool,\n        policyKeys: [SandboxCapability.ComputerUse],\n      });\n    }\n  }\n  if (args.localMcp) {\n    const servers = Object.entries(args.catalog.localMcp ?? {}).filter(\n      ([server]) => args.localServer == null || server === args.localServer,\n    );\n    const counts = new Map<string, number>();\n    for (const [, serverTools] of servers) {\n      for (const tool of serverTools) counts.set(tool.name, (counts.get(tool.name) ?? 0) + 1);\n    }\n    for (const [server, serverTools] of servers) {\n      for (const tool of serverTools) {\n        const prefixed = `${toolNameSafe(server)}_${tool.name}`;\n        const name =\n          (counts.get(tool.name) ?? 0) > 1 ? claim(prefixed, prefixed) : claim(tool.name, prefixed);\n        if (name == null) continue;\n        tools.push({\n          name,\n          server: { kind: SandboxHostedServerKind.Local, name: server },\n          tool,\n          policyKeys: [`${server}/${tool.name}`, SandboxCapability.LocalMcp],\n        });\n      }\n    }\n  }\n  return tools;\n};\n\nconst serverKeyOf = (server: SandboxHostedServer): string =>\n  server.kind === SandboxHostedServerKind.ComputerUse\n    ? 'computer-use'\n    : `local\\u0000${server.name}`;\n\nexport interface HostedMcpConnectionsIface {\n  call(server: SandboxHostedServer, tool: string, input: JsonObject): Promise<CallToolResult>;\n  // One server's live tools, over the connection its calls use.\n  tools(server: SandboxHostedServer): Promise<ToolDescriptorIface[]>;\n  // Reads the catalogs `needed` asks for (null fields) from the live sandbox.\n  learn(\n    sandbox: NetworkSandboxSessionIface,\n    needed: { computerUse: boolean; localMcp: boolean },\n  ): Promise<Partial<SandboxMcpCatalogIface>>;\n  close(): Promise<void>;\n}\n\nexport const createHostedMcpConnections = (args: {\n  getSandbox: () => Promise<NetworkSandboxSessionIface>;\n  fetch?: FetchLike;\n  name?: string;\n  version?: string;\n}): HostedMcpConnectionsIface => {\n  const clients = new Map<string, Promise<Client>>();\n\n  const connect = async (endpoint: SandboxMcpEndpoint): Promise<Client> => {\n    const client = new Client({ name: args.name ?? 'final-sandbox', version: args.version ?? '1' });\n    if (isMcpChannelEndpoint(endpoint)) {\n      await client.connect(createMcpChannelTransport({ channel: await endpoint.connect() }));\n      return client;\n    }\n    await client.connect(\n      new StreamableHTTPClientTransport(new URL(endpoint.url), {\n        requestInit: { headers: endpoint.headers },\n        fetch: args.fetch,\n      }),\n    );\n    return client;\n  };\n\n  const endpointOf = async (\n    sandbox: NetworkSandboxSessionIface,\n    server: SandboxHostedServer,\n  ): Promise<SandboxMcpEndpoint> => {\n    if (server.kind === SandboxHostedServerKind.ComputerUse) {\n      if (sandbox.computerUse == null) throw new Error('this sandbox has no computer use');\n      return sandbox.computerUse();\n    }\n    if (sandbox.localMcp == null) throw new Error('this sandbox has no local MCP servers');\n    const found = (await sandbox.localMcp()).find((endpoint) => endpoint.name === server.name);\n    if (found == null) throw new Error(`this sandbox has no local MCP server ${server.name}`);\n    return found;\n  };\n\n  const forget = (key: string) => {\n    const client = clients.get(key);\n    clients.delete(key);\n    void client?.then((connected) => connected.close()).catch(() => undefined);\n  };\n\n  const clientFor = (key: string, endpoint: () => Promise<SandboxMcpEndpoint>): Promise<Client> => {\n    const existing = clients.get(key);\n    if (existing != null) return existing;\n    const connecting = endpoint().then(connect);\n    clients.set(key, connecting);\n    connecting.catch(() => {\n      if (clients.get(key) === connecting) clients.delete(key);\n    });\n    return connecting;\n  };\n\n  // One retry on a fresh connection: a parked or restarted server drops the old\n  // one. An error the server answered with leaves the connection as it is.\n  const withClient = async <T>(\n    key: string,\n    endpoint: () => Promise<SandboxMcpEndpoint>,\n    work: (client: Client) => Promise<T>,\n    retry = true,\n  ): Promise<T> => {\n    for (let attempt = 0; ; attempt += 1) {\n      try {\n        return await work(await clientFor(key, endpoint));\n      } catch (error) {\n        if (error instanceof ProtocolError) throw error;\n        forget(key);\n        if (!retry || attempt > 0) throw error;\n      }\n    }\n  };\n\n  const toolsOf = async (client: Client): Promise<ToolDescriptorIface[]> => {\n    const tools: ToolDescriptorIface[] = [];\n    let cursor: string | undefined;\n    do {\n      const page = await client.listTools(cursor == null ? undefined : { cursor });\n      for (const tool of page.tools) {\n        const parsed = toolDescriptorSchema.safeParse(\n          JSON.parse(\n            JSON.stringify({\n              name: tool.name,\n              description: tool.description ?? tool.title ?? tool.name,\n              inputSchema: tool.inputSchema,\n              outputSchema: tool.outputSchema,\n              annotations: tool.annotations,\n            }),\n          ),\n        );\n        if (parsed.success) tools.push(parsed.data);\n      }\n      cursor = page.nextCursor;\n    } while (cursor != null);\n    return tools;\n  };\n\n  return {\n    call: async (server, tool, input) =>\n      withClient(\n        serverKeyOf(server),\n        async () => endpointOf(await args.getSandbox(), server),\n        async (client) => {\n          const result = await client.callTool({ name: tool, arguments: input });\n          const proxied: CallToolResult = { content: result.content };\n          if (result.structuredContent != null)\n            proxied.structuredContent = result.structuredContent;\n          if (result.isError === true) proxied.isError = true;\n          return proxied;\n        },\n        false,\n      ),\n    tools: async (server) =>\n      withClient(\n        serverKeyOf(server),\n        async () => endpointOf(await args.getSandbox(), server),\n        toolsOf,\n      ),\n    learn: async (sandbox, needed) => {\n      const learned: Partial<SandboxMcpCatalogIface> = {};\n      if (needed.computerUse && sandbox.computerUse != null) {\n        const server: SandboxHostedServer = { kind: SandboxHostedServerKind.ComputerUse };\n        learned.computerUse = await withClient(\n          serverKeyOf(server),\n          () => endpointOf(sandbox, server),\n          toolsOf,\n        );\n      }\n      if (needed.localMcp && sandbox.localMcp != null) {\n        const local: Record<string, ToolDescriptorIface[]> = {};\n        for (const endpoint of await sandbox.localMcp()) {\n          const server: SandboxHostedServer = {\n            kind: SandboxHostedServerKind.Local,\n            name: endpoint.name,\n          };\n          try {\n            local[endpoint.name] = await withClient(\n              serverKeyOf(server),\n              async () => endpoint,\n              toolsOf,\n            );\n          } catch {\n            // A local server that fails to start lists nothing; the rest still do.\n            local[endpoint.name] = [];\n          }\n        }\n        learned.localMcp = local;\n      }\n      return learned;\n    },\n    close: async () => {\n      const open = [...clients.values()];\n      clients.clear();\n      await Promise.all(\n        open.map((client) => client.then((connected) => connected.close()).catch(() => undefined)),\n      );\n    },\n  };\n};\n\n// A handle whose hosted servers are re-addressed: `computerUse()` and\n// `localMcp()` return HTTP endpoints where the host of the handle serves them\n// (its per-binding MCP addresses), so they can cross the handle RPC and the\n// sandbox's own endpoints and credentials never leave the host.\nexport const withHostedMcpEndpoints = <S extends NetworkSandboxSessionIface>(\n  sandbox: S,\n  endpointFor: (server: SandboxHostedServer) => McpEndpointIface,\n): S => {\n  const addressed: S = { ...sandbox };\n  if (sandbox.computerUse != null) {\n    addressed.computerUse = async () => endpointFor({ kind: SandboxHostedServerKind.ComputerUse });\n  }\n  const localMcp = sandbox.localMcp;\n  if (localMcp != null) {\n    addressed.localMcp = async () =>\n      (await localMcp()).map((endpoint) =>\n        endpointFor({ kind: SandboxHostedServerKind.Local, name: endpoint.name }),\n      );\n  }\n  return addressed;\n};\n"],
+  "mappings": "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",
+  "names": ["SandboxHostedServerKind"]
+}

package/dist/modules/sandbox/mcp-search.d.mts

@@ -0,0 +1,51 @@
+import { SandboxEntryType, type SandboxSessionIface } from "./types.mjs";
+export interface WalkLimitsIface {
+    maxEntries: number;
+    maxFileBytes: number;
+}
+export declare const DEFAULT_WALK_LIMITS: WalkLimitsIface;
+export declare const globToRegExp: (glob: string) => {
+    test(input: string): boolean;
+};
+export interface WalkEntryIface {
+    path: string;
+    relative: string;
+    type: SandboxEntryType;
+    size: number | null;
+}
+export declare const walkTree: (sandbox: Pick<SandboxSessionIface, "readDir">, root: string, options: {
+    limits?: WalkLimitsIface;
+    signal?: AbortSignal;
+    onEntry: (entry: WalkEntryIface) => boolean | Promise<boolean>;
+}) => Promise<{
+    truncated: boolean;
+}>;
+export declare const globFiles: (args: {
+    sandbox: Pick<SandboxSessionIface, "readDir">;
+    cwd: string;
+    pattern: string;
+    path?: string;
+    maxResults: number;
+    signal?: AbortSignal;
+}) => Promise<{
+    paths: string[];
+    truncated: boolean;
+}>;
+export interface GrepMatchIface {
+    path: string;
+    line: number;
+    text: string;
+}
+export declare const grepFiles: (args: {
+    sandbox: Pick<SandboxSessionIface, "readDir" | "readTextFile" | "stat">;
+    cwd: string;
+    pattern: string;
+    path?: string;
+    glob?: string;
+    ignoreCase?: boolean;
+    maxResults: number;
+    signal?: AbortSignal;
+}) => Promise<{
+    matches: GrepMatchIface[];
+    truncated: boolean;
+}>;