@botbotgo/agent-harness 0.0.475 → 0.0.476

package/dist/workspace/compile.js

@@ -1,472 +1 @@
-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";
-import { validateSkillMetadata } from "../runtime/skills/skill-metadata.js";
-import { parseEmbeddingModelObject, parseMcpServerObject, parseModelObject, parseToolObject, parseVectorStoreObject, validateEmbeddingModelObject, validateMcpServerObject, validateModelObject, validateToolObject, validateVectorStoreObject, } from "./resource-compilers.js";
-import { validateAgent, validateTopology } from "./validate.js";
-import { compileBinding } from "./agent-binding-compiler.js";
-import { resolveFrameworkContractValidationMode, validateFrameworkContracts, } from "./framework-contract-validation.js";
-import { discoverSubagents, ensureDiscoverySources } from "./support/discovery.js";
-import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./support/source-collectors.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 { ensurePackageSource, ensureRemoteSkillSource, isFileSourceUri, isHttpSourceUri, isNpmSourceUri, resolveFileSourcePath, } from "./support/source-protocols.js";
-import { discoverToolModuleDefinitions } from "../tooling/module-loader.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();
-    const models = new Map();
-    const vectorStores = new Map();
-    const tools = new Map();
-    for (const [ref, object] of refs) {
-        if (typeof object !== "object" || !object || "executionMode" in object) {
-            continue;
-        }
-        const typed = object;
-        if (ref.startsWith("embedding-model/")) {
-            embeddings.set(typed.id, parseEmbeddingModelObject(object));
-        }
-        else if (ref.startsWith("mcp/")) {
-            mcpServers.set(typed.id, parseMcpServerObject(object));
-        }
-        else if (ref.startsWith("vector-store/")) {
-            vectorStores.set(typed.id, parseVectorStoreObject(object));
-        }
-        else if (ref.startsWith("model/")) {
-            models.set(typed.id, parseModelObject(object));
-        }
-        else if (ref.startsWith("tool/")) {
-            tools.set(typed.id, parseToolObject(object));
-        }
-    }
-    return { embeddings, mcpServers, models, vectorStores, tools };
-}
-function validateWorkspaceResources(embeddings, mcpServers, models, vectorStores, tools, agents) {
-    embeddings.forEach((embedding) => validateEmbeddingModelObject(embedding));
-    mcpServers.forEach((server) => validateMcpServerObject(server));
-    models.forEach((model) => validateModelObject(model, models));
-    vectorStores.forEach((vectorStore) => validateVectorStoreObject(vectorStore));
-    tools.forEach((tool) => validateToolObject(tool, tools));
-    tools.forEach((tool) => {
-        if (!tool.embeddingModelRef) {
-            return;
-        }
-        const embeddingModelId = tool.embeddingModelRef.startsWith("embedding-model/")
-            ? tool.embeddingModelRef.slice("embedding-model/".length)
-            : tool.embeddingModelRef;
-        if (!embeddings.has(embeddingModelId)) {
-            throw new Error(`Tool ${tool.id} references missing embedding model ${tool.embeddingModelRef}`);
-        }
-    });
-    agents.forEach(validateAgent);
-    validateTopology(agents);
-    tools.forEach((tool) => {
-        if (tool.type !== "mcp") {
-            return;
-        }
-        const mcpConfig = typeof tool.config?.mcp === "object" && tool.config.mcp
-            ? tool.config.mcp
-            : undefined;
-        const serverRef = typeof mcpConfig?.serverRef === "string" ? mcpConfig.serverRef : undefined;
-        if (!serverRef) {
-            throw new Error(`MCP tool ${tool.id} must define mcp.server or mcp.serverRef`);
-        }
-        const serverId = serverRef.startsWith("mcp/") ? serverRef.slice(4) : serverRef;
-        if (!mcpServers.has(serverId)) {
-            throw new Error(`MCP tool ${tool.id} references missing MCP server ${serverRef}`);
-        }
-    });
-}
-function compileBindings(workspaceRoot, refs, agentsList, models, tools) {
-    const agents = new Map(agentsList.map((agent) => [agent.id, agent]));
-    const referencedSubagentIds = new Set(agentsList.flatMap((agent) => agent.subagentRefs.map((ref) => resolveRefId(ref))));
-    const bindings = new Map();
-    for (const agent of agentsList) {
-        bindings.set(agent.id, compileBinding(workspaceRoot, agent, agents, referencedSubagentIds, refs, models, tools));
-    }
-    return bindings;
-}
-function validateRoutingTargets(refs, agentsList) {
-    const runtimeEntryAgentIds = new Set(agentsList.map((agent) => agent.id));
-    const defaultAgentId = getRoutingDefaultAgentId(refs);
-    if (defaultAgentId && !runtimeEntryAgentIds.has(defaultAgentId)) {
-        throw new Error(`Runtime routing.defaultAgentId references unknown runtime entry agent ${defaultAgentId}`);
-    }
-    for (const rule of getRoutingRules(refs)) {
-        if (!runtimeEntryAgentIds.has(rule.agentId)) {
-            throw new Error(`Runtime routing.rules references unknown runtime entry agent ${rule.agentId}`);
-        }
-    }
-}
-function resolveLocalResourceRoot(candidate, workspaceRoot) {
-    const resolved = path.resolve(workspaceRoot, candidate);
-    const directPackageJsonPath = path.join(resolved, "package.json");
-    const resourceRoot = existsSync(directPackageJsonPath) ? resolved : resolveResourcePackageRoot(resolved);
-    if (!resourceRoot) {
-        throw new Error(`Workspace resource ${candidate} is missing package.json or resources/package.json.`);
-    }
-    return resourceRoot;
-}
-async function resolveConfiguredResources(entries, workspaceRoot) {
-    const resolved = [];
-    for (const entry of entries) {
-        const key = entry.trim();
-        if (!key) {
-            continue;
-        }
-        const root = isExternalSourceLocator(key)
-            ? await ensureExternalResourceSource(key, workspaceRoot)
-            : resolveLocalResourceRoot(key, workspaceRoot);
-        resolved.push({ key, root });
-    }
-    return resolved;
-}
-async function registerAttachedResourceTools(tools, resourceRoot, toolModuleDiscoveryScope) {
-    const toolsRoot = path.join(resourceRoot, "tools");
-    for (const { item, sourcePath } of await readYamlItems(toolsRoot, 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(toolsRoot, { 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 collectSkillRoots(root) {
-    try {
-        const entries = await readdir(root, { withFileTypes: true });
-        const skillDocument = entries.find((entry) => entry.isFile() && entry.name === "SKILL.md");
-        if (skillDocument) {
-            return [root];
-        }
-        const nested = await Promise.all(entries
-            .filter((entry) => entry.isDirectory() && !shouldSkipScanDirectory(entry.name))
-            .map((entry) => collectSkillRoots(path.join(root, entry.name))));
-        return nested.flat();
-    }
-    catch {
-        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;
-        }
-        if (isNpmSourceUri(source)) {
-            const installed = await ensurePackageSource(source, workspaceRoot);
-            resolved.push(path.join(installed.packageRoot, "skills"));
-            continue;
-        }
-        throw new Error(`Unsupported skill source ${source}. Use file://, npm://, 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, toolModuleDiscoveryScope) {
-    const installed = await ensurePackageSource(source, workspaceRoot);
-    const toolsRoot = path.join(installed.packageRoot, "tools");
-    if (existsSync(toolsRoot)) {
-        await registerToolFolderSource(tools, toolsRoot, toolModuleDiscoveryScope);
-        return;
-    }
-    if (!installed.entryPath) {
-        return;
-    }
-    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) {
-        for (const skillRoot of await collectSkillRoots(skillsRoot)) {
-            const metadata = validateSkillMetadata(skillRoot);
-            const existing = registry.get(metadata.name);
-            if (existing && existing !== skillRoot) {
-                throw new Error(`Duplicate skill name ${metadata.name} found in ${existing} and ${skillRoot}`);
-            }
-            registry.set(metadata.name, skillRoot);
-        }
-    }
-    return registry;
-}
-function validateToolNameConflicts(tools) {
-    const seen = new Map();
-    for (const tool of tools.values()) {
-        const existing = seen.get(tool.name);
-        if (existing && existing !== tool.sourcePath) {
-            throw new Error(`Duplicate tool name ${tool.name} found in ${existing} and ${tool.sourcePath}`);
-        }
-        seen.set(tool.name, tool.sourcePath);
-    }
-}
-function resolveAgentSkillNames(agents, skillRegistry, skillCollectionRoots) {
-    for (const agent of agents) {
-        agent.skillPathRefs = agent.skillPathRefs.map((entry) => {
-            const normalizedEntry = entry.startsWith("skill/") ? entry.slice("skill/".length) : entry;
-            const registered = skillRegistry.get(normalizedEntry);
-            if (registered) {
-                return registered;
-            }
-            if (path.isAbsolute(entry) || entry.startsWith("builtin://") || entry.startsWith("resource://")) {
-                return entry;
-            }
-            for (const skillsRoot of skillCollectionRoots) {
-                const candidate = path.join(skillsRoot, normalizedEntry);
-                if (existsSync(path.join(candidate, "SKILL.md"))) {
-                    return candidate;
-                }
-            }
-            return normalizedEntry;
-        });
-    }
-}
-export async function loadWorkspace(workspaceRoot, options = {}) {
-    const loaded = await traceStartupStage("workspace.load.objects", () => loadWorkspaceObjects(workspaceRoot, options), {
-        workspaceRoot,
-    });
-    const runtimeStorage = getRuntimeStorageRoots(loaded.refs, workspaceRoot);
-    if (path.resolve(runtimeStorage.applicationRoot) !== path.resolve(workspaceRoot)) {
-        throw new Error(`Runtime applicationRoot ${runtimeStorage.applicationRoot} must resolve to the loaded workspace root ${workspaceRoot}. ` +
-            "Load the shared application folder as the workspace root and use Runtime.dataRoot for writable profile data.");
-    }
-    loaded.agents = await traceStartupStage("workspace.discover.subagents", () => discoverSubagents(loaded.agents, workspaceRoot), {
-        workspaceRoot,
-    });
-    const discoverySourceRefs = collectAgentDiscoverySourceRefs(loaded.agents);
-    await traceStartupStage("workspace.ensure.discoverySources", () => ensureDiscoverySources(discoverySourceRefs, workspaceRoot), {
-        workspaceRoot,
-        sourceCount: discoverySourceRefs.length,
-    });
-    for (const agent of loaded.agents) {
-        loaded.refs.set(`agent/${agent.id}`, agent);
-    }
-    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, toolModuleDiscoveryConfig.scope), {
-                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 ?? []),
-    ]));
-    const resolvedConfiguredResources = await traceStartupStage("workspace.resolve.configuredResources", () => resolveConfiguredResources(configuredResources, workspaceRoot), {
-        workspaceRoot,
-        configuredResourceCount: configuredResources.length,
-    });
-    for (const resource of resolvedConfiguredResources) {
-        await traceStartupStage("workspace.register.attachedResourceTools", () => registerAttachedResourceTools(tools, resource.root, toolModuleDiscoveryConfig.scope), {
-            workspaceRoot,
-            resourceRoot: resource.root,
-        });
-    }
-    const localResourceRoot = resolveResourcePackageRoot(workspaceRoot);
-    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,
-    });
-    resolveAgentSkillNames(loaded.agents, skillRegistry, skillCollectionRoots);
-    const collectedResources = collectToolSourceRefs(tools, loaded.agents, {
-        ...options,
-        resources: configuredResources,
-    });
-    const externalResources = collectedResources.filter((resource) => isExternalSourceLocator(resource));
-    await traceStartupStage("workspace.ensure.externalResourceSources", () => ensureResourceSources(externalResources, workspaceRoot), {
-        workspaceRoot,
-        externalResourceCount: externalResources.length,
-    });
-    await traceStartupStage("workspace.hydrate.externalTools", () => hydrateResourceAndExternalTools(tools, externalResources, workspaceRoot, toolModuleDiscoveryConfig.scope), {
-        workspaceRoot,
-        externalResourceCount: externalResources.length,
-    });
-    validateToolNameConflicts(tools);
-    const frameworkContractValidation = resolveFrameworkContractValidationMode(options.frameworkContractValidation);
-    const contractOwnedRoots = Array.from(new Set([
-        workspaceRoot,
-        ...(localResourceRoot ? [localResourceRoot] : []),
-        ...resolvedConfiguredResources.map((resource) => resource.root),
-    ]));
-    await traceStartupStage("workspace.validate.frameworkContracts", async () => {
-        validateFrameworkContracts({
-            agents: loaded.agents,
-            tools,
-            skillRegistry,
-            ownedRoots: contractOwnedRoots,
-            refs: loaded.refs,
-            mode: frameworkContractValidation,
-        });
-    }, {
-        workspaceRoot,
-        mode: frameworkContractValidation,
-    });
-    const resources = Array.from(new Set([
-        ...(localResourceRoot ? [localResourceRoot] : []),
-        ...runtimeSources.tools.filter((source) => isNpmSourceUri(source)),
-        ...runtimeSources.skills.filter((source) => isNpmSourceUri(source)),
-        ...collectedResources,
-    ]));
-    await traceStartupStage("workspace.validate.resources", async () => {
-        validateWorkspaceResources(embeddings, mcpServers, models, vectorStores, tools, loaded.agents);
-    }, {
-        workspaceRoot,
-        agentCount: loaded.agents.length,
-        toolCount: tools.size,
-        modelCount: models.size,
-        mcpServerCount: mcpServers.size,
-    });
-    await traceStartupStage("workspace.validate.routingTargets", async () => {
-        validateRoutingTargets(loaded.refs, loaded.agents);
-    }, {
-        workspaceRoot,
-        agentCount: loaded.agents.length,
-    });
-    const bindings = await traceStartupStage("workspace.compile.bindings", async () => compileBindings(workspaceRoot, loaded.refs, loaded.agents, models, tools), {
-        workspaceRoot,
-        agentCount: loaded.agents.length,
-    });
-    return {
-        workspaceRoot,
-        resources,
-        refs: loaded.refs,
-        embeddings,
-        mcpServers,
-        models,
-        vectorStores,
-        tools,
-        agents: new Map(loaded.agents.map((agent) => [agent.id, agent])),
-        bindings,
-    };
-}
+import u from"node:path";import{existsSync as k}from"node:fs";import{readdir as z}from"node:fs/promises";import{pathToFileURL as K}from"node:url";import{ensureResourceSources as B}from"../resource/resource.js";import{ensureExternalResourceSource as H,isExternalSourceLocator as P,resolveResourcePackageRoot as E}from"../resource/sources.js";import{loadWorkspaceObjects as J,readToolModuleItems as T,readYamlItems as $}from"./object-loader.js";import{validateSkillMetadata as Y}from"../runtime/skills/skill-metadata.js";import{parseEmbeddingModelObject as q,parseMcpServerObject as G,parseModelObject as Q,parseToolObject as g,parseVectorStoreObject as X,validateEmbeddingModelObject as Z,validateMcpServerObject as _,validateModelObject as ee,validateToolObject as te,validateVectorStoreObject as oe}from"./resource-compilers.js";import{validateAgent as re,validateTopology as se}from"./validate.js";import{compileBinding as ne}from"./agent-binding-compiler.js";import{resolveFrameworkContractValidationMode as ie,validateFrameworkContracts as ae}from"./framework-contract-validation.js";import{discoverSubagents as ce,ensureDiscoverySources as le}from"./support/discovery.js";import{collectAgentDiscoverySourceRefs as de,collectToolSourceRefs as ue}from"./support/source-collectors.js";import{getRoutingDefaultAgentId as fe,getRuntimeSources as me,getRuntimeResources as ge,getRuntimeStorageRoots as pe,getToolModuleDiscoveryConfig as he,getRoutingRules as Se,resolveRefId as ye}from"./support/workspace-ref-utils.js";import{hydrateAgentMcpTools as we,hydrateResourceAndExternalTools as ve}from"./tool-hydration.js";import{traceStartupStage as f}from"../runtime/startup-tracing.js";import{shouldSkipScanDirectory as be}from"../utils/fs.js";import{ensurePackageSource as A,ensureRemoteSkillSource as Re,isFileSourceUri as O,isHttpSourceUri as ke,isNpmSourceUri as w,resolveFileSourcePath as W}from"./support/source-protocols.js";import{discoverToolModuleDefinitions as Me}from"../tooling/module-loader.js";function I(e,r){if(r===void 0)return e;if(typeof e=="object"&&e&&typeof r=="object"&&r&&!Array.isArray(e)&&!Array.isArray(r)){const t={...e};for(const[s,o]of Object.entries(r))t[s]=s in t?I(t[s],o):o;return t}return r}function je(e){const r=new Map,t=new Map,s=new Map,o=new Map,a=new Map;for(const[n,c]of e){if(typeof c!="object"||!c||"executionMode"in c)continue;const i=c;n.startsWith("embedding-model/")?r.set(i.id,q(c)):n.startsWith("mcp/")?t.set(i.id,G(c)):n.startsWith("vector-store/")?o.set(i.id,X(c)):n.startsWith("model/")?s.set(i.id,Q(c)):n.startsWith("tool/")&&a.set(i.id,g(c))}return{embeddings:r,mcpServers:t,models:s,vectorStores:o,tools:a}}function Ce(e,r,t,s,o,a){e.forEach(n=>Z(n)),r.forEach(n=>_(n)),t.forEach(n=>ee(n,t)),s.forEach(n=>oe(n)),o.forEach(n=>te(n,o)),o.forEach(n=>{if(!n.embeddingModelRef)return;const c=n.embeddingModelRef.startsWith("embedding-model/")?n.embeddingModelRef.slice(16):n.embeddingModelRef;if(!e.has(c))throw new Error(`Tool ${n.id} references missing embedding model ${n.embeddingModelRef}`)}),a.forEach(re),se(a),o.forEach(n=>{if(n.type!=="mcp")return;const c=typeof n.config?.mcp=="object"&&n.config.mcp?n.config.mcp:void 0,i=typeof c?.serverRef=="string"?c.serverRef:void 0;if(!i)throw new Error(`MCP tool ${n.id} must define mcp.server or mcp.serverRef`);const d=i.startsWith("mcp/")?i.slice(4):i;if(!r.has(d))throw new Error(`MCP tool ${n.id} references missing MCP server ${i}`)})}function Pe(e,r,t,s,o){const a=new Map(t.map(i=>[i.id,i])),n=new Set(t.flatMap(i=>i.subagentRefs.map(d=>ye(d)))),c=new Map;for(const i of t)c.set(i.id,ne(e,i,a,n,r,s,o));return c}function Ee(e,r){const t=new Set(r.map(o=>o.id)),s=fe(e);if(s&&!t.has(s))throw new Error(`Runtime routing.defaultAgentId references unknown runtime entry agent ${s}`);for(const o of Se(e))if(!t.has(o.agentId))throw new Error(`Runtime routing.rules references unknown runtime entry agent ${o.agentId}`)}function Te(e,r){const t=u.resolve(r,e),s=u.join(t,"package.json"),o=k(s)?t:E(t);if(!o)throw new Error(`Workspace resource ${e} is missing package.json or resources/package.json.`);return o}async function $e(e,r){const t=[];for(const s of e){const o=s.trim();if(!o)continue;const a=P(o)?await H(o,r):Te(o,r);t.push({key:o,root:a})}return t}async function Ae(e,r,t){const s=u.join(r,"tools");for(const{item:o,sourcePath:a}of await $(s,void 0,{recursive:!0})){const n=g({id:typeof o.id=="string"?o.id:u.basename(a).replace(/\.(yaml|yml|json)$/i,""),kind:"tool",sourcePath:a,value:o});e.set(n.id,h(e.get(n.id),n))}for(const{item:o,sourcePath:a}of await T(s,{scope:t})){const n=g({id:String(o.id),kind:"tool",sourcePath:a,value:o});e.set(n.id,h(e.get(n.id),n))}}async function x(e){try{const r=await z(e,{withFileTypes:!0});return r.find(o=>o.isFile()&&o.name==="SKILL.md")?[e]:(await Promise.all(r.filter(o=>o.isDirectory()&&!be(o.name)).map(o=>x(u.join(e,o.name))))).flat()}catch{return[]}}async function Oe(e,r){const t=[];for(const s of e){if(O(s)){const o=W(s,r);t.push(o.endsWith(`${u.sep}SKILL.md`)||o.endsWith("/SKILL.md")?u.dirname(o):o);continue}if(ke(s)){t.push(await Re(s));continue}if(w(s)){const o=await A(s,r);t.push(u.join(o.packageRoot,"skills"));continue}throw new Error(`Unsupported skill source ${s}. Use file://, npm://, or https://.`)}return t}async function D(e,r,t){for(const{item:s,sourcePath:o}of await $(r,void 0,{recursive:!0})){const a=g({id:typeof s.id=="string"?s.id:u.basename(o).replace(/\.(yaml|yml|json)$/i,""),kind:"tool",sourcePath:o,value:s});e.set(a.id,h(e.get(a.id),a))}for(const{item:s,sourcePath:o}of await T(r,{scope:t})){const a=g({id:String(s.id),kind:"tool",sourcePath:o,value:s});e.set(a.id,h(e.get(a.id),a))}}async function We(e,r,t,s){const o=await A(r,t),a=u.join(o.packageRoot,"tools");if(k(a)){await D(e,a,s);return}if(!o.entryPath)return;const n=await import(K(o.entryPath).href),c=Me("",n);for(const i of c){const d=g({id:i.implementationName,kind:"tool",sourcePath:o.entryPath,value:{kind:"tool",id:i.implementationName,type:"function",name:i.implementationName,description:i.description,implementationName:i.implementationName,hasModuleSchema:i.hasModuleSchema,...i.modelSchema?{modelSchema:i.modelSchema}:{},...i.retryable!==void 0?{retryable:i.retryable}:{},...i.memory?{config:{memory:i.memory}}:{}}});e.set(d.id,h(e.get(d.id),d))}}function h(e,r){return e?{...e,...r,config:I(e.config,r.config),subprocess:r.subprocess??e.subprocess,inputSchemaRef:r.inputSchemaRef??e.inputSchemaRef,hasModuleSchema:r.hasModuleSchema??e.hasModuleSchema,modelSchema:r.modelSchema??e.modelSchema,embeddingModelRef:r.embeddingModelRef??e.embeddingModelRef,backendOperation:r.backendOperation??e.backendOperation,mcpRef:r.mcpRef??e.mcpRef,bundleRefs:r.bundleRefs.length>0?r.bundleRefs:e.bundleRefs,hitl:r.hitl??e.hitl,retryable:r.retryable??e.retryable,sourcePath:r.sourcePath}:r}async function Ie(e){const r=new Map;for(const t of e)for(const s of await x(t)){const o=Y(s),a=r.get(o.name);if(a&&a!==s)throw new Error(`Duplicate skill name ${o.name} found in ${a} and ${s}`);r.set(o.name,s)}return r}function xe(e){const r=new Map;for(const t of e.values()){const s=r.get(t.name);if(s&&s!==t.sourcePath)throw new Error(`Duplicate tool name ${t.name} found in ${s} and ${t.sourcePath}`);r.set(t.name,t.sourcePath)}}function De(e,r,t){for(const s of e)s.skillPathRefs=s.skillPathRefs.map(o=>{const a=o.startsWith("skill/")?o.slice(6):o,n=r.get(a);if(n)return n;if(u.isAbsolute(o)||o.startsWith("builtin://")||o.startsWith("resource://"))return o;for(const c of t){const i=u.join(c,a);if(k(u.join(i,"SKILL.md")))return i}return a})}async function rt(e,r={}){const t=await f("workspace.load.objects",()=>J(e,r),{workspaceRoot:e}),s=pe(t.refs,e);if(u.resolve(s.applicationRoot)!==u.resolve(e))throw new Error(`Runtime applicationRoot ${s.applicationRoot} must resolve to the loaded workspace root ${e}. Load the shared application folder as the workspace root and use Runtime.dataRoot for writable profile data.`);t.agents=await f("workspace.discover.subagents",()=>ce(t.agents,e),{workspaceRoot:e});const o=de(t.agents);await f("workspace.ensure.discoverySources",()=>le(o,e),{workspaceRoot:e,sourceCount:o.length});for(const l of t.agents)t.refs.set(`agent/${l.id}`,l);const{embeddings:a,mcpServers:n,models:c,vectorStores:i,tools:d}=je(t.refs),S=he(t.refs),p=me(t.refs);await f("workspace.hydrate.agentMcpTools",()=>we(t.agents,n,d),{workspaceRoot:e,agentCount:t.agents.length});for(const l of p.tools){if(O(l)){const V=W(l,e);await f("workspace.register.toolFolderSource",()=>D(d,V,S.scope),{workspaceRoot:e,source:l});continue}if(w(l)){await f("workspace.register.toolPackageSource",()=>We(d,l,e,S.scope),{workspaceRoot:e,source:l});continue}throw new Error(`Unsupported tool source ${l}. Use file:// or npm://.`)}const v=Array.from(new Set([...ge(t.refs),...r.resources??[]])),b=await f("workspace.resolve.configuredResources",()=>$e(v,e),{workspaceRoot:e,configuredResourceCount:v.length});for(const l of b)await f("workspace.register.attachedResourceTools",()=>Ae(d,l.root,S.scope),{workspaceRoot:e,resourceRoot:l.root});const m=E(e),L=await f("workspace.resolve.skillSources",()=>Oe(p.skills,e),{workspaceRoot:e,skillSourceCount:p.skills.length}),R=Array.from(new Set([u.join(e,"modules","skills"),...m?[u.join(m,"skills")]:[],...L,...b.map(l=>u.join(l.root,"skills"))])),M=await f("workspace.register.skillRegistry",()=>Ie(R),{workspaceRoot:e,skillCollectionRootCount:R.length});De(t.agents,M,R);const j=ue(d,t.agents,{...r,resources:v}),y=j.filter(l=>P(l));await f("workspace.ensure.externalResourceSources",()=>B(y,e),{workspaceRoot:e,externalResourceCount:y.length}),await f("workspace.hydrate.externalTools",()=>ve(d,y,e,S.scope),{workspaceRoot:e,externalResourceCount:y.length}),xe(d);const C=ie(r.frameworkContractValidation),F=Array.from(new Set([e,...m?[m]:[],...b.map(l=>l.root)]));await f("workspace.validate.frameworkContracts",async()=>{ae({agents:t.agents,tools:d,skillRegistry:M,ownedRoots:F,refs:t.refs,mode:C})},{workspaceRoot:e,mode:C});const N=Array.from(new Set([...m?[m]:[],...p.tools.filter(l=>w(l)),...p.skills.filter(l=>w(l)),...j]));await f("workspace.validate.resources",async()=>{Ce(a,n,c,i,d,t.agents)},{workspaceRoot:e,agentCount:t.agents.length,toolCount:d.size,modelCount:c.size,mcpServerCount:n.size}),await f("workspace.validate.routingTargets",async()=>{Ee(t.refs,t.agents)},{workspaceRoot:e,agentCount:t.agents.length});const U=await f("workspace.compile.bindings",async()=>Pe(e,t.refs,t.agents,c,d),{workspaceRoot:e,agentCount:t.agents.length});return{workspaceRoot:e,resources:N,refs:t.refs,embeddings:a,mcpServers:n,models:c,vectorStores:i,tools:d,agents:new Map(t.agents.map(l=>[l.id,l])),bindings:U}}export{rt as loadWorkspace};