@botbotgo/agent-harness 0.0.290 → 0.0.291

package/dist/runtime/harness/run/run-slot-acquisition.js

@@ -1,27 +1,27 @@
-import { shiftNextPendingRunSlot } from "./run-queue.js";
-export async function acquireRunSlot(runtime, options = {}) {
-    const { threadId, runId } = options;
+import { shiftNextPendingRequestSlot } from "./run-queue.js";
+export async function acquireRequestSlot(runtime, options = {}) {
+    const { sessionId, requestId } = options;
     const activeState = options.activeState ?? "running";
     const priority = options.priority ?? 0;
     let stopHeartbeat = () => undefined;
     const beginLease = async (mode) => {
-        if (!threadId || !runId) {
+        if (!sessionId || !requestId) {
             return;
         }
         const claimedAt = new Date().toISOString();
         const leaseExpiresAt = new Date(Date.now() + runtime.concurrencyConfig.leaseMs).toISOString();
         if (mode === "queue-claim") {
-            await runtime.persistence.claimQueuedRun({
-                threadId,
-                runId,
+            await runtime.persistence.claimQueuedRequest({
+                sessionId,
+                requestId,
                 workerId: runtime.workerId,
                 claimedAt,
                 leaseExpiresAt,
             });
         }
         else {
-            await runtime.persistence.renewRunLease({
-                runId,
+            await runtime.persistence.renewRequestLease({
+                requestId,
                 workerId: runtime.workerId,
                 heartbeatAt: claimedAt,
                 leaseExpiresAt,
@@ -31,8 +31,8 @@ export async function acquireRunSlot(runtime, options = {}) {
             return;
         }
         const timer = setInterval(() => {
-            void runtime.persistence.renewRunLease({
-                runId,
+            void runtime.persistence.renewRequestLease({
+                requestId,
                 workerId: runtime.workerId,
                 heartbeatAt: new Date().toISOString(),
                 leaseExpiresAt: new Date(Date.now() + runtime.concurrencyConfig.leaseMs).toISOString(),
@@ -45,13 +45,13 @@ export async function acquireRunSlot(runtime, options = {}) {
     };
     const releaseLease = async () => {
         stopHeartbeat();
-        if (runId) {
-            await runtime.persistence.releaseRunClaim(runId);
+        if (requestId) {
+            await runtime.persistence.releaseRequestClaim(requestId);
         }
     };
     const releaseAndAdvance = async (shiftNext) => {
         await releaseLease();
-        runtime.setActiveRunSlots(Math.max(0, runtime.getActiveRunSlots() - 1));
+        runtime.setActiveRequestSlots(Math.max(0, runtime.getActiveRequestSlots() - 1));
         const next = shiftNext();
         void next?.activate();
     };
@@ -62,12 +62,12 @@ export async function acquireRunSlot(runtime, options = {}) {
             await releaseLease();
         };
     }
-    const canActivateImmediately = runtime.getActiveRunSlots() < maxConcurrentRuns;
+    const canActivateImmediately = runtime.getActiveRequestSlots() < maxConcurrentRuns;
     const useDirectHeartbeatFastPath = canActivateImmediately && maxConcurrentRuns > 1;
     if (canActivateImmediately) {
-        runtime.setActiveRunSlots(runtime.getActiveRunSlots() + 1);
-        if (threadId && runId && !useDirectHeartbeatFastPath) {
-            await runtime.persistence.enqueueRun({ threadId, runId, priority });
+        runtime.setActiveRequestSlots(runtime.getActiveRequestSlots() + 1);
+        if (sessionId && requestId && !useDirectHeartbeatFastPath) {
+            await runtime.persistence.enqueueRequest({ sessionId, requestId, priority });
         }
         await beginLease(useDirectHeartbeatFastPath ? "direct-heartbeat" : "queue-claim");
         let released = false;
@@ -76,39 +76,39 @@ export async function acquireRunSlot(runtime, options = {}) {
                 return;
             }
             released = true;
-            await releaseAndAdvance(() => shiftNextPendingRunSlot(runtime.pendingRunSlots));
+            await releaseAndAdvance(() => shiftNextPendingRequestSlot(runtime.pendingRequestSlots));
         };
     }
-    const activateQueuedRun = async () => {
-        const currentRun = runId ? await runtime.persistence.getRun(runId) : null;
-        if (currentRun?.state === "cancelled") {
+    const activateQueuedRequest = async () => {
+        const currentRequest = requestId ? await runtime.persistence.getRequest(requestId) : null;
+        if (currentRequest?.state === "cancelled") {
             return "abort";
         }
-        runtime.setActiveRunSlots(runtime.getActiveRunSlots() + 1);
-        if (threadId && runId) {
-            await runtime.emit(threadId, runId, 4, "run.dequeued", {
+        runtime.setActiveRequestSlots(runtime.getActiveRequestSlots() + 1);
+        if (sessionId && requestId) {
+            await runtime.emit(sessionId, requestId, 4, "request.dequeued", {
                 queuePosition: 0,
-                activeRunCount: runtime.getActiveRunSlots(),
+                activeRequestCount: runtime.getActiveRequestSlots(),
                 maxConcurrentRuns,
                 priority,
             });
-            await runtime.setRunStateAndEmit(threadId, runId, 5, activeState, {
+            await runtime.setRequestStateAndEmit(sessionId, requestId, 5, activeState, {
                 previousState: "queued",
             });
             await beginLease("queue-claim");
         }
         return "activate";
     };
-    if (threadId && runId) {
-        await runtime.persistence.enqueueRun({ threadId, runId, priority });
+    if (sessionId && requestId) {
+        await runtime.persistence.enqueueRequest({ sessionId, requestId, priority });
         const slotAcquisition = new Promise((resolve, reject) => {
-            const displacedEntries = runtime.enqueuePendingRunSlot({
-                threadId,
-                runId,
+            const displacedEntries = runtime.enqueuePendingRequestSlot({
+                sessionId,
+                requestId,
                 priority,
                 activate: async () => {
                     try {
-                        resolve(await activateQueuedRun());
+                        resolve(await activateQueuedRequest());
                     }
                     catch (error) {
                         reject(error);
@@ -116,20 +116,20 @@ export async function acquireRunSlot(runtime, options = {}) {
                 },
                 abort: () => resolve("abort"),
             });
-            void Promise.all(displacedEntries.map((candidate) => runtime.emit(candidate.threadId, candidate.runId, 3, "run.queued", {
+            void Promise.all(displacedEntries.map((candidate) => runtime.emit(candidate.sessionId, candidate.requestId, 3, "request.queued", {
                 queuePosition: candidate.queuePosition,
-                activeRunCount: runtime.getActiveRunSlots(),
+                activeRequestCount: runtime.getActiveRequestSlots(),
                 maxConcurrentRuns,
                 priority: candidate.priority,
             })));
         });
-        const queuePosition = runtime.pendingRunSlots.findIndex((entry) => entry.runId === runId) + 1;
-        await runtime.setRunStateAndEmit(threadId, runId, 2, "queued", {
+        const queuePosition = runtime.pendingRequestSlots.findIndex((entry) => entry.requestId === requestId) + 1;
+        await runtime.setRequestStateAndEmit(sessionId, requestId, 2, "queued", {
             previousState: activeState,
         });
-        await runtime.emit(threadId, runId, 3, "run.queued", {
+        await runtime.emit(sessionId, requestId, 3, "request.queued", {
             queuePosition,
-            activeRunCount: runtime.getActiveRunSlots(),
+            activeRequestCount: runtime.getActiveRequestSlots(),
             maxConcurrentRuns,
             priority,
         });
@@ -143,7 +143,7 @@ export async function acquireRunSlot(runtime, options = {}) {
                 return;
             }
             released = true;
-            await releaseAndAdvance(() => runtime.pendingRunSlots.shift());
+            await releaseAndAdvance(() => runtime.pendingRequestSlots.shift());
         };
     }
     let released = false;
@@ -152,6 +152,6 @@ export async function acquireRunSlot(runtime, options = {}) {
             return;
         }
         released = true;
-        await releaseAndAdvance(() => shiftNextPendingRunSlot(runtime.pendingRunSlots));
+        await releaseAndAdvance(() => shiftNextPendingRequestSlot(runtime.pendingRequestSlots));
     };
 }

package/dist/runtime/harness/run/{thread-records.d.ts → session-records.d.ts}

@@ -1,29 +1,22 @@
-import type { ApprovalRecord, RequestRecord, SessionRecord, SessionSummary, RunSummary, ThreadRecord, ThreadSummary } from "../../../contracts/types.js";
+import type { ApprovalRecord, RequestRecord, SessionRecord, SessionSummary, RequestSummary } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
-export declare function buildRequestInspectionRecord(persistence: RuntimePersistence, request: RunSummary): Promise<RequestRecord>;
+export declare function buildRequestInspectionRecord(persistence: RuntimePersistence, request: RequestSummary): Promise<RequestRecord>;
 export declare function buildSessionInspectionRecord(input: {
     persistence: RuntimePersistence;
     getSession: (sessionId: string) => Promise<SessionSummary | null>;
 }, sessionId: string): Promise<SessionRecord | null>;
-export declare function buildThreadInspectionRecord(input: {
-    persistence: RuntimePersistence;
-    getSession: (threadId: string) => Promise<ThreadSummary | null>;
-}, threadId: string): Promise<ThreadRecord | null>;
 export declare function listPublicApprovals(input: {
     persistence: RuntimePersistence;
 }, filter?: {
     status?: ApprovalRecord["status"];
-    threadId?: string;
-    runId?: string;
+    sessionId?: string;
+    requestId?: string;
+    legacySessionId?: string;
+    legacyRunId?: string;
 }): Promise<ApprovalRecord[]>;
 export declare function getPublicApproval(input: {
     persistence: RuntimePersistence;
 }, approvalId: string): Promise<ApprovalRecord | null>;
-export declare function deleteThreadRecord(input: {
-    getThread: (threadId: string) => Promise<ThreadRecord | null>;
-    deleteThread: (threadId: string) => Promise<boolean>;
-    deleteThreadCheckpoints: (threadId: string) => Promise<void>;
-}, threadId: string): Promise<boolean>;
 export declare function deleteSessionRecord(input: {
     getSession: (sessionId: string) => Promise<SessionRecord | null>;
     deleteSession: (sessionId: string) => Promise<boolean>;

package/dist/runtime/harness/run/{thread-records.js → session-records.js}

@@ -1,4 +1,4 @@
-import { isTerminalRunState, toInspectableApprovalRecord } from "./helpers.js";
+import { isTerminalRequestState, toInspectableApprovalRecord } from "./helpers.js";
 import { projectRuntimeTimeline } from "../events/timeline.js";
 function selectLatestPendingApproval(approvals) {
     return approvals
@@ -6,13 +6,13 @@ function selectLatestPendingApproval(approvals) {
         .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
 }
 export async function buildRequestInspectionRecord(persistence, request) {
-    const inspection = await persistence.getRunInspection(request.sessionId, request.requestId);
-    const runtimeEvents = await persistence.listRunEvents(request.sessionId, request.requestId);
+    const inspection = await persistence.getRequestInspection(request.sessionId, request.requestId);
+    const runtimeEvents = await persistence.listRequestEvents(request.sessionId, request.requestId);
     return {
         requestId: request.requestId,
         sessionId: request.sessionId,
         agentId: request.agentId,
-        parentRunId: request.parentRunId,
+        parentRequestId: request.parentRequestId,
         executionMode: request.executionMode,
         adapterKind: request.adapterKind,
         createdAt: request.createdAt,
@@ -33,42 +33,19 @@ export async function buildRequestInspectionRecord(persistence, request) {
         }),
     };
 }
-function toRunRecord(request) {
-    return {
-        requestId: request.requestId,
-        sessionId: request.sessionId,
-        agentId: request.agentId,
-        parentRunId: request.parentRunId,
-        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,
-    };
-}
 export async function buildSessionInspectionRecord(input, sessionId) {
     const [sessionSummary, meta, messages, requestSummaries] = await Promise.all([
         input.getSession(sessionId),
-        input.persistence.getThreadMeta(sessionId),
-        input.persistence.listThreadMessages(sessionId, 200),
-        input.persistence.listThreadRuns(sessionId),
+        input.persistence.getSessionMeta(sessionId),
+        input.persistence.listSessionMessages(sessionId, 200),
+        input.persistence.listSessionRequests(sessionId),
     ]);
     if (!sessionSummary || !meta) {
         return null;
     }
     const latestRequestId = sessionSummary.latestRequestId;
     const requests = await Promise.all(requestSummaries.map((request) => buildRequestInspectionRecord(input.persistence, request)));
-    const latestApprovals = await input.persistence.getRunApprovals(sessionId, latestRequestId);
+    const latestApprovals = await input.persistence.getRequestApprovals(sessionId, latestRequestId);
     const pendingApproval = selectLatestPendingApproval(latestApprovals);
     return {
         sessionId,
@@ -91,47 +68,24 @@ export async function buildSessionInspectionRecord(input, sessionId) {
             : undefined,
     };
 }
-export async function buildThreadInspectionRecord(input, threadId) {
-    const session = await buildSessionInspectionRecord({
-        persistence: input.persistence,
-        getSession: async (sessionId) => {
-            const summary = await input.getSession(sessionId);
-            return summary
-                ? { ...summary }
-                : null;
-        },
-    }, threadId);
-    return session ? { ...session } : null;
-}
 export async function listPublicApprovals(input, filter) {
-    const approvals = await input.persistence.listApprovals(filter);
+    const approvals = await input.persistence.listApprovals({
+        status: filter?.status,
+        sessionId: filter?.sessionId ?? filter?.legacySessionId,
+        requestId: filter?.requestId ?? filter?.legacyRunId,
+    });
     return approvals.map((approval) => toInspectableApprovalRecord(approval));
 }
 export async function getPublicApproval(input, approvalId) {
     const approval = await input.persistence.getApproval(approvalId);
     return approval ? toInspectableApprovalRecord(approval) : null;
 }
-export async function deleteThreadRecord(input, threadId) {
-    const thread = await input.getThread(threadId);
-    if (!thread) {
-        return false;
-    }
-    const activeRun = thread.requests.find((run) => !isTerminalRunState(run.state));
-    if (activeRun) {
-        throw new Error(`Cannot delete thread ${threadId} while run ${activeRun.requestId} is ${activeRun.state}`);
-    }
-    const deleted = await input.deleteThread(threadId);
-    if (deleted) {
-        await input.deleteThreadCheckpoints(threadId);
-    }
-    return deleted;
-}
 export async function deleteSessionRecord(input, sessionId) {
     const session = await input.getSession(sessionId);
     if (!session) {
         return false;
     }
-    const activeRequest = session.requests.find((request) => !isTerminalRunState(request.state));
+    const activeRequest = session.requests.find((request) => !isTerminalRequestState(request.state));
     if (activeRequest) {
         throw new Error(`Cannot delete session ${sessionId} while request ${activeRequest.requestId} is ${activeRequest.state}`);
     }

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

@@ -1,14 +1,14 @@
-import type { HarnessEvent, InvocationEnvelope, MessageContent, RunResult, RunStartOptions, WorkspaceBundle } from "../../../contracts/types.js";
-import type { PersistedRunRequest } from "../../../persistence/types.js";
+import type { HarnessEvent, InvocationEnvelope, MessageContent, RequestResult, RequestStartOptions, WorkspaceBundle } from "../../../contracts/types.js";
+import type { PersistedRequestInput } from "../../../persistence/types.js";
 import type { PolicyEngine } from "../system/policy-engine.js";
 type Binding = WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never;
-type EnsureThreadStartedRuntime = {
+type EnsureSessionStartedRuntime = {
     persistence: {
-        bootstrapRun?: (input: {
-            threadId: string;
+        bootstrapRequest?: (input: {
+            sessionId: string;
             agentId: string;
-            runId: string;
-            status: RunResult["state"];
+            requestId: string;
+            status: RequestResult["state"];
             createdAt: string;
             executionMode: string;
             adapterKind: string;
@@ -18,29 +18,29 @@ type EnsureThreadStartedRuntime = {
                 requestId: string;
                 createdAt: string;
             };
-            runRequest: PersistedRunRequest;
-            createThread: boolean;
+            requestInput: PersistedRequestInput;
+            createSession: boolean;
             startedAt?: string;
             currentAgentId?: string;
             delegationChain?: string[];
             runtimeSnapshot?: import("../../../contracts/types.js").RuntimeSnapshot;
         }) => Promise<void>;
-        createThread: (input: {
-            threadId: string;
+        createSession: (input: {
+            sessionId: string;
             agentId: string;
-            runId: string;
-            status: RunResult["state"];
+            requestId: string;
+            status: RequestResult["state"];
             createdAt: string;
         }) => Promise<void>;
-        appendThreadMessage: (threadId: string, message: {
+        appendSessionMessage?: (sessionId: string, message: {
             role: "user";
             content: MessageContent;
             requestId: string;
             createdAt: string;
         }) => Promise<void>;
-        createRun: (input: {
-            threadId: string;
-            runId: string;
+        createRequest: (input: {
+            sessionId: string;
+            requestId: string;
             agentId: string;
             executionMode: string;
             adapterKind: string;
@@ -50,41 +50,41 @@ type EnsureThreadStartedRuntime = {
             delegationChain?: string[];
             runtimeSnapshot?: import("../../../contracts/types.js").RuntimeSnapshot;
         }) => Promise<void>;
-        saveRunRequest: (threadId: string, runId: string, runRequest: PersistedRunRequest) => Promise<void>;
+        saveRequestInput?: (sessionId: string, requestId: string, requestInput: PersistedRequestInput) => Promise<void>;
     };
 };
-type PrepareRunStartRuntime = EnsureThreadStartedRuntime & {
+type PrepareRequestStartRuntime = EnsureSessionStartedRuntime & {
     workspace: WorkspaceBundle;
     policyEngine: PolicyEngine;
-    resolveSelectedAgentId: (input: MessageContent, requestedAgentId?: string, threadId?: string) => Promise<string>;
-    emitRunCreated: (threadId: string, runId: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;
-    acquireRunSlot: (threadId?: string, runId?: string, activeState?: RunResult["state"], priority?: number) => Promise<() => Promise<void>>;
+    resolveSelectedAgentId: (input: MessageContent, requestedAgentId?: string, sessionId?: string) => Promise<string>;
+    emitRequestCreated: (sessionId: string, requestId: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;
+    acquireRequestSlot: (sessionId?: string, requestId?: string, activeState?: RequestResult["state"], priority?: number) => Promise<() => Promise<void>>;
 };
-export declare function ensureThreadStarted(runtime: EnsureThreadStartedRuntime, input: {
+export declare function ensureSessionStarted(runtime: EnsureSessionStartedRuntime, input: {
     selectedAgentId: string;
     binding: Binding;
     message: MessageContent;
-    runRequest: PersistedRunRequest;
-    existingThreadId?: string;
+    requestInput: PersistedRequestInput;
+    existingSessionId?: string;
 }): Promise<{
-    threadId: string;
-    runId: string;
+    sessionId: string;
+    requestId: string;
     createdAt: string;
-    isNewThread: boolean;
+    isNewSession: boolean;
 }>;
-export declare function prepareRunStart(runtime: PrepareRunStartRuntime, input: {
-    options: Pick<RunStartOptions, "input" | "agentId" | "sessionId" | "priority">;
+export declare function prepareRunStart(runtime: PrepareRequestStartRuntime, input: {
+    options: Pick<RequestStartOptions, "input" | "agentId" | "sessionId" | "priority">;
     invocation: InvocationEnvelope;
-    runCreatedPayload: (binding: Binding, selectedAgentId: string) => Record<string, unknown>;
+    requestCreatedPayload: (binding: Binding, selectedAgentId: string) => Record<string, unknown>;
 }): Promise<{
     binding: Binding;
     selectedAgentId: string;
     priority: number;
-    threadId: string;
-    runId: string;
-    isNewThread: boolean;
-    runCreatedEventPromise: Promise<HarnessEvent>;
-    releaseRunSlotPromise: Promise<() => Promise<void>>;
+    sessionId: string;
+    requestId: string;
+    isNewSession: boolean;
+    requestCreatedEventPromise: Promise<HarnessEvent>;
+    releaseRequestSlotPromise: Promise<() => Promise<void>>;
 }>;
 export declare function defaultRequestedAgentId(agentId?: string): string;
 export {};

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

@@ -1,38 +1,60 @@
 import { AUTO_AGENT_ID } from "../../../contracts/types.js";
 import { createPersistentId } from "../../../utils/id.js";
 import { normalizeMessageContent } from "../../../utils/message-content.js";
-import { buildPersistedRunRequest, normalizeRunPriority } from "./helpers.js";
+import { buildPersistedRequestInput, normalizeRequestPriority } from "./helpers.js";
 import { getRequiredWorkspaceBinding } from "../bindings.js";
 import { getBindingAdapterKind, getBindingRuntimeExecutionMode } from "../../support/compiled-binding.js";
-import { buildRunRuntimeSnapshot } from "./inspection.js";
-export async function ensureThreadStarted(runtime, input) {
-    const { selectedAgentId, binding, message, runRequest, existingThreadId } = input;
-    const threadId = existingThreadId ?? createPersistentId();
-    const runId = createPersistentId();
+import { buildRequestRuntimeSnapshot } from "./inspection.js";
+async function appendUserMessage(runtime, sessionId, message) {
+    await runtime.persistence.appendSessionMessage?.(sessionId, message);
+}
+async function saveRequestInput(runtime, sessionId, requestId, requestInput) {
+    await runtime.persistence.saveRequestInput?.(sessionId, requestId, requestInput);
+}
+async function createSessionRecord(runtime, sessionId, input) {
+    await runtime.persistence.createSession({
+        sessionId,
+        agentId: input.agentId,
+        requestId: input.requestId,
+        status: input.status,
+        createdAt: input.createdAt,
+    });
+}
+async function createRequestRecord(runtime, sessionId, requestId, input) {
+    await runtime.persistence.createRequest({
+        sessionId,
+        requestId,
+        ...input,
+    });
+}
+export async function ensureSessionStarted(runtime, input) {
+    const { selectedAgentId, binding, message, requestInput, existingSessionId } = input;
+    const sessionId = existingSessionId ?? createPersistentId();
+    const requestId = createPersistentId();
     const createdAt = new Date().toISOString();
-    const isNewThread = !existingThreadId;
+    const isNewSession = !existingSessionId;
     const startedAt = createdAt;
     const currentAgentId = selectedAgentId;
     const delegationChain = [selectedAgentId];
-    const runtimeSnapshot = buildRunRuntimeSnapshot(binding, { runId });
+    const runtimeSnapshot = buildRequestRuntimeSnapshot(binding, { requestId });
     const userMessage = {
         role: "user",
         content: normalizeMessageContent(message),
-        requestId: runId,
+        requestId,
         createdAt,
     };
-    if (typeof runtime.persistence.bootstrapRun === "function") {
-        await runtime.persistence.bootstrapRun({
-            threadId,
+    if (typeof runtime.persistence.bootstrapRequest === "function") {
+        await runtime.persistence.bootstrapRequest({
+            sessionId,
             agentId: binding.agent.id,
-            runId,
+            requestId,
             status: "running",
             createdAt,
             executionMode: getBindingRuntimeExecutionMode(binding),
             adapterKind: getBindingAdapterKind(binding),
             userMessage,
-            runRequest,
-            createThread: isNewThread,
+            requestInput,
+            createSession: isNewSession,
             startedAt,
             currentAgentId,
             delegationChain,
@@ -40,20 +62,17 @@ export async function ensureThreadStarted(runtime, input) {
         });
     }
     else {
-        if (isNewThread) {
-            await runtime.persistence.createThread({
-                threadId,
+        if (isNewSession) {
+            await createSessionRecord(runtime, sessionId, {
                 agentId: selectedAgentId,
-                runId,
+                requestId,
                 status: "running",
                 createdAt,
             });
         }
         await Promise.all([
-            runtime.persistence.appendThreadMessage(threadId, userMessage),
-            runtime.persistence.createRun({
-                threadId,
-                runId,
+            appendUserMessage(runtime, sessionId, userMessage),
+            createRequestRecord(runtime, sessionId, requestId, {
                 agentId: binding.agent.id,
                 executionMode: getBindingRuntimeExecutionMode(binding),
                 adapterKind: getBindingAdapterKind(binding),
@@ -63,37 +82,37 @@ export async function ensureThreadStarted(runtime, input) {
                 delegationChain,
                 runtimeSnapshot,
             }),
-            runtime.persistence.saveRunRequest(threadId, runId, runRequest),
+            saveRequestInput(runtime, sessionId, requestId, requestInput),
         ]);
     }
-    return { threadId, runId, createdAt, isNewThread };
+    return { sessionId, requestId, createdAt, isNewSession };
 }
 export async function prepareRunStart(runtime, input) {
-    const { options, invocation, runCreatedPayload } = input;
+    const { options, invocation, requestCreatedPayload } = input;
     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) {
         throw new Error(`Policy evaluation blocked agent ${selectedAgentId}: ${policyDecision.reasons.join(", ")}`);
     }
-    const priority = normalizeRunPriority(options.priority);
-    const runRequest = buildPersistedRunRequest(options.input, invocation, priority);
-    const { threadId, runId, isNewThread } = await ensureThreadStarted(runtime, {
+    const priority = normalizeRequestPriority(options.priority);
+    const requestInput = buildPersistedRequestInput(options.input, invocation, priority);
+    const { sessionId, requestId, isNewSession } = await ensureSessionStarted(runtime, {
         selectedAgentId,
         binding,
         message: options.input,
-        runRequest,
-        existingThreadId: options.sessionId,
+        requestInput,
+        existingSessionId: options.sessionId,
     });
     return {
         binding,
         selectedAgentId,
         priority,
-        threadId,
-        runId,
-        isNewThread,
-        runCreatedEventPromise: runtime.emitRunCreated(threadId, runId, runCreatedPayload(binding, selectedAgentId)),
-        releaseRunSlotPromise: runtime.acquireRunSlot(threadId, runId, "running", priority),
+        sessionId,
+        requestId,
+        isNewSession,
+        requestCreatedEventPromise: runtime.emitRequestCreated(sessionId, requestId, requestCreatedPayload(binding, selectedAgentId)),
+        releaseRequestSlotPromise: runtime.acquireRequestSlot(sessionId, requestId, "running", priority),
     };
 }
 export function defaultRequestedAgentId(agentId) {

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

@@ -1,4 +1,4 @@
-import type { RunResult, ThreadSummary } from "../../../contracts/types.js";
+import type { RequestResult, SessionSummary } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
 import type { ConcurrencyConfig, RecoveryConfig } from "../../../workspace/support/workspace-ref-utils.js";
 import { type StartupRecoveryContext } from "./recovery.js";
@@ -10,25 +10,25 @@ export declare function initializeHarnessRuntime(input: {
     healthMonitor: Startable | null;
     scheduleBackgroundTask?: (task: Promise<void>) => void;
 }): Promise<void>;
-export declare function recoverStartupRuns(input: {
+export declare function recoverStartupRequests(input: {
     recoveryConfig: RecoveryConfig;
     persistence: RuntimePersistence;
     createStartupRecoveryContext: () => StartupRecoveryContext;
-    reclaimExpiredClaimedRuns: (nowIso?: string) => Promise<void>;
+    reclaimExpiredClaimedRequests: (nowIso?: string) => Promise<void>;
 }): Promise<void>;
-export declare function reclaimExpiredClaimedRuns(input: {
+export declare function reclaimExpiredClaimedRequests(input: {
     persistence: RuntimePersistence;
-    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+    setRequestStateAndEmit: (sessionId: string, requestId: string, sequence: number, state: RequestResult["state"], options: {
         previousState: string | null;
         checkpointRef?: string | null;
         error?: string;
     }) => Promise<unknown>;
-    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
+    emit: (sessionId: string, requestId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
     concurrencyConfig: ConcurrencyConfig;
-    getActiveRunSlots: () => number;
+    getActiveRequestSlots: () => number;
 }, nowIso?: string): Promise<void>;
-export declare function isStaleRunningRun(input: {
+export declare function isStaleRunningRequest(input: {
     persistence: RuntimePersistence;
     concurrencyConfig: ConcurrencyConfig;
-}, thread: ThreadSummary, nowMs?: number): Promise<boolean>;
+}, session: SessionSummary, nowMs?: number): Promise<boolean>;
 export {};