@botbotgo/agent-harness 0.0.228 → 0.0.230

package/dist/contracts/runtime.d.ts

@@ -62,6 +62,26 @@ export type RuntimeTimelineProjectionOptions = {
     threadId?: string;
     runId?: string;
 };
+/**
+ * Ordered upstream/runtime execution trace projected from persisted upstream events.
+ * This is an inspection surface for recovery/debugging, not a second execution protocol.
+ */
+export type RuntimeHistoryItem = {
+    type: "thinking";
+    text: string;
+} | {
+    type: "step";
+    step: string;
+    category: "llm" | "tool" | "skill" | "memory" | "chain" | "approval";
+    status: "started" | "completed" | "failed";
+    key: string;
+} | {
+    type: "tool-result";
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+    key: string;
+};
 export type RuntimeQueueDiagnostics = {
     status: HealthStatus;
     activeRunSlots: number;
@@ -462,7 +482,11 @@ export type RequestSummary = Omit<ThreadRunRecord, "threadId" | "runId"> & {
     sessionId: string;
     requestId: string;
 };
-export type RequestRecord = RequestSummary;
+export type RequestRecord = RequestSummary & {
+    history?: RuntimeHistoryItem[];
+    upstreamEvents?: unknown[];
+    runtimeTimeline?: RuntimeTimelineItem[];
+};
 /**
  * Backward-compatible alias for older thread/run terminology.
  */
@@ -470,7 +494,11 @@ export type RunSummary = Omit<RequestSummary, "sessionId" | "requestId"> & {
     threadId: string;
     runId: string;
 };
-export type RunRecord = RunSummary;
+export type RunRecord = RunSummary & {
+    history?: RuntimeHistoryItem[];
+    upstreamEvents?: unknown[];
+    runtimeTimeline?: RuntimeTimelineItem[];
+};
 /**
  * Persisted session inspection record assembled from runtime records.
  * This is an inspectable projection, not a second session semantic model.
@@ -484,7 +512,7 @@ export type SessionRecord = {
     createdAt: string;
     updatedAt: string;
     messages: TranscriptMessage[];
-    requests: RequestSummary[];
+    requests: RequestRecord[];
     pendingDecision?: {
         approvalId: string;
         pendingActionId: string;
@@ -499,7 +527,7 @@ export type SessionRecord = {
 export type ThreadRecord = Omit<SessionRecord, "sessionId" | "latestRequestId" | "requests"> & {
     threadId: string;
     latestRunId: string;
-    runs: RunSummary[];
+    runs: RunRecord[];
 };
 export type ResumeOptions = {
     threadId?: string;

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.229";

package/dist/package-version.js

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

package/dist/persistence/file-store.d.ts

@@ -60,6 +60,8 @@ export declare class FilePersistence implements RuntimePersistence {
         currentAgentId?: string | null;
         delegationChain?: string[];
         runtimeSnapshot?: RunSummary["runtimeSnapshot"] | null;
+        upstreamEvents?: unknown[];
+        appendUpstreamEvent?: unknown;
     }): Promise<void>;
     deleteThread(threadId: string): Promise<boolean>;
     saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;

package/dist/persistence/file-store.js

@@ -91,6 +91,7 @@ export class FilePersistence {
             currentAgentId: input.currentAgentId ?? input.agentId,
             delegationChain: input.delegationChain ?? [input.currentAgentId ?? input.agentId],
             runtimeSnapshot: input.runtimeSnapshot ?? null,
+            upstreamEvents: [],
         };
         await Promise.all([
             writeJson(path.join(runDir, "meta.json"), meta),
@@ -375,11 +376,17 @@ export class FilePersistence {
         return readJson(path.join(this.runDir(threadId, runId), "lifecycle.json"));
     }
     async getRunInspection(threadId, runId) {
-        return readJson(path.join(this.runDir(threadId, runId), "inspection.json"));
+        const inspection = await readJson(path.join(this.runDir(threadId, runId), "inspection.json"));
+        return {
+            ...inspection,
+            upstreamEvents: Array.isArray(inspection.upstreamEvents) ? inspection.upstreamEvents : [],
+        };
     }
     async updateRunInspection(threadId, runId, patch) {
         const inspectionPath = path.join(this.runDir(threadId, runId), "inspection.json");
-        const current = await readJson(inspectionPath);
+        const current = await this.getRunInspection(threadId, runId);
+        const nextUpstreamEvents = patch.upstreamEvents
+            ?? (patch.appendUpstreamEvent === undefined ? current.upstreamEvents : [...current.upstreamEvents, patch.appendUpstreamEvent]);
         await writeJson(inspectionPath, {
             ...current,
             ...(patch.endedAt !== undefined ? { endedAt: patch.endedAt } : {}),
@@ -387,6 +394,7 @@ export class FilePersistence {
             ...(patch.currentAgentId !== undefined ? { currentAgentId: patch.currentAgentId } : {}),
             ...(patch.delegationChain ? { delegationChain: patch.delegationChain } : {}),
             ...(patch.runtimeSnapshot !== undefined ? { runtimeSnapshot: patch.runtimeSnapshot } : {}),
+            upstreamEvents: nextUpstreamEvents,
         });
     }
     async deleteThread(threadId) {

package/dist/persistence/sqlite-store.d.ts

@@ -81,6 +81,8 @@ export declare class SqlitePersistence implements RuntimePersistence {
         currentAgentId?: string | null;
         delegationChain?: string[];
         runtimeSnapshot?: RunSummary["runtimeSnapshot"] | null;
+        upstreamEvents?: unknown[];
+        appendUpstreamEvent?: unknown;
     }): Promise<void>;
     deleteThread(threadId: string): Promise<boolean>;
     saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;

package/dist/persistence/sqlite-store.js

@@ -4,7 +4,7 @@ import { createClient } from "@libsql/client";
 import { fileExists, readJson, writeJson } from "../utils/fs.js";
 import { SqliteRunContextStore } from "./sqlite-run-context-store.js";
 import { SqliteRunQueueStore } from "./sqlite-run-queue-store.js";
-const RUNTIME_SQLITE_SCHEMA_VERSION = 3;
+const RUNTIME_SQLITE_SCHEMA_VERSION = 4;
 const RUNTIME_SQLITE_SCHEMA_FAMILY = "agent-harness-runtime";
 function asRow(value) {
     return value;
@@ -191,6 +191,7 @@ export class SqlitePersistence {
           current_agent_id TEXT,
           delegation_chain_json TEXT NOT NULL,
           runtime_snapshot_json TEXT,
+          upstream_events_json TEXT NOT NULL DEFAULT '[]',
           FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
           FOREIGN KEY (run_id) REFERENCES runs(run_id)
         )
@@ -461,19 +462,26 @@ export class SqlitePersistence {
           current_agent_id TEXT,
           delegation_chain_json TEXT NOT NULL,
           runtime_snapshot_json TEXT,
+          upstream_events_json TEXT NOT NULL DEFAULT '[]',
           FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
           FOREIGN KEY (run_id) REFERENCES runs(run_id)
         )
       `);
             await this.rawExecute(`
         INSERT OR IGNORE INTO run_inspection
-        (run_id, thread_id, started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json)
-        SELECT run_id, thread_id, created_at, NULL, updated_at, agent_id, json_array(agent_id), NULL
+        (run_id, thread_id, started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json, upstream_events_json)
+        SELECT run_id, thread_id, created_at, NULL, updated_at, agent_id, json_array(agent_id), NULL, '[]'
         FROM runs
       `);
             await this.rawExecute("INSERT OR REPLACE INTO runtime_metadata (key, value) VALUES (?, ?)", ["schema_version", String(RUNTIME_SQLITE_SCHEMA_VERSION)]);
             return;
         }
+        if (version === "3") {
+            await this.rawExecute("ALTER TABLE run_inspection ADD COLUMN upstream_events_json TEXT NOT NULL DEFAULT '[]'");
+            await this.rawExecute("UPDATE run_inspection SET upstream_events_json = '[]' WHERE upstream_events_json IS NULL");
+            await this.rawExecute("INSERT OR REPLACE INTO runtime_metadata (key, value) VALUES (?, ?)", ["schema_version", String(RUNTIME_SQLITE_SCHEMA_VERSION)]);
+            return;
+        }
         if (version !== String(RUNTIME_SQLITE_SCHEMA_VERSION)) {
             throw new Error(`Unsupported runtime sqlite schema version ${JSON.stringify(version)} in ${this.dbPath}. Expected ${RUNTIME_SQLITE_SCHEMA_VERSION}.`);
         }
@@ -522,8 +530,8 @@ export class SqlitePersistence {
             args: [input.runId],
         }, {
             sql: `INSERT OR REPLACE INTO run_inspection
-       (run_id, thread_id, started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json)
-       VALUES (?, ?, ?, NULL, ?, ?, ?, ?)`,
+       (run_id, thread_id, started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json, upstream_events_json)
+       VALUES (?, ?, ?, NULL, ?, ?, ?, ?, ?)`,
             args: [
                 input.runId,
                 input.threadId,
@@ -532,6 +540,7 @@ export class SqlitePersistence {
                 input.currentAgentId ?? input.agentId,
                 JSON.stringify(input.delegationChain ?? [input.currentAgentId ?? input.agentId]),
                 input.runtimeSnapshot ? JSON.stringify(input.runtimeSnapshot) : null,
+                "[]",
             ],
         }, {
             sql: `INSERT INTO thread_messages
@@ -575,8 +584,8 @@ export class SqlitePersistence {
        (run_id, cancel_requested, cancel_reason, cancel_requested_at, heartbeat_at, worker_id, worker_started_at)
        VALUES (?, 0, NULL, NULL, NULL, NULL, NULL)`, [input.runId]);
         await this.execute(`INSERT OR REPLACE INTO run_inspection
-       (run_id, thread_id, started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json)
-       VALUES (?, ?, ?, NULL, ?, ?, ?, ?)`, [
+       (run_id, thread_id, started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json, upstream_events_json)
+       VALUES (?, ?, ?, NULL, ?, ?, ?, ?, ?)`, [
             input.runId,
             input.threadId,
             input.startedAt ?? input.createdAt,
@@ -584,6 +593,7 @@ export class SqlitePersistence {
             input.currentAgentId ?? input.agentId,
             JSON.stringify(input.delegationChain ?? [input.currentAgentId ?? input.agentId]),
             input.runtimeSnapshot ? JSON.stringify(input.runtimeSnapshot) : null,
+            "[]",
         ]);
     }
     async setRunState(threadId, runId, state, checkpointRef) {
@@ -734,7 +744,7 @@ export class SqlitePersistence {
         };
     }
     async getRunInspection(threadId, runId) {
-        const row = await this.selectOne(`SELECT started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json
+        const row = await this.selectOne(`SELECT started_at, ended_at, last_activity_at, current_agent_id, delegation_chain_json, runtime_snapshot_json, upstream_events_json
        FROM run_inspection
        WHERE thread_id = ? AND run_id = ?`, [threadId, runId]);
         if (!row) {
@@ -747,18 +757,22 @@ export class SqlitePersistence {
             currentAgentId: asNullableString(row.current_agent_id),
             delegationChain: parseJson(row.delegation_chain_json),
             runtimeSnapshot: row.runtime_snapshot_json ? parseJson(row.runtime_snapshot_json) : null,
+            upstreamEvents: row.upstream_events_json ? parseJson(row.upstream_events_json) : [],
         };
     }
     async updateRunInspection(threadId, runId, patch) {
         const current = await this.getRunInspection(threadId, runId);
+        const nextUpstreamEvents = patch.upstreamEvents
+            ?? (patch.appendUpstreamEvent === undefined ? current.upstreamEvents : [...current.upstreamEvents, patch.appendUpstreamEvent]);
         await this.execute(`UPDATE run_inspection
-       SET ended_at = ?, last_activity_at = ?, current_agent_id = ?, delegation_chain_json = ?, runtime_snapshot_json = ?
+       SET ended_at = ?, last_activity_at = ?, current_agent_id = ?, delegation_chain_json = ?, runtime_snapshot_json = ?, upstream_events_json = ?
        WHERE run_id = ? AND thread_id = ?`, [
             patch.endedAt === undefined ? current.endedAt : patch.endedAt,
             patch.lastActivityAt ?? current.lastActivityAt,
             patch.currentAgentId === undefined ? current.currentAgentId : patch.currentAgentId,
             JSON.stringify(patch.delegationChain ?? current.delegationChain),
             JSON.stringify(patch.runtimeSnapshot === undefined ? current.runtimeSnapshot : patch.runtimeSnapshot),
+            JSON.stringify(nextUpstreamEvents),
             runId,
             threadId,
         ]);

package/dist/persistence/types.d.ts

@@ -32,6 +32,7 @@ export type PersistedRunInspection = {
     currentAgentId: string | null;
     delegationChain: string[];
     runtimeSnapshot: RuntimeSnapshot | null;
+    upstreamEvents: unknown[];
 };
 export type PersistedRunRequest = {
     input: MessageContent;
@@ -139,6 +140,8 @@ export interface RuntimePersistence {
         currentAgentId?: string | null;
         delegationChain?: string[];
         runtimeSnapshot?: RuntimeSnapshot | null;
+        upstreamEvents?: unknown[];
+        appendUpstreamEvent?: unknown;
     }): Promise<void>;
     deleteThread(threadId: string): Promise<boolean>;
     saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;

package/dist/protocol/a2a/http.js

@@ -382,6 +382,9 @@ function toSessionRecord(session) {
             currentAgentId: run.currentAgentId,
             delegationChain: run.delegationChain,
             runtimeSnapshot: run.runtimeSnapshot,
+            upstreamEvents: run.upstreamEvents,
+            history: run.history,
+            runtimeTimeline: run.runtimeTimeline,
         })),
         pendingDecision: session.pendingDecision,
     };
@@ -407,6 +410,9 @@ function toRequestRecord(request) {
         currentAgentId: request.currentAgentId,
         delegationChain: request.delegationChain,
         runtimeSnapshot: request.runtimeSnapshot,
+        upstreamEvents: request.upstreamEvents,
+        history: request.history,
+        runtimeTimeline: request.runtimeTimeline,
     };
 }
 function buildTaskFromSessionAndRequest(session, request, approvals, output, failureMessage) {

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/runtime/harness/run/stream-run.d.ts

@@ -53,6 +53,8 @@ type StreamRunOptions = {
         currentAgentId?: string | null;
         delegationChain?: string[];
         runtimeSnapshot?: RuntimeSnapshot | null;
+        upstreamEvents?: unknown[];
+        appendUpstreamEvent?: unknown;
     }) => Promise<void>;
     emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown) => Promise<void>;
 };

package/dist/runtime/harness/run/stream-run.js

@@ -80,6 +80,7 @@ export async function* streamHarnessRun(options) {
                 await options.updateRunInspection(options.threadId, options.runId, {
                     currentAgentId,
                     delegationChain,
+                    appendUpstreamEvent: normalizedChunk.event,
                 });
                 yield {
                     type: "upstream-event",

package/dist/runtime/harness/run/thread-records.d.ts

@@ -1,5 +1,6 @@
-import type { ApprovalRecord, SessionRecord, SessionSummary, ThreadRecord, ThreadSummary } from "../../../contracts/types.js";
+import type { ApprovalRecord, RequestRecord, SessionRecord, SessionSummary, RunSummary, ThreadRecord, ThreadSummary } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
+export declare function buildRequestInspectionRecord(persistence: RuntimePersistence, request: RunSummary): Promise<RequestRecord>;
 export declare function buildSessionInspectionRecord(input: {
     persistence: RuntimePersistence;
     getSession: (sessionId: string) => Promise<SessionSummary | null>;

package/dist/runtime/harness/run/thread-records.js

@@ -1,11 +1,73 @@
 import { isTerminalRunState, toInspectableApprovalRecord } from "./helpers.js";
+import { projectRuntimeTimeline } from "../events/timeline.js";
+import { createUpstreamTimelineReducer } from "../../../upstream-events.js";
 function selectLatestPendingApproval(approvals) {
     return approvals
         .filter((approval) => approval.status === "pending")
         .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
 }
+function buildRunInspectionProjection(upstreamEvents) {
+    const reducer = createUpstreamTimelineReducer();
+    const history = upstreamEvents.flatMap((event) => reducer.consume(event));
+    return {
+        upstreamEvents,
+        history,
+    };
+}
+export async function buildRequestInspectionRecord(persistence, request) {
+    const inspection = await persistence.getRunInspection(request.threadId, request.runId);
+    const runtimeEvents = await persistence.listRunEvents(request.threadId, request.runId);
+    const { upstreamEvents, history } = buildRunInspectionProjection(inspection.upstreamEvents);
+    return {
+        requestId: request.runId,
+        sessionId: request.threadId,
+        agentId: request.agentId,
+        executionMode: request.executionMode,
+        adapterKind: request.adapterKind,
+        createdAt: request.createdAt,
+        updatedAt: request.updatedAt,
+        state: request.state,
+        checkpointRef: request.checkpointRef,
+        resumable: request.resumable,
+        startedAt: request.startedAt,
+        endedAt: request.endedAt,
+        lastActivityAt: request.lastActivityAt,
+        currentAgentId: request.currentAgentId,
+        delegationChain: request.delegationChain,
+        runtimeSnapshot: request.runtimeSnapshot,
+        upstreamEvents,
+        history,
+        runtimeTimeline: projectRuntimeTimeline(runtimeEvents, {
+            threadId: request.threadId,
+            runId: request.runId,
+        }),
+    };
+}
+function toRunRecord(request) {
+    return {
+        runId: request.requestId,
+        threadId: request.sessionId,
+        agentId: request.agentId,
+        executionMode: request.executionMode,
+        adapterKind: request.adapterKind,
+        createdAt: request.createdAt,
+        updatedAt: request.updatedAt,
+        state: request.state,
+        checkpointRef: request.checkpointRef,
+        resumable: request.resumable,
+        startedAt: request.startedAt,
+        endedAt: request.endedAt,
+        lastActivityAt: request.lastActivityAt,
+        currentAgentId: request.currentAgentId,
+        delegationChain: request.delegationChain,
+        runtimeSnapshot: request.runtimeSnapshot,
+        upstreamEvents: request.upstreamEvents,
+        history: request.history,
+        runtimeTimeline: request.runtimeTimeline,
+    };
+}
 export async function buildSessionInspectionRecord(input, sessionId) {
-    const [sessionSummary, meta, messages, requests] = await Promise.all([
+    const [sessionSummary, meta, messages, requestSummaries] = await Promise.all([
         input.getSession(sessionId),
         input.persistence.getThreadMeta(sessionId),
         input.persistence.listThreadMessages(sessionId, 200),
@@ -15,6 +77,7 @@ export async function buildSessionInspectionRecord(input, sessionId) {
         return null;
     }
     const latestRequestId = sessionSummary.latestRequestId;
+    const requests = await Promise.all(requestSummaries.map((request) => buildRequestInspectionRecord(input.persistence, request)));
     const latestApprovals = await input.persistence.getRunApprovals(sessionId, latestRequestId);
     const pendingApproval = selectLatestPendingApproval(latestApprovals);
     return {
@@ -26,24 +89,7 @@ export async function buildSessionInspectionRecord(input, sessionId) {
         createdAt: meta.createdAt,
         updatedAt: sessionSummary.updatedAt,
         messages,
-        requests: requests.map((request) => ({
-            requestId: request.runId,
-            sessionId: request.threadId,
-            agentId: request.agentId,
-            executionMode: request.executionMode,
-            adapterKind: request.adapterKind,
-            createdAt: request.createdAt,
-            updatedAt: request.updatedAt,
-            state: request.state,
-            checkpointRef: request.checkpointRef,
-            resumable: request.resumable,
-            startedAt: request.startedAt,
-            endedAt: request.endedAt,
-            lastActivityAt: request.lastActivityAt,
-            currentAgentId: request.currentAgentId,
-            delegationChain: request.delegationChain,
-            runtimeSnapshot: request.runtimeSnapshot,
-        })),
+        requests,
         pendingDecision: pendingApproval
             ? {
                 approvalId: pendingApproval.approvalId,
@@ -83,24 +129,7 @@ export async function buildThreadInspectionRecord(input, threadId) {
             createdAt: session.createdAt,
             updatedAt: session.updatedAt,
             messages: session.messages,
-            runs: session.requests.map((request) => ({
-                runId: request.requestId,
-                threadId: request.sessionId,
-                agentId: request.agentId,
-                executionMode: request.executionMode,
-                adapterKind: request.adapterKind,
-                createdAt: request.createdAt,
-                updatedAt: request.updatedAt,
-                state: request.state,
-                checkpointRef: request.checkpointRef,
-                resumable: request.resumable,
-                startedAt: request.startedAt,
-                endedAt: request.endedAt,
-                lastActivityAt: request.lastActivityAt,
-                currentAgentId: request.currentAgentId,
-                delegationChain: request.delegationChain,
-                runtimeSnapshot: request.runtimeSnapshot,
-            })),
+            runs: session.requests.map((request) => toRunRecord(request)),
             pendingDecision: session.pendingDecision,
         }
         : null;

package/dist/runtime/harness.js

@@ -39,7 +39,7 @@ import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.
 import { initializeHarnessRuntime, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
 import { defaultRequestedAgentId, prepareRunStart } from "./harness/run/start-run.js";
-import { buildSessionInspectionRecord, deleteSessionRecord, deleteThreadRecord, getPublicApproval, listPublicApprovals, } from "./harness/run/thread-records.js";
+import { buildRequestInspectionRecord, buildSessionInspectionRecord, deleteSessionRecord, deleteThreadRecord, getPublicApproval, listPublicApprovals, } from "./harness/run/thread-records.js";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -541,26 +541,7 @@ export class AgentHarnessRuntime {
     }
     async getRequest(requestId) {
         const request = await this.persistence.getRun(requestId);
-        return request
-            ? {
-                requestId: request.runId,
-                sessionId: request.threadId,
-                agentId: request.agentId,
-                executionMode: request.executionMode,
-                adapterKind: request.adapterKind,
-                createdAt: request.createdAt,
-                updatedAt: request.updatedAt,
-                state: request.state,
-                checkpointRef: request.checkpointRef,
-                resumable: request.resumable,
-                startedAt: request.startedAt,
-                endedAt: request.endedAt,
-                lastActivityAt: request.lastActivityAt,
-                currentAgentId: request.currentAgentId,
-                delegationChain: request.delegationChain,
-                runtimeSnapshot: request.runtimeSnapshot,
-            }
-            : null;
+        return request ? buildRequestInspectionRecord(this.persistence, request) : null;
     }
     async getRun(runId) {
         const request = await this.getRequest(runId);
@@ -582,6 +563,9 @@ export class AgentHarnessRuntime {
                 currentAgentId: request.currentAgentId,
                 delegationChain: request.delegationChain,
                 runtimeSnapshot: request.runtimeSnapshot,
+                upstreamEvents: request.upstreamEvents,
+                history: request.history,
+                runtimeTimeline: request.runtimeTimeline,
             }
             : null;
     }
@@ -648,6 +632,9 @@ export class AgentHarnessRuntime {
                     currentAgentId: request.currentAgentId,
                     delegationChain: request.delegationChain,
                     runtimeSnapshot: request.runtimeSnapshot,
+                    upstreamEvents: request.upstreamEvents,
+                    history: request.history,
+                    runtimeTimeline: request.runtimeTimeline,
                 })),
                 pendingDecision: session.pendingDecision,
             }
@@ -1760,12 +1747,17 @@ function toSessionRecord(record) {
         createdAt: record.createdAt,
         updatedAt: record.updatedAt,
         messages: record.messages,
-        requests: record.runs.map(toRequestSummary),
+        requests: record.runs.map(toRequestRecord),
         pendingDecision: record.pendingDecision,
     };
 }
 function toRequestRecord(record) {
-    return toRequestSummary(record);
+    return {
+        ...toRequestSummary(record),
+        upstreamEvents: record.upstreamEvents,
+        history: record.history,
+        runtimeTimeline: record.runtimeTimeline,
+    };
 }
 function deriveRunRequestFromTranscript(transcript, runId) {
     const candidate = [...transcript]

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.230",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",