@cursor/july 0.1.100 → 0.1.102

package/dist/internal/discovery/extensions.js

@@ -0,0 +1,238 @@
+/**
+ * `agent/extensions/<ns>.ts` | `agent/extensions/<ns>/extension.ts`: agent-shaped trees and Cursor plugins mounted under a namespace.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { join, resolve } from "node:path";
+import { getDefinitionKind } from "../brand.js";
+import { compileConnection } from "./connections.js";
+import { displayPath } from "./context.js";
+import { readCursorPlugin } from "./cursor-plugin.js";
+import { findModuleFile, isDirectory, isFile, isModuleFile, moduleStem, sortedEntries, } from "./fs.js";
+import { helperCall, importDefault, moduleEntries } from "./modules.js";
+import { validateName } from "./names.js";
+import { loadSkills } from "./skills.js";
+import { subagent } from "./subagent.js";
+import { compileTool, loadTools } from "./tools.js";
+/**
+ * Mount every extension under `agent/extensions/` and append what it
+ * contributes to the authored lists as `<ns>__<name>`, stamped with
+ * `extension`. The namespace is the mount's filename stem or directory name.
+ */
+export function appendExtensions(ctx, extensionsDir, into) {
+    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, into));
+        }
+        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 ci({ ... })`).",
+                });
+                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, lay the mount's overlay on top (a same-named
+ * file replaces, `disableTool()` removes), then namespace what is left.
+ */
+function mountExtension(ctx, site, mount, into) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const mounted = {
+            name: site.ns,
+            description: mount.extension.description,
+            tools: [],
+            skills: [],
+            connections: [],
+            subagents: [],
+        };
+        const root = resolve(ctx.rootDir, mount.extension.root);
+        if (!(yield isDirectory(root))) {
+            const hint = "layout" in mount.extension
+                ? "Point `path` at the plugin directory."
+                : "Pass `import.meta.dirname` from extension.ts.";
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, site.mountPath),
+                message: `Extension "${site.ns}" declares root ${root}, which is not a directory. ${hint}`,
+            });
+            return mounted;
+        }
+        // The connection overlay is read first so the tree can leave overlaid
+        // servers uncompiled: a plugin server you replace or drop needs no values.
+        const connectionOverlay = site.overlayDir === undefined
+            ? []
+            : yield moduleEntries(ctx, join(site.overlayDir, "mcp-connections"), "connection");
+        const tree = yield readExtensionTree(ctx, site, mount, root, new Set(connectionOverlay.map((entry) => entry.name)));
+        if (tree === undefined) {
+            return mounted;
+        }
+        mounted.description = (_a = mount.extension.description) !== null && _a !== void 0 ? _a : tree.description;
+        const tools = byName(tree.tools);
+        const skills = byName(tree.skills);
+        const connections = byName(tree.connections);
+        if (site.overlayDir !== undefined) {
+            yield overlaySlot(ctx, site, tools, yield moduleEntries(ctx, join(site.overlayDir, "tools"), "tool"), {
+                kind: "tool",
+                declared: new Set(tools.keys()),
+                compile: (ctx, path, name, definition) => compileTool(ctx, path, name, definition),
+            });
+            yield overlaySlot(ctx, site, connections, connectionOverlay, {
+                kind: "connection",
+                declared: new Set([...connections.keys(), ...tree.overlaidServers]),
+                compile: (ctx, path, name, definition) => compileConnection(ctx, path, name, definition, "model"),
+            });
+            for (const skill of yield loadSkills(ctx, join(site.overlayDir, "skills"))) {
+                skills.set(skill.name, skill);
+            }
+        }
+        for (const [name, tool] of tools) {
+            const composed = `${site.ns}__${name}`;
+            into.tools.push(Object.assign(Object.assign({}, tool), { name: composed, extension: site.ns }));
+            mounted.tools.push(composed);
+        }
+        for (const [name, skill] of skills) {
+            const composed = `${site.ns}__${name}`;
+            into.skills.push(Object.assign(Object.assign({}, skill), { name: composed, extension: site.ns }));
+            mounted.skills.push(composed);
+        }
+        for (const [name, connection] of connections) {
+            const composed = `${site.ns}__${name}`;
+            into.connections.push(Object.assign(Object.assign({}, connection), { name: composed }));
+            mounted.connections.push(composed);
+        }
+        for (const agent of tree.agents) {
+            const composed = `${site.ns}__${agent.name}`;
+            into.subagents.push(subagent(composed, agent));
+            mounted.subagents.push(composed);
+        }
+        return mounted;
+    });
+}
+function readExtensionTree(ctx, site, mount, root, overlaidServers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if ("layout" in mount.extension) {
+            const plugin = yield readCursorPlugin(ctx, root, site.mountPath, mount.extension.variables, overlaidServers);
+            return plugin === undefined ? undefined : Object.assign(Object.assign({}, plugin), { tools: [] });
+        }
+        yield warnUnsupportedExtensionSlots(ctx, root);
+        return {
+            tools: yield loadTools(ctx, join(root, "tools")),
+            skills: yield loadSkills(ctx, join(root, "skills")),
+            connections: [],
+            overlaidServers: [],
+            agents: [],
+        };
+    });
+}
+function byName(items) {
+    return new Map(items.map((item) => [item.name, item]));
+}
+/**
+ * Lay a directory mount's slot over the extension's contributions: a
+ * same-named file replaces, a disable marker removes, a new name adds.
+ */
+function overlaySlot(ctx, site, contributed, entries, slot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const disabledKind = `disabled-${slot.kind}`;
+        for (const { name, path } of entries) {
+            const definition = yield importDefault(ctx, path, [
+                slot.kind,
+                disabledKind,
+            ]);
+            if (definition === undefined) {
+                continue;
+            }
+            if (getDefinitionKind(definition) === disabledKind) {
+                contributed.delete(name);
+                if (!slot.declared.has(name)) {
+                    ctx.diagnostics.push({
+                        severity: "error",
+                        path: displayPath(ctx, path),
+                        message: `${helperCall(disabledKind)} targets "${name}", which extension "${site.ns}" does not contribute.`,
+                    });
+                }
+                continue;
+            }
+            const item = yield slot.compile(ctx, path, name, definition);
+            if (item !== undefined) {
+                contributed.set(name, item);
+            }
+        }
+    });
+}
+/** 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.`,
+                });
+            }
+        }
+    });
+}

package/dist/internal/discovery/fs.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Filesystem primitives discovery walks with: module-file detection, directory listing, and project-root markers.
+ */
+import type { Dirent } from "node:fs";
+export declare function findModuleFile(dir: string, stem: string): Promise<string | undefined>;
+export declare function isModuleFile(fileName: string): boolean;
+export declare function moduleStem(fileName: string): string;
+export declare function sortedEntries(dir: string): Promise<Dirent[]>;
+export declare function walkFiles(dir: string): Promise<string[]>;
+export declare function isDirectory(path: string): Promise<boolean>;
+export declare function isFile(path: string): Promise<boolean>;
+export declare function toPosix(path: string): string;
+export declare function hasFlatLayoutMarkers(rootDir: string): Promise<boolean>;
+export declare function readPackageName(rootDir: string): Promise<string | undefined>;
+//# sourceMappingURL=fs.d.ts.map

package/dist/internal/discovery/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../../src/internal/discovery/fs.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAMtC,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAQ7B;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAYtD;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGlE;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAc9D;AAED,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAMhE;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAM3D;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAK5E;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAgB7B"}

package/dist/internal/discovery/fs.js

@@ -0,0 +1,115 @@
+/**
+ * Filesystem primitives discovery walks with: module-file detection, directory listing, and project-root markers.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readdir, readFile, stat } from "node:fs/promises";
+import { extname, join } from "node:path";
+const MODULE_EXTENSIONS = new Set([".ts", ".mts", ".js", ".mjs"]);
+export function findModuleFile(dir, stem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const extension of [".ts", ".mts", ".js", ".mjs"]) {
+            const candidate = join(dir, `${stem}${extension}`);
+            if (yield isFile(candidate)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    });
+}
+export function isModuleFile(fileName) {
+    if (fileName.endsWith(".d.ts") || fileName.startsWith(".")) {
+        return false;
+    }
+    if (!MODULE_EXTENSIONS.has(extname(fileName))) {
+        return false;
+    }
+    // Colocated unit tests (Vitest/Jest convention) are not definitions.
+    // Without this, `channels/slack.test.ts` is scanned as a channel named
+    // "slack.test", fails NAME_PATTERN, and the whole agent refuses to serve.
+    const stem = moduleStem(fileName);
+    return !stem.endsWith(".test") && !stem.endsWith(".spec");
+}
+export function moduleStem(fileName) {
+    return fileName.slice(0, -extname(fileName).length);
+}
+export function sortedEntries(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const entries = yield readdir(dir, { withFileTypes: true });
+        return entries.sort((a, b) => a.name.localeCompare(b.name));
+    });
+}
+export function walkFiles(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const files = [];
+        for (const entry of yield sortedEntries(dir)) {
+            if (entry.name.startsWith(".")) {
+                continue;
+            }
+            const entryPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...(yield walkFiles(entryPath)));
+            }
+            else if (entry.isFile()) {
+                files.push(entryPath);
+            }
+        }
+        return files;
+    });
+}
+export function isDirectory(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return (yield stat(path)).isDirectory();
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+export function isFile(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return (yield stat(path)).isFile();
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+export function toPosix(path) {
+    return path.split("\\").join("/");
+}
+export function hasFlatLayoutMarkers(rootDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (yield isFile(join(rootDir, "instructions.md"))) {
+            return true;
+        }
+        return (yield findModuleFile(rootDir, "agent")) !== undefined;
+    });
+}
+export function readPackageName(rootDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const packageJsonPath = join(rootDir, "package.json");
+        if (!(yield isFile(packageJsonPath))) {
+            return undefined;
+        }
+        try {
+            const parsed = JSON.parse(yield readFile(packageJsonPath, "utf8"));
+            if (typeof parsed.name === "string" && parsed.name !== "") {
+                return parsed.name;
+            }
+        }
+        catch (_a) {
+            // Malformed package.json falls back to the directory name.
+        }
+        return undefined;
+    });
+}

package/dist/internal/discovery/hooks.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `agent/hooks/*.ts`: observe-only event subscribers.
+ */
+import type { DiscoveredHook } from "../../types.js";
+import { type DiscoveryContext } from "./context.js";
+export declare function loadHooks(ctx: DiscoveryContext, hooksDir: string): Promise<DiscoveredHook[]>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/internal/discovery/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/internal/discovery/hooks.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,cAAc,CAAC;AAIlE,wBAAsB,SAAS,CAC7B,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,EAAE,CAAC,CA+B3B"}

package/dist/internal/discovery/hooks.js

@@ -0,0 +1,48 @@
+/**
+ * `agent/hooks/*.ts`: observe-only event subscribers.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { basename, extname, relative } from "node:path";
+import { displayPath } from "./context.js";
+import { isDirectory, isModuleFile, toPosix, walkFiles } from "./fs.js";
+import { importDefault } from "./modules.js";
+export function loadHooks(ctx, hooksDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(hooksDir))) {
+            return [];
+        }
+        const hooks = [];
+        for (const filePath of yield walkFiles(hooksDir)) {
+            if (!isModuleFile(basename(filePath))) {
+                continue;
+            }
+            const rel = toPosix(relative(hooksDir, filePath));
+            const name = rel.slice(0, -extname(rel).length);
+            const definition = yield importDefault(ctx, filePath, "hook");
+            if (definition === undefined) {
+                continue;
+            }
+            const hook = definition;
+            if (typeof hook.events !== "object" ||
+                hook.events === null ||
+                Object.keys(hook.events).length === 0) {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, filePath),
+                    message: "Hook declares no event handlers.",
+                });
+                continue;
+            }
+            hooks.push({ name, definition: hook });
+        }
+        return hooks;
+    });
+}

package/dist/internal/discovery/info.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The `info` / `GET /v1/info` projection of an {@link AgentProject}.
+ */
+import { type AgentProject, type AgentProjectInfo } from "../../types.js";
+export declare function projectInfo(project: AgentProject): AgentProjectInfo;
+//# sourceMappingURL=info.d.ts.map

package/dist/internal/discovery/info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../src/internal/discovery/info.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EAEtB,MAAM,gBAAgB,CAAC;AAKxB,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,gBAAgB,CAmKnE"}

package/dist/internal/discovery/info.js

@@ -0,0 +1,141 @@
+/**
+ * The `info` / `GET /v1/info` projection of an {@link AgentProject}.
+ */
+import { resolveABMaxPlaygroundSessions } from "../../ab.js";
+import { resolveArtifactsMax } from "../../artifacts.js";
+import { toPublicCloudInfo, } from "../../types.js";
+import { toolInputJsonSchema } from "../json-schema.js";
+import { MCP_ENDPOINT_PATH, mcpEndpointToolNames } from "../mcp-endpoint.js";
+import { connectionTransportLabel } from "./connections.js";
+export function projectInfo(project) {
+    var _a, _b, _c, _d;
+    var _e, _f;
+    const agent = project.agent;
+    const httpRoutes = [
+        { method: "POST", path: "/v1/session", url: "/v1/session" },
+        {
+            method: "POST",
+            path: "/v1/session/:sessionId",
+            url: "/v1/session/:sessionId",
+        },
+        {
+            method: "POST",
+            path: "/v1/session/:sessionId/stop",
+            url: "/v1/session/:sessionId/stop",
+        },
+        {
+            method: "GET",
+            path: "/v1/session/:sessionId/stream",
+            url: "/v1/session/:sessionId/stream",
+        },
+        {
+            method: "GET",
+            path: "/v1/session/:sessionId/approvals",
+            url: "/v1/session/:sessionId/approvals",
+        },
+        {
+            method: "POST",
+            path: "/v1/session/:sessionId/approvals/:callId",
+            url: "/v1/session/:sessionId/approvals/:callId",
+        },
+    ];
+    return Object.assign(Object.assign({ name: project.name, description: agent.description, model: agent.model, runtime: agent.runtime, cloud: agent.cloud === undefined ? undefined : toPublicCloudInfo(agent.cloud), local: agent.local, hosting: agent.hosting, concurrency: agent.concurrency, mcp: { path: MCP_ENDPOINT_PATH, tools: mcpEndpointToolNames(project) }, instructions: agent.instructions === undefined
+            ? undefined
+            : {
+                chars: agent.instructions.length,
+                preview: agent.instructions.length > 280
+                    ? `${agent.instructions.slice(0, 277)}...`
+                    : agent.instructions,
+            }, tools: agent.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            execution: tool.execution,
+            needsApproval: tool.needsApproval,
+            effect: tool.effect,
+            inputSchema: tool.inputSchema,
+        })), skills: agent.skills.map((skill) => ({
+            name: skill.name,
+            description: skill.description,
+        })), 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,
+        }); }), subagents: agent.subagents.map((subagent) => ({
+            name: subagent.name,
+            description: subagent.description,
+            model: subagent.model,
+        })), channels: [
+            { id: "http", routes: httpRoutes },
+            ...project.channels.map((channel) => {
+                var _a;
+                const info = {
+                    id: channel.id,
+                    routes: ((_a = channel.definition.routes) !== null && _a !== void 0 ? _a : []).map((r) => {
+                        const routeInfo = {
+                            method: r.method,
+                            path: r.path,
+                            url: `/v1/channels/${channel.id}${r.path}`,
+                        };
+                        if (r.description !== undefined) {
+                            routeInfo.description = r.description;
+                        }
+                        if (r.bodySchema !== undefined) {
+                            routeInfo.bodySchema = toolInputJsonSchema(r.bodySchema);
+                        }
+                        if (r.querySchema !== undefined) {
+                            routeInfo.querySchema = toolInputJsonSchema(r.querySchema);
+                        }
+                        return routeInfo;
+                    }),
+                };
+                const meta = channel.definition.meta;
+                if ((meta === null || meta === void 0 ? void 0 : meta.kind) !== undefined) {
+                    info.kind = meta.kind;
+                }
+                if ((meta === null || meta === void 0 ? void 0 : meta.githubWebhookEvents) !== undefined) {
+                    info.githubWebhookEvents = meta.githubWebhookEvents;
+                }
+                if ((meta === null || meta === void 0 ? void 0 : meta.originWebhookEvents) !== undefined) {
+                    info.originWebhookEvents = meta.originWebhookEvents;
+                }
+                if ((meta === null || meta === void 0 ? void 0 : meta.deploymentEventTypes) !== undefined) {
+                    info.deploymentEventTypes = meta.deploymentEventTypes;
+                }
+                if ((meta === null || meta === void 0 ? void 0 : meta.slackChannelPosts) !== undefined) {
+                    info.slackChannelPosts = meta.slackChannelPosts;
+                }
+                return info;
+            }),
+        ], schedules: project.schedules.map((schedule) => ({
+            name: schedule.name,
+            cron: schedule.cron,
+            kind: schedule.kind,
+        })), hooks: project.hooks.map((hook) => hook.name), abs: project.abs.map((experiment) => experiment.name) }, (project.abConfig === undefined && project.abs.length === 0
+        ? {}
+        : {
+            abConfig: {
+                maxPlaygroundSessions: resolveABMaxPlaygroundSessions((_a = project.abConfig) === null || _a === void 0 ? void 0 : _a.maxPlaygroundSessions),
+                durableSamples: ((_b = project.storage) === null || _b === void 0 ? void 0 : _b.abs) !== undefined,
+                durableSnapshots: ((_d = (_c = project.storage) === null || _c === void 0 ? void 0 : _c.abs) === null || _d === void 0 ? void 0 : _d.putSnapshot) !== undefined,
+            },
+        })), { storage: project.storage === undefined
+            ? undefined
+            : { name: project.storage.name }, artifacts: project.artifacts === undefined
+            ? undefined
+            : {
+                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
+            ? undefined
+            : {
+                enabled: true,
+                serviceName: project.otel.serviceName,
+            }, diagnostics: project.diagnostics });
+}

package/dist/internal/discovery/instructions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `agent/instructions.md` (or `.ts`, or a directory): the always-on system prompt.
+ */
+import type { AgentConfigDefinition } from "../../types.js";
+import { type DiscoveryContext } from "./context.js";
+export declare function loadInstructions(ctx: DiscoveryContext, agentDir: string, config: AgentConfigDefinition | undefined, isRoot: boolean): Promise<string | undefined>;
+//# sourceMappingURL=instructions.d.ts.map

package/dist/internal/discovery/instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.d.ts","sourceRoot":"","sources":["../../../src/internal/discovery/instructions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,qBAAqB,EAEtB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,KAAK,gBAAgB,EAItB,MAAM,cAAc,CAAC;AAStB,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,qBAAqB,GAAG,SAAS,EACzC,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAmD7B"}