chainlesschain 0.166.130 → 0.166.131

package/src/lib/mcp-tool-catalog-authority.js

@@ -0,0 +1,244 @@
+import { createHash } from "node:crypto";
+
+// Only host-owned publications can enlarge a live catalog. A plain object or a
+// mutated startup array is not a catalog authority.
+const authorities = new WeakMap();
+const publishers = new WeakMap();
+
+function freezeMetadata(value, seen = new WeakSet()) {
+  if (!value || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  for (const child of Object.values(value)) freezeMetadata(child, seen);
+  return Object.freeze(value);
+}
+
+export function captureMcpToolCatalog(authority) {
+  if (authority == null) return null;
+  if (!authorities.has(authority)) {
+    const error = new TypeError("MCP tool catalog authority is invalid");
+    error.code = "CC_MCP_TOOL_CATALOG_AUTHORITY_INVALID";
+    throw error;
+  }
+  return authority;
+}
+
+export function readMcpToolCatalog(authority) {
+  return authorities.get(captureMcpToolCatalog(authority))?.read() || null;
+}
+
+function installAuthority(read, extendSelection = false, selectionBase = null) {
+  const authority = Object.freeze({});
+  authorities.set(authority, {
+    read,
+    extendSelection,
+    selectionBase: Array.isArray(selectionBase)
+      ? Object.freeze([...selectionBase])
+      : null,
+  });
+  return authority;
+}
+
+/** Publish a completed, admitted host inventory; never expose a partial batch. */
+export function publishMcpToolCatalog(mcp, { create = false } = {}) {
+  let publisher = publishers.get(mcp);
+  if (!publisher && !create) return null;
+  if (!publisher) {
+    publisher = { snapshot: null, records: new Map(), revision: 0 };
+    publisher.authority = installAuthority(() => {
+      publisher.refresh?.();
+      return publisher.snapshot;
+    });
+    publishers.set(mcp, publisher);
+    Object.defineProperty(mcp, "mcpToolCatalog", {
+      value: publisher.authority,
+      enumerable: true,
+    });
+  }
+  const records = new Map();
+  const identities = new Map();
+  for (const definition of mcp.extraToolDefinitions || []) {
+    const name = definition?.function?.name;
+    const executor = mcp.externalToolExecutors?.[name];
+    if (!name || !executor) continue;
+    const full =
+      executor.registry?.deferred?.get(name)?.definition || definition;
+    freezeMetadata(full);
+    freezeMetadata(definition);
+    freezeMetadata(mcp.externalToolDescriptors?.[name]);
+    for (const key of [
+      "kind",
+      "serverName",
+      "toolName",
+      "op",
+      "toolResultConfig",
+    ]) {
+      if (!Object.hasOwn(executor, key)) continue;
+      Object.defineProperty(executor, key, {
+        value: freezeMetadata(executor[key]),
+        enumerable: true,
+        writable: false,
+        configurable: false,
+      });
+    }
+    const fingerprint = createHash("sha256")
+      .update(
+        JSON.stringify({
+          definition: full,
+          descriptor: mcp.externalToolDescriptors?.[name] || null,
+          route: {
+            kind: executor.kind,
+            serverName: executor.serverName,
+            toolName: executor.toolName,
+            op: executor.op,
+            inheritable: executor.inheritable,
+          },
+        }),
+      )
+      .digest("hex");
+    const previous = publisher.records.get(name);
+    const identity =
+      previous?.executor === executor && previous.fingerprint === fingerprint
+        ? previous.identity
+        : Object.freeze({});
+    records.set(name, { executor, fingerprint, identity });
+    identities.set(name, identity);
+  }
+  publisher.records = records;
+  publisher.snapshot = Object.freeze({
+    revision: ++publisher.revision,
+    extraToolDefinitions: Object.freeze([...(mcp.extraToolDefinitions || [])]),
+    externalToolDescriptors: Object.freeze({ ...mcp.externalToolDescriptors }),
+    externalToolExecutors: Object.freeze({ ...mcp.externalToolExecutors }),
+    mcpClient: mcp.mcpClient || null,
+    identities,
+  });
+  return publisher.authority;
+}
+
+export function setMcpToolCatalogRefresh(mcp, refresh) {
+  if (!publishers.has(mcp)) publishMcpToolCatalog(mcp, { create: true });
+  publishers.get(mcp).refresh = refresh;
+}
+
+/** A derived authority can only remove names from its parent. */
+export function projectMcpToolCatalog(
+  authority,
+  project,
+  { extendSelection = false, selectionBase = null } = {},
+) {
+  captureMcpToolCatalog(authority);
+  let previousSource;
+  let previousResult;
+  return installAuthority(
+    () => {
+      const source = readMcpToolCatalog(authority);
+      if (source === previousSource) return previousResult;
+      const result = project(source, previousResult);
+      const permitted = new Set(
+        source.extraToolDefinitions.map((def) => def.function.name),
+      );
+      const definitions = (result?.extraToolDefinitions || []).filter((def) =>
+        permitted.has(def?.function?.name),
+      );
+      const names = new Set(definitions.map((def) => def.function.name));
+      const subset = (values) =>
+        Object.fromEntries(
+          Object.entries(values || {}).filter(([name]) => names.has(name)),
+        );
+      previousSource = source;
+      previousResult = Object.freeze({
+        ...result,
+        revision: source.revision,
+        extraToolDefinitions: Object.freeze(definitions),
+        externalToolDescriptors: Object.freeze(
+          subset(result?.externalToolDescriptors),
+        ),
+        externalToolExecutors: Object.freeze(
+          subset(result?.externalToolExecutors),
+        ),
+        mcpClient: source.mcpClient,
+        identities: new Map(
+          [...source.identities].filter(([name]) => names.has(name)),
+        ),
+      });
+      return previousResult;
+    },
+    extendSelection,
+    selectionBase,
+  );
+}
+
+export function restrictMcpToolCatalog(snapshot, names) {
+  const allowed = new Set(names);
+  return {
+    ...snapshot,
+    extraToolDefinitions: snapshot.extraToolDefinitions.filter((def) =>
+      allowed.has(def.function.name),
+    ),
+  };
+}
+
+export function assertMcpCatalogBinding(binding, name) {
+  if (!binding) return;
+  const current = readMcpToolCatalog(binding.authority);
+  const identity = binding.snapshot.identities.get(name);
+  if (!identity || current.identities.get(name) !== identity) {
+    const error = new Error(
+      `MCP tool catalog changed before dispatch of ${name}; request its current schema again`,
+    );
+    error.code = "CC_MCP_TOOL_CATALOG_STALE";
+    error.dispatched = false;
+    throw error;
+  }
+}
+
+/** Replace catalog-owned fields while retaining unrelated host tools. */
+export function mergeMcpToolCatalog(options, snapshot, authority) {
+  const selection = authorities.get(captureMcpToolCatalog(authority));
+  const mayExtendSelection =
+    selection.extendSelection === true &&
+    Array.isArray(selection.selectionBase) &&
+    Array.isArray(options.enabledToolNames) &&
+    options.enabledToolNames.length === selection.selectionBase.length &&
+    options.enabledToolNames.every((name) =>
+      selection.selectionBase.includes(name),
+    );
+  const owned = (name) =>
+    name === "tool_search" ||
+    name?.startsWith("mcp__") ||
+    ["mcp", "mcp-resource", "tool-search"].includes(
+      options.externalToolExecutors?.[name]?.kind,
+    );
+  const other = (map) =>
+    Object.fromEntries(
+      Object.entries(map || {}).filter(([name]) => !owned(name)),
+    );
+  return {
+    ...options,
+    extraToolDefinitions: [
+      ...(options.extraToolDefinitions || []).filter(
+        (def) => !owned(def?.function?.name),
+      ),
+      ...snapshot.extraToolDefinitions,
+    ],
+    externalToolDescriptors: {
+      ...other(options.externalToolDescriptors),
+      ...snapshot.externalToolDescriptors,
+    },
+    externalToolExecutors: {
+      ...other(options.externalToolExecutors),
+      ...snapshot.externalToolExecutors,
+    },
+    ...(mayExtendSelection
+      ? {
+          enabledToolNames: [
+            ...new Set([
+              ...options.enabledToolNames,
+              ...snapshot.extraToolDefinitions.map((def) => def.function.name),
+            ]),
+          ],
+        }
+      : {}),
+    mcpClient: snapshot.mcpClient,
+  };
+}

package/src/lib/model-capabilities.js

@@ -277,6 +277,9 @@ export function resolveModelCapabilityProfile({
     runtimeVerified: false,
     ...output,
     advertisedMaxOutputTokens: documented?.advertisedMaxOutputTokens ?? null,
+    ...(documented?.advertisedMaxInputTokens != null
+      ? { advertisedMaxInputTokens: documented.advertisedMaxInputTokens }
+      : {}),
     ...(documented?.adaptiveThinkingDefault
       ? {
           adaptiveThinkingDefault: true,
@@ -286,6 +289,9 @@ export function resolveModelCapabilityProfile({
     ...(documented?.reasoningEfforts
       ? { reasoningEfforts: [...documented.reasoningEfforts] }
       : {}),
+    ...(documented?.defaultReasoningEffort
+      ? { defaultReasoningEffort: documented.defaultReasoningEffort }
+      : {}),
     sources: documented ? [...documented.sources] : [],
     limitations,
   };

package/src/lib/model-catalog-review.js

@@ -65,7 +65,9 @@ export function reviewModelCatalog(review, snapshots = {}) {
       "runtimeProtocol",
       "contextWindowTokens",
       "advertisedMaxOutputTokens",
+      "advertisedMaxInputTokens",
       "reviewedAt",
+      "defaultReasoningEffort",
     ]) {
       if (
         Object.hasOwn(expected, field) &&
@@ -110,6 +112,7 @@ export function reviewModelCatalog(review, snapshots = {}) {
       "cacheReadMultiplier",
       "cacheWriteMultiplier",
       "cacheWrite1hMultiplier",
+      "cacheWrite12hMultiplier",
       "longContext",
       "serviceMultipliers",
     ]) {

package/src/lib/model-context-catalog.js

@@ -45,7 +45,7 @@ export const CONTEXT_WINDOWS = Object.freeze({
   }),
 });
 
-export const MODEL_CAPABILITY_CATALOG_VERSION = "2026-10-15";
+export const MODEL_CAPABILITY_CATALOG_VERSION = "2026-10-29";
 
 // Explicit ownership prevents a model name served by an unrelated provider
 // from silently inheriting another provider's catalog window.
@@ -82,9 +82,50 @@ export const LEGACY_MODEL_PROVIDERS = Object.freeze({
   "doubao-seed-2-1-pro-260628": "volcengine",
 });
 
-// Official pages reviewed on the catalog version date. These describe the
+// Official pages reviewed on each entry's review date. These describe the
 // named models, not endpoint access, account entitlement, or a live CLI run.
 export const DOCUMENTED_OPENAI_MODELS = Object.freeze({
+  "gpt-6.1-terra": Object.freeze({
+    reviewedAt: "2026-10-29",
+    serviceTiers: Object.freeze([
+      "standard",
+      "default",
+      "auto",
+      "fast",
+      "priority",
+      "flex",
+    ]),
+    serviceMultipliers: Object.freeze({
+      standard: 1,
+      default: 1,
+      auto: 1,
+      batch: 0.5,
+      flex: 0.5,
+      fast: 2,
+      priority: 2,
+    }),
+    contextWindowTokens: 1050000,
+    advertisedMaxInputTokens: 922000,
+    advertisedMaxOutputTokens: 128000,
+    requiresResponsesForTools: true,
+    reasoningEfforts: Object.freeze([
+      "none",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max",
+    ]),
+    defaultReasoningEffort: "medium",
+    pricing: Object.freeze({ in: 1, out: 5 }),
+    cacheReadMultiplier: 0.05,
+    sources: Object.freeze([
+      "https://developers.openai.com/api/docs/models/gpt-6.1-terra",
+      "https://developers.openai.com/api/docs/guides/latest-model",
+      "https://developers.openai.com/api/docs/pricing",
+      "https://developers.openai.com/api/docs/guides/prompt-caching",
+    ]),
+  }),
   "gpt-6.1-sol": Object.freeze({
     reviewedAt: "2026-10-15",
     serviceTiers: Object.freeze([
@@ -235,6 +276,7 @@ export const DOCUMENTED_ANTHROPIC_MODELS = Object.freeze({
 export const GPT6_PRICING_TERMS = Object.freeze({
   cacheReadMultiplier: 0.1,
   cacheWriteMultiplier: 1.25,
+  cacheWrite12hMultiplier: 2.5,
   longContext: Object.freeze({
     threshold: 272000,
     inputMultiplier: 2,

package/src/lib/openai-responses.js

@@ -1,4 +1,5 @@
 import { resolveModelServiceTier } from "./model-capabilities.js";
+import { projectEnvelopePricingContext } from "./usage-pricing-context.js";
 
 const RESPONSES_FAILURE_CODE = "CC_OPENAI_RESPONSES_FAILED";
 const MAX_REASONING_ITEMS = 16;
@@ -212,7 +213,13 @@ export function createOpenAIResponsesReasoning(
   modelProfile = null,
 ) {
   const want = options.thinking;
-  if (!want || want === "off" || want === "none") return null;
+  const disabled = want === false || want === "off" || want === "none";
+  if (disabled) {
+    return modelProfile?.reasoningEfforts?.includes("none")
+      ? { effort: "none" }
+      : null;
+  }
+  if (!want && options.thinkingEffort == null) return null;
   const requested =
     typeof options.thinkingEffort === "string"
       ? options.thinkingEffort.toLowerCase()
@@ -233,7 +240,7 @@ export function createOpenAIResponsesReasoning(
       `Unsupported reasoning effort for ${modelProfile.model}; allowed: ${modelProfile.reasoningEfforts.join(", ")}`,
     );
   }
-  return { effort, summary: "auto" };
+  return effort === "none" ? { effort } : { effort, summary: "auto" };
 }
 
 export function normalizeOpenAIResponsesUsage(usage) {
@@ -244,6 +251,8 @@ export function normalizeOpenAIResponsesUsage(usage) {
   const details = usage.input_tokens_details;
   const outputDetails = usage.output_tokens_details;
   let cached = 0;
+  let written = 0;
+  let cacheWriteContext = {};
   let reasoning = null;
   if (details != null) {
     if (typeof details !== "object" || Array.isArray(details)) return null;
@@ -251,6 +260,24 @@ export function normalizeOpenAIResponsesUsage(usage) {
       cached = nonNegativeInteger(details.cached_tokens);
       if (cached === null || cached > input) return null;
     }
+    if (Object.hasOwn(details, "cache_write_tokens")) {
+      written = nonNegativeInteger(details.cache_write_tokens);
+      if (written === null || written > input - cached) return null;
+    }
+    if (written > 0 || Object.hasOwn(details, "cache_write_tokens_details")) {
+      const split = details.cache_write_tokens_details;
+      const thirty = nonNegativeInteger(split?.ttl_30m_tokens);
+      const twelve = nonNegativeInteger(split?.ttl_12h_tokens);
+      cacheWriteContext =
+        split &&
+        !Array.isArray(split) &&
+        thirty !== null &&
+        twelve !== null &&
+        Object.hasOwn(details, "cache_write_tokens") &&
+        thirty + twelve === written
+          ? { cacheCreation30mTokens: thirty, cacheCreation12hTokens: twelve }
+          : { cacheCreationInvalid: true };
+    }
   }
   if (outputDetails != null) {
     if (typeof outputDetails !== "object" || Array.isArray(outputDetails)) {
@@ -265,9 +292,13 @@ export function normalizeOpenAIResponsesUsage(usage) {
     }
   }
   return {
-    input_tokens: input - cached,
+    input_tokens: input - cached - written,
     output_tokens: output,
     cache_read_input_tokens: cached,
+    ...(Object.hasOwn(details || {}, "cache_write_tokens") ||
+    Object.keys(cacheWriteContext).length
+      ? { cache_creation_input_tokens: written, ...cacheWriteContext }
+      : {}),
     ...(reasoning !== null ? { reasoning_tokens: reasoning } : {}),
   };
 }
@@ -350,9 +381,7 @@ export function normalizeOpenAIResponsesResponse(data) {
   if (usage)
     result.usage = {
       ...usage,
-      ...(typeof data.service_tier === "string"
-        ? { service_tier: data.service_tier }
-        : {}),
+      ...projectEnvelopePricingContext(usage, data),
     };
   return result;
 }

package/src/lib/sub-agent-context.js

@@ -14,6 +14,7 @@ import {
   resolveAgentToolSelection,
 } from "./agent-execution-policy.js";
 import { CLIContextEngineering } from "./cli-context-engineering.js";
+import { markCompactionHostBase } from "./compaction-host-provenance.js";
 import {
   agentLoop,
   buildSystemPrompt,
@@ -23,6 +24,7 @@ import { feature } from "./feature-flags.js";
 import { isEvolutionIngressFailure } from "./model-failure-policy.js";
 import { isFormalBudgetError } from "./formal-budget-errors.js";
 import { captureAgentEvolutionIngress } from "./evolution/agent-evolution-ingress.js";
+import { captureMcpToolCatalog } from "./mcp-tool-catalog-authority.js";
 import {
   createWorktree,
   removeWorktree,
@@ -359,6 +361,7 @@ export class SubAgentContext {
         ? options.externalToolExecutors
         : {};
     this._mcpClient = options.mcpClient || null;
+    this._mcpToolCatalog = captureMcpToolCatalog(options.mcpToolCatalog);
     this._mcpHostClient = options.mcpHostClient || this._mcpClient;
     this._mcpCallLedger = options.mcpCallLedger || null;
     this._mcpConflictScheduler = options.mcpConflictScheduler || null;
@@ -404,10 +407,12 @@ export class SubAgentContext {
       ? `\n\n## Parent Context\n${this.inheritedContext}`
       : "";
 
-    this.messages.push({
-      role: "system",
-      content: basePrompt + profilePrompt + rolePrompt + contextSection,
-    });
+    this.messages.push(
+      markCompactionHostBase({
+        role: "system",
+        content: basePrompt + profilePrompt + rolePrompt + contextSection,
+      }),
+    );
   }
 
   /**
@@ -881,6 +886,9 @@ export class SubAgentContext {
     if (this._mcpClient) {
       options.mcpClient = this._mcpClient;
     }
+    if (this._mcpToolCatalog) {
+      options.mcpToolCatalog = this._mcpToolCatalog;
+    }
     if (this._mcpHostClient) {
       options.mcpHostClient = this._mcpHostClient;
     }

package/src/lib/subagent-inheritance.js

@@ -17,6 +17,61 @@
  *
  * @module subagent-inheritance
  */
+import {
+  projectMcpToolCatalog,
+  restrictMcpToolCatalog,
+} from "./mcp-tool-catalog-authority.js";
+
+/** Keep a child's directory live without broadening its captured contract. */
+export function createInheritedMcpToolCatalog(
+  parent,
+  allow,
+  requestedTools,
+  effectiveTools,
+) {
+  const servers = Array.isArray(allow) ? Object.freeze([...allow]) : null;
+  const names = Array.isArray(requestedTools)
+    ? Object.freeze([...requestedTools])
+    : null;
+  const staticParentNames =
+    parent.mcpCatalogBinding?.authority !== parent.mcpToolCatalog &&
+    Array.isArray(parent.effectiveAllowedToolNames)
+      ? Object.freeze([...parent.effectiveAllowedToolNames])
+      : null;
+  return projectMcpToolCatalog(
+    parent.mcpToolCatalog,
+    (snapshot, previous) => {
+      let inherited = filterInheritedMcp(snapshot, servers) || {
+        extraToolDefinitions: [],
+        externalToolDescriptors: {},
+        externalToolExecutors: {},
+      };
+      if (names) inherited = restrictMcpToolCatalog(inherited, names);
+      if (staticParentNames)
+        inherited = restrictMcpToolCatalog(inherited, staticParentNames);
+      if (previous) {
+        const registries = new Set(
+          Object.values(inherited.externalToolExecutors)
+            .map((executor) => executor.registry)
+            .filter(Boolean),
+        );
+        for (const registry of registries) registry.loaded.clear();
+        for (const [name, executor] of Object.entries(
+          inherited.externalToolExecutors,
+        )) {
+          if (
+            executor.registry &&
+            previous.identities.get(name) === snapshot.identities.get(name) &&
+            previous.externalToolExecutors[name]?.registry?.loaded.has(name)
+          )
+            executor.registry.loaded.add(name);
+        }
+      }
+      return inherited;
+    },
+    { extendSelection: names === null, selectionBase: effectiveTools },
+  );
+}
 
 /** Extract the server segment from an `mcp__<server>__<tool>` wire name. */
 export function mcpServerOf(name) {
@@ -27,6 +82,102 @@ export function mcpServerOf(name) {
   return idx === -1 ? rest || null : rest.slice(0, idx) || null;
 }
 
+/**
+ * Discovery state belongs to one loop. Keep the inherited snapshot bounded to
+ * its tools, while observing revocation of the source entries. Sharing the
+ * parent's registry would expose excluded schemas and let one child's search
+ * change the provider projection of its parent and siblings.
+ */
+function forkDiscoveryRegistries(parent, definitions, descriptors, executors) {
+  const registries = new Map();
+  const definitionsByName = new Map(
+    definitions.map((definition) => [definition?.function?.name, definition]),
+  );
+  for (const [name, sourceExecutor] of Object.entries(executors)) {
+    const source = sourceExecutor?.registry;
+    if (sourceExecutor?.deferred !== true || !(source?.deferred instanceof Map))
+      continue;
+    let registry = registries.get(source);
+    if (!registry) {
+      registry = {
+        catalogMode: source.catalogMode,
+        maxResults: source.maxResults,
+        compactSearchDefinition: source.compactSearchDefinition
+          ? structuredClone(source.compactSearchDefinition)
+          : undefined,
+        deferred: new Map(),
+        loaded: new Set(),
+        instructionsByServer: Object.create(null),
+      };
+      registries.set(source, registry);
+    }
+    const executor = { ...sourceExecutor, registry };
+    executors[name] = executor;
+    const entry = source.deferred.get(name);
+    // A missing/mismatched entry remains unavailable through the ordinary
+    // deferred-call gate; never reconstruct a schema from a stale stub.
+    if (
+      !entry ||
+      !definitionsByName.has(name) ||
+      entry.executor !== sourceExecutor ||
+      entry.serverName !== sourceExecutor.serverName ||
+      entry.toolName !== sourceExecutor.toolName
+    )
+      continue;
+    const sourceDescriptor = parent.externalToolDescriptors?.[name];
+    const inherited = {
+      definition: structuredClone(entry.definition),
+      stub: structuredClone(entry.stub),
+      executor,
+      serverName: entry.serverName,
+      toolName: entry.toolName,
+      get stale() {
+        return (
+          entry.stale === true ||
+          source.deferred.get(name) !== entry ||
+          parent.externalToolExecutors?.[name] !== sourceExecutor ||
+          parent.externalToolDescriptors?.[name] !== sourceDescriptor ||
+          sourceExecutor.inheritable === false ||
+          sourceDescriptor?.inheritable === false
+        );
+      },
+    };
+    registry.deferred.set(name, inherited);
+    if (source.loaded?.has(name) && !inherited.stale) registry.loaded.add(name);
+    if (definitionsByName.get(name) === entry.stub)
+      definitionsByName.set(name, inherited.stub);
+    if (Object.hasOwn(source.instructionsByServer || {}, entry.serverName)) {
+      registry.instructionsByServer[entry.serverName] =
+        source.instructionsByServer[entry.serverName];
+    }
+  }
+
+  const searchName = "tool_search";
+  const search = parent?.externalToolExecutors?.[searchName];
+  const searchDescriptor = parent?.externalToolDescriptors?.[searchName];
+  const searchDefinition = Array.isArray(parent?.extraToolDefinitions)
+    ? parent.extraToolDefinitions.find(
+        (definition) => definition?.function?.name === searchName,
+      )
+    : null;
+  const registry = registries.get(search?.registry);
+  // Search is a directory helper, not a server capability of its own. Restore
+  // it only for an inherited deferred directory and only if the parent grants
+  // inheritance of the helper itself. Execution still checks the tool ceiling.
+  if (
+    search?.kind === "tool-search" &&
+    search.inheritable !== false &&
+    searchDescriptor?.inheritable !== false &&
+    searchDefinition &&
+    registry?.deferred.size > 0
+  ) {
+    definitionsByName.set(searchName, structuredClone(searchDefinition));
+    executors[searchName] = { ...search, registry };
+    if (searchDescriptor) descriptors[searchName] = { ...searchDescriptor };
+  }
+  return [...definitionsByName.values()];
+}
+
 /**
  * Filter the parent's MCP plumbing to the servers the child may use.
  *
@@ -57,21 +208,30 @@ export function filterInheritedMcp(parent, allow) {
   const inheritable = (name) =>
     descs[name]?.inheritable !== false && execs[name]?.inheritable !== false;
 
-  const outDefs = defs.filter((d) => {
+  let outDefs = defs.filter((d) => {
     const name = d?.function?.name;
-    return name && inheritable(name) && serverAllowed(mcpServerOf(name));
+    return (
+      name &&
+      name !== "tool_search" &&
+      inheritable(name) &&
+      serverAllowed(mcpServerOf(name))
+    );
   });
   const outDescs = {};
   for (const [name, desc] of Object.entries(descs)) {
+    if (name === "tool_search") continue;
     const server = desc?.serverName || mcpServerOf(name);
     if (inheritable(name) && serverAllowed(server)) outDescs[name] = desc;
   }
   const outExecs = {};
   for (const [name, exec] of Object.entries(execs)) {
+    if (name === "tool_search") continue;
     const server = exec?.serverName || mcpServerOf(name);
     if (inheritable(name) && serverAllowed(server)) outExecs[name] = exec;
   }
 
+  outDefs = forkDiscoveryRegistries(parent, outDefs, outDescs, outExecs);
+
   if (
     outDefs.length === 0 &&
     Object.keys(outDescs).length === 0 &&