@botbotgo/agent-harness 0.0.307 → 0.0.309

package/dist/mcp.js

@@ -1,5 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
 import { pathToFileURL } from "node:url";
 import { z } from "zod";
 import { AGENT_HARNESS_VERSION } from "./package-version.js";
@@ -46,6 +49,33 @@ function renderToolOutput(output) {
     }
     return JSON.stringify(output, null, 2);
 }
+function normalizePath(value, fallback) {
+    const source = typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+    return source.startsWith("/") ? source : `/${source}`;
+}
+function writeJson(response, statusCode, payload) {
+    response.statusCode = statusCode;
+    response.setHeader("content-type", "application/json; charset=utf-8");
+    response.end(JSON.stringify(payload));
+}
+function readRequestBody(request) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        request.on("data", (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        request.on("end", () => {
+            resolve(Buffer.concat(chunks).toString("utf8"));
+        });
+        request.on("error", reject);
+    });
+}
+function isInitializeRequest(payload) {
+    return typeof payload === "object"
+        && payload !== null
+        && !Array.isArray(payload)
+        && payload.method === "initialize";
+}
 function jsonSchemaObjectToRawShape(schema) {
     if (!schema || schema.type !== "object") {
         return undefined;
@@ -251,3 +281,148 @@ export async function serveRuntimeMcpOverStdio(runtime, options = {}) {
     await server.connect(new StdioServerTransport());
     return server;
 }
+export async function serveRuntimeMcpOverStreamableHttp(runtime, options = {}) {
+    const hostname = options.hostname?.trim() || "127.0.0.1";
+    const port = typeof options.port === "number" && Number.isFinite(options.port) ? options.port : 0;
+    const mcpPath = normalizePath(options.path, "/mcp");
+    const sessions = new Map();
+    const closeSession = async (sessionId) => {
+        const session = sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        sessions.delete(sessionId);
+        await Promise.allSettled([
+            session.transport.close(),
+            session.server.close(),
+        ]);
+    };
+    const httpServer = createServer(async (request, response) => {
+        try {
+            const requestUrl = new URL(request.url ?? "/", `http://${hostname}`);
+            if (requestUrl.pathname !== mcpPath) {
+                writeJson(response, 404, {
+                    error: "Not Found",
+                    path: mcpPath,
+                });
+                return;
+            }
+            const headerValue = request.headers["mcp-session-id"];
+            const sessionId = Array.isArray(headerValue) ? headerValue[0] : headerValue;
+            if (request.method === "POST") {
+                const body = await readRequestBody(request);
+                let payload;
+                try {
+                    payload = JSON.parse(body);
+                }
+                catch {
+                    writeJson(response, 400, {
+                        jsonrpc: "2.0",
+                        id: null,
+                        error: {
+                            code: -32700,
+                            message: "Invalid JSON payload.",
+                        },
+                    });
+                    return;
+                }
+                const existingSession = sessionId ? sessions.get(sessionId) : undefined;
+                if (existingSession) {
+                    await existingSession.transport.handleRequest(request, response, payload);
+                    return;
+                }
+                if (sessionId || !isInitializeRequest(payload)) {
+                    writeJson(response, 400, {
+                        jsonrpc: "2.0",
+                        id: null,
+                        error: {
+                            code: -32000,
+                            message: "Bad Request: No valid MCP session was provided.",
+                        },
+                    });
+                    return;
+                }
+                let createdTransport;
+                const server = await createRuntimeMcpServer(runtime, options);
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    onsessioninitialized: (initializedSessionId) => {
+                        sessions.set(initializedSessionId, { transport, server });
+                    },
+                });
+                createdTransport = transport;
+                transport.onclose = () => {
+                    const activeSessionId = createdTransport?.sessionId;
+                    if (activeSessionId) {
+                        const active = sessions.get(activeSessionId);
+                        if (active?.transport === createdTransport) {
+                            sessions.delete(activeSessionId);
+                        }
+                    }
+                };
+                await server.connect(transport);
+                await transport.handleRequest(request, response, payload);
+                return;
+            }
+            if (request.method === "GET" || request.method === "DELETE") {
+                if (!sessionId || !sessions.has(sessionId)) {
+                    writeJson(response, 400, {
+                        jsonrpc: "2.0",
+                        id: null,
+                        error: {
+                            code: -32000,
+                            message: "Bad Request: No valid MCP session was provided.",
+                        },
+                    });
+                    return;
+                }
+                const session = sessions.get(sessionId);
+                await session.transport.handleRequest(request, response);
+                if (request.method === "DELETE") {
+                    await closeSession(sessionId);
+                }
+                return;
+            }
+            response.statusCode = 405;
+            response.setHeader("allow", "GET, POST, DELETE");
+            response.end();
+        }
+        catch (error) {
+            writeJson(response, 500, {
+                error: error instanceof Error ? error.message : "Runtime MCP Streamable HTTP transport failed.",
+            });
+        }
+    });
+    const completed = new Promise((resolve, reject) => {
+        httpServer.once("close", resolve);
+        httpServer.once("error", reject);
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.listen(port, hostname, () => resolve());
+        httpServer.once("error", reject);
+    });
+    const address = httpServer.address();
+    const resolvedPort = typeof address === "object" && address ? address.port : port;
+    return {
+        hostname,
+        port: resolvedPort,
+        path: mcpPath,
+        url: `http://${hostname}:${resolvedPort}${mcpPath}`,
+        completed,
+        close: async () => {
+            const sessionIds = Array.from(sessions.keys());
+            for (const sessionId of sessionIds) {
+                await closeSession(sessionId);
+            }
+            await new Promise((resolve, reject) => {
+                httpServer.close((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        },
+    };
+}

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.306";
+export declare const AGENT_HARNESS_VERSION = "0.0.308";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.306";
+export const AGENT_HARNESS_VERSION = "0.0.308";

package/dist/resource/isolation.js

@@ -93,7 +93,9 @@ async function linkHarnessPackage(isolatedRoot) {
 }
 async function buildIsolatedResourceRoot(packageRoot) {
     const packageJsonPath = path.join(packageRoot, "package.json");
-    const manifest = JSON.parse(await readFile(packageJsonPath, "utf8"));
+    const manifest = existsSync(packageJsonPath)
+        ? JSON.parse(await readFile(packageJsonPath, "utf8"))
+        : {};
     const isolatedRoot = createIsolatedSnapshotDir(packageRoot);
     await mkdir(path.dirname(isolatedRoot), { recursive: true });
     await cp(packageRoot, isolatedRoot, {
@@ -101,6 +103,9 @@ async function buildIsolatedResourceRoot(packageRoot) {
         force: true,
         filter: (source) => path.basename(source) !== "node_modules",
     });
+    if (!existsSync(path.join(isolatedRoot, "package.json"))) {
+        await cp(path.join(HARNESS_PACKAGE_ROOT, "resources", "package.json"), path.join(isolatedRoot, "package.json"));
+    }
     await mkdir(path.join(isolatedRoot, "node_modules"), { recursive: true });
     await linkDeclaredDependencies(isolatedRoot, packageRoot, manifest);
     await linkHarnessPackage(isolatedRoot);

package/dist/runtime/adapter/model/invocation-request.d.ts

@@ -2,6 +2,7 @@ import type { CompiledAgentBinding, MessageContent, TranscriptMessage } from "..
 export declare function buildAgentMessages(history: TranscriptMessage[], input: MessageContent, options?: {
     suppressExplicitResourceTurns?: boolean;
     suppressAssistantTurns?: boolean;
+    suppressHistoryTurns?: boolean;
 }): Array<{
     role: string;
     content: MessageContent;

package/dist/runtime/adapter/model/invocation-request.js

@@ -84,6 +84,9 @@ function selectRelevantHistoryTurns(groupedHistory, inputText, options = {}) {
 }
 export function buildAgentMessages(history, input, options = {}) {
     const inputText = extractMessageText(input).trim();
+    if (options.suppressHistoryTurns) {
+        return [{ role: "user", content: normalizeMessageContent(input) }];
+    }
     const groupedHistory = history.reduce((groups, item) => {
         const current = groups.at(-1);
         if (current && current[0]?.requestId === item.requestId) {
@@ -156,6 +159,7 @@ export function buildInvocationRequest(binding, history, input, options = {}) {
     const messages = buildAgentMessages(history, input, {
         suppressExplicitResourceTurns: Boolean(memoryInstruction) && !hasExplicitResourceReference(inputText),
         suppressAssistantTurns: Boolean(memoryInstruction) && !hasExplicitResourceReference(inputText),
+        suppressHistoryTurns: Boolean(memoryInstruction) && !hasExplicitResourceReference(inputText),
     });
     const contextualFollowUpInstruction = buildContextualFollowUpInstruction(inputText, Boolean(memoryInstruction));
     const conversationLanguage = resolveConversationLanguage(history, inputText);

package/dist/runtime/harness.d.ts

@@ -125,6 +125,7 @@ export declare class AgentHarnessRuntime {
     serveToolsOverStdio(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
     createRuntimeMcpServer(options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
     serveRuntimeMcpOverStdio(options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
+    serveRuntimeMcpOverStreamableHttp(options?: import("../mcp.js").RuntimeMcpStreamableHttpServerOptions): Promise<import("../mcp.js").RuntimeMcpStreamableHttpServer>;
     routeAgent(input: MessageContent, options?: {
         sessionId?: string;
     }): Promise<string>;

package/dist/runtime/harness.js

@@ -1049,6 +1049,10 @@ export class AgentHarnessRuntime {
     async serveRuntimeMcpOverStdio(options = {}) {
         return serveRuntimeMcpOverStdio(this, options);
     }
+    async serveRuntimeMcpOverStreamableHttp(options = {}) {
+        const { serveRuntimeMcpOverStreamableHttp } = await import("../mcp.js");
+        return serveRuntimeMcpOverStreamableHttp(this, options);
+    }
     async routeAgent(input, options = {}) {
         return routeAgentId({
             workspace: this.workspace,

package/dist/workspace/compile.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { existsSync } from "node:fs";
 import { readdir } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
 import { ensureResourceSources } from "../resource/resource.js";
 import { ensureExternalResourceSource, isExternalSourceLocator, resolveResourcePackageRoot } from "../resource/sources.js";
 import { loadWorkspaceObjects, readToolModuleItems, readYamlItems } from "./object-loader.js";
@@ -10,10 +11,30 @@ import { validateAgent, validateTopology } from "./validate.js";
 import { compileBinding } from "./agent-binding-compiler.js";
 import { discoverSubagents, ensureDiscoverySources } from "./support/discovery.js";
 import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./support/source-collectors.js";
-import { getRoutingDefaultAgentId, getRuntimeResources, getRuntimeStorageRoots, getToolModuleDiscoveryConfig, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
+import { getRoutingDefaultAgentId, getRuntimeSources, getRuntimeResources, getRuntimeStorageRoots, getToolModuleDiscoveryConfig, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
 import { hydrateAgentMcpTools, hydrateResourceAndExternalTools } from "./tool-hydration.js";
 import { traceStartupStage } from "../runtime/startup-tracing.js";
 import { shouldSkipScanDirectory } from "../utils/fs.js";
+import { ensureRemoteSkillSource, ensureToolPackageSource, isFileSourceUri, isHttpSourceUri, isNpmSourceUri, resolveFileSourcePath, } from "./support/source-protocols.js";
+import { discoverToolModuleDefinitions } from "../tool-modules.js";
+function mergeObjectValues(base, override) {
+    if (override === undefined) {
+        return base;
+    }
+    if (typeof base === "object" &&
+        base &&
+        typeof override === "object" &&
+        override &&
+        !Array.isArray(base) &&
+        !Array.isArray(override)) {
+        const merged = { ...base };
+        for (const [key, value] of Object.entries(override)) {
+            merged[key] = key in merged ? mergeObjectValues(merged[key], value) : value;
+        }
+        return merged;
+    }
+    return override;
+}
 function collectParsedResources(refs) {
     const embeddings = new Map();
     const mcpServers = new Map();
@@ -132,7 +153,7 @@ async function registerAttachedResourceTools(tools, resourceRoot, toolModuleDisc
             sourcePath,
             value: item,
         });
-        tools.set(parsed.id, parsed);
+        tools.set(parsed.id, mergeParsedToolObject(tools.get(parsed.id), parsed));
     }
     for (const { item, sourcePath } of await readToolModuleItems(toolsRoot, { scope: toolModuleDiscoveryScope })) {
         const parsed = parseToolObject({
@@ -141,7 +162,7 @@ async function registerAttachedResourceTools(tools, resourceRoot, toolModuleDisc
             sourcePath,
             value: item,
         });
-        tools.set(parsed.id, parsed);
+        tools.set(parsed.id, mergeParsedToolObject(tools.get(parsed.id), parsed));
     }
 }
 async function collectSkillRoots(root) {
@@ -160,6 +181,90 @@ async function collectSkillRoots(root) {
         return [];
     }
 }
+async function resolveConfiguredSkillSourceRoots(sources, workspaceRoot) {
+    const resolved = [];
+    for (const source of sources) {
+        if (isFileSourceUri(source)) {
+            const resolvedPath = resolveFileSourcePath(source, workspaceRoot);
+            resolved.push(resolvedPath.endsWith(`${path.sep}SKILL.md`) || resolvedPath.endsWith("/SKILL.md")
+                ? path.dirname(resolvedPath)
+                : resolvedPath);
+            continue;
+        }
+        if (isHttpSourceUri(source)) {
+            resolved.push(await ensureRemoteSkillSource(source));
+            continue;
+        }
+        throw new Error(`Unsupported skill source ${source}. Use file:// or https://.`);
+    }
+    return resolved;
+}
+async function registerToolFolderSource(tools, folderRoot, toolModuleDiscoveryScope) {
+    for (const { item, sourcePath } of await readYamlItems(folderRoot, undefined, { recursive: true })) {
+        const parsed = parseToolObject({
+            id: typeof item.id === "string" ? item.id : path.basename(sourcePath).replace(/\.(yaml|yml|json)$/i, ""),
+            kind: "tool",
+            sourcePath,
+            value: item,
+        });
+        tools.set(parsed.id, mergeParsedToolObject(tools.get(parsed.id), parsed));
+    }
+    for (const { item, sourcePath } of await readToolModuleItems(folderRoot, { scope: toolModuleDiscoveryScope })) {
+        const parsed = parseToolObject({
+            id: String(item.id),
+            kind: "tool",
+            sourcePath,
+            value: item,
+        });
+        tools.set(parsed.id, mergeParsedToolObject(tools.get(parsed.id), parsed));
+    }
+}
+async function registerToolPackageSource(tools, source, workspaceRoot) {
+    const installed = await ensureToolPackageSource(source, workspaceRoot);
+    const imported = await import(pathToFileURL(installed.entryPath).href);
+    const definitions = discoverToolModuleDefinitions("", imported);
+    for (const definition of definitions) {
+        const parsed = parseToolObject({
+            id: definition.implementationName,
+            kind: "tool",
+            sourcePath: installed.entryPath,
+            value: {
+                kind: "tool",
+                id: definition.implementationName,
+                type: "function",
+                name: definition.implementationName,
+                description: definition.description,
+                implementationName: definition.implementationName,
+                hasModuleSchema: definition.hasModuleSchema,
+                ...(definition.modelSchema ? { modelSchema: definition.modelSchema } : {}),
+                ...(definition.retryable !== undefined ? { retryable: definition.retryable } : {}),
+                ...(definition.memory ? { config: { memory: definition.memory } } : {}),
+            },
+        });
+        tools.set(parsed.id, mergeParsedToolObject(tools.get(parsed.id), parsed));
+    }
+}
+function mergeParsedToolObject(current, incoming) {
+    if (!current) {
+        return incoming;
+    }
+    return {
+        ...current,
+        ...incoming,
+        config: mergeObjectValues(current.config, incoming.config),
+        subprocess: incoming.subprocess ?? current.subprocess,
+        inputSchemaRef: incoming.inputSchemaRef ?? current.inputSchemaRef,
+        hasModuleSchema: incoming.hasModuleSchema ?? current.hasModuleSchema,
+        modelSchema: incoming.modelSchema ?? current.modelSchema,
+        embeddingModelRef: incoming.embeddingModelRef ?? current.embeddingModelRef,
+        backendOperation: incoming.backendOperation ?? current.backendOperation,
+        mcpRef: incoming.mcpRef ?? current.mcpRef,
+        bundleRefs: incoming.bundleRefs.length > 0 ? incoming.bundleRefs : current.bundleRefs,
+        hitl: incoming.hitl ?? current.hitl,
+        retryable: incoming.retryable ?? current.retryable,
+        sourcePath: incoming.sourcePath,
+    };
+}
 async function registerWorkspaceSkillRegistry(skillCollectionRoots) {
     const registry = new Map();
     for (const skillsRoot of skillCollectionRoots) {
@@ -227,10 +332,29 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
     }
     const { embeddings, mcpServers, models, vectorStores, tools } = collectParsedResources(loaded.refs);
     const toolModuleDiscoveryConfig = getToolModuleDiscoveryConfig(loaded.refs);
+    const runtimeSources = getRuntimeSources(loaded.refs);
     await traceStartupStage("workspace.hydrate.agentMcpTools", () => hydrateAgentMcpTools(loaded.agents, mcpServers, tools), {
         workspaceRoot,
         agentCount: loaded.agents.length,
     });
+    for (const source of runtimeSources.tools) {
+        if (isFileSourceUri(source)) {
+            const folderRoot = resolveFileSourcePath(source, workspaceRoot);
+            await traceStartupStage("workspace.register.toolFolderSource", () => registerToolFolderSource(tools, folderRoot, toolModuleDiscoveryConfig.scope), {
+                workspaceRoot,
+                source,
+            });
+            continue;
+        }
+        if (isNpmSourceUri(source)) {
+            await traceStartupStage("workspace.register.toolPackageSource", () => registerToolPackageSource(tools, source, workspaceRoot), {
+                workspaceRoot,
+                source,
+            });
+            continue;
+        }
+        throw new Error(`Unsupported tool source ${source}. Use file:// or npm://.`);
+    }
     const configuredResources = Array.from(new Set([
         ...getRuntimeResources(loaded.refs),
         ...(options.resources ?? []),
@@ -246,11 +370,16 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
         });
     }
     const localResourceRoot = resolveResourcePackageRoot(workspaceRoot);
-    const skillCollectionRoots = [
+    const configuredSkillSourceRoots = await traceStartupStage("workspace.resolve.skillSources", () => resolveConfiguredSkillSourceRoots(runtimeSources.skills, workspaceRoot), {
+        workspaceRoot,
+        skillSourceCount: runtimeSources.skills.length,
+    });
+    const skillCollectionRoots = Array.from(new Set([
         path.join(workspaceRoot, "modules", "skills"),
         ...(localResourceRoot ? [path.join(localResourceRoot, "skills")] : []),
+        ...configuredSkillSourceRoots,
         ...resolvedConfiguredResources.map((resource) => path.join(resource.root, "skills")),
-    ];
+    ]));
     const skillRegistry = await traceStartupStage("workspace.register.skillRegistry", () => registerWorkspaceSkillRegistry(skillCollectionRoots), {
         workspaceRoot,
         skillCollectionRootCount: skillCollectionRoots.length,
@@ -272,6 +401,7 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
     validateToolNameConflicts(tools);
     const resources = Array.from(new Set([
         ...(localResourceRoot ? [localResourceRoot] : []),
+        ...runtimeSources.tools.filter((source) => isNpmSourceUri(source)),
         ...collectedResources,
     ]));
     await traceStartupStage("workspace.validate.resources", async () => {

package/dist/workspace/object-loader.js

@@ -6,6 +6,7 @@ import { resolveIsolatedResourceModulePath } from "../resource/isolation.js";
 import { isExternalSourceLocator, resolveResourcePackageRoot } from "../resource/sources.js";
 import { discoverToolModuleDefinitions, isSupportedToolModulePath, loadToolModuleDefinition } from "../tool-modules.js";
 import { fileExists, shouldSkipScanDirectory } from "../utils/fs.js";
+import { isFileSourceUri, readRuntimeSources, resolveFileSourcePath } from "./support/source-protocols.js";
 import { readNamedYamlItems, readYamlItems, } from "./yaml-object-reader.js";
 export { normalizeYamlItem, readYamlItems } from "./yaml-object-reader.js";
 const CONVENTIONAL_OBJECT_DIRECTORIES = ["tools"];
@@ -682,23 +683,32 @@ function getMergedToolModuleDiscoveryScope(mergedObjects) {
         : {};
     return toolModuleDiscovery.scope === "top-level" ? "top-level" : "recursive";
 }
-async function loadConventionalObjectsForRoot(root, mergedObjects, toolModuleDiscoveryScope) {
-    for (const directory of CONVENTIONAL_OBJECT_DIRECTORIES) {
-        for (const objectRoot of conventionalDirectoryRoots(root, directory)) {
-            for (const { item, sourcePath } of await readYamlItemsIgnoringNodeModules(objectRoot)) {
-                const workspaceObject = parseWorkspaceObject(item, sourcePath);
-                if (!workspaceObject) {
-                    continue;
-                }
-                mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
+async function loadConventionalObjectsForRoot(root, runtimeRoot, mergedObjects, toolModuleDiscoveryScope) {
+    const runtimeDefaults = mergedObjects.get("runtime/default")?.item;
+    const configuredToolRoots = readRuntimeSources(runtimeDefaults).tools
+        .filter((source) => isFileSourceUri(source))
+        .map((source) => resolveFileSourcePath(source, runtimeRoot));
+    const conventionalToolRoots = CONVENTIONAL_OBJECT_DIRECTORIES.flatMap((directory) => conventionalDirectoryRoots(root, directory));
+    const objectRoots = root === runtimeRoot
+        ? Array.from(new Set([
+            ...conventionalToolRoots,
+            ...configuredToolRoots,
+        ]))
+        : conventionalToolRoots;
+    for (const objectRoot of objectRoots) {
+        for (const { item, sourcePath } of await readYamlItemsIgnoringNodeModules(objectRoot)) {
+            const workspaceObject = parseWorkspaceObject(item, sourcePath);
+            if (!workspaceObject) {
+                continue;
             }
-            for (const { item, sourcePath } of await readToolModuleItems(objectRoot, { scope: toolModuleDiscoveryScope })) {
-                const workspaceObject = parseWorkspaceObject(item, sourcePath);
-                if (!workspaceObject) {
-                    continue;
-                }
-                mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
+            mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
+        }
+        for (const { item, sourcePath } of await readToolModuleItems(objectRoot, { scope: toolModuleDiscoveryScope })) {
+            const workspaceObject = parseWorkspaceObject(item, sourcePath);
+            if (!workspaceObject) {
+                continue;
             }
+            mergeWorkspaceObjectRecord(mergedObjects, workspaceObject, item, sourcePath);
         }
     }
 }
@@ -882,7 +892,7 @@ export async function readToolModuleItems(root, options = {}) {
     const records = [];
     for (const filePath of files) {
         const sourceText = await readFile(filePath, "utf8");
-        const packageRoot = path.dirname(root);
+        const packageRoot = findToolPackageRoot(filePath);
         const isolatedSourcePath = await resolveIsolatedResourceModulePath(packageRoot, filePath);
         const imported = await import(pathToFileURL(isolatedSourcePath).href);
         const definitions = discoverToolModuleDefinitions(sourceText, imported);
@@ -958,7 +968,7 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
         await loadConfigYamlForRoot(root, configRoot, mergedAgents, mergedObjects);
         await loadModuleAgentsForRoot(root, mergedAgents);
         if (root !== defaultRoot) {
-            await loadConventionalObjectsForRoot(root, mergedObjects, getMergedToolModuleDiscoveryScope(mergedObjects));
+            await loadConventionalObjectsForRoot(root, workspaceRoot, mergedObjects, getMergedToolModuleDiscoveryScope(mergedObjects));
         }
         await loadModuleObjectsForRoot(root, mergedObjects);
         await loadRootObjects(root, mergedObjects);

package/dist/workspace/resource-compilers.js

@@ -302,9 +302,9 @@ export function parseToolObject(object) {
                 ...(mcpServerConfig && Object.keys(mcpServerConfig).length > 0 ? { mcpServer: mcpServerConfig } : {}),
             }
             : undefined),
-        subprocess: value.subprocess === true,
+        subprocess: value.subprocess === true ? true : undefined,
         inputSchemaRef: typeof asObject(value.inputSchema)?.ref === "string" ? String(asObject(value.inputSchema)?.ref) : undefined,
-        hasModuleSchema: value.hasModuleSchema === true,
+        hasModuleSchema: value.hasModuleSchema === true ? true : undefined,
         modelSchema: asObject(value.modelSchema),
         embeddingModelRef: typeof value.embeddingModelRef === "string"
             ? value.embeddingModelRef
@@ -325,7 +325,7 @@ export function parseToolObject(object) {
                 : undefined,
         bundleRefs,
         hitl: parseHitlPolicy(value.hitl),
-        retryable: value.retryable === true,
+        retryable: value.retryable === true ? true : undefined,
         sourcePath: object.sourcePath,
     };
 }

package/dist/workspace/support/source-protocols.d.ts

@@ -0,0 +1,19 @@
+export declare const DEFAULT_TOOL_SOURCE_URIS: string[];
+export declare const DEFAULT_SKILL_SOURCE_URIS: string[];
+export type RuntimeSourceConfig = {
+    tools: string[];
+    skills: string[];
+};
+type ToolPackageInstallation = {
+    entryPath: string;
+    packageRoot: string;
+    packageName: string;
+};
+export declare function readRuntimeSources(runtimeDefaults: Record<string, unknown> | undefined): RuntimeSourceConfig;
+export declare function isFileSourceUri(value: string): boolean;
+export declare function isNpmSourceUri(value: string): boolean;
+export declare function isHttpSourceUri(value: string): boolean;
+export declare function resolveFileSourcePath(uri: string, workspaceRoot: string): string;
+export declare function ensureToolPackageSource(uri: string, workspaceRoot: string): Promise<ToolPackageInstallation>;
+export declare function ensureRemoteSkillSource(uri: string): Promise<string>;
+export {};