@sideboard-ai/core 0.1.311 → 0.1.312

package/dist/{chunk-4YBQBVYL.js → chunk-4FZUUH6W.js}

@@ -513,6 +513,9 @@ var brightsyAdapter = {
 
 // src/agents/claude.ts
 import { existsSync as existsSync7 } from "fs";
+
+// src/mcp-ui/host.ts
+import { createHash } from "crypto";
 import { homedir as homedir4 } from "os";
 
 // src/agents/orch-mcp-isolation.ts
@@ -608,18 +611,18 @@ function mcpUiContentSecurityPolicy(csp) {
   const connect = (csp?.connectDomains ?? []).join(" ");
   const frames = csp?.frameDomains?.length ? csp.frameDomains.join(" ") : "'none'";
   const base = csp?.baseUriDomains?.length ? csp.baseUriDomains.join(" ") : "'none'";
+  const connectSrc = connect ? `'self' ${connect}`.trim() : "'none'";
   return [
     "default-src 'none'",
-    `script-src 'self' 'unsafe-inline' 'unsafe-eval' ${resource}`.trim(),
+    `script-src 'self' 'unsafe-inline' ${resource}`.trim(),
     `style-src 'self' 'unsafe-inline' ${resource}`.trim(),
-    `img-src 'self' data: blob: ${resource}`.trim(),
-    `font-src 'self' data: ${resource}`.trim(),
-    `connect-src 'self' ${connect}`.trim(),
-    `media-src 'self' data: blob: ${resource}`.trim(),
+    `img-src 'self' data: ${resource}`.trim(),
+    `font-src 'self' ${resource}`.trim(),
+    `connect-src ${connectSrc}`,
+    `media-src 'self' data: ${resource}`.trim(),
     `frame-src ${frames}`,
     `base-uri ${base}`,
-    "object-src 'none'",
-    "form-action 'self'"
+    "object-src 'none'"
   ].join("; ");
 }
 function htmlText(text, blob) {
@@ -656,8 +659,10 @@ function originList(value) {
   return out;
 }
 function originToken(value) {
+  const trimmed = value.trim();
+  if (/^(https?|wss?):\/\/\*\.[a-z0-9.-]+(?::\d+)?$/i.test(trimmed)) return trimmed;
   try {
-    const url = new URL(value.trim());
+    const url = new URL(trimmed);
     if (url.protocol !== "https:" && url.protocol !== "http:" && url.protocol !== "wss:" && url.protocol !== "ws:") {
       return null;
     }
@@ -1493,6 +1498,497 @@ function toCodexUnattendedAppsArgs() {
   ];
 }
 
+// src/mcp-ui/proxy-http.ts
+import { randomBytes, randomUUID } from "crypto";
+import { createServer } from "http";
+import { Server as Server2 } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/mcp-ui/proxy-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/mcp-ui/visibility.ts
+function visibilityFromMeta(meta) {
+  const rec = asRecord2(meta);
+  const ui = asRecord2(rec.ui);
+  const raw = ui.visibility;
+  if (!Array.isArray(raw)) return ["model", "app"];
+  const out = [];
+  for (const item of raw) {
+    if (item !== "model" && item !== "app") continue;
+    if (!out.includes(item)) out.push(item);
+  }
+  return out.length ? out : ["model", "app"];
+}
+function toolVisibleTo(visibility, audience) {
+  const vis = visibility?.length ? visibility : ["model", "app"];
+  return vis.includes(audience);
+}
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+
+// src/mcp-ui/proxy-server.ts
+function attachMcpUiProxyHandlers(server, session) {
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = await session.listTools();
+    return { tools: tools.filter((tool) => toolVisibleTo(tool.visibility, "model")).map(listedTool) };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const name = request.params.name;
+    const tools = await session.listTools();
+    const tool = tools.find((item) => item.name === name);
+    if (!tool || !toolVisibleTo(tool.visibility, "model")) {
+      throw new Error(`Tool ${name} is not available to the model`);
+    }
+    return await session.callTool(name, request.params.arguments ?? {});
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const resource = await session.readResource(request.params.uri);
+    if (!resource) throw new Error(`Resource ${request.params.uri} was empty`);
+    return {
+      contents: [
+        {
+          uri: resource.uri,
+          ...resource.mimeType ? { mimeType: resource.mimeType } : {},
+          ...resource.text != null ? { text: resource.text } : {},
+          ...resource.blob != null ? { blob: resource.blob } : {}
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => session.listResources());
+  server.setRequestHandler(
+    ListResourceTemplatesRequestSchema,
+    async () => session.listResourceTemplates()
+  );
+  server.setRequestHandler(ListPromptsRequestSchema, async () => session.listPrompts());
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    return await session.getPrompt(request.params.name, request.params.arguments);
+  });
+  server.fallbackRequestHandler = async (request) => {
+    return await session.forward(request.method, request.params);
+  };
+}
+function listedTool(tool) {
+  return {
+    name: tool.name,
+    ...tool.description ? { description: tool.description } : {},
+    inputSchema: tool.inputSchema ?? { type: "object", properties: {} },
+    _meta: {
+      ui: {
+        ...tool.resourceUri ? { resourceUri: tool.resourceUri } : {},
+        visibility: tool.visibility
+      }
+    }
+  };
+}
+
+// src/mcp-ui/proxy-http.ts
+async function listenMcpUiProxy(opts) {
+  const token = randomBytes(24).toString("hex");
+  const transports = /* @__PURE__ */ new Map();
+  const httpServer = createServer((req, res) => {
+    void handle(req, res);
+  });
+  await new Promise((resolve2, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(0, "127.0.0.1", () => resolve2());
+  });
+  const addr = httpServer.address();
+  if (!addr || typeof addr === "string") throw new Error("mcp-ui proxy failed to bind");
+  const origin = `http://127.0.0.1:${addr.port}`;
+  async function handle(req, res) {
+    if (req.headers.authorization !== `Bearer ${token}`) {
+      res.writeHead(401).end();
+      return;
+    }
+    const target = parseMcpUiProxyPath(req.url);
+    if (!target) {
+      res.writeHead(404).end();
+      return;
+    }
+    try {
+      const session = await opts.sessionFor(target.server, target.dirsKey);
+      if (!session) {
+        res.writeHead(404).end();
+        return;
+      }
+      const header = req.headers["mcp-session-id"];
+      const sid = typeof header === "string" ? header : "";
+      const sessionKey = `${target.server}:${target.dirsKey}`;
+      let transport = sid ? transports.get(`${sessionKey}:${sid}`) : void 0;
+      if (!transport) {
+        if (req.method !== "POST") {
+          res.writeHead(400).end();
+          return;
+        }
+        const created = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID(),
+          allowedHosts: ["127.0.0.1", "localhost"],
+          onsessioninitialized: (id) => {
+            transports.set(`${sessionKey}:${id}`, created);
+          },
+          onsessionclosed: (id) => {
+            transports.delete(`${sessionKey}:${id}`);
+          }
+        });
+        transport = created;
+        const mcp = new Server2(
+          { name: `sideboard-ui-proxy-${target.server}`, version: "1.0.0" },
+          { capabilities: session.capabilities() }
+        );
+        attachMcpUiProxyHandlers(mcp, session);
+        await mcp.connect(created);
+      }
+      await transport.handleRequest(req, res);
+    } catch {
+      if (!res.headersSent) res.writeHead(500).end();
+    }
+  }
+  return {
+    urlFor(server, dirsKey) {
+      const base = `${origin}/s/${encodeURIComponent(server)}`;
+      return dirsKey ? `${base}/d/${dirsKey}` : base;
+    },
+    headers: { Authorization: `Bearer ${token}` },
+    async close() {
+      await Promise.all([...transports.values()].map((item) => item.close().catch(() => void 0)));
+      transports.clear();
+      await new Promise((resolve2) => httpServer.close(() => resolve2()));
+    }
+  };
+}
+function parseMcpUiProxyPath(url) {
+  const path = (url ?? "").split("?")[0] ?? "";
+  if (!path.startsWith("/s/")) return null;
+  const rest = path.slice(3).replace(/\/$/, "");
+  const split = rest.indexOf("/d/");
+  try {
+    if (split < 0) {
+      const server2 = decodeURIComponent(rest).trim();
+      return server2 ? { server: server2, dirsKey: "" } : null;
+    }
+    const server = decodeURIComponent(rest.slice(0, split)).trim();
+    const dirsKey = rest.slice(split + 3);
+    if (!server || !/^[a-f0-9]{16}$/.test(dirsKey)) return null;
+    return { server, dirsKey };
+  } catch {
+    return null;
+  }
+}
+
+// src/mcp-ui/session.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport, getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { ResultSchema } from "@modelcontextprotocol/sdk/types.js";
+var REQUEST_TIMEOUT_MS = 2e4;
+async function orEmpty(run2, fallback) {
+  try {
+    return await run2();
+  } catch {
+    return fallback;
+  }
+}
+var UI_CAPABILITIES = {
+  extensions: {
+    "io.modelcontextprotocol/ui": {
+      mimeTypes: ["text/html;profile=mcp-app"]
+    }
+  }
+};
+async function openMcpUiSession(launch) {
+  return openMcpUiSessionFromTransport(transportForLaunch(launch));
+}
+async function openMcpUiSessionFromTransport(transport) {
+  const client = new Client(
+    { name: "sideboard", version: "1.0.0" },
+    { capabilities: UI_CAPABILITIES }
+  );
+  await client.connect(transport, { timeout: REQUEST_TIMEOUT_MS });
+  return {
+    async listTools() {
+      const listed = await client.listTools(void 0, { timeout: REQUEST_TIMEOUT_MS });
+      return listed.tools.map((tool) => {
+        const meta = tool._meta;
+        return {
+          name: tool.name,
+          ...tool.description ? { description: tool.description } : {},
+          ...tool.inputSchema ? { inputSchema: tool.inputSchema } : {},
+          resourceUri: uiResourceUriFromMeta(meta),
+          visibility: visibilityFromMeta(meta),
+          ...cspFromMeta(meta) ? { csp: cspFromMeta(meta) } : {}
+        };
+      });
+    },
+    listResources: () => orEmpty(
+      () => client.listResources(void 0, { timeout: REQUEST_TIMEOUT_MS }),
+      { resources: [] }
+    ),
+    listResourceTemplates: () => orEmpty(
+      () => client.listResourceTemplates(void 0, { timeout: REQUEST_TIMEOUT_MS }),
+      { resourceTemplates: [] }
+    ),
+    listPrompts: () => orEmpty(
+      () => client.listPrompts(void 0, { timeout: REQUEST_TIMEOUT_MS }),
+      { prompts: [] }
+    ),
+    getPrompt(name, args) {
+      return client.getPrompt({ name, arguments: args }, { timeout: REQUEST_TIMEOUT_MS });
+    },
+    async readResource(uri) {
+      const result = await client.readResource({ uri }, { timeout: REQUEST_TIMEOUT_MS });
+      const content = result.contents?.[0];
+      if (!content) return null;
+      const text = "text" in content && typeof content.text === "string" ? content.text : void 0;
+      const blob = "blob" in content && typeof content.blob === "string" ? content.blob : void 0;
+      return {
+        uri: content.uri,
+        ...content.mimeType ? { mimeType: content.mimeType } : {},
+        ...text != null ? { text } : {},
+        ...blob != null ? { blob } : {},
+        ...cspFromMeta(content._meta) ? { csp: cspFromMeta(content._meta) } : {}
+      };
+    },
+    async callTool(name, args) {
+      return client.callTool({ name, arguments: args }, void 0, { timeout: REQUEST_TIMEOUT_MS });
+    },
+    capabilities() {
+      const caps = client.getServerCapabilities() ?? {};
+      return {
+        tools: caps.tools ?? {},
+        resources: caps.resources ?? {},
+        prompts: caps.prompts ?? {},
+        completions: caps.completions ?? {},
+        ...caps.logging ? { logging: caps.logging } : {}
+      };
+    },
+    forward(method, params) {
+      return client.request(
+        { method, params },
+        ResultSchema,
+        { timeout: REQUEST_TIMEOUT_MS }
+      );
+    },
+    async close() {
+      await client.close();
+    }
+  };
+}
+function transportForLaunch(launch) {
+  if (launch.kind === "stdio") {
+    return new StdioClientTransport({
+      command: launch.command,
+      args: launch.args,
+      env: { ...getDefaultEnvironment(), ...launch.env },
+      stderr: "ignore",
+      ...launch.cwd ? { cwd: launch.cwd } : {}
+    });
+  }
+  const url = new URL(launch.url);
+  const requestInit = launch.headers ? { headers: launch.headers } : void 0;
+  if (launch.kind === "sse") {
+    return new SSEClientTransport(url, requestInit ? { requestInit } : void 0);
+  }
+  return new StreamableHTTPClientTransport(url, requestInit ? { requestInit } : void 0);
+}
+
+// src/mcp-ui/host.ts
+var TOOL_TTL_MS = 5 * 60 * 1e3;
+var McpUiHost = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  sessions = /* @__PURE__ */ new Map();
+  toolLists = /* @__PURE__ */ new Map();
+  proxy;
+  proxyDirs = /* @__PURE__ */ new Map();
+  async viewForClaudeTool(toolName, projectDirs) {
+    const entries = this.userEntries(projectDirs);
+    const match = matchClaudeMcpTool(toolName, Object.keys(entries));
+    if (!match) return null;
+    const launch = parseMcpServerLaunch(entries[match.server] ?? {});
+    if (!launch) return null;
+    try {
+      const session = await this.sessionFor(match.server, launch);
+      const tools = await this.toolsFor(match.server, launch, session);
+      const tool = tools.find((item) => item.name === match.tool);
+      if (!tool?.resourceUri) return null;
+      const resource = await session.readResource(tool.resourceUri);
+      if (!resource) return null;
+      const html = htmlFromResourceContent(resource);
+      if (!html) return null;
+      const csp = resource.csp ?? tool.csp;
+      return {
+        server: match.server,
+        tool: match.tool,
+        uri: html.uri,
+        mimeType: html.mimeType,
+        html: html.html,
+        csp: mcpUiContentSecurityPolicy(csp)
+      };
+    } catch (err) {
+      console.error(
+        `[mcp-ui] ${match.server}/${match.tool}:`,
+        err instanceof Error ? err.message : err
+      );
+      return null;
+    }
+  }
+  /**
+   * Point Claude at loopback HTTP so it shares this host's upstream session
+   * and never sees `visibility: ["app"]` tools.
+   */
+  async proxyEntries(entries, projectDirs) {
+    const names = Object.keys(entries).filter((name) => name.trim());
+    if (names.length === 0) return {};
+    const dirsKey = dirsKeyFor(projectDirs);
+    this.proxyDirs.set(dirsKey, projectDirs);
+    try {
+      const listen = await this.ensureProxy();
+      const out = {};
+      for (const name of names) {
+        out[name] = {
+          type: "http",
+          url: listen.urlFor(name, dirsKey),
+          headers: listen.headers
+        };
+      }
+      return out;
+    } catch (err) {
+      console.error("[mcp-ui] proxy:", err instanceof Error ? err.message : err);
+      return { ...entries };
+    }
+  }
+  async callTool(server, tool, args, projectDirs) {
+    const entry = this.userEntries(projectDirs)[server];
+    if (!entry) throw new Error(`MCP server ${server} is not available`);
+    const launch = parseMcpServerLaunch(entry);
+    if (!launch) throw new Error(`MCP server ${server} is not available`);
+    const session = await this.sessionFor(server, launch);
+    const tools = await this.toolsFor(server, launch, session);
+    const info = tools.find((item) => item.name === tool);
+    if (!info || !toolVisibleTo(info.visibility, "app")) {
+      throw new Error(`Tool ${tool} is not available to the app`);
+    }
+    return session.callTool(tool, args);
+  }
+  async readResource(server, uri, projectDirs) {
+    const session = await this.sessionForName(server, projectDirs);
+    if (!session) throw new Error(`MCP server ${server} is not available`);
+    const resource = await session.readResource(uri);
+    if (!resource) throw new Error(`Resource ${uri} was empty`);
+    return {
+      contents: [
+        {
+          uri: resource.uri,
+          ...resource.mimeType ? { mimeType: resource.mimeType } : {},
+          ...resource.text != null ? { text: resource.text } : {},
+          ...resource.blob != null ? { blob: resource.blob } : {}
+        }
+      ]
+    };
+  }
+  async closeAll() {
+    const pending = [...this.sessions.values()];
+    const proxy = this.proxy;
+    this.sessions.clear();
+    this.toolLists.clear();
+    this.proxyDirs.clear();
+    this.proxy = void 0;
+    await Promise.all([
+      ...pending.map((session) => session.then((open) => open.close()).catch(() => void 0)),
+      proxy ? proxy.then((listen) => listen.close()).catch(() => void 0) : Promise.resolve()
+    ]);
+  }
+  ensureProxy() {
+    if (this.proxy) return this.proxy;
+    this.proxy = listenMcpUiProxy({
+      sessionFor: (server, dirsKey) => {
+        if (dirsKey && !this.proxyDirs.has(dirsKey)) return Promise.resolve(null);
+        return this.sessionForName(server, this.proxyDirs.get(dirsKey));
+      }
+    }).catch((err) => {
+      this.proxy = void 0;
+      throw err;
+    });
+    return this.proxy;
+  }
+  userEntries(projectDirs) {
+    const out = {};
+    for (const [name, entry] of Object.entries(this.opts.entries(projectDirs))) {
+      if (!name.trim() || isInjectedOrchMcpName(name) || !entry) continue;
+      out[name] = entry;
+    }
+    return out;
+  }
+  async sessionForName(server, projectDirs) {
+    const entry = this.userEntries(projectDirs)[server];
+    if (!entry) return null;
+    const launch = parseMcpServerLaunch(entry);
+    if (!launch) return null;
+    return this.sessionFor(server, launch);
+  }
+  sessionFor(server, launch) {
+    const key = `${server}
+${JSON.stringify(launch)}`;
+    const existing = this.sessions.get(key);
+    if (existing) return existing;
+    const open = this.opts.openSession ?? openMcpUiSession;
+    const pending = open(launch).catch((err) => {
+      this.sessions.delete(key);
+      throw err;
+    });
+    this.sessions.set(key, pending);
+    return pending;
+  }
+  async toolsFor(server, launch, session) {
+    const key = `${server}
+${JSON.stringify(launch)}`;
+    const cached = this.toolLists.get(key);
+    if (cached && cached.key === key && Date.now() - cached.at < TOOL_TTL_MS) return cached.tools;
+    const tools = await session.listTools();
+    this.toolLists.set(key, { at: Date.now(), key, tools });
+    return tools;
+  }
+};
+var singleton;
+function getMcpUiHost() {
+  if (!singleton) {
+    singleton = new McpUiHost({
+      entries: (projectDirs) => listUserClaudeMcpServerEntries(homedir4(), projectDirs)
+    });
+  }
+  return singleton;
+}
+async function proxyClaudeUserMcp(orchestrator, projectDirs) {
+  if (orchestrator) return {};
+  const dirs = projectDirs.filter((d) => typeof d === "string" && d.length > 0);
+  return getMcpUiHost().proxyEntries(listUserClaudeMcpServerEntries(homedir4(), dirs), dirs);
+}
+function closeMcpUiHost() {
+  const host = singleton;
+  singleton = void 0;
+  if (host) void host.closeAll();
+}
+function dirsKeyFor(projectDirs) {
+  if (!projectDirs?.length) return "";
+  return createHash("sha256").update(projectDirs.join("\0")).digest("hex").slice(0, 16);
+}
+
 // src/agents/types.ts
 var PLAN_MODE_INSTRUCTION = "Plan mode is active and must remain active until the user turns Plan mode off in the UI (or Approves / Hands off the plan). Analyze the codebase, search and read files as needed, and produce or refine a clear implementation plan. Do not modify, create, or delete any project files except via Sideboard MCP present_plan (writes .context/attachments/plan.md). When you need a clarifying decision (approach forks, auth choice, scope) \u2014 not greetings, check-ins, or an invented task menu: (1) first write a short chat message that explains the decision and what each option means (tradeoffs, when to pick it) \u2014 do not leave the user staring at bare labels; (2) then call Sideboard MCP ask_user with the same options, including a description on every option. If one option is the obvious default, proceed without asking. Sideboard shows questions in the composer and mirrors them in chat. After ask_user, wait for the user's next message with their answers before finalizing the plan. When the plan is ready for approval: (1) call present_plan with the full markdown plan (title + content) so Sideboard saves .context/attachments/plan.md and shows it in chat for Approve / Hand off / Copy; (2) Claude should also call ExitPlanMode after present_plan. Do not skip present_plan \u2014 the plan must be a markdown file, not only chat prose.";
 var PLAN_MODE_OFF_INSTRUCTION = "Plan mode is off. Do not call present_plan or ExitPlanMode \u2014 those only work when the user turns Plan on in the composer. If you need to propose an approach, write it in chat.";
@@ -2063,7 +2559,7 @@ var claudeAdapter = {
     });
     const injectedBrightsyNames = injectedServers.filter((s) => s.name === "brightsy" || s.name.startsWith("brightsy_")).map((s) => s.name);
     const chromeOn = claudeChromeEnabled();
-    const userMcpEntries = isOrchestrator ? {} : listUserClaudeMcpServerEntries(homedir4(), [thread.repoPath, thread.worktreePath]);
+    const userMcpEntries = await proxyClaudeUserMcp(isOrchestrator, [thread.repoPath, thread.worktreePath]);
     let allowedTools;
     if (isOrchestrator) {
       allowedTools = [
@@ -2401,7 +2897,7 @@ function unwrapCodexMcpResult(result) {
     return String(result);
   }
 }
-function asRecord2(value) {
+function asRecord3(value) {
   if (value && typeof value === "object" && !Array.isArray(value)) {
     return value;
   }
@@ -2554,7 +3050,7 @@ var codexAdapter = {
         }
         if (itemType === "mcp_tool_call" && item.id && item.server && item.tool) {
           const name = `mcp__${item.server}__${item.tool}`;
-          const input = asRecord2(item.arguments);
+          const input = asRecord3(item.arguments);
           const events = [
             { type: "tool_use", id: item.id, name, input }
           ];
@@ -3039,7 +3535,7 @@ var FALLBACK_OPENCODE_MODELS = [
 ];
 var cachedOpencodeModels = null;
 var OPENCODE_MODEL_CACHE_MS = 5 * 60 * 1e3;
-function asRecord3(value) {
+function asRecord4(value) {
   if (value && typeof value === "object" && !Array.isArray(value)) {
     return value;
   }
@@ -3210,7 +3706,7 @@ var opencodeAdapter = {
         const name = part?.tool ?? part?.name ?? obj.tool ?? obj.name ?? "tool";
         const state = part?.state;
         const input = (state?.input && typeof state.input === "object" ? state.input : void 0) ?? part?.input ?? obj.input;
-        const metadata = asRecord3(state?.metadata);
+        const metadata = asRecord4(state?.metadata);
         const id = opencodeToolId(
           name,
           part?.callID ?? part?.id ?? obj.id,
@@ -3245,7 +3741,7 @@ var opencodeAdapter = {
       }
       if (obj.type === "subtask_event") {
         const parentId = str(obj.childSessionID) ?? str(obj.childSessionId);
-        const part = asRecord3(obj.part);
+        const part = asRecord4(obj.part);
         if (!parentId || !part) return null;
         if (part.type === "text" && str(part.text)) {
           return withTaskParent(
@@ -3256,8 +3752,8 @@ var opencodeAdapter = {
         if (part.type === "tool" || str(part.tool)) {
           const name = str(part.tool) ?? str(part.name) ?? "tool";
           const id = str(part.callID) ?? str(part.id) ?? `${parentId}-${name}`;
-          const state = asRecord3(part.state);
-          const input = asRecord3(state?.input) ?? asRecord3(part.input);
+          const state = asRecord4(part.state);
+          const input = asRecord4(state?.input) ?? asRecord4(part.input);
           const nested = [
             withEventParentId({ type: "tool_use", id, name, input }, parentId)
           ];
@@ -3976,11 +4472,6 @@ export {
   adjustBrightsyTurnExit,
   listBrightsyChatTargets,
   brightsyAdapter,
-  matchClaudeMcpTool,
-  parseMcpServerLaunch,
-  uiResourceUriFromMeta,
-  cspFromMeta,
-  htmlFromResourceContent,
   mcpUiContentSecurityPolicy,
   SIDEBOARD_MCP_PROFILE_ENV,
   SIDEBOARD_THREAD_ID_ENV,
@@ -4005,7 +4496,8 @@ export {
   registerPackagedUserMcpClients,
   isInjectedOrchMcpName,
   userMcpNamesToDisable,
-  listUserClaudeMcpServerEntries,
+  getMcpUiHost,
+  closeMcpUiHost,
   PLAN_MODE_INSTRUCTION,
   PLAN_MODE_OFF_INSTRUCTION,
   planModeTurnInstruction,

package/dist/{chunk-7ORMOP3D.js → chunk-LLTWP4PK.js}

@@ -27,7 +27,7 @@ import {
   parseSessionQuotaResetAt,
   planModeTurnInstruction,
   resolveQuotaFallbackAgent
-} from "./chunk-GQJOLTZU.js";
+} from "./chunk-2P2HYXA2.js";
 import {
   REVIEW_TAB_TITLE,
   applyWorktreePkgCacheEnv,
@@ -1500,6 +1500,15 @@ function thisProcessShouldDrainAgentQueues() {
   return !isDesktopHostAlive();
 }
 
+// src/mcp-ui/model-context.ts
+function takeMcpAppModelContext(threadId) {
+  const thread = readThread(threadId);
+  const text3 = thread?.mcpAppModelContext?.trim();
+  if (!text3) return void 0;
+  updateThread(threadId, { mcpAppModelContext: null });
+  return text3;
+}
+
 // src/agents/tool-permission.ts
 import { randomUUID } from "crypto";
 import { dirname } from "path";
@@ -6429,7 +6438,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-3W5S6TNP.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-S44BMNN7.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -7516,6 +7525,7 @@ ${formatEnvReminder(projectNameForRepoPath(thread.repoPath || thread.worktreePat
         orchestrationReminder,
         prGateDirective,
         injectedNoticeContext,
+        takeMcpAppModelContext(threadId),
         expandedPrompt
       ].filter(Boolean).join("\n\n");
       if (!autoContinue && sentAttachments) {