@botbotgo/agent-harness 0.0.98 → 0.0.100

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

@@ -0,0 +1,64 @@
+export type BuiltinMiddlewareBackend = {
+    lsInfo?: (path: string) => Promise<Array<{
+        path: string;
+        is_dir?: boolean;
+        size?: number;
+    }>> | Array<{
+        path: string;
+        is_dir?: boolean;
+        size?: number;
+    }>;
+    read?: (filePath: string, offset?: number, limit?: number) => Promise<string> | string;
+    write?: (filePath: string, content: string) => Promise<{
+        error?: string;
+        path?: string;
+        metadata?: Record<string, unknown>;
+    }> | {
+        error?: string;
+        path?: string;
+        metadata?: Record<string, unknown>;
+    };
+    edit?: (filePath: string, oldString: string, newString: string, replaceAll?: boolean) => Promise<{
+        error?: string;
+        path?: string;
+        occurrences?: number;
+        metadata?: Record<string, unknown>;
+    }> | {
+        error?: string;
+        path?: string;
+        occurrences?: number;
+        metadata?: Record<string, unknown>;
+    };
+    globInfo?: (pattern: string, path?: string) => Promise<Array<{
+        path: string;
+    }>> | Array<{
+        path: string;
+    }>;
+    grepRaw?: (pattern: string, path?: string | null, glob?: string | null) => Promise<Array<{
+        path: string;
+        line: number;
+        text: string;
+    }> | string> | Array<{
+        path: string;
+        line: number;
+        text: string;
+    }> | string;
+    execute?: (command: string) => Promise<{
+        output: string;
+        exitCode: number | null;
+        truncated: boolean;
+    }> | {
+        output: string;
+        exitCode: number | null;
+        truncated: boolean;
+    };
+};
+export type BuiltinExecutableTool = {
+    name: string;
+    schema: unknown;
+    invoke: (input: unknown) => Promise<unknown>;
+};
+export declare function createBuiltinMiddlewareTools(backend: BuiltinMiddlewareBackend, options: {
+    includeTaskTool: boolean;
+    invokeTaskTool?: (input: unknown) => Promise<unknown>;
+}): Promise<Map<string, BuiltinExecutableTool>>;

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

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import { isSandboxBackend } from "deepagents";
+import { summarizeBuiltinWriteTodosArgs, truncateLines, isObject } from "../runtime-adapter-support.js";
+export async function createBuiltinMiddlewareTools(backend, options) {
+    const tools = new Map();
+    tools.set("write_todos", {
+        name: "write_todos",
+        schema: z.object({
+            todos: z.array(z.object({}).passthrough()).optional(),
+        }).passthrough(),
+        invoke: async (input) => {
+            const args = isObject(input) ? input : {};
+            const summary = summarizeBuiltinWriteTodosArgs(args);
+            return {
+                ok: true,
+                tool: "write_todos",
+                message: `Tracked ${summary.total} todo item(s).`,
+                summary,
+            };
+        },
+    });
+    tools.set("ls", {
+        name: "ls",
+        schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
+        invoke: async (input) => {
+            const targetPath = isObject(input) && typeof input.path === "string" ? input.path : "/";
+            const infos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
+            if (infos.length === 0) {
+                return `No files found in ${targetPath}`;
+            }
+            return truncateLines(infos.map((info) => info.is_dir ? `${info.path} (directory)` : `${info.path}${info.size ? ` (${info.size} bytes)` : ""}`));
+        },
+    });
+    tools.set("read_file", {
+        name: "read_file",
+        schema: z.object({
+            file_path: z.string(),
+            offset: z.number().optional(),
+            limit: z.number().optional(),
+        }).passthrough(),
+        invoke: async (input) => {
+            const typed = isObject(input) ? input : {};
+            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)) ?? "";
+        },
+    });
+    tools.set("write_file", {
+        name: "write_file",
+        schema: z.object({ file_path: z.string(), content: z.string().optional() }).passthrough(),
+        invoke: async (input) => {
+            const typed = isObject(input) ? input : {};
+            const result = await Promise.resolve(backend.write?.(typeof typed.file_path === "string" ? typed.file_path : "", typeof typed.content === "string" ? typed.content : ""));
+            return result?.error ?? `Successfully wrote to '${result?.path ?? (typed.file_path ?? "")}'`;
+        },
+    });
+    tools.set("edit_file", {
+        name: "edit_file",
+        schema: z.object({
+            file_path: z.string(),
+            old_string: z.string(),
+            new_string: z.string(),
+            replace_all: z.boolean().optional(),
+        }).passthrough(),
+        invoke: async (input) => {
+            const typed = isObject(input) ? input : {};
+            const result = await Promise.resolve(backend.edit?.(typeof typed.file_path === "string" ? typed.file_path : "", typeof typed.old_string === "string" ? typed.old_string : "", typeof typed.new_string === "string" ? typed.new_string : "", typed.replace_all === true));
+            return result?.error ?? `Successfully replaced ${result?.occurrences ?? 0} occurrence(s) in '${result?.path ?? (typed.file_path ?? "")}'`;
+        },
+    });
+    tools.set("glob", {
+        name: "glob",
+        schema: z.object({ pattern: z.string(), path: z.string().optional().default("/") }).passthrough(),
+        invoke: async (input) => {
+            const typed = isObject(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))) ?? [];
+            if (infos.length === 0) {
+                return `No files found matching pattern '${pattern}'`;
+            }
+            return truncateLines(infos.map((info) => info.path));
+        },
+    });
+    tools.set("grep", {
+        name: "grep",
+        schema: z.object({
+            pattern: z.string(),
+            path: z.string().optional().default("/"),
+            glob: z.string().nullable().optional(),
+        }).passthrough(),
+        invoke: async (input) => {
+            const typed = isObject(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;
+            }
+            if (!result || result.length === 0) {
+                return `No matches found for pattern '${typeof typed.pattern === "string" ? typed.pattern : ""}'`;
+            }
+            const lines = [];
+            let currentFile = "";
+            for (const match of result) {
+                if (match.path !== currentFile) {
+                    currentFile = match.path;
+                    lines.push(`\n${currentFile}:`);
+                }
+                lines.push(`  ${match.line}: ${match.text}`);
+            }
+            return truncateLines(lines);
+        },
+    });
+    tools.set("execute", {
+        name: "execute",
+        schema: z.object({ command: z.string() }).passthrough(),
+        invoke: async (input) => {
+            if (!isSandboxBackend(backend) || typeof backend.execute !== "function") {
+                return "Error: Execution not available. This agent's backend does not support command execution (SandboxBackendProtocol).";
+            }
+            const typed = isObject(input) ? input : {};
+            const result = await Promise.resolve(backend.execute(typeof typed.command === "string" ? typed.command : ""));
+            const parts = [result.output];
+            if (result.exitCode !== null) {
+                parts.push(`\n[Command ${result.exitCode === 0 ? "succeeded" : "failed"} with exit code ${result.exitCode}]`);
+            }
+            if (result.truncated) {
+                parts.push("\n[Output was truncated due to size limits]");
+            }
+            return parts.join("");
+        },
+    });
+    if (options.includeTaskTool && options.invokeTaskTool) {
+        tools.set("task", {
+            name: "task",
+            schema: z.object({
+                description: z.string(),
+                subagent_type: z.string(),
+            }).passthrough(),
+            invoke: options.invokeTaskTool,
+        });
+    }
+    return tools;
+}

package/dist/runtime/adapter/tool/tool-replay.d.ts

@@ -0,0 +1,18 @@
+import type { CompiledAgentBinding, CompiledTool } from "../../../contracts/types.js";
+import type { ToolNameMapping } from "./tool-name-mapping.js";
+type ExecutableToolRecord = {
+    name: string;
+    schema: unknown;
+    invoke: (input: unknown) => Promise<unknown>;
+};
+type BuiltinExecutableTool = {
+    name: string;
+    schema: unknown;
+    invoke: (input: unknown) => Promise<unknown>;
+};
+export declare function canReplayToolCallsLocally(binding: CompiledAgentBinding, toolCalls: Array<{
+    id?: string;
+    name: string;
+    args: Record<string, unknown>;
+}>, primaryTools: CompiledTool[], toolNameMapping: ToolNameMapping, executableTools: Map<string, ExecutableToolRecord>, builtinExecutableTools: Map<string, BuiltinExecutableTool>): boolean;
+export {};

package/dist/runtime/adapter/tool/tool-replay.js

@@ -0,0 +1,26 @@
+import { createModelFacingToolNameLookupCandidates, resolveModelFacingToolName } from "./tool-name-mapping.js";
+import { isLangChainBinding } from "../../support/compiled-binding.js";
+export function canReplayToolCallsLocally(binding, toolCalls, primaryTools, toolNameMapping, executableTools, builtinExecutableTools) {
+    if (toolCalls.length === 0) {
+        return false;
+    }
+    if (isLangChainBinding(binding)) {
+        return true;
+    }
+    return toolCalls.every((toolCall) => {
+        const resolvedToolName = resolveModelFacingToolName(toolCall.name, toolNameMapping, primaryTools);
+        if (resolvedToolName === "task" || toolCall.name === "task") {
+            return false;
+        }
+        const executable = executableTools.get(toolCall.name) ?? executableTools.get(resolvedToolName);
+        if (executable) {
+            return false;
+        }
+        const builtinExecutable = builtinExecutableTools.get(toolCall.name) ??
+            builtinExecutableTools.get(resolvedToolName) ??
+            createModelFacingToolNameLookupCandidates(toolCall.name)
+                .map((candidate) => builtinExecutableTools.get(candidate))
+                .find((candidate) => candidate !== undefined);
+        return builtinExecutable !== undefined;
+    });
+}

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -20,7 +20,6 @@ export declare class AgentRuntimeAdapter {
     private readonly options;
     private readonly modelCache;
     private readonly runnableCache;
-    private readonly langGraphSessions;
     constructor(options?: RuntimeAdapterOptions);
     private getModelCacheKey;
     private invokeWithProviderRetry;
@@ -41,60 +40,20 @@ export declare class AgentRuntimeAdapter {
     private resolveBuiltinMiddlewareBackend;
     private invokeBuiltinTaskTool;
     private resolveBuiltinMiddlewareTools;
-    private canReplayToolCallsLocally;
     private resolveAutomaticSummarizationMiddleware;
     private resolveLangChainAutomaticMiddleware;
     private resolveDeepAgentAutomaticMiddleware;
     private resolveMiddleware;
     private resolveCheckpointer;
-    private resolveLangGraphWorkflowCheckpointer;
-    private buildRouteSystemPrompt;
     private resolveSubagents;
     private createLangChainRunnable;
-    private normalizeLangGraphWorkflowNode;
-    private invokeLangGraphToolNode;
-    private listLangGraphWorkflowNodes;
-    private normalizeLangGraphWorkflowEdge;
-    private listLangGraphWorkflowEdges;
-    private shouldFollowLangGraphEdge;
-    private listLangGraphWorkflowNextNodes;
     private extractInvocationRequestText;
     private prependSystemMessage;
     private replaceLastUserMessage;
-    private resolveLangGraphSessionKey;
-    private resolveLangGraphSessionIdentity;
-    private langGraphCheckpointNamespace;
-    private langGraphCheckpointConfig;
-    private buildLangGraphWorkflowCheckpoint;
-    private saveLangGraphSessionToCheckpointer;
-    private loadLangGraphSessionFromCheckpointer;
-    private clearLangGraphSessionInCheckpointer;
-    private langGraphSessionFilePath;
-    private artifactLangGraphSessionFilePath;
-    private legacyLangGraphSessionFilePath;
-    private saveLangGraphSession;
-    private loadLangGraphSession;
-    private clearLangGraphSession;
-    private invokeWorkflowNodeModel;
-    private invokeLangGraphAgentNode;
-    private createLangGraphRunnable;
     private extractExecutedToolResults;
-    private extractLangGraphResultOutput;
-    private streamLangGraphWorkflow;
     private createRunnable;
+    private createDeepAgentRunnable;
     create(binding: CompiledAgentBinding): Promise<RunnableLike>;
-    route(input: MessageContent, primaryBinding: CompiledAgentBinding, secondaryBinding: CompiledAgentBinding, options?: {
-        systemPrompt?: string;
-    }): Promise<string>;
-    reviewRunResult(binding: CompiledAgentBinding, input: MessageContent, result: Pick<RunResult, "output" | "state" | "finalMessageText">): Promise<{
-        assessment: string;
-        modelId: string;
-    } | null>;
-    synthesizeFinalResult(binding: CompiledAgentBinding, input: MessageContent, result: Pick<RunResult, "output" | "state" | "finalMessageText">): Promise<{
-        output: string;
-        finalMessageText: string;
-        modelId: string;
-    } | null>;
     invoke(binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string, resumePayload?: unknown, history?: TranscriptMessage[], options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;