@botbotgo/agent-harness 0.0.24 → 0.0.25

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.23";
+export declare const AGENT_HARNESS_VERSION = "0.0.24";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.23";
+export const AGENT_HARNESS_VERSION = "0.0.24";

package/dist/resource/resource-impl.js

@@ -1,9 +1,10 @@
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { stat } from "node:fs/promises";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { CompositeBackend, LocalShellBackend, StateBackend, StoreBackend } from "deepagents";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -62,6 +63,113 @@ function createProviderBackendResolver(provider, workspace) {
     return (provider?.createResourceBackendResolver?.(workspace) ??
         provider?.createBuiltinBackendResolver?.(workspace));
 }
+class CompatibleCompositeBackend {
+    id;
+    execute;
+    composite;
+    constructor(defaultBackend, routes) {
+        this.composite = new CompositeBackend(defaultBackend, routes);
+        const sandboxLike = defaultBackend;
+        if (typeof sandboxLike.id === "string" && typeof sandboxLike.execute === "function") {
+            this.id = sandboxLike.id;
+            this.execute = (command) => this.composite.execute(command);
+        }
+    }
+    lsInfo(filePath) {
+        return this.composite.lsInfo(filePath);
+    }
+    read(filePath, offset, limit) {
+        return this.composite.read(filePath, offset, limit);
+    }
+    readRaw(filePath) {
+        return this.composite.readRaw(filePath);
+    }
+    grepRaw(pattern, filePath, glob) {
+        return this.composite.grepRaw(pattern, filePath ?? undefined, glob ?? undefined);
+    }
+    globInfo(pattern, filePath) {
+        return this.composite.globInfo(pattern, filePath);
+    }
+    write(filePath, content) {
+        return this.composite.write(filePath, content);
+    }
+    edit(filePath, oldString, newString, replaceAll) {
+        return this.composite.edit(filePath, oldString, newString, replaceAll);
+    }
+    uploadFiles(files) {
+        return this.composite.uploadFiles(files);
+    }
+    downloadFiles(paths) {
+        return this.composite.downloadFiles(paths);
+    }
+}
+function createInlineBackendResolver(workspace) {
+    return (binding) => {
+        const backendConfig = binding.deepAgentParams?.backend;
+        if (!backendConfig || typeof backendConfig !== "object") {
+            return undefined;
+        }
+        const resolveBackendRootDir = (configuredRootDir) => {
+            if (typeof configuredRootDir === "string" && configuredRootDir.trim().length > 0) {
+                return path.isAbsolute(configuredRootDir)
+                    ? configuredRootDir
+                    : path.resolve(workspace.workspaceRoot, configuredRootDir);
+            }
+            return workspace.workspaceRoot;
+        };
+        const createBackend = (kind, config, runtimeLike) => {
+            switch (kind) {
+                case "LocalShellBackend": {
+                    const rootDir = resolveBackendRootDir(config?.rootDir);
+                    mkdirSync(rootDir, { recursive: true });
+                    return new LocalShellBackend({
+                        rootDir,
+                        virtualMode: config?.virtualMode === true,
+                        timeout: typeof config?.timeout === "number" ? config.timeout : undefined,
+                        maxOutputBytes: typeof config?.maxOutputBytes === "number" ? config.maxOutputBytes : undefined,
+                        env: typeof config?.env === "object" && config.env
+                            ? Object.fromEntries(Object.entries(config.env).filter((entry) => typeof entry[1] === "string"))
+                            : undefined,
+                        inheritEnv: config?.inheritEnv !== false,
+                    });
+                }
+                case "StateBackend":
+                    return new StateBackend(runtimeLike);
+                case "StoreBackend":
+                    return new StoreBackend(runtimeLike);
+                default:
+                    throw new Error(`Unsupported DeepAgent backend kind "${kind}". Supported inline kinds: LocalShellBackend, StateBackend, StoreBackend, CompositeBackend.`);
+            }
+        };
+        return (runtimeLike) => {
+            const kind = typeof backendConfig.kind === "string" ? backendConfig.kind : "CompositeBackend";
+            switch (kind) {
+                case "LocalShellBackend":
+                    return createBackend("LocalShellBackend", backendConfig, runtimeLike);
+                case "StateBackend":
+                    return new StateBackend(runtimeLike);
+                case "StoreBackend":
+                    return new StoreBackend(runtimeLike);
+                case "CompositeBackend": {
+                    const stateConfig = typeof backendConfig.state === "object" && backendConfig.state
+                        ? backendConfig.state
+                        : { kind: "StateBackend" };
+                    const defaultBackendKind = typeof stateConfig.kind === "string" ? stateConfig.kind : "StateBackend";
+                    const routes = typeof backendConfig.routes === "object" && backendConfig.routes
+                        ? backendConfig.routes
+                        : { "/memories/": { kind: "StoreBackend" } };
+                    const mappedRoutes = Object.fromEntries(Object.entries(routes).map(([route, routeConfig]) => {
+                        const routeKind = typeof routeConfig?.kind === "string" ? routeConfig.kind : "StoreBackend";
+                        return [route, createBackend(routeKind, routeConfig, runtimeLike)];
+                    }));
+                    return new CompatibleCompositeBackend(createBackend(defaultBackendKind, stateConfig, runtimeLike), mappedRoutes);
+                }
+                default:
+                    throw new Error(`Unsupported DeepAgent backend kind "${kind}". Supported inline kinds: LocalShellBackend, StateBackend, StoreBackend, CompositeBackend.`);
+            }
+        };
+    };
+}
 function requireLocalResource(feature) {
     if (localResource) {
         return localResource;
@@ -385,7 +493,17 @@ export async function listResourceToolsForSource(source, workspaceRoot = process
 }
 export function createResourceBackendResolver(workspace) {
     const localResolver = createProviderBackendResolver(localResource, workspace);
-    return (binding) => localResolver?.(binding);
+    const remoteResolvers = (workspace.resourceSources ?? workspace.builtinSources ?? [])
+        .map((source) => remoteResourceCache.get(source))
+        .filter((provider) => Boolean(provider))
+        .map((provider) => createProviderBackendResolver(provider, workspace))
+        .filter((resolver) => Boolean(resolver));
+    const inlineResolver = createInlineBackendResolver(workspace);
+    return (binding) => {
+        const providerResolved = localResolver?.(binding) ??
+            remoteResolvers.map((resolver) => resolver(binding)).find((resolved) => resolved !== undefined);
+        return providerResolved ?? inlineResolver(binding);
+    };
 }
 export function createResourceToolResolver(workspace, options = {}) {
     const functionResolver = createFunctionToolResolver(workspace);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "description": "Agent Harness framework package",
   "type": "module",
   "packageManager": "npm@10.9.2",