@botbotgo/agent-harness 0.0.268 → 0.0.269

package/dist/persistence/file-store.js

@@ -197,10 +197,10 @@ export class FilePersistence {
     }
     async appendEvent(event) {
         const sequenceId = String(event.sequence).padStart(6, "0");
-        const inspectionPath = path.join(this.runDir(event.threadId, event.runId), "inspection.json");
+        const inspectionPath = path.join(this.runDir(event.sessionId, event.requestId), "inspection.json");
         const inspection = await readJson(inspectionPath);
         await Promise.all([
-            writeJson(path.join(this.runDir(event.threadId, event.runId), "events", `${sequenceId}.json`), event),
+            writeJson(path.join(this.runDir(event.sessionId, event.requestId), "events", `${sequenceId}.json`), event),
             writeJson(inspectionPath, {
                 ...inspection,
                 lastActivityAt: event.timestamp,
@@ -221,8 +221,8 @@ export class FilePersistence {
             ]);
             return {
                 agentId: meta.entryAgentId,
-                threadId: index.threadId,
-                latestRunId: index.latestRunId,
+                sessionId: index.threadId,
+                latestRequestId: index.latestRunId,
                 createdAt: meta.createdAt,
                 updatedAt: index.updatedAt,
                 status: index.status,
@@ -237,9 +237,9 @@ export class FilePersistence {
         const sessions = await this.listSessions(filter);
         const summaries = await Promise.all(sessions.map(async (session) => {
             const [meta, messageBundle] = await Promise.all([
-                readJson(path.join(this.threadDir(session.threadId), "meta.json")),
-                readJson(path.join(this.threadDir(session.threadId), "messages.json"))
-                    .catch(() => ({ threadId: session.threadId, items: [] })),
+                readJson(path.join(this.threadDir(session.sessionId), "meta.json")),
+                readJson(path.join(this.threadDir(session.sessionId), "messages.json"))
+                    .catch(() => ({ threadId: session.sessionId, items: [] })),
             ]);
             const items = messageBundle.items;
             return {
@@ -268,8 +268,8 @@ export class FilePersistence {
             readJson(path.join(runDir, "inspection.json")),
         ]);
         return {
-            runId: meta.runId,
-            threadId: meta.threadId,
+            requestId: meta.runId,
+            sessionId: meta.threadId,
             agentId: meta.agentId,
             ...(meta.parentRunId ? { parentRunId: meta.parentRunId } : {}),
             executionMode: meta.executionMode,
@@ -295,7 +295,7 @@ export class FilePersistence {
             if (filter.agentId && run.agentId !== filter.agentId) {
                 return false;
             }
-            if (filter.threadId && run.threadId !== filter.threadId) {
+            if (filter.threadId && run.sessionId !== filter.threadId) {
                 return false;
             }
             if (filter.state && run.state !== filter.state) {
@@ -325,8 +325,8 @@ export class FilePersistence {
         const runInspection = await readJson(path.join(this.runDir(threadId, index.latestRunId), "inspection.json")).catch(() => null);
         return {
             agentId: meta.entryAgentId,
-            threadId,
-            latestRunId: index.latestRunId,
+            sessionId: threadId,
+            latestRequestId: index.latestRunId,
             createdAt: meta.createdAt,
             updatedAt: index.updatedAt,
             status: index.status,
@@ -370,10 +370,10 @@ export class FilePersistence {
             if (filter.status && approval.status !== filter.status) {
                 return false;
             }
-            if (filter.threadId && approval.threadId !== filter.threadId) {
+            if (filter.threadId && approval.sessionId !== filter.threadId) {
                 return false;
             }
-            if (filter.runId && approval.runId !== filter.runId) {
+            if (filter.runId && approval.requestId !== filter.runId) {
                 return false;
             }
             return true;
@@ -460,7 +460,7 @@ export class FilePersistence {
                 .filter((record) => record.threadId === threadId)
                 .map((record) => rm(this.runIndexPath(record.runId), { force: true })),
             ...approvals
-                .filter((record) => record.threadId === threadId)
+                .filter((record) => record.sessionId === threadId)
                 .map((record) => rm(this.approvalIndexPath(record.approvalId), { force: true })),
             ...runIndexes
                 .filter((record) => record.threadId === threadId)
@@ -487,9 +487,16 @@ export class FilePersistence {
         }
     }
     async createApproval(record) {
+        const sessionId = record.sessionId ?? record.threadId ?? "";
+        const requestId = record.requestId ?? record.runId ?? "";
+        const normalized = {
+            ...record,
+            sessionId,
+            requestId,
+        };
         await Promise.all([
-            writeJson(path.join(this.runDir(record.threadId, record.runId), "approvals", `${record.approvalId}.json`), record),
-            writeJson(path.join(this.runRoot, "indexes", "approvals", `${record.approvalId}.json`), record),
+            writeJson(path.join(this.runDir(sessionId, requestId), "approvals", `${record.approvalId}.json`), normalized),
+            writeJson(path.join(this.runRoot, "indexes", "approvals", `${record.approvalId}.json`), normalized),
         ]);
     }
     async resolveApproval(threadId, runId, approvalId, status) {

package/dist/persistence/sqlite-run-context-store.js

@@ -27,7 +27,7 @@ export class SqliteRunContextStore {
     async appendThreadMessage(threadId, message) {
         await this.db.execute(`INSERT INTO thread_messages
        (thread_id, role, content_json, run_id, created_at)
-       VALUES (?, ?, ?, ?, ?)`, [threadId, message.role, JSON.stringify(message.content), message.runId, message.createdAt]);
+       VALUES (?, ?, ?, ?, ?)`, [threadId, message.role, JSON.stringify(message.content), message.requestId ?? message.runId, message.createdAt]);
     }
     async listThreadMessages(threadId, limit = 12) {
         const rows = await this.db.selectAll(`SELECT role, content_json, run_id, created_at
@@ -42,7 +42,7 @@ export class SqliteRunContextStore {
         return rows.map((row) => ({
             role: asString(row.role),
             content: parseJson(row.content_json),
-            runId: asString(row.run_id),
+            requestId: asString(row.run_id),
             createdAt: asString(row.created_at),
         }));
     }

package/dist/persistence/sqlite-store.js

@@ -413,8 +413,8 @@ export class SqlitePersistence {
     mapThreadSummary(row) {
         return {
             agentId: asString(row.entry_agent_id),
-            threadId: asString(row.thread_id),
-            latestRunId: asString(row.latest_run_id),
+            sessionId: asString(row.thread_id),
+            latestRequestId: asString(row.latest_run_id),
             createdAt: asString(row.created_at),
             updatedAt: asString(row.updated_at),
             status: asString(row.status),
@@ -424,8 +424,8 @@ export class SqlitePersistence {
     mapRunSummary(row) {
         const runtimeSnapshot = row.runtime_snapshot_json ? parseJson(row.runtime_snapshot_json) : null;
         return {
-            runId: asString(row.run_id),
-            threadId: asString(row.thread_id),
+            requestId: asString(row.run_id),
+            sessionId: asString(row.thread_id),
             agentId: asString(row.agent_id),
             ...(asNullableString(row.parent_run_id) ? { parentRunId: asNullableString(row.parent_run_id) } : {}),
             executionMode: asString(row.execution_mode),
@@ -458,8 +458,8 @@ export class SqlitePersistence {
         return {
             approvalId: asString(row.approval_id),
             pendingActionId: asString(row.pending_action_id),
-            threadId: asString(row.thread_id),
-            runId: asString(row.run_id),
+            sessionId: asString(row.thread_id),
+            requestId: asString(row.run_id),
             toolCallId: asString(row.tool_call_id),
             toolName: asString(row.tool_name),
             status: asString(row.status),
@@ -612,7 +612,7 @@ export class SqlitePersistence {
                 input.threadId,
                 input.userMessage.role,
                 JSON.stringify(input.userMessage.content),
-                input.userMessage.runId,
+                input.userMessage.requestId ?? input.userMessage.runId,
                 input.userMessage.createdAt,
             ],
         }, {
@@ -681,10 +681,10 @@ export class SqlitePersistence {
     async appendEvent(event) {
         await this.execute(`INSERT OR REPLACE INTO events
        (thread_id, run_id, sequence, event_json, created_at)
-       VALUES (?, ?, ?, ?, ?)`, [event.threadId, event.runId, event.sequence, JSON.stringify(event), event.timestamp]);
+       VALUES (?, ?, ?, ?, ?)`, [event.sessionId, event.requestId, event.sequence, JSON.stringify(event), event.timestamp]);
         await this.execute(`UPDATE run_inspection
        SET last_activity_at = ?
-       WHERE run_id = ? AND thread_id = ?`, [event.timestamp, event.runId, event.threadId]);
+       WHERE run_id = ? AND thread_id = ?`, [event.timestamp, event.requestId, event.sessionId]);
     }
     async listSessions(filter = {}) {
         const { clause, args } = buildWhereClause([
@@ -750,7 +750,7 @@ export class SqlitePersistence {
                 ? {
                     role: asString(row.first_message_role),
                     content: parseJson(row.first_message_content_json),
-                    runId: asString(row.first_message_run_id),
+                    requestId: asString(row.first_message_run_id),
                     createdAt: asString(row.first_message_created_at),
                 }
                 : undefined,
@@ -758,7 +758,7 @@ export class SqlitePersistence {
                 ? {
                     role: asString(row.last_message_role),
                     content: parseJson(row.last_message_content_json),
-                    runId: asString(row.last_message_run_id),
+                    requestId: asString(row.last_message_run_id),
                     createdAt: asString(row.last_message_created_at),
                 }
                 : undefined,
@@ -972,13 +972,15 @@ export class SqlitePersistence {
         await this.runContextStore.clearRunRequest(threadId, runId);
     }
     async createApproval(record) {
+        const sessionId = record.sessionId ?? record.threadId ?? "";
+        const requestId = record.requestId ?? record.runId ?? "";
         await this.execute(`INSERT OR REPLACE INTO approvals
        (approval_id, pending_action_id, thread_id, run_id, tool_call_id, tool_name, status, requested_at, resolved_at, allowed_decisions_json, input_preview_json, checkpoint_ref, event_refs_json)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
             record.approvalId,
             record.pendingActionId,
-            record.threadId,
-            record.runId,
+            sessionId,
+            requestId,
             record.toolCallId,
             record.toolName,
             record.status,
@@ -992,7 +994,7 @@ export class SqlitePersistence {
     }
     async resolveApproval(threadId, runId, approvalId, status) {
         const current = await this.getApproval(approvalId);
-        if (!current || current.threadId !== threadId || current.runId !== runId) {
+        if (!current || current.sessionId !== threadId || current.requestId !== runId) {
             throw new Error(`Missing approval ${approvalId} for run ${runId}`);
         }
         const updated = {
@@ -1018,8 +1020,8 @@ export class SqlitePersistence {
        WHERE thread_id = ? AND run_id = ?
        ORDER BY created_at ASC, artifact_id ASC`, [threadId, runId]);
         return {
-            threadId,
-            runId,
+            sessionId: threadId,
+            requestId: runId,
             items: rows.map((row) => ({
                 artifactId: asString(row.artifact_id),
                 kind: asString(row.kind),

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,