@botbotgo/agent-harness 0.0.23 → 0.0.25

package/README.md

@@ -195,6 +195,8 @@ const server = await createToolMcpServer(harness, { agentId: "orchestra" });
 await serveToolsOverStdio(harness, { agentId: "orchestra" });
 ```
 
+If you omit `serverInfo`, the harness uses `agent-harness-<agentId>` as the MCP server name and the current package version as the server version.
+
 ### Read Back Thread State
 
 ```ts

package/dist/mcp.js

@@ -2,6 +2,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { pathToFileURL } from "node:url";
 import { z } from "zod";
+import { AGENT_HARNESS_VERSION } from "./package-version.js";
 import { loadToolModuleDefinition } from "./tool-modules.js";
 function asResolvedTool(value) {
     return typeof value === "object" && value !== null ? value : null;
@@ -86,7 +87,7 @@ function jsonSchemaToZod(schema) {
 export async function createToolMcpServerFromHarness(harness, options) {
     const server = new McpServer({
         name: options.serverInfo?.name ?? `agent-harness-${options.agentId}`,
-        version: options.serverInfo?.version ?? "0.0.16",
+        version: options.serverInfo?.version ?? AGENT_HARNESS_VERSION,
     });
     const allowedNames = options.includeToolNames ? new Set(options.includeToolNames) : null;
     for (const { compiledTool, resolvedTool } of harness.resolveAgentTools(options.agentId)) {

package/dist/package-version.d.ts

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

package/dist/package-version.js

@@ -0,0 +1 @@
+export const AGENT_HARNESS_VERSION = "0.0.24";

package/dist/resource/resource-impl.js

@@ -1,14 +1,16 @@
-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";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
+import { AGENT_HARNESS_VERSION } from "../package-version.js";
 import { isSupportedToolModulePath, loadToolModuleDefinition } from "../tool-modules.js";
 import { resolveIsolatedResourceModulePath } from "./isolation.js";
 import { ensureExternalResourceSource, ensureExternalSource, isExternalSourceLocator, parseExternalSourceLocator } from "./sources.js";
@@ -61,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;
@@ -176,7 +285,7 @@ export async function getOrCreateMcpClient(config) {
     const loading = (async () => {
         const client = new Client({
             name: "agent-harness",
-            version: "0.0.16",
+            version: AGENT_HARNESS_VERSION,
         });
         const headers = {
             ...(config.headers ?? {}),
@@ -384,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.23",
+  "version": "0.0.25",
   "description": "Agent Harness framework package",
   "type": "module",
   "packageManager": "npm@10.9.2",