@botbotgo/agent-harness 0.0.268 → 0.0.270

package/dist/runtime/harness/run/operator-overview.js

@@ -29,6 +29,8 @@ function projectGovernanceDiagnostics(runs) {
     const toolPolicies = collectGovernanceToolPolicies(runs);
     const highRiskTools = toolPolicies.filter((tool) => tool.risk === "high").length;
     const approvalRequiredTools = toolPolicies.filter((tool) => tool.requiresApproval).length;
+    const autoApprovedTools = toolPolicies.filter((tool) => tool.decisionMode === "auto-approve").length;
+    const autoRejectedTools = toolPolicies.filter((tool) => tool.decisionMode === "auto-reject" || tool.decisionMode === "deny-and-continue").length;
     const untrustedMcpTools = toolPolicies.filter((tool) => tool.mcpTrustTier === "untrusted").length;
     const crossTenantTools = toolPolicies.filter((tool) => tool.tenantScope === "cross-tenant").length;
     const writeAccessMcpTools = toolPolicies.filter((tool) => tool.category === "mcp" && tool.mcpAccess === "read-write").length;
@@ -36,11 +38,15 @@ function projectGovernanceDiagnostics(runs) {
         runsWithGovernance: runs.filter((run) => (run.runtimeSnapshot?.governance?.bundles?.length ?? 0) > 0).length,
         highRiskTools,
         approvalRequiredTools,
+        autoApprovedTools,
+        autoRejectedTools,
         untrustedMcpTools,
         crossTenantTools,
         writeAccessMcpTools,
         summary: `highRisk=${highRiskTools} ` +
             `approvalRequired=${approvalRequiredTools} ` +
+            `autoApproved=${autoApprovedTools} ` +
+            `autoRejected=${autoRejectedTools} ` +
             `untrusted=${untrustedMcpTools} ` +
             `crossTenant=${crossTenantTools}`,
     };

package/dist/runtime/harness/run/recovery.js

@@ -1,16 +1,16 @@
 import { normalizeRunPriority } from "./helpers.js";
 async function failRecovery(context, thread, previousState, error, options = {}) {
-    await context.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
+    await context.setRunStateAndEmit(thread.sessionId, thread.latestRequestId, 100, "failed", {
         previousState,
         error,
     });
     if (options.releaseRunClaim) {
-        await context.persistence.releaseRunClaim(thread.latestRunId);
+        await context.persistence.releaseRunClaim(thread.latestRequestId);
     }
     return true;
 }
 async function resolveRecoveryBinding(context, thread) {
-    const runMeta = await context.persistence.getRunMeta(thread.threadId, thread.latestRunId);
+    const runMeta = await context.persistence.getRunMeta(thread.sessionId, thread.latestRequestId);
     const binding = context.getBinding(runMeta.agentId);
     if (!binding) {
         return null;
@@ -22,12 +22,12 @@ async function resolveRecoveryBinding(context, thread) {
 }
 async function executeRecoveredRun(context, input) {
     const { thread, binding, agentId, request, previousState, emitResumeEvent } = input;
-    const releaseRunSlot = await context.acquireRunSlot(thread.threadId, thread.latestRunId, "running", normalizeRunPriority(request.priority));
+    const releaseRunSlot = await context.acquireRunSlot(thread.sessionId, thread.latestRequestId, "running", normalizeRunPriority(request.priority));
     try {
         if (emitResumeEvent) {
-            await context.emit(thread.threadId, thread.latestRunId, emitResumeEvent.sequence, emitResumeEvent.eventType, emitResumeEvent.payload);
+            await context.emit(thread.sessionId, thread.latestRequestId, emitResumeEvent.sequence, emitResumeEvent.eventType, emitResumeEvent.payload);
         }
-        await context.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, agentId, {
+        await context.executeQueuedRun(binding, request.input, thread.sessionId, thread.latestRequestId, agentId, {
             context: request.invocation?.context,
             state: request.invocation?.inputs,
             files: request.invocation?.attachments,
@@ -42,9 +42,9 @@ async function executeRecoveredRun(context, input) {
     return true;
 }
 async function failResumingRecovery(context, thread, checkpointRef, error) {
-    await context.persistence.setRunState(thread.threadId, thread.latestRunId, "failed", checkpointRef);
-    await context.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
-    await context.emit(thread.threadId, thread.latestRunId, 101, "run.state.changed", {
+    await context.persistence.setRunState(thread.sessionId, thread.latestRequestId, "failed", checkpointRef);
+    await context.persistence.clearRecoveryIntent(thread.sessionId, thread.latestRequestId);
+    await context.emit(thread.sessionId, thread.latestRequestId, 101, "run.state.changed", {
         previousState: "resuming",
         state: "failed",
         checkpointRef,
@@ -60,7 +60,7 @@ export async function recoverQueuedStartupRun(context, thread) {
     if (!resolved) {
         return true;
     }
-    const request = await context.persistence.getRunRequest(thread.threadId, thread.latestRunId);
+    const request = await context.persistence.getRunRequest(thread.sessionId, thread.latestRequestId);
     if (!request) {
         return failRecovery(context, thread, "queued", "missing persisted run request for queued run recovery");
     }
@@ -89,7 +89,7 @@ export async function recoverRunningStartupRun(context, thread) {
             releaseRunClaim: true,
         });
     }
-    const request = await context.persistence.getRunRequest(thread.threadId, thread.latestRunId);
+    const request = await context.persistence.getRunRequest(thread.sessionId, thread.latestRequestId);
     if (!request) {
         return failRecovery(context, thread, "running", "missing persisted run request for stale running run recovery", {
             releaseRunClaim: true,
@@ -119,31 +119,31 @@ export async function recoverResumingStartupRun(context, thread) {
     if (!binding) {
         return true;
     }
-    const recoveryIntent = await context.persistence.getRecoveryIntent(thread.threadId, thread.latestRunId);
+    const recoveryIntent = await context.persistence.getRecoveryIntent(thread.sessionId, thread.latestRequestId);
     if (!recoveryIntent || recoveryIntent.kind !== "approval-decision") {
         return true;
     }
     if (recoveryIntent.attempts >= context.recoveryConfig.maxRecoveryAttempts) {
         return failResumingRecovery(context, thread, recoveryIntent.checkpointRef, "recovery attempts exhausted");
     }
-    await context.persistence.saveRecoveryIntent(thread.threadId, thread.latestRunId, {
+    await context.persistence.saveRecoveryIntent(thread.sessionId, thread.latestRequestId, {
         ...recoveryIntent,
         attempts: recoveryIntent.attempts + 1,
     });
-    await context.emit(thread.threadId, thread.latestRunId, 100, "run.resumed", {
+    await context.emit(thread.sessionId, thread.latestRequestId, 100, "run.resumed", {
         resumeKind: "startup-recovery",
         checkpointRef: recoveryIntent.checkpointRef,
         state: "resuming",
     });
-    const history = await context.persistence.listThreadMessages(thread.threadId);
-    const priorHistory = history.filter((message) => message.runId !== thread.latestRunId);
-    const runInput = await context.loadRunInput(thread.threadId, thread.latestRunId);
+    const history = await context.persistence.listThreadMessages(thread.sessionId);
+    const priorHistory = history.filter((message) => message.requestId !== thread.latestRequestId);
+    const runInput = await context.loadRunInput(thread.sessionId, thread.latestRequestId);
     const startedAt = Date.now();
     try {
-        const actual = await context.runtimeAdapter.invoke(binding, "", thread.threadId, thread.latestRunId, recoveryIntent.resumePayload, priorHistory);
+        const actual = await context.runtimeAdapter.invoke(binding, "", thread.sessionId, thread.latestRequestId, recoveryIntent.resumePayload, priorHistory);
         context.recordLlmSuccess(startedAt);
-        await context.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
-        await context.finalizeContinuedRun(binding, thread.threadId, thread.latestRunId, runInput, actual, {
+        await context.persistence.clearRecoveryIntent(thread.sessionId, thread.latestRequestId);
+        await context.finalizeContinuedRun(binding, thread.sessionId, thread.latestRequestId, runInput, actual, {
             previousState: "resuming",
             stateSequence: 101,
             approvalSequence: 102,

package/dist/runtime/harness/run/resume.js

@@ -7,13 +7,13 @@ export async function resolveApprovalRecord(persistence, options, thread) {
         }
         return approval;
     }
-    const runId = options.runId ?? thread.latestRunId;
-    const approvals = await persistence.getRunApprovals(options.threadId ?? thread.threadId, runId);
+    const requestId = options.requestId ?? thread.latestRequestId;
+    const approvals = await persistence.getRunApprovals(options.sessionId ?? thread.sessionId, requestId);
     const approval = approvals
         .filter((candidate) => candidate.status === "pending")
         .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
     if (!approval) {
-        throw new Error(`No pending approval for run ${runId}`);
+        throw new Error(`No pending approval for run ${requestId}`);
     }
     return approval;
 }

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

@@ -5,7 +5,7 @@ export async function appendAssistantMessage(persistence, threadId, runId, conte
     await persistence.appendThreadMessage(threadId, {
         role: "assistant",
         content,
-        runId,
+        requestId: runId,
         createdAt: new Date().toISOString(),
     });
 }
@@ -38,8 +38,8 @@ export async function finalizeCancelledRun(runtime, threadId, runId, previousSta
     });
     const runMeta = await runtime.persistence.getRunMeta(threadId, runId);
     return {
-        threadId,
-        runId,
+        sessionId: threadId,
+        requestId: runId,
         agentId: runMeta.agentId,
         state: "cancelled",
         output: reason ? `cancelled: ${reason}` : "cancelled",
@@ -58,8 +58,8 @@ export async function finalizeContinuedRun(runtime, binding, threadId, runId, in
     }
     return {
         ...actual,
-        threadId,
-        runId,
+        sessionId: threadId,
+        requestId: runId,
         approvalId: approval?.approvalId ?? actual.approvalId,
         pendingActionId: approval?.pendingActionId ?? actual.pendingActionId,
     };

package/dist/runtime/harness/run/run-operations.d.ts

@@ -31,8 +31,8 @@ type ResumeOperationRuntime = {
 };
 type CancelOperationRuntime = {
     getRun: (runId: string) => Promise<{
-        threadId: string;
-        runId: string;
+        sessionId: string;
+        requestId: string;
         agentId: string;
         state: RunResult["state"];
     } | null>;

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

@@ -11,17 +11,17 @@ function normalizeContinuationState(previousState) {
 }
 export async function resumeRun(runtime, options) {
     const approvalById = options.approvalId ? await runtime.getApprovalById(options.approvalId) : null;
-    const thread = options.threadId
-        ? await runtime.getSession(options.threadId)
+    const thread = options.sessionId
+        ? await runtime.getSession(options.sessionId)
         : approvalById
-            ? await runtime.getSession(approvalById.threadId)
+            ? await runtime.getSession(approvalById.sessionId)
             : null;
     if (!thread) {
-        throw new Error("resume requires either threadId or approvalId");
+        throw new Error("resume requires either sessionId or approvalId");
     }
     const approval = approvalById ?? await runtime.resolveApprovalRecord(options, thread);
-    const threadId = approval.threadId;
-    const runId = approval.runId;
+    const threadId = approval.sessionId;
+    const runId = approval.requestId;
     const binding = runtime.getBinding(thread.agentId);
     if (!binding) {
         throw new Error(`Unknown agent ${thread.agentId}`);
@@ -63,7 +63,7 @@ export async function resumeRun(runtime, options) {
             toolName: approval.toolName,
         });
         const history = await runtime.listThreadMessages(threadId);
-        const priorHistory = history.filter((message) => message.runId !== runId);
+        const priorHistory = history.filter((message) => message.requestId !== runId);
         const runInput = await runtime.loadRunInput(threadId, runId);
         const startedAt = Date.now();
         try {
@@ -101,33 +101,33 @@ export async function resumeRun(runtime, options) {
     }
 }
 export async function cancelRunOperation(runtime, options) {
-    const run = await runtime.getRun(options.runId);
+    const run = await runtime.getRun(options.requestId);
     if (!run) {
-        throw new Error(`Unknown run ${options.runId}`);
+        throw new Error(`Unknown run ${options.requestId}`);
     }
     if (isTerminalRunState(run.state)) {
         return {
-            threadId: run.threadId,
-            runId: run.runId,
+            sessionId: run.sessionId,
+            requestId: run.requestId,
             agentId: run.agentId,
             state: run.state,
             output: run.state,
         };
     }
-    await runtime.requestRunCancel(run.runId, options.reason);
+    await runtime.requestRunCancel(run.requestId, options.reason);
     if (run.state === "queued" || run.state === "waiting_for_approval" || run.state === "claimed") {
         if (run.state === "queued") {
-            runtime.dropPendingRunSlot(run.runId);
+            runtime.dropPendingRunSlot(run.requestId);
         }
-        return runtime.finalizeCancelledRun(run.threadId, run.runId, run.state, options.reason);
+        return runtime.finalizeCancelledRun(run.sessionId, run.requestId, run.state, options.reason);
     }
-    await runtime.setRunStateAndEmit(run.threadId, run.runId, 103, "cancelling", {
+    await runtime.setRunStateAndEmit(run.sessionId, run.requestId, 103, "cancelling", {
         previousState: run.state,
         ...(options.reason ? { error: options.reason } : {}),
     });
     return {
-        threadId: run.threadId,
-        runId: run.runId,
+        sessionId: run.sessionId,
+        requestId: run.requestId,
         agentId: run.agentId,
         state: "cancelling",
         output: options.reason ? `cancelling: ${options.reason}` : "cancelling",
@@ -140,8 +140,8 @@ export async function executeQueuedRunOperation(runtime, input) {
     const currentRun = await runtime.persistence.getRun(runId);
     if (currentRun?.state === "cancelled") {
         return {
-            threadId,
-            runId,
+            sessionId: threadId,
+            requestId: runId,
             agentId,
             state: "cancelled",
             output: "cancelled",
@@ -202,8 +202,8 @@ export async function executeQueuedRunOperation(runtime, input) {
             error: error instanceof Error ? error.message : String(error),
         });
         return {
-            threadId,
-            runId,
+            sessionId: threadId,
+            requestId: runId,
             agentId,
             state: "failed",
             output: runtime.renderRuntimeFailure(error),

package/dist/runtime/harness/run/start-run.d.ts

@@ -15,7 +15,7 @@ type EnsureThreadStartedRuntime = {
             userMessage: {
                 role: "user";
                 content: MessageContent;
-                runId: string;
+                requestId: string;
                 createdAt: string;
             };
             runRequest: PersistedRunRequest;
@@ -35,7 +35,7 @@ type EnsureThreadStartedRuntime = {
         appendThreadMessage: (threadId: string, message: {
             role: "user";
             content: MessageContent;
-            runId: string;
+            requestId: string;
             createdAt: string;
         }) => Promise<void>;
         createRun: (input: {
@@ -73,7 +73,7 @@ export declare function ensureThreadStarted(runtime: EnsureThreadStartedRuntime,
     isNewThread: boolean;
 }>;
 export declare function prepareRunStart(runtime: PrepareRunStartRuntime, input: {
-    options: Pick<RunStartOptions, "input" | "agentId" | "threadId" | "priority">;
+    options: Pick<RunStartOptions, "input" | "agentId" | "sessionId" | "priority">;
     invocation: InvocationEnvelope;
     runCreatedPayload: (binding: Binding, selectedAgentId: string) => Record<string, unknown>;
 }): Promise<{

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

@@ -18,7 +18,7 @@ export async function ensureThreadStarted(runtime, input) {
     const userMessage = {
         role: "user",
         content: normalizeMessageContent(message),
-        runId,
+        requestId: runId,
         createdAt,
     };
     if (typeof runtime.persistence.bootstrapRun === "function") {
@@ -70,7 +70,7 @@ export async function ensureThreadStarted(runtime, input) {
 }
 export async function prepareRunStart(runtime, input) {
     const { options, invocation, runCreatedPayload } = input;
-    const selectedAgentId = await runtime.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
+    const selectedAgentId = await runtime.resolveSelectedAgentId(options.input, options.agentId, options.sessionId);
     const binding = getRequiredWorkspaceBinding(runtime.workspace, selectedAgentId);
     const policyDecision = runtime.policyEngine.evaluate(binding);
     if (!policyDecision.allowed) {
@@ -83,7 +83,7 @@ export async function prepareRunStart(runtime, input) {
         binding,
         message: options.input,
         runRequest,
-        existingThreadId: options.threadId,
+        existingThreadId: options.sessionId,
     });
     return {
         binding,

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

@@ -54,7 +54,7 @@ export async function reclaimExpiredClaimedRuns(input, nowIso = new Date().toISO
     }
 }
 export async function isStaleRunningRun(input, thread, nowMs = Date.now()) {
-    const control = await input.persistence.getRunControl(thread.latestRunId);
+    const control = await input.persistence.getRunControl(thread.latestRequestId);
     const heartbeatAt = control?.heartbeatAt;
     if (!heartbeatAt) {
         return true;

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

@@ -101,8 +101,8 @@ export async function* streamHarnessRun(options) {
                     });
                     yield {
                         type: "upstream-event",
-                        threadId: options.threadId,
-                        runId: options.runId,
+                        sessionId: options.threadId,
+                        requestId: options.runId,
                         event: normalizedChunk.event,
                     };
                     continue;
@@ -116,8 +116,8 @@ export async function* streamHarnessRun(options) {
                     });
                     yield {
                         type: "upstream-event",
-                        threadId: options.threadId,
-                        runId: options.runId,
+                        sessionId: options.threadId,
+                        requestId: options.runId,
                         surfaceItem,
                         event: normalizedChunk.event,
                     };
@@ -137,8 +137,8 @@ export async function* streamHarnessRun(options) {
                 yield {
                     type: "result",
                     result: {
-                        threadId: options.threadId,
-                        runId: options.runId,
+                        sessionId: options.threadId,
+                        requestId: options.runId,
                         agentId: currentAgentId,
                         state: "waiting_for_approval",
                         output: assistantOutput,
@@ -164,8 +164,8 @@ export async function* streamHarnessRun(options) {
                 }
                 yield {
                     type: "tool-result",
-                    threadId: options.threadId,
-                    runId: options.runId,
+                    sessionId: options.threadId,
+                    requestId: options.runId,
                     agentId: options.selectedAgentId,
                     toolName: normalizedChunk.toolName,
                     output: normalizedChunk.output,
@@ -181,8 +181,8 @@ export async function* streamHarnessRun(options) {
             };
             yield {
                 type: "content",
-                threadId: options.threadId,
-                runId: options.runId,
+                sessionId: options.threadId,
+                requestId: options.runId,
                 agentId: currentAgentId,
                 content: normalizedChunk.content,
             };
@@ -212,8 +212,8 @@ export async function* streamHarnessRun(options) {
         yield {
             type: "result",
             result: {
-                threadId: options.threadId,
-                runId: options.runId,
+                sessionId: options.threadId,
+                requestId: options.runId,
                 agentId: currentAgentId,
                 state: "completed",
                 output: assistantOutput,
@@ -236,16 +236,16 @@ export async function* streamHarnessRun(options) {
             };
             yield {
                 type: "content",
-                threadId: options.threadId,
-                runId: options.runId,
+                sessionId: options.threadId,
+                requestId: options.runId,
                 agentId: options.selectedAgentId,
                 content: runtimeFailure,
             };
             yield {
                 type: "result",
                 result: {
-                    threadId: options.threadId,
-                    runId: options.runId,
+                    sessionId: options.threadId,
+                    requestId: options.runId,
                     agentId: currentAgentId,
                     state: "failed",
                     output: runtimeFailure,
@@ -265,16 +265,16 @@ export async function* streamHarnessRun(options) {
             };
             yield {
                 type: "content",
-                threadId: options.threadId,
-                runId: options.runId,
+                sessionId: options.threadId,
+                requestId: options.runId,
                 agentId: options.selectedAgentId,
                 content: runtimeFailure,
             };
             yield {
                 type: "result",
                 result: {
-                    threadId: options.threadId,
-                    runId: options.runId,
+                    sessionId: options.threadId,
+                    requestId: options.runId,
                     agentId: options.selectedAgentId,
                     state: "failed",
                     output: runtimeFailure,
@@ -306,9 +306,19 @@ export async function* streamHarnessRun(options) {
             yield {
                 type: "result",
                 result: {
-                    ...actual,
-                    threadId: options.threadId,
-                    runId: options.runId,
+                    state: actual.state,
+                    output: actual.output,
+                    finalMessageText: actual.finalMessageText,
+                    outputContent: actual.outputContent,
+                    contentBlocks: actual.contentBlocks,
+                    structuredResponse: actual.structuredResponse,
+                    interruptContent: actual.interruptContent,
+                    approvalId: actual.approvalId,
+                    pendingActionId: actual.pendingActionId,
+                    delegationId: actual.delegationId,
+                    artifacts: actual.artifacts,
+                    sessionId: options.threadId,
+                    requestId: options.runId,
                     agentId: currentAgentId,
                     metadata: {
                         ...(actual.metadata ?? {}),
@@ -336,16 +346,16 @@ export async function* streamHarnessRun(options) {
             };
             yield {
                 type: "content",
-                threadId: options.threadId,
-                runId: options.runId,
+                sessionId: options.threadId,
+                requestId: options.runId,
                 agentId: options.selectedAgentId,
                 content: runtimeFailure,
             };
             yield {
                 type: "result",
                 result: {
-                    threadId: options.threadId,
-                    runId: options.runId,
+                    sessionId: options.threadId,
+                    requestId: options.runId,
                     agentId: currentAgentId,
                     state: "failed",
                     output: runtimeFailure,

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

@@ -6,11 +6,11 @@ function selectLatestPendingApproval(approvals) {
         .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
 }
 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 inspection = await persistence.getRunInspection(request.sessionId, request.requestId);
+    const runtimeEvents = await persistence.listRunEvents(request.sessionId, request.requestId);
     return {
-        requestId: request.runId,
-        sessionId: request.threadId,
+        requestId: request.requestId,
+        sessionId: request.sessionId,
         agentId: request.agentId,
         parentRunId: request.parentRunId,
         executionMode: request.executionMode,
@@ -28,15 +28,15 @@ export async function buildRequestInspectionRecord(persistence, request) {
         runtimeSnapshot: request.runtimeSnapshot,
         traceItems: inspection.traceItems,
         runtimeTimeline: projectRuntimeTimeline(runtimeEvents, {
-            threadId: request.threadId,
-            runId: request.runId,
+            sessionId: request.sessionId,
+            requestId: request.requestId,
         }),
     };
 }
 function toRunRecord(request) {
     return {
-        runId: request.requestId,
-        threadId: request.sessionId,
+        requestId: request.requestId,
+        sessionId: request.sessionId,
         agentId: request.agentId,
         parentRunId: request.parentRunId,
         executionMode: request.executionMode,
@@ -97,32 +97,11 @@ export async function buildThreadInspectionRecord(input, threadId) {
         getSession: async (sessionId) => {
             const summary = await input.getSession(sessionId);
             return summary
-                ? {
-                    agentId: summary.agentId,
-                    sessionId: summary.threadId,
-                    latestRequestId: summary.latestRunId,
-                    createdAt: summary.createdAt,
-                    updatedAt: summary.updatedAt,
-                    status: summary.status,
-                    currentAgentId: summary.currentAgentId,
-                }
+                ? { ...summary }
                 : null;
         },
     }, threadId);
-    return session
-        ? {
-            threadId: session.sessionId,
-            entryAgentId: session.entryAgentId,
-            currentAgentId: session.currentAgentId,
-            currentState: session.currentState,
-            latestRunId: session.latestRequestId,
-            createdAt: session.createdAt,
-            updatedAt: session.updatedAt,
-            messages: session.messages,
-            runs: session.requests.map((request) => toRunRecord(request)),
-            pendingDecision: session.pendingDecision,
-        }
-        : null;
+    return session ? { ...session } : null;
 }
 export async function listPublicApprovals(input, filter) {
     const approvals = await input.persistence.listApprovals(filter);
@@ -137,9 +116,9 @@ export async function deleteThreadRecord(input, threadId) {
     if (!thread) {
         return false;
     }
-    const activeRun = thread.runs.find((run) => !isTerminalRunState(run.state));
+    const activeRun = thread.requests.find((run) => !isTerminalRunState(run.state));
     if (activeRun) {
-        throw new Error(`Cannot delete thread ${threadId} while run ${activeRun.runId} is ${activeRun.state}`);
+        throw new Error(`Cannot delete thread ${threadId} while run ${activeRun.requestId} is ${activeRun.state}`);
     }
     const deleted = await input.deleteThread(threadId);
     if (deleted) {

package/dist/runtime/harness/system/mem0-ingestion-sync.js

@@ -161,7 +161,7 @@ export class Mem0IngestionSync {
         }
         const trigger = event.eventType === "approval.resolved" ? "approval.resolved" : "run.completed";
         const task = this.syncChain
-            .then(() => this.syncRun(event.threadId, event.runId, trigger))
+            .then(() => this.syncRun(event.sessionId ?? event.threadId ?? "", event.requestId ?? event.runId ?? "", trigger))
             .catch(() => {
             // Fail open: memory ingestion must not break run execution.
         });
@@ -182,7 +182,7 @@ export class Mem0IngestionSync {
     }
     async syncRun(threadId, runId, trigger) {
         const allMessages = await this.persistence.listThreadMessages(threadId, this.config.maxMessagesPerRun);
-        const runMessages = allMessages.filter((message) => message.runId === runId);
+        const runMessages = allMessages.filter((message) => (message.requestId ?? message.runId) === runId);
         const normalized = normalizeMessages(runMessages);
         if (normalized.length === 0) {
             return;

package/dist/runtime/harness/system/runtime-memory-manager.js

@@ -93,7 +93,7 @@ export function createBackgroundMemoryCandidates(input) {
     const approvals = summarizeApprovals(input.approvals);
     const summarySeed = latestUser ?? latestAssistant ?? `Run ${input.runId}`;
     const baseSummary = summarySeed.length > 120 ? `${summarySeed.slice(0, 117)}...` : summarySeed;
-    const sourceRefBase = `runtime://threads/${input.thread.threadId}/runs/${input.runId}/background-reflection`;
+    const sourceRefBase = `runtime://threads/${input.thread.sessionId}/runs/${input.runId}/background-reflection`;
     return input.scopes.map((scope) => ({
         kind: "episodic",
         scope,
@@ -101,7 +101,7 @@ export function createBackgroundMemoryCandidates(input) {
         sourceRef: `${sourceRefBase}#${scope}`,
         summary: `${baseSummary} (${scope})`,
         content: [
-            `Run ${input.runId} completed for thread ${input.thread.threadId}.`,
+            `Run ${input.runId} completed for thread ${input.thread.sessionId}.`,
             `Trigger: ${input.trigger}.`,
             `Latest user context: ${userContext}`,
             `Latest assistant context: ${assistantContext}`,
@@ -302,7 +302,7 @@ export class RuntimeMemoryFormationSync {
         }
         const trigger = event.eventType === "approval.resolved" ? "approval.resolved" : "run.completed";
         const task = this.syncChain
-            .then(() => this.reflectRun(event.threadId, event.runId, trigger, event.timestamp))
+            .then(() => this.reflectRun(event.sessionId ?? event.threadId ?? "", event.requestId ?? event.runId ?? "", trigger, event.timestamp))
             .catch(() => {
             // Fail open: reflection should not block runtime progress.
         });
@@ -325,7 +325,7 @@ export class RuntimeMemoryFormationSync {
         if (!thread || !run) {
             return;
         }
-        const messages = allMessages.filter((message) => message.runId === runId);
+        const messages = allMessages.filter((message) => (message.requestId ?? message.runId) === runId);
         if (messages.length === 0) {
             return;
         }