@botbotgo/agent-harness 0.0.99 → 0.0.101

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

@@ -0,0 +1,18 @@
+import type { CompiledAgentBinding } from "../../contracts/types.js";
+export declare function countConfiguredTools(binding: CompiledAgentBinding): number;
+export declare function asObject(value: unknown): Record<string, unknown> | undefined;
+export declare function sleep(ms: number): Promise<void>;
+export declare function hasConfiguredSubagentSupport(binding: CompiledAgentBinding): boolean;
+export declare function hasConfiguredMiddlewareKind(binding: CompiledAgentBinding, kind: string): boolean;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function truncateLines(lines: string[], maxChars?: number): string;
+export declare function summarizeBuiltinWriteTodosArgs(args: Record<string, unknown>): {
+    total: number;
+    pending: number;
+    completed: number;
+    items: Array<{
+        content: string;
+        status: string;
+    }>;
+};

package/dist/runtime/adapter/runtime-adapter-support.js

@@ -0,0 +1,54 @@
+import { getBindingLangChainParams, getBindingMiddlewareConfigs, getBindingPrimaryTools } from "../support/compiled-binding.js";
+export function countConfiguredTools(binding) {
+    return getBindingPrimaryTools(binding).length;
+}
+export function asObject(value) {
+    return typeof value === "object" && value ? value : undefined;
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function hasConfiguredSubagentSupport(binding) {
+    const params = getBindingLangChainParams(binding);
+    if (!params) {
+        return false;
+    }
+    return (params.subagents?.length ?? 0) > 0 || params.generalPurposeAgent === true || Boolean(params.taskDescription?.trim());
+}
+export function hasConfiguredMiddlewareKind(binding, kind) {
+    return getBindingMiddlewareConfigs(binding)?.some((entry) => entry.kind === kind) ?? false;
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isObject(value) {
+    return isRecord(value);
+}
+export function truncateLines(lines, maxChars = 12_000) {
+    const joined = lines.join("\n");
+    if (joined.length <= maxChars) {
+        return joined;
+    }
+    return `${joined.slice(0, maxChars - 18)}\n...[truncated]`;
+}
+export function summarizeBuiltinWriteTodosArgs(args) {
+    const todos = Array.isArray(args.todos) ? args.todos : [];
+    const items = todos.flatMap((todo) => {
+        if (!isObject(todo)) {
+            return [];
+        }
+        const content = typeof todo.content === "string" && todo.content.trim().length > 0
+            ? todo.content.trim()
+            : typeof todo.description === "string" && todo.description.trim().length > 0
+                ? todo.description.trim()
+                : "";
+        const status = typeof todo.status === "string" && todo.status.trim().length > 0 ? todo.status.trim() : "pending";
+        return content ? [{ content, status }] : [];
+    });
+    return {
+        total: items.length,
+        pending: items.filter((item) => item.status !== "completed").length,
+        completed: items.filter((item) => item.status === "completed").length,
+        items,
+    };
+}

package/dist/runtime/adapter/stream-event-projection.d.ts

@@ -0,0 +1,19 @@
+import type { CompiledTool } from "../../contracts/types.js";
+import { type RuntimeStreamChunk } from "../parsing/stream-event-parsing.js";
+import { type ToolNameMapping } from "./tool/tool-name-mapping.js";
+export type StreamEventProjectionState = {
+    emittedOutput: string;
+    emittedToolError: boolean;
+    emittedToolResult: boolean;
+    seenTerminalOutputs: Set<string>;
+    lastStep: string;
+};
+export declare function createStreamEventProjectionState(): StreamEventProjectionState;
+export declare function projectRuntimeStreamEvent(params: {
+    event: unknown;
+    allowVisibleStreamDeltas: boolean;
+    includeStateStreamOutput: boolean;
+    toolNameMapping: ToolNameMapping;
+    primaryTools: CompiledTool[];
+    state: StreamEventProjectionState;
+}): RuntimeStreamChunk[];

package/dist/runtime/adapter/stream-event-projection.js

@@ -0,0 +1,79 @@
+import { sanitizeVisibleText } from "../parsing/output-parsing.js";
+import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, normalizeUpstreamRuntimeEvent, } from "../parsing/stream-event-parsing.js";
+import { resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
+export function createStreamEventProjectionState() {
+    return {
+        emittedOutput: "",
+        emittedToolError: false,
+        emittedToolResult: false,
+        seenTerminalOutputs: new Set(),
+        lastStep: "",
+    };
+}
+export function projectRuntimeStreamEvent(params) {
+    const { event, allowVisibleStreamDeltas, includeStateStreamOutput, toolNameMapping, primaryTools, state, } = params;
+    const chunks = [{
+            kind: "upstream-event",
+            event: normalizeUpstreamRuntimeEvent(event),
+        }];
+    const interruptPayload = extractInterruptPayload(event);
+    if (interruptPayload) {
+        chunks.push({ kind: "interrupt", content: interruptPayload });
+        return chunks;
+    }
+    const reasoning = extractReasoningStreamOutput(event);
+    if (reasoning) {
+        chunks.push({ kind: "reasoning", content: reasoning });
+    }
+    if (allowVisibleStreamDeltas) {
+        const visibleStreamOutput = extractVisibleStreamOutput(event);
+        if (visibleStreamOutput) {
+            const nextOutput = computeIncrementalOutput(state.emittedOutput, visibleStreamOutput);
+            state.emittedOutput = nextOutput.accumulated;
+            if (nextOutput.delta) {
+                chunks.push({ kind: "content", content: nextOutput.delta });
+            }
+        }
+    }
+    if (includeStateStreamOutput) {
+        const stateStreamOutput = extractStateStreamOutput(event);
+        if (stateStreamOutput) {
+            const nextOutput = computeIncrementalOutput(state.emittedOutput, sanitizeVisibleText(stateStreamOutput));
+            state.emittedOutput = nextOutput.accumulated;
+            if (nextOutput.delta) {
+                chunks.push({ kind: "content", content: nextOutput.delta });
+            }
+        }
+    }
+    const agentStep = extractAgentStep(event);
+    if (agentStep && agentStep !== state.lastStep) {
+        state.lastStep = agentStep;
+        chunks.push({ kind: "step", content: agentStep });
+    }
+    const toolResult = extractToolResult(event);
+    if (toolResult) {
+        state.emittedToolResult = true;
+        state.emittedToolError = state.emittedToolError || toolResult.isError === true;
+        chunks.push({
+            kind: "tool-result",
+            toolName: resolveModelFacingToolName(toolResult.toolName, toolNameMapping, primaryTools),
+            output: toolResult.output,
+            isError: toolResult.isError,
+        });
+    }
+    const output = extractTerminalStreamOutput(event);
+    if (output) {
+        const outputKey = normalizeTerminalOutputKey(output);
+        if (!outputKey || !state.seenTerminalOutputs.has(outputKey)) {
+            if (outputKey) {
+                state.seenTerminalOutputs.add(outputKey);
+            }
+            const nextOutput = computeIncrementalOutput(state.emittedOutput, sanitizeVisibleText(output));
+            state.emittedOutput = nextOutput.accumulated;
+            if (nextOutput.delta) {
+                chunks.push({ kind: "content", content: nextOutput.delta });
+            }
+        }
+    }
+    return chunks;
+}

package/dist/runtime/adapter/stream-text-consumption.d.ts

@@ -0,0 +1,4 @@
+import { type RuntimeStreamChunk } from "../parsing/stream-event-parsing.js";
+export declare function projectTextStreamChunks(stream: AsyncIterable<unknown>): AsyncGenerator<RuntimeStreamChunk, {
+    emittedContent: boolean;
+}>;

package/dist/runtime/adapter/stream-text-consumption.js

@@ -0,0 +1,18 @@
+import { extractReasoningText } from "../parsing/output-parsing.js";
+import { readStreamDelta } from "../parsing/stream-event-parsing.js";
+export async function* projectTextStreamChunks(stream) {
+    let emittedContent = false;
+    for await (const chunk of stream) {
+        const delta = readStreamDelta(chunk);
+        if (delta) {
+            emittedContent = true;
+            yield { kind: "content", content: delta };
+            continue;
+        }
+        const reasoning = extractReasoningText(chunk);
+        if (reasoning) {
+            yield { kind: "reasoning", content: reasoning };
+        }
+    }
+    return { emittedContent };
+}

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;
@@ -30,71 +29,20 @@ export declare class AgentRuntimeAdapter {
     private createModelFallbackRunnable;
     private applyStrictToolJsonInstruction;
     private resolveModel;
-    private buildToolNameMapping;
-    private buildSlashCommandSkillInstruction;
-    private buildInvocationRequest;
-    private buildRawModelMessages;
     private resolveTools;
-    private compileInterruptOn;
-    private resolveInterruptOn;
     private resolveFilesystemBackend;
     private resolveBuiltinMiddlewareBackend;
+    private createDeclaredMiddlewareResolverOptions;
     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>;