@botbotgo/agent-harness 0.0.306 → 0.0.308

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 {};

package/dist/workspace/support/source-protocols.js

@@ -0,0 +1,192 @@
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { parse as parseYaml } from "yaml";
+const execFileAsync = promisify(execFile);
+export const DEFAULT_TOOL_SOURCE_URIS = ["file://./resources/tools"];
+export const DEFAULT_SKILL_SOURCE_URIS = ["file://./resources/skills"];
+const require = createRequire(import.meta.url);
+function normalizeSourceList(value, fallback) {
+    if (!Array.isArray(value)) {
+        return [...fallback];
+    }
+    return value
+        .filter((item) => typeof item === "string" && item.trim().length > 0)
+        .map((item) => item.trim());
+}
+export function readRuntimeSources(runtimeDefaults) {
+    const rawSources = typeof runtimeDefaults?.sources === "object" && runtimeDefaults.sources && !Array.isArray(runtimeDefaults.sources)
+        ? runtimeDefaults.sources
+        : {};
+    return {
+        tools: normalizeSourceList(rawSources.tools, DEFAULT_TOOL_SOURCE_URIS),
+        skills: normalizeSourceList(rawSources.skills, DEFAULT_SKILL_SOURCE_URIS),
+    };
+}
+export function isFileSourceUri(value) {
+    return value.startsWith("file://");
+}
+export function isNpmSourceUri(value) {
+    return value.startsWith("npm://");
+}
+export function isHttpSourceUri(value) {
+    return value.startsWith("http://") || value.startsWith("https://");
+}
+export function resolveFileSourcePath(uri, workspaceRoot) {
+    if (!isFileSourceUri(uri)) {
+        throw new Error(`Unsupported file source URI ${uri}`);
+    }
+    const rawPath = uri.slice("file://".length).trim();
+    if (!rawPath) {
+        throw new Error(`File source URI ${uri} must include a path`);
+    }
+    return path.isAbsolute(rawPath) ? rawPath : path.resolve(workspaceRoot, rawPath);
+}
+function parseToolPackageName(spec, workspaceRoot) {
+    if (spec.startsWith("file:")) {
+        const localPath = spec.slice("file:".length);
+        const resolvedPath = path.isAbsolute(localPath) ? localPath : path.resolve(workspaceRoot, localPath);
+        const packageJsonPath = path.join(resolvedPath, "package.json");
+        if (!existsSync(packageJsonPath)) {
+            throw new Error(`Package tool source ${spec} is missing package.json`);
+        }
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        if (typeof packageJson.name !== "string" || packageJson.name.trim().length === 0) {
+            throw new Error(`Package tool source ${spec} must define a package.json name`);
+        }
+        return packageJson.name.trim();
+    }
+    const match = spec.match(/^(@[^/]+\/[^@/]+|[^@/]+)(?:@.+)?$/);
+    if (!match?.[1]) {
+        throw new Error(`Unsupported package tool source ${spec}. Use npm://<package-name> or npm://<package-name>@<version>.`);
+    }
+    return match[1];
+}
+function packageInstallCacheRoot(spec) {
+    const digest = createHash("sha256").update(spec).digest("hex").slice(0, 16);
+    return path.join(os.tmpdir(), "agent-harness-package-tools", digest);
+}
+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");
+}
+function resolveInstalledPackageRoot(packageName, workspaceRoot) {
+    const packageJsonRef = `${packageName}/package.json`;
+    const directNodeModulesPath = path.join(workspaceRoot, "node_modules", ...packageName.split("/"), "package.json");
+    if (existsSync(directNodeModulesPath)) {
+        return path.dirname(directNodeModulesPath);
+    }
+    for (const candidateRoot of [workspaceRoot, process.cwd()]) {
+        try {
+            const candidateRequire = createRequire(path.join(candidateRoot, "__agent_harness_package_resolve__.cjs"));
+            return path.dirname(candidateRequire.resolve(packageJsonRef));
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function installPackageToolSource(spec, workspaceRoot) {
+    const packageName = parseToolPackageName(spec, workspaceRoot);
+    const installRoot = packageInstallCacheRoot(spec);
+    const packageJsonPath = path.join(installRoot, "package.json");
+    await mkdir(installRoot, { recursive: true });
+    if (!existsSync(packageJsonPath)) {
+        await writeFile(packageJsonPath, `${JSON.stringify({ name: "agent-harness-package-tool-cache", private: true }, null, 2)}\n`, "utf8");
+    }
+    const installedRoot = path.join(installRoot, "node_modules", ...packageName.split("/"));
+    if (!existsSync(path.join(installedRoot, "package.json"))) {
+        await execFileAsync("npm", ["install", "--no-save", spec], {
+            cwd: installRoot,
+            maxBuffer: 1024 * 1024 * 20,
+            env: process.env,
+        });
+    }
+    const packageJson = JSON.parse(await readFile(path.join(installedRoot, "package.json"), "utf8"));
+    return {
+        packageName,
+        packageRoot: installedRoot,
+        entryPath: resolvePackageEntry(installedRoot, packageJson),
+    };
+}
+export async function ensureToolPackageSource(uri, workspaceRoot) {
+    if (!isNpmSourceUri(uri)) {
+        throw new Error(`Unsupported package source URI ${uri}`);
+    }
+    const spec = uri.slice("npm://".length).trim();
+    if (!spec) {
+        throw new Error(`Package source URI ${uri} must include a package name`);
+    }
+    const packageName = parseToolPackageName(spec, workspaceRoot);
+    const installedRoot = resolveInstalledPackageRoot(packageName, workspaceRoot);
+    if (installedRoot && !spec.startsWith("file:") && !spec.includes("@", packageName.startsWith("@") ? packageName.length : 0)) {
+        const packageJson = JSON.parse(await readFile(path.join(installedRoot, "package.json"), "utf8"));
+        return {
+            packageName,
+            packageRoot: installedRoot,
+            entryPath: resolvePackageEntry(installedRoot, packageJson),
+        };
+    }
+    return installPackageToolSource(spec, workspaceRoot);
+}
+function parseSkillFrontmatterName(document) {
+    const match = document.match(/^---\s*\n([\s\S]*?)\n---\s*(?:\n|$)/);
+    if (!match?.[1]) {
+        return undefined;
+    }
+    const parsed = parseYaml(match[1]);
+    return typeof parsed?.name === "string" && parsed.name.trim().length > 0 ? parsed.name.trim() : undefined;
+}
+function sanitizeSkillDirName(input) {
+    const normalized = input.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    return normalized || "remote-skill";
+}
+function remoteSkillCacheRoot(uri) {
+    const digest = createHash("sha256").update(uri).digest("hex").slice(0, 16);
+    return path.join(os.tmpdir(), "agent-harness-remote-skills", digest);
+}
+export async function ensureRemoteSkillSource(uri) {
+    if (!isHttpSourceUri(uri)) {
+        throw new Error(`Unsupported remote skill source ${uri}`);
+    }
+    const response = await fetch(uri);
+    if (!response.ok) {
+        throw new Error(`Remote skill source ${uri} returned ${response.status}`);
+    }
+    const document = await response.text();
+    const skillName = sanitizeSkillDirName(parseSkillFrontmatterName(document)
+        ?? path.basename(new URL(uri).pathname).replace(/\.md$/i, "")
+        ?? "remote-skill");
+    const cacheRoot = remoteSkillCacheRoot(uri);
+    const skillRoot = path.join(cacheRoot, skillName);
+    await mkdir(skillRoot, { recursive: true });
+    await writeFile(path.join(skillRoot, "SKILL.md"), document, "utf8");
+    return skillRoot;
+}

package/dist/workspace/support/workspace-ref-utils.d.ts

@@ -44,6 +44,10 @@ export type RuntimeStorageRoots = {
 };
 export declare function getRuntimeStorageRoots(refs: Map<string, WorkspaceObject | ParsedAgentObject>, workspaceRoot: string): RuntimeStorageRoots;
 export declare function getRuntimeResources(refs: Map<string, WorkspaceObject | ParsedAgentObject>): string[];
+export declare function getRuntimeSources(refs: Map<string, WorkspaceObject | ParsedAgentObject>): {
+    tools: string[];
+    skills: string[];
+};
 export declare function getToolModuleDiscoveryConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): ToolModuleDiscoveryConfig;
 export declare function getRuntimeMemoryDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
 export declare function getProceduralMemoryDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;

package/dist/workspace/support/workspace-ref-utils.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
+import { readRuntimeSources } from "./source-protocols.js";
 function getRoutingObject(refs) {
     const runtimeDefaults = getRuntimeDefaults(refs);
     return typeof runtimeDefaults?.routing === "object" && runtimeDefaults.routing
@@ -60,6 +61,9 @@ export function getRuntimeResources(refs) {
         .filter((value) => typeof value === "string" && value.trim().length > 0)
         .map((value) => value.trim());
 }
+export function getRuntimeSources(refs) {
+    return readRuntimeSources(getRuntimeDefaults(refs));
+}
 export function getToolModuleDiscoveryConfig(refs) {
     const runtimeDefaults = getRuntimeDefaults(refs);
     const toolModuleDiscovery = typeof runtimeDefaults?.toolModuleDiscovery === "object" && runtimeDefaults.toolModuleDiscovery

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.306",
+  "version": "0.0.308",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",