@botbotgo/agent-harness 0.0.267 → 0.0.269

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

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

@@ -121,8 +121,8 @@ function createMemoryRecord(candidate, options) {
         sourceRefs: sourceRef ? [sourceRef] : [],
         tags: candidate.tags ?? [],
         provenance: {
-            threadId: options.threadId,
-            runId: options.runId,
+            sessionId: options.threadId,
+            requestId: options.runId,
             agentId: options.agentId,
             workspaceId: options.workspaceId,
             userId: options.userId,
@@ -149,8 +149,8 @@ function refreshRecord(existing, incoming, recordedAt) {
         provenance: {
             ...existing.provenance,
             refreshedFrom: incoming.provenance,
-            lastRefreshRunId: incoming.provenance.runId,
-            lastRefreshThreadId: incoming.provenance.threadId,
+            lastRefreshRequestId: incoming.provenance.requestId,
+            lastRefreshSessionId: incoming.provenance.sessionId,
         },
         revision: existing.revision + 1,
     };
@@ -168,8 +168,8 @@ function mergeRecord(existing, incoming, recordedAt) {
         provenance: {
             ...existing.provenance,
             mergedFrom: incoming.provenance,
-            lastMergeRunId: incoming.provenance.runId,
-            lastMergeThreadId: incoming.provenance.threadId,
+            lastMergeRequestId: incoming.provenance.requestId,
+            lastMergeSessionId: incoming.provenance.sessionId,
         },
         revision: existing.revision + 1,
     };

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

@@ -40,12 +40,13 @@ function formatApprovalSection(approvals) {
     return lines;
 }
 function renderRunSummaryMarkdown(input) {
+    const sessionId = input.thread.sessionId ?? input.thread.threadId ?? "";
     const userMessages = input.messages.filter((message) => message.role === "user").slice(-3);
     const assistantMessages = input.messages.filter((message) => message.role === "assistant").slice(-3);
     return [
         "# Run Memory Summary",
         "",
-        `- thread_id: ${input.thread.threadId}`,
+        `- thread_id: ${sessionId}`,
         `- run_id: ${input.runId}`,
         `- agent_id: ${input.agentId}`,
         `- status: ${input.thread.status}`,
@@ -58,12 +59,13 @@ function renderRunSummaryMarkdown(input) {
     ].join("\n");
 }
 function renderThreadDigestMarkdown(input) {
+    const sessionId = input.thread.sessionId ?? input.thread.threadId ?? "";
     const latestUser = input.messages.filter((message) => message.role === "user").at(-1);
     const latestAssistant = input.messages.filter((message) => message.role === "assistant").at(-1);
     return [
         "# Durable Thread Digest",
         "",
-        `- thread_id: ${input.thread.threadId}`,
+        `- thread_id: ${sessionId}`,
         `- latest_run_id: ${input.runId}`,
         `- status: ${input.thread.status}`,
         `- last_memory_trigger: ${input.trigger}`,
@@ -125,7 +127,7 @@ export class RuntimeMemorySync {
         }
         const trigger = event.eventType === "approval.resolved" ? "approval.resolved" : "run.completed";
         const task = this.syncChain
-            .then(() => this.syncRun(event.threadId, event.runId, trigger, event.timestamp))
+            .then(() => this.syncRun(event.sessionId ?? event.threadId ?? "", event.requestId ?? event.runId ?? "", trigger, event.timestamp))
             .catch(() => {
             // Fail open: runtime memory sync must not break the hot path.
         });
@@ -148,7 +150,7 @@ export class RuntimeMemorySync {
         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;
         }

package/dist/runtime/harness/system/thread-memory-sync.js

@@ -7,13 +7,15 @@ function excerpt(message) {
     return normalized.length > 240 ? `${normalized.slice(0, 237)}...` : normalized;
 }
 function renderThreadSnapshotMarkdown(thread, messages, approvals) {
+    const sessionId = thread.sessionId ?? thread.threadId ?? "";
+    const latestRequestId = thread.latestRequestId ?? thread.latestRunId ?? "";
     const userMessages = messages.filter((message) => message.role === "user");
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     return [
         "# Thread Snapshot",
         "",
-        `- thread_id: ${thread.threadId}`,
-        `- latest_run_id: ${thread.latestRunId}`,
+        `- thread_id: ${sessionId}`,
+        `- latest_run_id: ${latestRequestId}`,
         `- agent_id: ${thread.agentId}`,
         `- status: ${thread.status}`,
         `- updated_at: ${thread.updatedAt}`,
@@ -37,7 +39,7 @@ function formatOpenApprovalsSection(approvals) {
         lines.push(`### ${approval.approvalId}`);
         lines.push(`- pending_action_id: ${approval.pendingActionId}`);
         lines.push(`- tool: ${approval.toolName}`);
-        lines.push(`- run_id: ${approval.runId}`);
+        lines.push(`- run_id: ${approval.requestId ?? approval.runId}`);
         lines.push(`- requested_at: ${approval.requestedAt}`);
         lines.push(`- allowed: ${approval.allowedDecisions.join(", ")}`);
         lines.push("");
@@ -74,7 +76,7 @@ export class ThreadMemorySync {
             return;
         }
         const task = this.syncChain
-            .then(() => this.syncThread(event.threadId))
+            .then(() => this.syncThread(event.sessionId ?? event.threadId ?? ""))
             .catch(() => {
             // Fail open: background memory digestion must not break the hot path.
         });
@@ -96,7 +98,7 @@ export class ThreadMemorySync {
             this.persistence.listThreadMessages(threadId, 24),
             this.persistence.listApprovals(),
         ]);
-        const pendingApprovals = approvals.filter((approval) => approval.threadId === threadId && approval.status === "pending");
+        const pendingApprovals = approvals.filter((approval) => (approval.sessionId ?? approval.threadId) === threadId && approval.status === "pending");
         if (!this.store) {
             return;
         }

package/dist/runtime/harness.d.ts

@@ -95,8 +95,8 @@ export declare class AgentHarnessRuntime {
     getThread(threadId: string): Promise<ThreadRecord | null>;
     listApprovals(filter?: {
         status?: ApprovalRecord["status"];
-        threadId?: string;
-        runId?: string;
+        sessionId?: string;
+        requestId?: string;
     }): Promise<ApprovalRecord[]>;
     getApproval(approvalId: string): Promise<ApprovalRecord | null>;
     listArtifacts(threadId: string, runId: string): Promise<ArtifactListing>;