@botbotgo/agent-harness 0.0.267 → 0.0.269

package/dist/protocol/a2a/http.js

@@ -356,18 +356,19 @@ function toSessionRecord(session) {
     if (!session) {
         return null;
     }
+    const typed = session;
     return {
-        sessionId: session.threadId,
-        entryAgentId: session.entryAgentId,
-        currentAgentId: session.currentAgentId,
-        currentState: session.currentState,
-        latestRequestId: session.latestRunId,
-        createdAt: session.createdAt,
-        updatedAt: session.updatedAt,
-        messages: session.messages,
-        requests: session.runs.map((run) => ({
-            requestId: run.runId,
-            sessionId: run.threadId,
+        sessionId: typed.sessionId ?? typed.threadId ?? "",
+        entryAgentId: typed.entryAgentId,
+        currentAgentId: typed.currentAgentId,
+        currentState: typed.currentState,
+        latestRequestId: typed.latestRequestId ?? typed.latestRunId ?? "",
+        createdAt: typed.createdAt,
+        updatedAt: typed.updatedAt,
+        messages: typed.messages,
+        requests: (typed.requests ?? typed.runs ?? []).map((run) => ({
+            requestId: run.requestId,
+            sessionId: run.sessionId,
             agentId: run.agentId,
             executionMode: run.executionMode,
             adapterKind: run.adapterKind,
@@ -392,25 +393,26 @@ function toRequestRecord(request) {
     if (!request) {
         return null;
     }
+    const typed = request;
     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,
-        traceItems: request.traceItems,
-        runtimeTimeline: request.runtimeTimeline,
+        requestId: typed.requestId ?? typed.runId ?? "",
+        sessionId: typed.sessionId ?? typed.threadId ?? "",
+        agentId: typed.agentId,
+        executionMode: typed.executionMode,
+        adapterKind: typed.adapterKind,
+        createdAt: typed.createdAt,
+        updatedAt: typed.updatedAt,
+        state: typed.state,
+        checkpointRef: typed.checkpointRef,
+        resumable: typed.resumable,
+        startedAt: typed.startedAt,
+        endedAt: typed.endedAt,
+        lastActivityAt: typed.lastActivityAt,
+        currentAgentId: typed.currentAgentId,
+        delegationChain: typed.delegationChain,
+        runtimeSnapshot: typed.runtimeSnapshot,
+        traceItems: typed.traceItems,
+        runtimeTimeline: typed.runtimeTimeline,
     };
 }
 function buildTaskFromSessionAndRequest(session, request, approvals, output, failureMessage) {
@@ -473,8 +475,8 @@ async function buildTaskFromRuntime(runtime, requestId) {
     if (!request) {
         return null;
     }
-    const session = await runtime.getThread(request.threadId);
-    const approvals = await runtime.listApprovals({ threadId: request.threadId, runId: request.runId });
+    const session = await runtime.getThread(request.sessionId);
+    const approvals = await runtime.listApprovals({ sessionId: request.sessionId, requestId: request.requestId });
     return buildTaskFromSessionAndRequest(toSessionRecord(session), toRequestRecord(request), approvals);
 }
 async function hydrateTaskStateFromEvents(runtime, task) {
@@ -508,7 +510,7 @@ async function listTasksFromRuntime(runtime, params) {
     });
     const startIndex = params.cursor ? Number.parseInt(Buffer.from(params.cursor, "base64url").toString("utf8"), 10) || 0 : 0;
     const page = runs.slice(startIndex, startIndex + params.limit);
-    const tasks = (await Promise.all(page.map((run) => buildTaskFromRuntime(runtime, run.runId)))).filter((task) => Boolean(task));
+    const tasks = (await Promise.all(page.map((run) => buildTaskFromRuntime(runtime, run.requestId)))).filter((task) => Boolean(task));
     const nextIndex = startIndex + page.length;
     const nextPageToken = nextIndex < runs.length ? Buffer.from(String(nextIndex), "utf8").toString("base64url") : "";
     return {
@@ -718,12 +720,12 @@ async function* streamSendMessageTaskUpdates(runtime, options, method) {
     let emittedInitialTask = false;
     for await (const item of runtime.streamEvents(options)) {
         if (item.type === "event") {
-            runId = runId ?? item.event.runId;
+            runId = runId ?? item.event.requestId;
             if (item.event.eventType === "output.delta" && typeof item.event.payload.content === "string") {
                 streamedText += item.event.payload.content;
             }
             if (item.event.eventType === "run.created" || item.event.eventType === "run.state.changed" || item.event.eventType === "output.delta" || item.event.eventType === "approval.requested") {
-                const task = withStreamingStatusText(await buildTaskFromRuntime(runtime, item.event.runId), streamedText || undefined);
+                const task = withStreamingStatusText(await buildTaskFromRuntime(runtime, item.event.requestId), streamedText || undefined);
                 if (task) {
                     yield { task, mode: emittedInitialTask ? "status-update" : "task" };
                     emittedInitialTask = true;
@@ -732,8 +734,8 @@ async function* streamSendMessageTaskUpdates(runtime, options, method) {
             continue;
         }
         if (item.type === "result") {
-            runId = item.result.runId;
-            const task = withRunResult(await buildTaskFromRuntime(runtime, item.result.runId), item.result, streamedText || item.result.output);
+            runId = item.result.requestId;
+            const task = withRunResult(await buildTaskFromRuntime(runtime, item.result.requestId), item.result, streamedText || item.result.output);
             yield { task, mode: emittedInitialTask ? "status-update" : "task" };
             return;
         }
@@ -810,7 +812,7 @@ async function streamExistingTaskUpdates(runtime, response, id, method, taskId)
             }
         };
         const unsubscribe = runtime.subscribe((event) => {
-            if (event.runId !== taskId) {
+            if (event.requestId !== taskId) {
                 return;
             }
             if (event.eventType !== "run.state.changed"
@@ -893,10 +895,10 @@ export async function serveA2aOverHttp(runtime, options = {}) {
     };
     const pushRelevantEventTypes = new Set(["run.state.changed", "approval.requested", "approval.resolved"]);
     const unsubscribePushNotifications = runtime.subscribe((event) => {
-        if (!pushRelevantEventTypes.has(event.eventType) || !pushConfigsByTask.has(event.runId)) {
+        if (!pushRelevantEventTypes.has(event.eventType) || !pushConfigsByTask.has(event.requestId)) {
             return;
         }
-        void dispatchPushNotificationsForTask(event.runId);
+        void dispatchPushNotificationsForTask(event.requestId);
     });
     const httpServer = createServer(async (request, response) => {
         try {
@@ -934,12 +936,12 @@ export async function serveA2aOverHttp(runtime, options = {}) {
                         const result = await runtime.run({
                             agentId: parsed.agentId ?? options.defaultAgentId,
                             input: parsed.input,
-                            ...(parsed.sessionId ? { threadId: parsed.sessionId } : {}),
+                            ...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
                             invocation: attachServiceParameters(parsed.invocation, serviceParameters),
                         });
-                        const session = await runtime.getThread(result.threadId);
-                        const requestRecord = await runtime.getRun(result.runId);
-                        const approvals = await runtime.listApprovals({ threadId: result.threadId, runId: result.runId });
+                        const session = await runtime.getThread(result.sessionId);
+                        const requestRecord = await runtime.getRun(result.requestId);
+                        const approvals = await runtime.listApprovals({ sessionId: result.sessionId, requestId: result.requestId });
                         const task = buildTaskFromSessionAndRequest(toSessionRecord(session), toRequestRecord(requestRecord), approvals, result.output);
                         if (task && parsed.pushNotificationConfig) {
                             registerPushNotificationConfig(task.id, parsed.pushNotificationConfig);
@@ -958,7 +960,7 @@ export async function serveA2aOverHttp(runtime, options = {}) {
                         const sourceIterator = streamSendMessageTaskUpdates(runtime, {
                             agentId: parsed.agentId ?? options.defaultAgentId,
                             input: parsed.input,
-                            ...(parsed.sessionId ? { threadId: parsed.sessionId } : {}),
+                            ...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
                             invocation: attachServiceParameters(parsed.invocation, serviceParameters),
                         }, payload.method);
                         const iterator = (async function* () {
@@ -991,8 +993,8 @@ export async function serveA2aOverHttp(runtime, options = {}) {
                     }
                     if (payload.method === "tasks/cancel" || payload.method === "CancelTask") {
                         const { taskId } = parseTaskLocatorParams(payload.params);
-                        const result = await runtime.cancelRun({ runId: taskId, reason: "Cancelled via A2A bridge." });
-                        const task = await buildTaskFromRuntime(runtime, result.runId);
+                        const result = await runtime.cancelRun({ requestId: taskId, reason: "Cancelled via A2A bridge." });
+                        const task = await buildTaskFromRuntime(runtime, result.requestId);
                         writeJson(response, 200, toSuccess(payload.id ?? null, task));
                         return;
                     }

package/dist/protocol/ag-ui/http.js

@@ -51,8 +51,8 @@ function toRunStarted(event, input) {
     return {
         type: "RUN_STARTED",
         timestamp: createTimestamp(),
-        threadId: event.threadId,
-        runId: event.runId,
+        threadId: event.sessionId,
+        runId: event.requestId,
         input,
     };
 }
@@ -187,19 +187,19 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
             const result = await runtime.run({
                 agentId: input.agentId,
                 input: input.input,
-                ...(input.sessionId ? { threadId: input.sessionId } : {}),
+                ...(input.sessionId ? { sessionId: input.sessionId } : {}),
                 ...(input.invocation ? { invocation: input.invocation } : {}),
                 listeners: {
                     onEvent: async (event) => {
                         if (event.eventType === "run.created") {
-                            runId = event.runId;
-                            threadId = event.threadId;
+                            runId = event.requestId;
+                            threadId = event.sessionId;
                             await writeSseEvent(response, toRunStarted(event, input.input));
                             return;
                         }
                         if (event.eventType === "output.delta") {
-                            runId = runId ?? event.runId;
-                            threadId = threadId ?? event.threadId;
+                            runId = runId ?? event.requestId;
+                            threadId = threadId ?? event.sessionId;
                             const delta = typeof event.payload.content === "string" ? event.payload.content : "";
                             if (!delta) {
                                 return;
@@ -301,8 +301,8 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
                     },
                 },
             });
-            runId = runId ?? result.runId;
-            threadId = threadId ?? result.threadId;
+            runId = runId ?? result.requestId;
+            threadId = threadId ?? result.sessionId;
             if (!textMessageStarted && result.output) {
                 await ensureTextStart();
                 await writeSseEvent(response, {

package/dist/runtime/adapter/invocation-result.js

@@ -20,8 +20,8 @@ export function finalizeInvocationResult(params) {
     const stateSnapshot = buildStateSnapshot(result);
     const memoryCandidates = executedToolResults.flatMap((toolResult) => toolResult.memoryCandidates ?? []);
     return {
-        threadId,
-        runId,
+        sessionId: threadId,
+        requestId: runId,
         agentId: bindingAgentId,
         state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
         interruptContent,

package/dist/runtime/harness/events/listener-runtime.d.ts

@@ -4,10 +4,10 @@ export declare function createListenerDispatchRuntime(input: {
     notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
     getThread: (threadId: string) => Promise<{
         currentState: RunResult["state"];
-        latestRunId: string;
+        latestRequestId: string;
         entryAgentId: string;
         currentAgentId?: string;
-        runs: Array<{
+        requests: Array<{
             agentId: string;
         }>;
         pendingDecision?: {

package/dist/runtime/harness/events/streaming.d.ts

@@ -1,20 +1,20 @@
 import type { HarnessEvent, HarnessStreamItem, RunListeners, RunResult } from "../../../contracts/types.js";
 export type InternalHarnessStreamItem = HarnessStreamItem | {
     type: "content";
-    threadId: string;
-    runId: string;
+    sessionId: string;
+    requestId: string;
     agentId: string;
     content: string;
 } | {
     type: "content-blocks";
-    threadId: string;
-    runId: string;
+    sessionId: string;
+    requestId: string;
     agentId: string;
     contentBlocks: unknown[];
 } | {
     type: "tool-result";
-    threadId: string;
-    runId: string;
+    sessionId: string;
+    requestId: string;
     agentId: string;
     toolName: string;
     output: unknown;
@@ -27,10 +27,10 @@ export declare function dispatchRunListeners(stream: AsyncGenerator<InternalHarn
     notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
     getThread: (threadId: string) => Promise<{
         currentState: RunResult["state"];
-        latestRunId: string;
+        latestRequestId: string;
         entryAgentId: string;
         currentAgentId?: string;
-        runs: Array<{
+        requests: Array<{
             agentId: string;
         }>;
         pendingDecision?: {

package/dist/runtime/harness/events/streaming.js

@@ -5,8 +5,8 @@ export async function emitOutputDeltaAndCreateItem(emit, threadId, runId, agentI
     });
     return {
         type: "content",
-        threadId,
-        runId,
+        sessionId: threadId,
+        requestId: runId,
         agentId,
         content,
     };
@@ -14,8 +14,8 @@ export async function emitOutputDeltaAndCreateItem(emit, threadId, runId, agentI
 export function createContentBlocksItem(threadId, runId, agentId, contentBlocks) {
     return {
         type: "content-blocks",
-        threadId,
-        runId,
+        sessionId: threadId,
+        requestId: runId,
         agentId,
         contentBlocks,
     };
@@ -44,8 +44,8 @@ export async function dispatchRunListeners(stream, listeners, options) {
             await options.notifyListener(listeners.onUpstreamEvent, item.event);
             if (item.surfaceItem) {
                 await options.notifyListener(listeners.onTraceItem, {
-                    threadId: item.threadId,
-                    runId: item.runId,
+                    sessionId: item.sessionId,
+                    requestId: item.requestId,
                     surfaceItem: item.surfaceItem,
                     event: item.event,
                 });
@@ -67,16 +67,16 @@ export async function dispatchRunListeners(stream, listeners, options) {
     if (latestResult) {
         return mergeRunResultOutput(latestResult, output);
     }
-    const thread = await options.getThread(latestEvent.threadId);
+    const thread = await options.getThread(latestEvent.sessionId);
     if (!thread) {
-        throw new Error(`Unknown thread ${latestEvent.threadId}`);
+        throw new Error(`Unknown session ${latestEvent.sessionId}`);
     }
     return createFallbackRunResultFromLatestEvent({
         latestEvent,
         currentState: thread.currentState,
-        latestRunId: thread.latestRunId,
+        latestRunId: thread.latestRequestId,
         entryAgentId: thread.entryAgentId,
-        latestAgentId: thread.currentAgentId ?? thread.runs[0]?.agentId,
+        latestAgentId: thread.currentAgentId ?? thread.requests[0]?.agentId,
         approvalId: thread.pendingDecision?.approvalId,
         pendingActionId: thread.pendingDecision?.pendingActionId,
         output,

package/dist/runtime/harness/events/timeline.js

@@ -19,10 +19,10 @@ function classifyTimelineItem(event) {
 }
 export function projectRuntimeTimeline(events, options = {}) {
     const filtered = events.filter((event) => {
-        if (options.threadId && event.threadId !== options.threadId) {
+        if (options.sessionId && event.sessionId !== options.sessionId) {
             return false;
         }
-        if (options.runId && event.runId !== options.runId) {
+        if (options.requestId && event.requestId !== options.requestId) {
             return false;
         }
         return true;
@@ -40,8 +40,8 @@ export function projectRuntimeTimeline(events, options = {}) {
     })
         .map((event) => ({
         eventId: event.eventId,
-        threadId: event.threadId,
-        runId: event.runId,
+        sessionId: event.sessionId,
+        requestId: event.requestId,
         eventType: event.eventType,
         timestamp: event.timestamp,
         sequence: event.sequence,

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

@@ -57,8 +57,8 @@ export function mergeRunResultOutput(result, streamedOutput) {
 }
 export function createFallbackRunResultFromLatestEvent(input) {
     return {
-        threadId: input.latestEvent.threadId,
-        runId: input.latestRunId,
+        sessionId: input.latestEvent.sessionId,
+        requestId: input.latestRunId,
         agentId: input.latestAgentId ?? input.entryAgentId,
         state: input.currentState,
         output: input.output,

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>;