@cursor/july 0.1.100 → 0.1.101

package/dist/internal/discovery.js

@@ -31,7 +31,7 @@ import { pathToFileURL } from "node:url";
 import { resolveABMaxPlaygroundSessions } from "../ab.js";
 import { resolveArtifactsMax } from "../artifacts.js";
 import { httpChannel } from "../channels.js";
-import { cursorAccountServersHasMixedWildcard, DEFAULT_MODEL, isInlineStdioConnection, isToolEffect, MAX_RUNNING_TURNS_LIMIT, normalizeConnectionEffects, normalizeCursorAccountServers, toPublicCloudInfo, } from "../types.js";
+import { cursorAccountServersHasMixedWildcard, DEFAULT_MODEL, isInlineStdioConnection, isToolEffect, MAX_RUNNING_TURNS_LIMIT, normalizeConnectionEffects, normalizeConnectionTools, normalizeCursorAccountServers, toPublicCloudInfo, } from "../types.js";
 import { registerAuthoredModuleLoaders } from "./authored-loaders.js";
 import { normalizePositiveInt } from "./bounded-int.js";
 import { getDefinitionKind } from "./brand.js";
@@ -310,6 +310,7 @@ function loadAgent(ctx, agentDir, options) {
         }
         const tools = yield loadTools(ctx, join(agentDir, "tools"));
         const skills = yield loadSkills(ctx, join(agentDir, "skills"));
+        const extensions = yield appendExtensions(ctx, join(agentDir, "extensions"), tools, skills);
         const connections = yield loadConnections(ctx, yield resolveMcpConnectionsDir(ctx, agentDir));
         const hostConnections = yield loadHostConnections(ctx, agentDir, connections);
         const seedFiles = yield loadSeedFiles(ctx, agentDir);
@@ -430,6 +431,7 @@ function loadAgent(ctx, agentDir, options) {
             local }, (allowedTools === undefined ? {} : { allowedTools })), { hosting,
             concurrency }), (architecture === undefined ? {} : { architecture })), { tools,
             skills,
+            extensions,
             connections,
             hostConnections,
             subagents,
@@ -662,17 +664,34 @@ function loadInstructionsModule(ctx, modulePath) {
 // Tools
 // ============================================================================
 function loadTools(ctx, toolsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tools = [];
+        for (const { name, path } of yield toolModuleEntries(ctx, toolsDir)) {
+            const definition = yield importDefault(ctx, path, "tool");
+            if (definition === undefined) {
+                continue;
+            }
+            const tool = compileTool(ctx, path, name, definition);
+            if (tool !== undefined) {
+                tools.push(tool);
+            }
+        }
+        return tools;
+    });
+}
+/** The module files of a `tools/` directory whose filenames are valid tool names. */
+function toolModuleEntries(ctx, toolsDir) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!(yield isDirectory(toolsDir))) {
             return [];
         }
-        const tools = [];
+        const entries = [];
         for (const entry of yield sortedEntries(toolsDir)) {
-            const entryPath = join(toolsDir, entry.name);
+            const path = join(toolsDir, entry.name);
             if (entry.isDirectory()) {
                 ctx.diagnostics.push({
                     severity: "warning",
-                    path: displayPath(ctx, entryPath),
+                    path: displayPath(ctx, path),
                     message: "Nested tool directories are not supported; ignoring.",
                 });
                 continue;
@@ -681,94 +700,99 @@ function loadTools(ctx, toolsDir) {
                 continue;
             }
             const name = moduleStem(entry.name);
-            if (!NAME_PATTERN.test(name)) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, entryPath),
-                    message: `Tool name "${name}" must match ${NAME_PATTERN} (the filename becomes the tool name the model sees).`,
-                });
-                continue;
-            }
-            const definition = yield importDefault(ctx, entryPath, "tool");
-            if (definition === undefined) {
-                continue;
-            }
-            const tool = definition;
-            if (isBlank(tool.description)) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, entryPath),
-                    message: "Tools require a non-empty description.",
-                });
-                continue;
-            }
-            const execution = tool.execution === "agent" ? "agent" : "server";
-            const needsApprovalConfigured = tool.needsApproval === true || typeof tool.needsApproval === "function";
-            const effect = declaredEffect(tool);
-            if (execution === "agent") {
-                if (isBlank(tool.script)) {
-                    ctx.diagnostics.push({
-                        severity: "error",
-                        path: displayPath(ctx, entryPath),
-                        message: 'Tools with execution: "agent" require a non-empty `script` (shell body; JSON on stdin, result on stdout).',
-                    });
-                    continue;
-                }
-                if (typeof tool.execute === "function") {
-                    ctx.diagnostics.push({
-                        severity: "warning",
-                        path: displayPath(ctx, entryPath),
-                        message: '`execute` is ignored when execution is "agent"; the Cursor agent runs `script` instead.',
-                    });
-                }
-                if (needsApprovalConfigured) {
-                    ctx.diagnostics.push({
-                        severity: "error",
-                        path: displayPath(ctx, entryPath),
-                        message: '`needsApproval` is only supported for execution: "server" tools (in-process).',
-                    });
-                    continue;
-                }
-            }
-            else if (typeof tool.execute !== "function") {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, entryPath),
-                    message: 'Tools require an execute(input, ctx) function (or set execution: "agent" with a script).',
-                });
-                continue;
+            if (validateName(ctx, "tool", name, path)) {
+                entries.push({ name, path });
             }
-            let inputSchema;
-            try {
-                inputSchema = toolInputJsonSchema(tool.inputSchema);
-            }
-            catch (error) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, entryPath),
-                    message: `Failed to convert inputSchema to JSON Schema: ${errorMessage(error)}`,
-                });
-                continue;
-            }
-            let outputSchema;
-            try {
-                outputSchema = toolOutputJsonSchema(tool.outputSchema);
-            }
-            catch (error) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, entryPath),
-                    message: `Failed to convert outputSchema to JSON Schema: ${errorMessage(error)}`,
-                });
-                continue;
-            }
-            tools.push(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ name, description: tool.description, inputSchema }, (outputSchema === undefined ? {} : { outputSchema })), { execution, needsApproval: needsApprovalConfigured }), (effect === undefined ? {} : { effect })), (execution === "agent" && tool.script !== undefined
-                ? { script: tool.script }
-                : {})), { definition: tool }));
         }
-        return tools;
+        return entries;
     });
 }
+/**
+ * Validate one tool definition against the tool contract and convert its
+ * schemas. Diagnostics point at `entryPath` (the authored file, or the
+ * extension mount that contributed the tool).
+ */
+function compileTool(ctx, entryPath, name, tool) {
+    if (isBlank(tool.description)) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: "Tools require a non-empty description.",
+        });
+        return undefined;
+    }
+    const execution = tool.execution === "agent" ? "agent" : "server";
+    const needsApprovalConfigured = tool.needsApproval === true || typeof tool.needsApproval === "function";
+    const effect = declaredEffect(tool);
+    if (execution === "agent") {
+        if (isBlank(tool.script)) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, entryPath),
+                message: 'Tools with execution: "agent" require a non-empty `script` (shell body; JSON on stdin, result on stdout).',
+            });
+            return undefined;
+        }
+        if (typeof tool.execute === "function") {
+            ctx.diagnostics.push({
+                severity: "warning",
+                path: displayPath(ctx, entryPath),
+                message: '`execute` is ignored when execution is "agent"; the Cursor agent runs `script` instead.',
+            });
+        }
+        if (needsApprovalConfigured) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, entryPath),
+                message: '`needsApproval` is only supported for execution: "server" tools (in-process).',
+            });
+            return undefined;
+        }
+    }
+    else if (typeof tool.execute !== "function") {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: 'Tools require an execute(input, ctx) function (or set execution: "agent" with a script).',
+        });
+        return undefined;
+    }
+    let inputSchema;
+    try {
+        inputSchema = toolInputJsonSchema(tool.inputSchema);
+    }
+    catch (error) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: `Failed to convert inputSchema to JSON Schema: ${errorMessage(error)}`,
+        });
+        return undefined;
+    }
+    let outputSchema;
+    try {
+        outputSchema = toolOutputJsonSchema(tool.outputSchema);
+    }
+    catch (error) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: `Failed to convert outputSchema to JSON Schema: ${errorMessage(error)}`,
+        });
+        return undefined;
+    }
+    return {
+        name,
+        description: tool.description,
+        inputSchema,
+        outputSchema,
+        execution,
+        needsApproval: needsApprovalConfigured,
+        effect,
+        script: execution === "agent" ? tool.script : undefined,
+        definition: tool,
+    };
+}
 /**
  * Static view of a tool's `effect` for the manifest: the literal when it is
  * one, `"dynamic"` for a per-call predicate, `undefined` when undeclared. A
@@ -788,7 +812,7 @@ function declaredEffect(tool) {
 // ============================================================================
 function loadSkills(ctx, skillsDir) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e;
+        var _a, _b;
         if (!(yield isDirectory(skillsDir))) {
             return [];
         }
@@ -807,7 +831,7 @@ function loadSkills(ctx, skillsDir) {
             }
             if (entry.name.endsWith(".md")) {
                 const name = entry.name.slice(0, -".md".length);
-                if (!validateSkillName(ctx, name, entryPath)) {
+                if (!validateName(ctx, "skill", name, entryPath)) {
                     continue;
                 }
                 const { data, body } = parseFrontmatter(yield readFile(entryPath, "utf8"));
@@ -821,27 +845,217 @@ function loadSkills(ctx, skillsDir) {
             }
             if (isModuleFile(entry.name)) {
                 const name = moduleStem(entry.name);
-                if (!validateSkillName(ctx, name, entryPath)) {
+                if (!validateName(ctx, "skill", name, entryPath)) {
                     continue;
                 }
                 const definition = yield importDefault(ctx, entryPath, "skill");
                 if (definition === undefined) {
                     continue;
                 }
-                const skill = definition;
-                const files = {};
-                for (const [rel, contents] of Object.entries((_c = skill.files) !== null && _c !== void 0 ? _c : {})) {
-                    files[rel] = { contents };
+                skills.push(compileSkill(name, definition));
+            }
+        }
+        return skills;
+    });
+}
+/** A skill whose body and sibling files are in memory (`defineSkill`, extensions). */
+function compileSkill(name, skill) {
+    var _a, _b, _c;
+    const files = {};
+    for (const [rel, contents] of Object.entries((_a = skill.files) !== null && _a !== void 0 ? _a : {})) {
+        files[rel] = { contents };
+    }
+    return {
+        name,
+        description: (_c = (_b = skill.description) !== null && _b !== void 0 ? _b : deriveSkillDescription(skill.markdown)) !== null && _c !== void 0 ? _c : SKILL_DESCRIPTION_FALLBACK(name),
+        markdown: skill.markdown.trim(),
+        files,
+    };
+}
+// ============================================================================
+// Extensions (agent/extensions/<ns>.ts | agent/extensions/<ns>/extension.ts)
+// ============================================================================
+/**
+ * Mount every extension under `agent/extensions/` and append its tools and
+ * skills to the authored lists as `<ns>__<name>`, stamped with `extension`.
+ * The namespace is the mount's filename stem or directory name.
+ */
+function appendExtensions(ctx, extensionsDir, tools, skills) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(extensionsDir))) {
+            return [];
+        }
+        const extensions = [];
+        for (const entry of yield sortedEntries(extensionsDir)) {
+            const path = join(extensionsDir, entry.name);
+            const site = yield resolveMountSite(ctx, path, entry);
+            if (site === undefined) {
+                continue;
+            }
+            if (extensions.some((extension) => extension.name === site.ns)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, path),
+                    message: `Extension "${site.ns}" is mounted twice (as a file and as a directory).`,
+                });
+                continue;
+            }
+            const mount = yield importDefault(ctx, site.mountPath, "extension");
+            if (mount === undefined) {
+                continue;
+            }
+            extensions.push(yield mountExtension(ctx, site, mount, tools, skills));
+        }
+        return extensions;
+    });
+}
+function resolveMountSite(ctx, path, entry) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (entry.isDirectory()) {
+            if (!validateName(ctx, "extension", entry.name, path)) {
+                return undefined;
+            }
+            const mountPath = yield findModuleFile(path, "extension");
+            if (mountPath === undefined) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, path),
+                    message: "A directory mount needs an extension.ts default-exporting the mount (`export default crm({ ... })`).",
+                });
+                return undefined;
+            }
+            return { ns: entry.name, mountPath, overlayDir: path };
+        }
+        if (!entry.isFile() || !isModuleFile(entry.name)) {
+            return undefined;
+        }
+        const ns = moduleStem(entry.name);
+        return validateName(ctx, "extension", ns, path)
+            ? { ns, mountPath: path }
+            : undefined;
+    });
+}
+/**
+ * Read the extension's tree with the agent loaders, lay the mount's overlay
+ * on top (a same-named file replaces, `disableTool()` removes), then
+ * namespace what is left.
+ */
+function mountExtension(ctx, site, mount, tools, skills) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mounted = {
+            name: site.ns,
+            description: mount.extension.description,
+            tools: [],
+            skills: [],
+        };
+        const root = mount.extension.root;
+        if (!(yield isDirectory(root))) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, site.mountPath),
+                message: `Extension "${site.ns}" declares root ${root}, which is not a directory. Pass \`import.meta.dirname\` from extension.ts.`,
+            });
+            return mounted;
+        }
+        yield warnUnsupportedExtensionSlots(ctx, root);
+        const contributedTools = new Map((yield loadTools(ctx, join(root, "tools"))).map((tool) => [tool.name, tool]));
+        const contributedSkills = new Map((yield loadSkills(ctx, join(root, "skills"))).map((skill) => [
+            skill.name,
+            skill,
+        ]));
+        if (site.overlayDir !== undefined) {
+            const overlay = yield loadOverlayTools(ctx, join(site.overlayDir, "tools"));
+            for (const tool of overlay.tools) {
+                contributedTools.set(tool.name, tool);
+            }
+            for (const disabled of overlay.disabled) {
+                if (!contributedTools.delete(disabled.name)) {
+                    ctx.diagnostics.push({
+                        severity: "error",
+                        path: displayPath(ctx, disabled.path),
+                        message: `disableTool() targets "${disabled.name}", which extension "${site.ns}" does not contribute.`,
+                    });
                 }
-                skills.push({
-                    name,
-                    description: (_e = (_d = skill.description) !== null && _d !== void 0 ? _d : deriveSkillDescription(skill.markdown)) !== null && _e !== void 0 ? _e : SKILL_DESCRIPTION_FALLBACK(name),
-                    markdown: skill.markdown.trim(),
-                    files,
+            }
+            for (const skill of yield loadSkills(ctx, join(site.overlayDir, "skills"))) {
+                contributedSkills.set(skill.name, skill);
+            }
+        }
+        for (const [name, tool] of contributedTools) {
+            const composed = `${site.ns}__${name}`;
+            tools.push(Object.assign(Object.assign({}, tool), { name: composed, extension: site.ns }));
+            mounted.tools.push(composed);
+        }
+        for (const [name, skill] of contributedSkills) {
+            const composed = `${site.ns}__${name}`;
+            skills.push(Object.assign(Object.assign({}, skill), { name: composed, extension: site.ns }));
+            mounted.skills.push(composed);
+        }
+        return mounted;
+    });
+}
+/** A directory mount's `tools/`: replacements plus `disableTool()` markers. */
+function loadOverlayTools(ctx, toolsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tools = [];
+        const disabled = [];
+        for (const { name, path } of yield toolModuleEntries(ctx, toolsDir)) {
+            let mod;
+            try {
+                mod = yield ctx.importModule(path);
+            }
+            catch (error) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, path),
+                    message: `Failed to load module: ${errorMessage(error)}`,
+                });
+                continue;
+            }
+            const kind = getDefinitionKind(mod.default);
+            if (kind === "disabled-tool") {
+                disabled.push({ name, path });
+                continue;
+            }
+            if (kind !== "tool") {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, path),
+                    message: "An override must default-export defineTool({ ... }) or disableTool().",
+                });
+                continue;
+            }
+            const tool = compileTool(ctx, path, name, mod.default);
+            if (tool !== undefined) {
+                tools.push(tool);
+            }
+        }
+        return { tools, disabled };
+    });
+}
+/** Slots an agent has that an extension tree may not contribute (yet). */
+function warnUnsupportedExtensionSlots(ctx, root) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const unsupported = [
+            ["instructions.md", "instructions"],
+            ["connections", "connections"],
+            ["mcp-connections", "MCP connections"],
+            ["hooks", "hooks"],
+            ["subagents", "subagents"],
+            ["channels", "channels"],
+            ["schedules", "schedules"],
+            ["extensions", "nested extensions"],
+        ];
+        for (const [slot, label] of unsupported) {
+            const path = join(root, slot);
+            if ((yield isDirectory(path)) || (yield isFile(path))) {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, path),
+                    message: `Extension ${label} are not supported yet; only tools/ and skills/ are mounted. Ignoring.`,
                 });
             }
         }
-        return skills;
     });
 }
 function loadPackagedSkill(ctx, skillDir, name) {
@@ -855,7 +1069,7 @@ function loadPackagedSkill(ctx, skillDir, name) {
             });
             return undefined;
         }
-        if (!validateSkillName(ctx, name, skillDir)) {
+        if (!validateName(ctx, "skill", name, skillDir)) {
             return undefined;
         }
         const { data, body } = parseFrontmatter(yield readFile(skillMdPath, "utf8"));
@@ -923,6 +1137,22 @@ function parseConnectionEffects(effects) {
     }
     return { ok: true, value: normalizeConnectionEffects(parsed) };
 }
+function parseConnectionTools(tools) {
+    if (tools === undefined) {
+        return { ok: true, value: undefined };
+    }
+    if (!Array.isArray(tools) || tools.length === 0) {
+        return { ok: false };
+    }
+    if (tools.some((name) => typeof name !== "string")) {
+        return { ok: false };
+    }
+    const normalized = normalizeConnectionTools(tools);
+    if (normalized.length === 0) {
+        return { ok: false };
+    }
+    return { ok: true, value: normalized };
+}
 function connectionHasSpawnOrRemote(connection) {
     if ("cursorAccount" in connection && connection.cursorAccount === true) {
         return true;
@@ -956,16 +1186,29 @@ function connectionTransport(connection) {
     }
     return undefined;
 }
-function validateSkillName(ctx, name, entryPath) {
-    if (NAME_PATTERN.test(name)) {
-        return true;
+/**
+ * Filenames become the names the model sees. `__` is reserved: it joins an
+ * extension's namespace to its contribution (`crm__search`).
+ */
+function validateName(ctx, kind, name, entryPath) {
+    const label = { skill: "Skill", tool: "Tool", extension: "Extension" }[kind];
+    if (!NAME_PATTERN.test(name)) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: `${label} name "${name}" must match ${NAME_PATTERN}.`,
+        });
+        return false;
     }
-    ctx.diagnostics.push({
-        severity: "error",
-        path: displayPath(ctx, entryPath),
-        message: `Skill name "${name}" must match ${NAME_PATTERN}.`,
-    });
-    return false;
+    if (name.includes("__")) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, entryPath),
+            message: `${label} name "${name}" may not contain "__"; it is reserved for extension contributions (\`<ns>__<name>\`).`,
+        });
+        return false;
+    }
+    return true;
 }
 /**
  * Advertise the first non-empty, non-code-fence line of the body, with any
@@ -1024,7 +1267,7 @@ function resolveMcpConnectionsDir(ctx, agentDir) {
 function loadHostConnections(ctx, agentDir, modelConnections) {
     return __awaiter(this, void 0, void 0, function* () {
         const hostDir = join(agentDir, "host-connections");
-        const loaded = yield loadConnections(ctx, hostDir);
+        const loaded = yield loadConnections(ctx, hostDir, "host");
         const modelNames = new Set(modelConnections.map((connection) => connection.name));
         const hostConnections = [];
         for (const connection of loaded) {
@@ -1057,8 +1300,8 @@ function loadHostConnections(ctx, agentDir, modelConnections) {
         return hostConnections;
     });
 }
-function loadConnections(ctx, connectionsDir) {
-    return __awaiter(this, void 0, void 0, function* () {
+function loadConnections(ctx_1, connectionsDir_1) {
+    return __awaiter(this, arguments, void 0, function* (ctx, connectionsDir, role = "model") {
         if (!(yield isDirectory(connectionsDir))) {
             return [];
         }
@@ -1143,6 +1386,48 @@ function loadConnections(ctx, connectionsDir) {
                 });
                 continue;
             }
+            const parsedTools = isInlineStdioConnection(connection)
+                ? { ok: true, value: undefined }
+                : parseConnectionTools(connection.tools);
+            if (!parsedTools.ok) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: "MCP connection `tools` allowlist must be a non-empty array of tool names.",
+                });
+                continue;
+            }
+            if (isInlineStdioConnection(connection) &&
+                connection.disallowedTools !== undefined) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: "MCP connection `disallowedTools` is not supported on inline `tools` connections — author only the tools you want.",
+                });
+                continue;
+            }
+            const parsedDisallowed = isInlineStdioConnection(connection)
+                ? { ok: true, value: undefined }
+                : parseConnectionTools(connection.disallowedTools);
+            if (!parsedDisallowed.ok) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: "MCP connection `disallowedTools` must be a non-empty array of tool names.",
+                });
+                continue;
+            }
+            if ((parsedTools.value !== undefined ||
+                parsedDisallowed.value !== undefined) &&
+                role === "model" &&
+                connection.advertiseTools !== true) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: "MCP connection `tools` / `disallowedTools` filter advertised tools; set `advertiseTools: true` or drop the name list. Put the connection in `agent/host-connections/` to restrict `host.mcp` only.",
+                });
+                continue;
+            }
             if (connection.advertiseTools === true &&
                 isInlineStdioConnection(connection)) {
                 ctx.diagnostics.push({
@@ -1225,6 +1510,8 @@ function loadConnections(ctx, connectionsDir) {
                 auth: connection.auth,
                 advertiseTools: connection.advertiseTools,
                 effects: parsedEffects.value,
+                tools: parsedTools.value,
+                disallowedTools: parsedDisallowed.value,
             });
         }
         return connections;
@@ -1324,6 +1611,7 @@ function warnUnsupportedSubagentSlots(ctx, subagentDir) {
         const unsupported = [
             ["tools", "tools"],
             ["skills", "skills"],
+            ["extensions", "extensions"],
             ["mcp-connections", "MCP connections"],
             ["host-connections", "host MCP connections"],
             ["connections", "MCP connections"],
@@ -1354,13 +1642,16 @@ function appendBuiltinTools(ctx, agentDir, tools, config) {
         return;
     }
     const agentPath = displayPath(ctx, join(agentDir, "agent.ts"));
-    const authored = new Set(tools.map((tool) => tool.name));
     for (const tool of builtin) {
-        if (authored.has(tool.name)) {
+        const existing = tools.find((t) => t.name === tool.name);
+        if (existing !== undefined) {
+            const owner = existing.extension === undefined
+                ? "Authored"
+                : `Extension "${existing.extension}"`;
             ctx.diagnostics.push({
                 severity: "warning",
                 path: agentPath,
-                message: `Authored tool "${tool.name}" shadows the built-in tool of the same name; the authored tool wins.`,
+                message: `${owner} tool "${tool.name}" shadows the built-in tool of the same name; the built-in is skipped.`,
             });
             continue;
         }
@@ -1875,7 +2166,7 @@ function loadSeedFiles(ctx, agentDir) {
 // ============================================================================
 export function projectInfo(project) {
     var _a, _b, _c, _d;
-    var _e;
+    var _e, _f;
     const agent = project.agent;
     const httpRoutes = [
         { method: "POST", path: "/v1/session", url: "/v1/session" },
@@ -1922,11 +2213,13 @@ export function projectInfo(project) {
         })), skills: agent.skills.map((skill) => ({
             name: skill.name,
             description: skill.description,
-        })), connections: agent.connections.map((connection) => { var _a; return ({
+        })), extensions: (_e = agent.extensions) !== null && _e !== void 0 ? _e : [], connections: agent.connections.map((connection) => { var _a; return ({
             name: connection.name,
             transport: connectionTransportLabel(connection.transport),
             advertiseTools: connection.advertiseTools,
             effects: connection.effects,
+            tools: connection.tools,
+            disallowedTools: connection.disallowedTools,
             cursorAccountServers: "cursorAccount" in connection.transport
                 ? ((_a = connection.transport.servers) !== null && _a !== void 0 ? _a : "*")
                 : undefined,
@@ -1993,7 +2286,7 @@ export function projectInfo(project) {
             : { name: project.storage.name }, artifacts: project.artifacts === undefined
             ? undefined
             : {
-                kinds: Object.keys((_e = project.artifacts.kinds) !== null && _e !== void 0 ? _e : {}),
+                kinds: Object.keys((_f = project.artifacts.kinds) !== null && _f !== void 0 ? _f : {}),
                 agentTool: project.artifacts.agentTool === true,
                 max: resolveArtifactsMax(project.artifacts),
             }, otel: project.otel === undefined
@@ -2040,6 +2333,7 @@ const DEFINE_HELPER_NAME = {
     instructions: "defineInstructions",
     tool: "defineTool",
     skill: "defineSkill",
+    extension: "defineExtension",
     connection: "defineConnection",
     channel: "defineChannel",
     "http-channel": "httpChannel",
@@ -2057,6 +2351,7 @@ function warnUnknownSlots(ctx, agentDir) {
             "instructions",
             "tools",
             "skills",
+            "extensions",
             "mcp-connections",
             "host-connections",
             // Legacy slot name; resolveMcpConnectionsDir warns and still loads it.