@botbotgo/agent-harness 0.0.229 → 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.228";
+export declare const AGENT_HARNESS_VERSION = "0.0.229";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.228";
+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/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/package.json

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