@botbotgo/agent-harness 0.0.121 → 0.0.122

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.120";
+export declare const AGENT_HARNESS_VERSION = "0.0.121";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.120";
+export const AGENT_HARNESS_VERSION = "0.0.121";

package/dist/resource/isolation.js

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { cp, mkdir, readFile, rm, symlink } from "node:fs/promises";
+import { cp, mkdir, readFile, rm, stat, symlink } from "node:fs/promises";
 const isolatedResourceRootCache = new Map();
 function isolationCacheRoot() {
     return path.join(os.tmpdir(), "agent-harness-resource-isolation");
@@ -64,16 +64,39 @@ async function buildIsolatedResourceRoot(packageRoot) {
     await linkDeclaredDependencies(isolatedRoot, packageRoot, manifest);
     return isolatedRoot;
 }
+async function rebuildIsolatedResourcePackageRoot(packageRoot) {
+    const loading = buildIsolatedResourceRoot(packageRoot);
+    isolatedResourceRootCache.set(packageRoot, loading);
+    return loading;
+}
 export async function ensureIsolatedResourcePackageRoot(packageRoot) {
     const cached = isolatedResourceRootCache.get(packageRoot);
     if (cached) {
         return cached;
     }
-    const loading = buildIsolatedResourceRoot(packageRoot);
-    isolatedResourceRootCache.set(packageRoot, loading);
-    return loading;
+    return rebuildIsolatedResourcePackageRoot(packageRoot);
 }
 export async function resolveIsolatedResourceModulePath(packageRoot, sourcePath) {
-    const isolatedRoot = await ensureIsolatedResourcePackageRoot(packageRoot);
-    return path.join(isolatedRoot, path.relative(packageRoot, sourcePath));
+    const relativeSourcePath = path.relative(packageRoot, sourcePath);
+    let isolatedRoot = await ensureIsolatedResourcePackageRoot(packageRoot);
+    let isolatedSourcePath = path.join(isolatedRoot, relativeSourcePath);
+    if (await isIsolatedModuleSnapshotCurrent(sourcePath, isolatedSourcePath)) {
+        return isolatedSourcePath;
+    }
+    isolatedRoot = await rebuildIsolatedResourcePackageRoot(packageRoot);
+    isolatedSourcePath = path.join(isolatedRoot, relativeSourcePath);
+    if (await isIsolatedModuleSnapshotCurrent(sourcePath, isolatedSourcePath)) {
+        return isolatedSourcePath;
+    }
+    throw new Error(`Isolated resource module ${relativeSourcePath} is missing from ${isolatedRoot}. Rebuild completed but the source package snapshot is still incomplete.`);
+}
+async function isIsolatedModuleSnapshotCurrent(sourcePath, isolatedSourcePath) {
+    if (!existsSync(isolatedSourcePath)) {
+        return false;
+    }
+    const [sourceStat, isolatedStat] = await Promise.all([
+        stat(sourcePath),
+        stat(isolatedSourcePath),
+    ]);
+    return isolatedStat.size === sourceStat.size && isolatedStat.mtimeMs >= sourceStat.mtimeMs;
 }

package/dist/resource/resource-impl.js

@@ -10,7 +10,7 @@ import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
 import { isSupportedToolModulePath, loadToolModuleDefinition } from "../tool-modules.js";
 import { createMcpToolResolver, } from "./mcp-tool-support.js";
 import { resolveIsolatedResourceModulePath } from "./isolation.js";
-import { ensureExternalResourceSource, ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator } from "./sources.js";
+import { ensureExternalResourceSource, ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator, resolveResourcePackageRoot, } from "./sources.js";
 export { getOrCreateMcpClient, listRemoteMcpTools, readMcpServerConfig, } from "./mcp-tool-support.js";
 const resourceDir = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
@@ -219,6 +219,10 @@ function requireLocalResource(feature) {
 }
 const remoteResourceCache = new Map();
 async function findPackageRoot(startPath) {
+    const resourcePackageRoot = findEnclosingResourcePackageRoot(startPath);
+    if (resourcePackageRoot) {
+        return resourcePackageRoot;
+    }
     let current = path.dirname(startPath);
     for (;;) {
         try {
@@ -233,6 +237,24 @@ async function findPackageRoot(startPath) {
         current = parent;
     }
 }
+function findEnclosingResourcePackageRoot(startPath) {
+    let current = path.dirname(startPath);
+    for (;;) {
+        const resourcePackageRoot = resolveResourcePackageRoot(current);
+        if (resourcePackageRoot && isPathWithinRoot(startPath, resourcePackageRoot)) {
+            return resourcePackageRoot;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function isPathWithinRoot(targetPath, rootPath) {
+    const relative = path.relative(rootPath, targetPath);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
 const functionToolModuleCache = new Map();
 function readStringRecord(value) {
     if (typeof value !== "object" || !value) {

package/dist/runtime/adapter/resilience.js

@@ -22,9 +22,9 @@ export function resolveStreamIdleTimeout(binding) {
     }
     const invokeTimeout = resolveBindingTimeout(binding);
     if (invokeTimeout) {
-        return Math.min(invokeTimeout, 15_000);
+        return Math.min(invokeTimeout, 60_000);
     }
-    return 15_000;
+    return 60_000;
 }
 export function resolveProviderRetryPolicy(binding) {
     const resilience = typeof binding.harnessRuntime.resilience === "object" && binding.harnessRuntime.resilience

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.121",
+  "version": "0.0.122",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",