@botbotgo/agent-harness 0.0.228 → 0.0.229

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.227";
+export declare const AGENT_HARNESS_VERSION = "0.0.228";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.227";
+export const AGENT_HARNESS_VERSION = "0.0.228";

package/dist/resource/resource-impl.js

@@ -5,7 +5,7 @@ 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 { CompositeBackend, LangSmithSandbox, LocalShellBackend, StateBackend, StoreBackend } from "deepagents";
 import { getBindingBackendConfig, getBindingExecutionView, getBindingPrimaryModel } from "../runtime/support/compiled-binding.js";
 import { resolveCompiledEmbeddingModelRef } from "../runtime/support/embedding-models.js";
 import { createRuntimeEnv } from "../runtime/support/runtime-env.js";
@@ -133,7 +133,60 @@ class CompatibleCompositeBackend {
         return this.composite.downloadFiles(paths);
     }
 }
-const INLINE_BACKEND_ERROR = 'Unsupported DeepAgent backend kind "%s". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend.';
+function omitKind(config) {
+    const { kind: _kind, ...rest } = config ?? {};
+    return rest;
+}
+class LazyLangSmithSandbox {
+    config;
+    sandboxPromise = null;
+    constructor(config) {
+        this.config = config;
+    }
+    get id() {
+        return "langsmith-pending";
+    }
+    get isRunning() {
+        return this.sandboxPromise !== null;
+    }
+    getSandbox() {
+        if (!this.sandboxPromise) {
+            this.sandboxPromise = LangSmithSandbox.create(omitKind(this.config));
+        }
+        return this.sandboxPromise;
+    }
+    async read(filePath, offset, limit) {
+        return (await this.getSandbox()).read(filePath, offset, limit);
+    }
+    async edit(filePath, oldString, newString, replaceAll) {
+        return (await this.getSandbox()).edit(filePath, oldString, newString, replaceAll);
+    }
+    async ls(dirPath) {
+        return (await this.getSandbox()).ls(dirPath);
+    }
+    async glob(pattern, searchPath) {
+        return (await this.getSandbox()).glob(pattern, searchPath);
+    }
+    async write(filePath, content) {
+        return (await this.getSandbox()).write(filePath, content);
+    }
+    async execute(command) {
+        return (await this.getSandbox()).execute(command);
+    }
+    async uploadFiles(files) {
+        return (await this.getSandbox()).uploadFiles(files);
+    }
+    async downloadFiles(paths) {
+        return (await this.getSandbox()).downloadFiles(paths);
+    }
+    async close() {
+        if (!this.sandboxPromise) {
+            return;
+        }
+        await (await this.sandboxPromise).close();
+    }
+}
+const INLINE_BACKEND_ERROR = 'Unsupported DeepAgent backend kind "%s". Supported inline kinds: LocalShellBackend, VfsSandbox, StateBackend, StoreBackend, CompositeBackend, LangSmithSandbox.';
 function unsupportedInlineBackend(kind) {
     throw new Error(INLINE_BACKEND_ERROR.replace("%s", kind));
 }
@@ -172,6 +225,8 @@ function createInlineBackendInstance(workspaceRoot, kind, config, runtimeLike) {
             return new StateBackend(runtimeLike);
         case "StoreBackend":
             return new StoreBackend(runtimeLike);
+        case "LangSmithSandbox":
+            return new LazyLangSmithSandbox(config);
         default:
             return unsupportedInlineBackend(kind);
     }
@@ -193,6 +248,8 @@ function createInlineBackendResolver(workspace) {
                     return createInlineBackendInstance(workspace.workspaceRoot, "StateBackend", backendConfig, runtimeLike);
                 case "StoreBackend":
                     return createInlineBackendInstance(workspace.workspaceRoot, "StoreBackend", backendConfig, runtimeLike);
+                case "LangSmithSandbox":
+                    return createInlineBackendInstance(workspace.workspaceRoot, "LangSmithSandbox", backendConfig, runtimeLike);
                 case "CompositeBackend": {
                     const stateConfig = typeof backendConfig.state === "object" && backendConfig.state
                         ? backendConfig.state

package/dist/runtime/adapter/tool/builtin-middleware-tools.d.ts

@@ -8,7 +8,28 @@ export type BuiltinMiddlewareBackend = {
         is_dir?: boolean;
         size?: number;
     }>;
-    read?: (filePath: string, offset?: number, limit?: number) => Promise<string> | string;
+    ls?: (path: string) => Promise<{
+        files?: Array<{
+            path: string;
+            isDir?: boolean;
+            size?: number;
+        }>;
+        error?: string;
+    }> | {
+        files?: Array<{
+            path: string;
+            isDir?: boolean;
+            size?: number;
+        }>;
+        error?: string;
+    };
+    read?: (filePath: string, offset?: number, limit?: number) => Promise<string | {
+        content?: string | Uint8Array;
+        error?: string;
+    }> | string | {
+        content?: string | Uint8Array;
+        error?: string;
+    };
     write?: (filePath: string, content: string) => Promise<{
         error?: string;
         path?: string;
@@ -34,6 +55,17 @@ export type BuiltinMiddlewareBackend = {
     }>> | Array<{
         path: string;
     }>;
+    glob?: (pattern: string, path?: string) => Promise<{
+        files?: Array<{
+            path: string;
+        }>;
+        error?: string;
+    }> | {
+        files?: Array<{
+            path: string;
+        }>;
+        error?: string;
+    };
     grepRaw?: (pattern: string, path?: string | null, glob?: string | null) => Promise<Array<{
         path: string;
         line: number;
@@ -43,6 +75,27 @@ export type BuiltinMiddlewareBackend = {
         line: number;
         text: string;
     }> | string;
+    grep?: (pattern: string, path?: string | null, glob?: string | null) => Promise<{
+        matches?: Array<{
+            path: string;
+            lineNumber?: number;
+            line_number?: number;
+            content?: string;
+            line?: number;
+            text?: string;
+        }>;
+        error?: string;
+    }> | {
+        matches?: Array<{
+            path: string;
+            lineNumber?: number;
+            line_number?: number;
+            content?: string;
+            line?: number;
+            text?: string;
+        }>;
+        error?: string;
+    };
     execute?: (command: string) => Promise<{
         output: string;
         exitCode: number | null;

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -2,6 +2,15 @@ import { z } from "zod";
 import { isSandboxBackend } from "deepagents";
 import { isRecord } from "../../../utils/object.js";
 import { summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
+function toDisplayContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (content instanceof Uint8Array) {
+        return new TextDecoder().decode(content);
+    }
+    return "";
+}
 export async function createBuiltinMiddlewareTools(backend, options) {
     const tools = new Map();
     tools.set("write_todos", {
@@ -25,7 +34,14 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
         invoke: async (input) => {
             const targetPath = isRecord(input) && typeof input.path === "string" ? input.path : "/";
-            const infos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
+            const legacyInfos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
+            const infos = legacyInfos.length > 0
+                ? legacyInfos
+                : ((await Promise.resolve(backend.ls?.(targetPath)))?.files ?? []).map((info) => ({
+                    path: info.path,
+                    is_dir: info.isDir,
+                    size: info.size,
+                }));
             if (infos.length === 0) {
                 return `No files found in ${targetPath}`;
             }
@@ -44,7 +60,11 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             const filePath = typeof typed.file_path === "string" ? typed.file_path : "";
             const offset = typeof typed.offset === "number" ? typed.offset : 0;
             const limit = typeof typed.limit === "number" ? typed.limit : 500;
-            return Promise.resolve(backend.read?.(filePath, offset, limit)) ?? "";
+            const result = await Promise.resolve(backend.read?.(filePath, offset, limit));
+            if (typeof result === "string") {
+                return result;
+            }
+            return toDisplayContent(result?.content);
         },
     });
     tools.set("write_file", {
@@ -77,7 +97,10 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             const typed = isRecord(input) ? input : {};
             const pattern = typeof typed.pattern === "string" ? typed.pattern : "";
             const targetPath = typeof typed.path === "string" ? typed.path : "/";
-            const infos = (await Promise.resolve(backend.globInfo?.(pattern, targetPath))) ?? [];
+            const legacyInfos = (await Promise.resolve(backend.globInfo?.(pattern, targetPath))) ?? [];
+            const infos = legacyInfos.length > 0
+                ? legacyInfos
+                : ((await Promise.resolve(backend.glob?.(pattern, targetPath)))?.files ?? []);
             if (infos.length === 0) {
                 return `No files found matching pattern '${pattern}'`;
             }
@@ -93,16 +116,23 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         }).passthrough(),
         invoke: async (input) => {
             const typed = isRecord(input) ? input : {};
-            const result = await Promise.resolve(backend.grepRaw?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
-            if (typeof result === "string") {
-                return result;
+            const legacyResult = await Promise.resolve(backend.grepRaw?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
+            const structuredResult = await Promise.resolve(backend.grep?.(typeof typed.pattern === "string" ? typed.pattern : "", typeof typed.path === "string" ? typed.path : "/", typeof typed.glob === "string" ? typed.glob : null));
+            const normalizedStructuredMatches = structuredResult?.matches?.map((match) => ({
+                path: match.path,
+                line: match.lineNumber ?? match.line_number ?? match.line ?? 0,
+                text: match.content ?? match.text ?? "",
+            }));
+            const normalizedResult = legacyResult ?? normalizedStructuredMatches;
+            if (typeof normalizedResult === "string") {
+                return normalizedResult;
             }
-            if (!result || result.length === 0) {
+            if (!normalizedResult || normalizedResult.length === 0) {
                 return `No matches found for pattern '${typeof typed.pattern === "string" ? typed.pattern : ""}'`;
             }
             const lines = [];
             let currentFile = "";
-            for (const match of result) {
+            for (const match of normalizedResult) {
                 if (match.path !== currentFile) {
                     currentFile = match.path;
                     lines.push(`\n${currentFile}:`);

package/dist/runtime/adapter/tool/declared-middleware.js

@@ -1,5 +1,5 @@
 import { anthropicPromptCachingMiddleware, contextEditingMiddleware, dynamicSystemPromptMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, modelCallLimitMiddleware, modelFallbackMiddleware, modelRetryMiddleware, openAIModerationMiddleware, piiMiddleware, piiRedactionMiddleware, summarizationMiddleware, todoListMiddleware, toolCallLimitMiddleware, toolEmulatorMiddleware, toolRetryMiddleware, } from "langchain";
-import { createFilesystemMiddleware, createPatchToolCallsMiddleware, createSummarizationMiddleware as createDeepAgentSummarizationMiddleware, } from "deepagents";
+import { createCompletionCallbackMiddleware, createFilesystemMiddleware, createPatchToolCallsMiddleware, createSummarizationMiddleware as createDeepAgentSummarizationMiddleware, } from "deepagents";
 function asMiddlewareConfig(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : null;
 }
@@ -84,6 +84,7 @@ async function createFilesystemDeclarativeMiddleware({ config, resolveFilesystem
     return createFilesystemMiddleware(runtimeConfig);
 }
 export const DECLARATIVE_MIDDLEWARE_REGISTRY = {
+    completionCallback: async ({ config }) => createCompletionCallbackMiddleware(config),
     filesystem: createFilesystemDeclarativeMiddleware,
     patchToolCalls: async () => createPatchToolCallsMiddleware(),
     summarization: createBindingAwareSummarizationMiddleware,

package/dist/workspace/validate.js

@@ -39,6 +39,9 @@ function validateMiddlewareConfig(agent) {
         if (kind === "humanInTheLoop" && typeof typed.interruptOn !== "object") {
             throw new Error(`Agent ${agent.id} humanInTheLoop middleware requires interruptOn`);
         }
+        if (kind === "completionCallback" && typeof typed.callbackGraphId !== "string") {
+            throw new Error(`Agent ${agent.id} completionCallback middleware requires callbackGraphId`);
+        }
         if (kind === "filesystem" && agent.executionMode === "deepagent") {
             throw new Error(`Agent ${agent.id} cannot use filesystem middleware with DeepAgents; configure filesystem behavior through the deepagent backend instead`);
         }

package/package.json

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