@botbotgo/agent-harness 0.0.1

package/dist/vendor/builtins.js

@@ -0,0 +1,103 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator } from "./sources.js";
+const vendorDir = path.dirname(fileURLToPath(import.meta.url));
+const builtinsDist = path.resolve(vendorDir, "../../../builtins/dist/src/index.js");
+const builtinsSource = path.resolve(vendorDir, "../../../builtins/src/index.ts");
+function preferSourceWhenAvailable(distPath, sourcePath) {
+    if (!existsSync(sourcePath)) {
+        return distPath;
+    }
+    return sourcePath;
+}
+const builtinsEntry = preferSourceWhenAvailable(builtinsDist, builtinsSource);
+const localBuiltins = await import(pathToFileURL(builtinsEntry).href);
+const remoteProviderCache = new Map();
+function resolvePackageEntry(packageRoot, pkg) {
+    const exportsField = pkg.exports;
+    if (typeof exportsField === "string") {
+        return path.resolve(packageRoot, exportsField);
+    }
+    if (exportsField && typeof exportsField === "object" && "." in exportsField) {
+        const rootExport = exportsField["."];
+        if (typeof rootExport === "string") {
+            return path.resolve(packageRoot, rootExport);
+        }
+        if (rootExport && typeof rootExport === "object") {
+            const importEntry = rootExport.import ?? rootExport.default;
+            if (typeof importEntry === "string") {
+                return path.resolve(packageRoot, importEntry);
+            }
+        }
+    }
+    if (typeof pkg.module === "string") {
+        return path.resolve(packageRoot, pkg.module);
+    }
+    if (typeof pkg.main === "string") {
+        return path.resolve(packageRoot, pkg.main);
+    }
+    return path.resolve(packageRoot, "index.js");
+}
+async function loadRemoteProvider(source, workspaceRoot) {
+    const cached = remoteProviderCache.get(source);
+    if (cached) {
+        return cached;
+    }
+    if (!isExternalSourceLocator(source)) {
+        throw new Error(`Unsupported builtin source ${source}. Use npm:, tgz:, or file:.`);
+    }
+    const parsed = parseExternalSourceLocator(source);
+    if (parsed.subpath) {
+        throw new Error(`Builtin source ${source} must point at a package root, not a subpath`);
+    }
+    const packageRoot = await ensureExternalSource(source, workspaceRoot);
+    const pkg = JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8"));
+    const entry = resolvePackageEntry(packageRoot, pkg);
+    const imported = await import(pathToFileURL(entry).href);
+    const provider = (imported.default ?? imported);
+    if (typeof provider.listBuiltinTools !== "function" || typeof provider.createBuiltinToolResolver !== "function") {
+        throw new Error(`Remote builtin source ${source} must export listBuiltinTools() and createBuiltinToolResolver().`);
+    }
+    const typedProvider = provider;
+    remoteProviderCache.set(source, typedProvider);
+    return typedProvider;
+}
+export async function ensureBuiltinSources(sources = [], workspaceRoot = process.cwd()) {
+    await Promise.all(sources.map((source) => loadRemoteProvider(source, workspaceRoot)));
+}
+export const builtinSkillsRoot = localBuiltins.builtinSkillsRoot;
+export const builtinConfigRoot = (localBuiltins.builtinConfigRoot ?? localBuiltins.builtinDefaultsRoot);
+export async function listBuiltinTools(sources = [], workspaceRoot = process.cwd()) {
+    await ensureBuiltinSources(sources, workspaceRoot);
+    const deduped = new Map();
+    const local = localBuiltins.listBuiltinTools;
+    for (const tool of local()) {
+        deduped.set(tool.builtinPath, tool);
+    }
+    for (const source of sources) {
+        for (const tool of remoteProviderCache.get(source)?.listBuiltinTools() ?? []) {
+            deduped.set(tool.builtinPath, tool);
+        }
+    }
+    return Array.from(deduped.values());
+}
+export async function listBuiltinToolsForSource(source, workspaceRoot = process.cwd()) {
+    await ensureBuiltinSources([source], workspaceRoot);
+    return remoteProviderCache.get(source)?.listBuiltinTools() ?? [];
+}
+export function createBuiltinBackendResolver(workspace) {
+    return localBuiltins.createBuiltinBackendResolver(workspace);
+}
+export function createBuiltinToolResolver(workspace, options = {}) {
+    const localResolver = localBuiltins.createBuiltinToolResolver(workspace, options);
+    const remoteResolvers = workspace.builtinSources
+        .map((source) => remoteProviderCache.get(source))
+        .filter((provider) => Boolean(provider))
+        .map((provider) => provider.createBuiltinToolResolver(workspace));
+    return (toolIds, binding) => [
+        ...localResolver(toolIds, binding),
+        ...remoteResolvers.flatMap((resolver) => resolver(toolIds, binding)),
+    ];
+}

package/dist/vendor/sources.d.ts

@@ -0,0 +1,12 @@
+type ParsedLocator = {
+    kind: "npm" | "tgz" | "file";
+    spec: string;
+    subpath?: string;
+};
+export declare function isExternalSourceLocator(value: unknown): boolean;
+export declare function parseExternalSourceLocator(locator: string): ParsedLocator;
+export declare function ensureExternalSource(locator: string, workspaceRoot: string): Promise<string>;
+export declare function ensureExternalSources(locators: string[], workspaceRoot: string): Promise<void>;
+export declare function resolveExternalSourcePath(locator: string, workspaceRoot: string): string;
+export declare function isDirectoryPath(candidate: string): boolean;
+export {};

package/dist/vendor/sources.js

@@ -0,0 +1,115 @@
+import { execFile } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const sourceCache = new Map();
+function cacheRoot() {
+    return path.join(os.tmpdir(), "agent-harness-external-sources");
+}
+function sourceCacheDir(locator) {
+    const digest = createHash("sha256").update(locator).digest("hex").slice(0, 16);
+    return path.join(cacheRoot(), digest);
+}
+export function isExternalSourceLocator(value) {
+    return typeof value === "string" && /^(npm|tgz|file):/.test(value);
+}
+export function parseExternalSourceLocator(locator) {
+    const separator = locator.indexOf("::");
+    const rawBase = separator >= 0 ? locator.slice(0, separator) : locator;
+    const subpath = separator >= 0 ? locator.slice(separator + 2) : undefined;
+    if (rawBase.startsWith("npm:")) {
+        return { kind: "npm", spec: rawBase.slice(4), subpath };
+    }
+    if (rawBase.startsWith("tgz:")) {
+        return { kind: "tgz", spec: rawBase.slice(4), subpath };
+    }
+    if (rawBase.startsWith("file:")) {
+        return { kind: "file", spec: rawBase.slice(5), subpath };
+    }
+    throw new Error(`Unsupported external source locator ${locator}. Use npm:, tgz:, or file:.`);
+}
+function resolveFileSpec(spec, workspaceRoot) {
+    if (path.isAbsolute(spec)) {
+        return spec;
+    }
+    return path.resolve(workspaceRoot, spec);
+}
+async function packAndExtract(packageSpec, cacheKey) {
+    const root = sourceCacheDir(cacheKey);
+    const extractRoot = path.join(root, "extract");
+    const packageRoot = path.join(extractRoot, "package");
+    if (existsSync(path.join(packageRoot, "package.json"))) {
+        return packageRoot;
+    }
+    await mkdir(root, { recursive: true });
+    await mkdir(extractRoot, { recursive: true });
+    const packed = await execFileAsync("npm", ["pack", packageSpec, "--silent"], {
+        cwd: root,
+        maxBuffer: 1024 * 1024 * 10,
+    });
+    const tarballName = packed.stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
+    if (!tarballName) {
+        throw new Error(`Failed to pack external source ${cacheKey}`);
+    }
+    await execFileAsync("tar", ["-xzf", tarballName, "-C", extractRoot], {
+        cwd: root,
+        maxBuffer: 1024 * 1024 * 10,
+    });
+    return packageRoot;
+}
+export async function ensureExternalSource(locator, workspaceRoot) {
+    const parsed = parseExternalSourceLocator(locator);
+    const cacheKey = `${parsed.kind}:${parsed.spec}`;
+    const cached = sourceCache.get(cacheKey);
+    if (cached) {
+        return parsed.subpath ? path.join(cached, parsed.subpath) : cached;
+    }
+    let basePath;
+    if (parsed.kind === "npm") {
+        basePath = await packAndExtract(parsed.spec, cacheKey);
+    }
+    else if (parsed.kind === "tgz") {
+        const resolved = resolveFileSpec(parsed.spec, workspaceRoot);
+        basePath = await packAndExtract(resolved, cacheKey);
+    }
+    else {
+        const resolved = resolveFileSpec(parsed.spec, workspaceRoot);
+        if (!existsSync(resolved)) {
+            throw new Error(`External file source ${locator} does not exist`);
+        }
+        if (resolved.endsWith(".tgz") || resolved.endsWith(".tar.gz")) {
+            basePath = await packAndExtract(resolved, cacheKey);
+        }
+        else {
+            basePath = resolved;
+        }
+    }
+    sourceCache.set(cacheKey, basePath);
+    return parsed.subpath ? path.join(basePath, parsed.subpath) : basePath;
+}
+export async function ensureExternalSources(locators, workspaceRoot) {
+    await Promise.all(Array.from(new Set(locators)).map((locator) => ensureExternalSource(locator, workspaceRoot)));
+}
+export function resolveExternalSourcePath(locator, workspaceRoot) {
+    const parsed = parseExternalSourceLocator(locator);
+    const cacheKey = `${parsed.kind}:${parsed.spec}`;
+    const cached = sourceCache.get(cacheKey);
+    if (cached) {
+        return parsed.subpath ? path.join(cached, parsed.subpath) : cached;
+    }
+    if (parsed.kind === "file") {
+        const resolved = resolveFileSpec(parsed.spec, workspaceRoot);
+        if (resolved.endsWith(".tgz") || resolved.endsWith(".tar.gz")) {
+            throw new Error(`External source ${locator} must be preloaded before synchronous resolution`);
+        }
+        return parsed.subpath ? path.join(resolved, parsed.subpath) : resolved;
+    }
+    throw new Error(`External source ${locator} must be preloaded before synchronous resolution`);
+}
+export function isDirectoryPath(candidate) {
+    return existsSync(candidate) && statSync(candidate).isDirectory();
+}

package/dist/workspace/agent-binding-compiler.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledAgentBinding, CompiledTool, ParsedAgentObject, ParsedModelObject, ParsedToolObject, WorkspaceObject } from "../contracts/types.js";
+export declare function compileAgentSkills(workspaceRoot: string, agent: ParsedAgentObject, parentSkills?: string[]): string[];
+export declare function requireTools(tools: Map<string, ParsedToolObject>, refs: string[], ownerId: string): CompiledTool[];
+export declare function compileBinding(workspaceRoot: string, agent: ParsedAgentObject, agents: Map<string, ParsedAgentObject>, referencedSubagentIds: Set<string>, refs: Map<string, WorkspaceObject | ParsedAgentObject>, models: Map<string, ParsedModelObject>, tools: Map<string, ParsedToolObject>): CompiledAgentBinding;

package/dist/workspace/agent-binding-compiler.js

@@ -0,0 +1,181 @@
+import path from "node:path";
+import { getSkillInheritancePolicy, resolveToolTargets } from "../extensions.js";
+import { compileModel, compileTool } from "./resource-compilers.js";
+import { discoverSkillPaths } from "./support/discovery.js";
+import { compileAgentMemories, getRuntimeDefaults, resolvePromptValue, resolveRefId } from "./support/workspace-ref-utils.js";
+function requireSkills(pathEntries, workspaceRoot) {
+    return Array.from(new Set(discoverSkillPaths(pathEntries, workspaceRoot)));
+}
+function resolveInheritancePolicy(agent) {
+    const langchainPolicy = typeof agent.langchainAgentConfig?.skillInheritancePolicy === "string" ? agent.langchainAgentConfig.skillInheritancePolicy : undefined;
+    const deepagentPolicy = typeof agent.deepAgentConfig?.skillInheritancePolicy === "string" ? agent.deepAgentConfig.skillInheritancePolicy : undefined;
+    return (langchainPolicy ?? deepagentPolicy ?? "default").trim();
+}
+export function compileAgentSkills(workspaceRoot, agent, parentSkills = []) {
+    const policyName = resolveInheritancePolicy(agent);
+    const policy = getSkillInheritancePolicy(policyName);
+    if (!policy) {
+        throw new Error(`Agent ${agent.id} skill inheritance policy ${policyName} is not registered`);
+    }
+    return Array.from(new Set(policy.apply({
+        agent,
+        ownSkills: requireSkills(agent.skillPathRefs, workspaceRoot),
+        parentSkills,
+    })));
+}
+function requireModel(models, ref, ownerId) {
+    const model = models.get(resolveRefId(ref));
+    if (!model) {
+        throw new Error(`Agent ${ownerId} references missing model ${ref}`);
+    }
+    return compileModel(model);
+}
+function resolveAgentRuntimeName(agent) {
+    const baseName = agent.id;
+    if (baseName.includes(".")) {
+        return baseName;
+    }
+    const normalizedSourcePath = agent.sourcePath.split(path.sep).join("/");
+    if (normalizedSourcePath.includes("/packages/builtins/")) {
+        return `builtin.${baseName}`;
+    }
+    if (normalizedSourcePath.includes("/packages/framework/")) {
+        return `core.${baseName}`;
+    }
+    if (["direct", "orchestra", "research-lite"].includes(baseName)) {
+        return `core.${baseName}`;
+    }
+    return baseName;
+}
+export function requireTools(tools, refs, ownerId) {
+    const compiled = refs.flatMap((ref) => {
+        const targets = resolveToolTargets(tools, ref);
+        if (targets.length === 0) {
+            throw new Error(`Agent ${ownerId} references missing tool ${ref}`);
+        }
+        return targets.flatMap((tool) => compileTool(tool, tools));
+    });
+    const deduped = new Map();
+    for (const tool of compiled) {
+        deduped.set(tool.name, tool);
+    }
+    return Array.from(deduped.values());
+}
+function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parentModel, parentMemory) {
+    const ownMemory = compileAgentMemories(workspaceRoot, agent.memorySources);
+    return {
+        name: resolveAgentRuntimeName(agent),
+        description: agent.description,
+        systemPrompt: resolvePromptValue(agent.deepAgentConfig?.systemPrompt) ?? "",
+        tools: requireTools(tools, agent.toolRefs, agent.id),
+        model: agent.modelRef ? requireModel(models, agent.modelRef, agent.id) : parentModel,
+        interruptOn: agent.deepAgentConfig?.interruptOn,
+        skills: compileAgentSkills(workspaceRoot, agent, parentSkills),
+        memory: ownMemory.length > 0 ? ownMemory : parentMemory,
+    };
+}
+function resolveDirectPrompt(agent) {
+    return resolvePromptValue(agent.langchainAgentConfig?.systemPrompt);
+}
+function resolveSystemPrompt(agent) {
+    if (agent.executionMode !== "deepagent") {
+        return resolveDirectPrompt(agent);
+    }
+    const deepagentPrompt = resolvePromptValue(agent.deepAgentConfig?.systemPrompt);
+    if (deepagentPrompt) {
+        return deepagentPrompt;
+    }
+    return resolveDirectPrompt(agent);
+}
+function resolveInterruptOn(agent) {
+    if (agent.executionMode !== "deepagent") {
+        return undefined;
+    }
+    return (agent.deepAgentConfig?.interruptOn ??
+        agent.langchainAgentConfig?.interruptOn);
+}
+function resolveBackendConfig(agent) {
+    if (agent.executionMode !== "deepagent") {
+        return undefined;
+    }
+    const backendConfig = typeof agent.deepAgentConfig?.backend === "object" && agent.deepAgentConfig.backend
+        ? agent.deepAgentConfig.backend
+        : undefined;
+    return backendConfig ? { config: backendConfig } : undefined;
+}
+function resolveStoreConfig(agent) {
+    if (agent.executionMode !== "deepagent") {
+        return undefined;
+    }
+    const inlineStore = typeof agent.deepAgentConfig?.store === "object" && agent.deepAgentConfig.store
+        ? agent.deepAgentConfig.store
+        : undefined;
+    return inlineStore ? { config: inlineStore } : undefined;
+}
+function resolveCheckpointerConfig(agent) {
+    const inlineAgentCheckpointer = typeof agent.deepAgentConfig?.checkpointer === "object" && agent.deepAgentConfig.checkpointer
+        ? agent.deepAgentConfig.checkpointer
+        : typeof agent.langchainAgentConfig?.checkpointer === "object" && agent.langchainAgentConfig.checkpointer
+            ? agent.langchainAgentConfig.checkpointer
+            : undefined;
+    return inlineAgentCheckpointer ? { config: inlineAgentCheckpointer } : undefined;
+}
+export function compileBinding(workspaceRoot, agent, agents, referencedSubagentIds, refs, models, tools) {
+    const internalSubagent = referencedSubagentIds.has(agent.id);
+    const runtimeDefaults = getRuntimeDefaults(refs);
+    const compiledAgentSkills = compileAgentSkills(workspaceRoot, agent);
+    const compiledAgentMemory = compileAgentMemories(workspaceRoot, agent.memorySources);
+    const compiledAgentModel = requireModel(models, agent.modelRef || (internalSubagent ? "model/default" : ""), agent.id);
+    const backend = resolveBackendConfig(agent);
+    const store = resolveStoreConfig(agent);
+    const checkpointer = resolveCheckpointerConfig(agent);
+    const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
+        ? path.resolve(workspaceRoot, agent.runRoot)
+        : typeof runtimeDefaults?.runRoot === "string" && runtimeDefaults.runRoot.trim().length > 0
+            ? path.resolve(workspaceRoot, runtimeDefaults.runRoot)
+            : path.join(workspaceRoot, "run-data");
+    const base = {
+        agent,
+        harnessRuntime: {
+            runRoot,
+            hostFacing: !internalSubagent,
+            ...(checkpointer ? { checkpointer: checkpointer.config } : {}),
+            ...(store ? { store: store.config } : {}),
+        },
+    };
+    if (agent.executionMode !== "deepagent") {
+        const langchainAgentParams = {
+            model: compiledAgentModel,
+            tools: requireTools(tools, agent.toolRefs, agent.id),
+            systemPrompt: resolveSystemPrompt(agent),
+            description: agent.description,
+        };
+        return {
+            ...base,
+            langchainAgentParams,
+            directAgentParams: langchainAgentParams,
+        };
+    }
+    return {
+        ...base,
+        deepAgentParams: {
+            model: compiledAgentModel,
+            tools: requireTools(tools, agent.toolRefs, agent.id),
+            systemPrompt: resolveSystemPrompt(agent),
+            description: agent.description,
+            subagents: agent.subagentRefs.map((ref) => {
+                const subagent = agents.get(resolveRefId(ref));
+                if (!subagent) {
+                    throw new Error(`Missing subagent ${ref} for agent ${agent.id}`);
+                }
+                return buildSubagent(subagent, workspaceRoot, models, tools, compiledAgentSkills, compiledAgentModel, compiledAgentMemory);
+            }),
+            interruptOn: resolveInterruptOn(agent),
+            ...(backend ? { backend: backend.config } : {}),
+            ...(store ? { store: store.config } : {}),
+            name: resolveAgentRuntimeName(agent),
+            memory: compiledAgentMemory,
+            skills: compiledAgentSkills,
+        },
+    };
+}

package/dist/workspace/compile.d.ts

@@ -0,0 +1,2 @@
+import type { WorkspaceBundle, WorkspaceLoadOptions } from "../contracts/types.js";
+export declare function loadWorkspace(workspaceRoot: string, options?: WorkspaceLoadOptions): Promise<WorkspaceBundle>;

package/dist/workspace/compile.js

@@ -0,0 +1,107 @@
+import { ensureBuiltinSources, listBuiltinTools, listBuiltinToolsForSource } from "../vendor/builtins.js";
+import { isExternalSourceLocator } from "../vendor/sources.js";
+import { loadWorkspaceObjects } from "./object-loader.js";
+import { parseEmbeddingModelObject, parseModelObject, parseToolObject, parseVectorStoreObject, validateEmbeddingModelObject, validateModelObject, validateToolObject, validateVectorStoreObject, } from "./resource-compilers.js";
+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 { resolveRefId } from "./support/workspace-ref-utils.js";
+function collectParsedResources(refs) {
+    const embeddings = 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("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, models, vectorStores, tools };
+}
+async function hydrateBuiltinAndExternalTools(tools, toolSourceRefs, workspaceRoot) {
+    for (const source of toolSourceRefs) {
+        if (isExternalSourceLocator(source)) {
+            const sourceTools = await listBuiltinToolsForSource(source, workspaceRoot);
+            if (sourceTools.length > 0) {
+                tools.set(source, {
+                    id: source,
+                    type: "bundle",
+                    name: source,
+                    description: `External builtin tool bundle loaded from ${source}`,
+                    bundleRefs: sourceTools.map((tool) => tool.builtinPath),
+                    sourcePath: source,
+                });
+            }
+        }
+    }
+    for (const builtinTool of await listBuiltinTools(toolSourceRefs, workspaceRoot)) {
+        const existing = tools.get(builtinTool.builtinPath);
+        tools.set(builtinTool.builtinPath, {
+            id: builtinTool.builtinPath,
+            type: existing?.type ?? "backend",
+            name: existing?.name || builtinTool.name,
+            description: existing?.description || builtinTool.description,
+            config: existing?.config,
+            backendOperation: existing?.backendOperation ?? builtinTool.backendOperation,
+            bundleRefs: existing?.bundleRefs ?? [],
+            hitl: existing?.hitl ?? builtinTool.hitl,
+            sourcePath: existing?.sourcePath ?? builtinTool.builtinPath,
+        });
+    }
+}
+function validateWorkspaceResources(embeddings, models, vectorStores, tools, agents) {
+    embeddings.forEach((embedding) => validateEmbeddingModelObject(embedding));
+    models.forEach((model) => validateModelObject(model, models));
+    vectorStores.forEach((vectorStore) => validateVectorStoreObject(vectorStore));
+    tools.forEach((tool) => validateToolObject(tool, tools));
+    agents.forEach(validateAgent);
+    validateTopology(agents);
+}
+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;
+}
+export async function loadWorkspace(workspaceRoot, options = {}) {
+    const loaded = await loadWorkspaceObjects(workspaceRoot, options);
+    loaded.agents = await discoverSubagents(loaded.agents, workspaceRoot);
+    const discoverySourceRefs = collectAgentDiscoverySourceRefs(loaded.agents);
+    await ensureDiscoverySources(discoverySourceRefs, workspaceRoot);
+    for (const agent of loaded.agents) {
+        loaded.refs.set(`agent/${agent.id}`, agent);
+    }
+    const { embeddings, models, vectorStores, tools } = collectParsedResources(loaded.refs);
+    const toolSourceRefs = collectToolSourceRefs(tools, loaded.agents, options);
+    await ensureBuiltinSources(toolSourceRefs, workspaceRoot);
+    await hydrateBuiltinAndExternalTools(tools, toolSourceRefs, workspaceRoot);
+    validateWorkspaceResources(embeddings, models, vectorStores, tools, loaded.agents);
+    return {
+        workspaceRoot,
+        builtinSources: [...toolSourceRefs],
+        refs: loaded.refs,
+        embeddings,
+        models,
+        vectorStores,
+        tools,
+        agents: new Map(loaded.agents.map((agent) => [agent.id, agent])),
+        bindings: compileBindings(workspaceRoot, loaded.refs, loaded.agents, models, tools),
+    };
+}

package/dist/workspace/index.d.ts

@@ -0,0 +1,6 @@
+export { compileBinding, compileAgentSkills, requireTools } from "./agent-binding-compiler.js";
+export { loadWorkspace } from "./compile.js";
+export { loadWorkspaceObjects } from "./object-loader.js";
+export { compileEmbeddingModel, compileModel, compileTool, compileVectorStore, parseEmbeddingModelObject, parseModelObject, parseToolObject, parseVectorStoreObject, validateEmbeddingModelObject, validateModelObject, validateToolObject, validateVectorStoreObject, } from "./resource-compilers.js";
+export * from "./support/index.js";
+export { validateAgent, validateTopology } from "./validate.js";

package/dist/workspace/index.js

@@ -0,0 +1,6 @@
+export { compileBinding, compileAgentSkills, requireTools } from "./agent-binding-compiler.js";
+export { loadWorkspace } from "./compile.js";
+export { loadWorkspaceObjects } from "./object-loader.js";
+export { compileEmbeddingModel, compileModel, compileTool, compileVectorStore, parseEmbeddingModelObject, parseModelObject, parseToolObject, parseVectorStoreObject, validateEmbeddingModelObject, validateModelObject, validateToolObject, validateVectorStoreObject, } from "./resource-compilers.js";
+export * from "./support/index.js";
+export { validateAgent, validateTopology } from "./validate.js";

package/dist/workspace/object-loader.d.ts

@@ -0,0 +1,16 @@
+import type { ParsedAgentObject, WorkspaceLoadOptions, WorkspaceObject } from "../contracts/types.js";
+type RefMap = Map<string, WorkspaceObject | ParsedAgentObject>;
+export type WorkspaceObjects = {
+    refs: RefMap;
+    agents: ParsedAgentObject[];
+};
+export declare function normalizeYamlItem(item: Record<string, unknown>): Record<string, unknown>;
+export declare function parseAgentItem(item: Record<string, unknown>, sourcePath: string): ParsedAgentObject;
+export declare function readYamlItems(root: string, relativeDir?: string, options?: {
+    recursive?: boolean;
+}): Promise<Array<{
+    item: Record<string, unknown>;
+    sourcePath: string;
+}>>;
+export declare function loadWorkspaceObjects(workspaceRoot: string, options?: WorkspaceLoadOptions): Promise<WorkspaceObjects>;
+export {};