@botbotgo/agent-harness 0.0.290 → 0.0.291

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

@@ -1,97 +1,97 @@
-import type { CancelOptions, CompiledAgentBinding, InternalApprovalRecord, MessageContent, ResumeOptions, RunResult, ThreadSummary, TranscriptMessage } from "../../../contracts/types.js";
+import type { CancelOptions, CompiledAgentBinding, InternalApprovalRecord, MessageContent, RequestResult, ResumeOptions, SessionRecord, TranscriptMessage } from "../../../contracts/types.js";
 import type { RecoveryIntent } from "../../../persistence/types.js";
 type ResumeOperationRuntime = {
     getApprovalById: (approvalId: string) => Promise<InternalApprovalRecord | null>;
-    getSession: (threadId: string) => Promise<ThreadSummary | null>;
-    resolveApprovalRecord: (options: ResumeOptions, thread: ThreadSummary) => Promise<InternalApprovalRecord>;
+    getSession: (sessionId: string) => Promise<SessionRecord | null>;
+    resolveApprovalRecord: (options: ResumeOptions, session: SessionRecord) => Promise<InternalApprovalRecord>;
     getBinding: (agentId: string) => CompiledAgentBinding | undefined;
     buildResumePayload: (binding: CompiledAgentBinding, approval: InternalApprovalRecord, options: ResumeOptions) => unknown;
-    getRunCancellation: (runId: string) => Promise<{
+    getRequestCancellation: (requestId: string) => Promise<{
         requested: boolean;
         reason?: string;
     }>;
-    finalizeCancelledRun: (threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string) => Promise<RunResult>;
-    setRunState: (threadId: string, runId: string, state: RunResult["state"], checkpointRef: string | null) => Promise<void>;
-    acquireRunSlot: (threadId?: string, runId?: string, activeState?: RunResult["state"], priority?: number) => Promise<() => Promise<void>>;
-    resolvePersistedRunPriority: (threadId: string, runId: string) => Promise<number>;
-    saveRecoveryIntent: (threadId: string, runId: string, payload: RecoveryIntent) => Promise<unknown>;
-    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
-    resolveApproval: (threadId: string, runId: string, approvalId: string, resolution: "approved" | "edited" | "rejected" | "expired") => Promise<unknown>;
-    listThreadMessages: (threadId: string) => Promise<TranscriptMessage[]>;
-    loadRunInput: (threadId: string, runId: string) => Promise<MessageContent>;
-    invoke: (binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string, resumePayload: unknown, priorHistory: TranscriptMessage[]) => Promise<RunResult>;
+    finalizeCancelledRequest: (sessionId: string, requestId: string, previousState: RequestResult["state"] | null, reason?: string) => Promise<RequestResult>;
+    setRequestState: (sessionId: string, requestId: string, state: RequestResult["state"], checkpointRef: string | null) => Promise<void>;
+    acquireRequestSlot: (sessionId?: string, requestId?: string, activeState?: RequestResult["state"], priority?: number) => Promise<() => Promise<void>>;
+    resolvePersistedRequestPriority: (sessionId: string, requestId: string) => Promise<number>;
+    saveRequestRecoveryIntent: (sessionId: string, requestId: string, payload: RecoveryIntent) => Promise<unknown>;
+    emit: (sessionId: string, requestId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
+    resolveApproval: (sessionId: string, requestId: string, approvalId: string, resolution: "approved" | "edited" | "rejected" | "expired") => Promise<unknown>;
+    listSessionMessages: (sessionId: string) => Promise<TranscriptMessage[]>;
+    loadRequestInput: (sessionId: string, requestId: string) => Promise<MessageContent>;
+    invoke: (binding: CompiledAgentBinding, input: MessageContent, sessionId: string, requestId: string, resumePayload: unknown, priorHistory: TranscriptMessage[]) => Promise<RequestResult>;
     recordLlmSuccess: (startedAt: number) => void;
     recordLlmFailure: (startedAt: number) => void;
-    clearRecoveryIntent: (threadId: string, runId: string) => Promise<void>;
-    finalizeContinuedRun: (binding: CompiledAgentBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
-        previousState: RunResult["state"] | null;
+    clearRequestRecoveryIntent: (sessionId: string, requestId: string) => Promise<void>;
+    finalizeContinuedRequest: (binding: CompiledAgentBinding, sessionId: string, requestId: string, input: MessageContent, actual: RequestResult, options: {
+        previousState: RequestResult["state"] | null;
         stateSequence: number;
         approvalSequence?: number;
-    }) => Promise<RunResult>;
+    }) => Promise<RequestResult>;
 };
 type CancelOperationRuntime = {
-    getRun: (runId: string) => Promise<{
+    getRequest: (requestId: string) => Promise<{
         sessionId: string;
         requestId: string;
         agentId: string;
-        state: RunResult["state"];
+        state: RequestResult["state"];
     } | null>;
-    requestRunCancel: (runId: string, reason?: string) => Promise<unknown>;
-    dropPendingRunSlot: (runId: string) => boolean;
-    finalizeCancelledRun: (threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string) => Promise<RunResult>;
-    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+    requestRequestCancel: (requestId: string, reason?: string) => Promise<unknown>;
+    dropPendingRequestSlot: (requestId: string) => boolean;
+    finalizeCancelledRequest: (sessionId: string, requestId: string, previousState: RequestResult["state"] | null, reason?: string) => Promise<RequestResult>;
+    setRequestStateAndEmit: (sessionId: string, requestId: string, sequence: number, state: RequestResult["state"], options: {
         previousState: string | null;
         checkpointRef?: string | null;
         error?: string;
     }) => Promise<unknown>;
 };
-type ExecuteQueuedRunOperationRuntime = {
+type ExecuteQueuedRequestOperationRuntime = {
     persistence: {
-        getRun: (runId: string) => Promise<{
-            state: RunResult["state"];
+        getRequest: (requestId: string) => Promise<{
+            state: RequestResult["state"];
         } | null>;
-        clearRunRequest: (threadId: string, runId: string) => Promise<void>;
+        clearRequestInput: (sessionId: string, requestId: string) => Promise<void>;
     };
-    getRunCancellation: (runId: string) => Promise<{
+    getRequestCancellation: (requestId: string) => Promise<{
         requested: boolean;
         reason?: string;
     }>;
-    finalizeCancelledRun: (threadId: string, runId: string, previousState: RunResult["state"] | null, reason?: string) => Promise<RunResult>;
-    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
-    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+    finalizeCancelledRequest: (sessionId: string, requestId: string, previousState: RequestResult["state"] | null, reason?: string) => Promise<RequestResult>;
+    emit: (sessionId: string, requestId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
+    setRequestStateAndEmit: (sessionId: string, requestId: string, sequence: number, state: RequestResult["state"], options: {
         previousState: string | null;
         checkpointRef?: string | null;
         error?: string;
     }) => Promise<unknown>;
-    invokeWithHistory: (binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string, resumePayload?: unknown, priorHistory?: TranscriptMessage[], options?: {
+    invokeWithHistory: (binding: CompiledAgentBinding, input: MessageContent, sessionId: string, requestId: string, resumePayload?: unknown, priorHistory?: TranscriptMessage[], options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
-    }) => Promise<RunResult>;
-    finalizeContinuedRun: (binding: CompiledAgentBinding, threadId: string, runId: string, input: MessageContent, actual: RunResult, options: {
-        previousState: RunResult["state"] | null;
+    }) => Promise<RequestResult>;
+    finalizeContinuedRequest: (binding: CompiledAgentBinding, sessionId: string, requestId: string, input: MessageContent, actual: RequestResult, options: {
+        previousState: RequestResult["state"] | null;
         stateSequence: number;
         approvalSequence?: number;
-    }) => Promise<RunResult>;
-    emitSyntheticFallback: (threadId: string, runId: string, agentId: string, error: unknown) => Promise<void>;
+    }) => Promise<RequestResult>;
+    emitSyntheticFallback: (sessionId: string, requestId: string, agentId: string, error: unknown) => Promise<void>;
     renderRuntimeFailure: (error: unknown) => string;
 };
-export declare function resumeRun(runtime: ResumeOperationRuntime, options: ResumeOptions): Promise<RunResult>;
-export declare function cancelRunOperation(runtime: CancelOperationRuntime, options: CancelOptions): Promise<RunResult>;
-export declare function executeQueuedRunOperation(runtime: ExecuteQueuedRunOperationRuntime, input: {
+export declare function resumeRequest(runtime: ResumeOperationRuntime, options: ResumeOptions): Promise<RequestResult>;
+export declare function cancelRequestOperation(runtime: CancelOperationRuntime, options: CancelOptions): Promise<RequestResult>;
+export declare function executeQueuedRequestOperation(runtime: ExecuteQueuedRequestOperationRuntime, input: {
     binding: CompiledAgentBinding;
     message: MessageContent;
-    threadId: string;
-    runId: string;
+    sessionId: string;
+    requestId: string;
     agentId: string;
     options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         priorHistory?: TranscriptMessage[];
-        previousState?: RunResult["state"];
+        previousState?: RequestResult["state"];
         stateSequence?: number;
         approvalSequence?: number;
     };
-}): Promise<RunResult>;
+}): Promise<RequestResult>;
 export {};

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

@@ -1,86 +1,87 @@
-import { isTerminalRunState } from "./helpers.js";
+import { isTerminalRequestState } from "./helpers.js";
 async function finalizeIfCancellationRequested(input) {
-    const cancellation = await input.getRunCancellation(input.runId);
+    const cancellation = await input.getRequestCancellation(input.requestId);
     if (!cancellation.requested) {
         return null;
     }
-    return input.finalizeCancelledRun(input.threadId, input.runId, input.previousState, cancellation.reason);
+    return input.finalizeCancelledRequest(input.sessionId, input.requestId, input.previousState, cancellation.reason);
 }
 function normalizeContinuationState(previousState) {
     return previousState === "queued" ? "running" : previousState;
 }
-export async function resumeRun(runtime, options) {
+export async function resumeRequest(runtime, options) {
     const approvalById = options.approvalId ? await runtime.getApprovalById(options.approvalId) : null;
-    const thread = options.sessionId
+    const session = options.sessionId
         ? await runtime.getSession(options.sessionId)
         : approvalById
             ? await runtime.getSession(approvalById.sessionId)
             : null;
-    if (!thread) {
+    if (!session) {
         throw new Error("resume requires either sessionId or approvalId");
     }
-    const approval = approvalById ?? await runtime.resolveApprovalRecord(options, thread);
-    const threadId = approval.sessionId;
-    const runId = approval.requestId;
-    const binding = runtime.getBinding(thread.agentId);
+    const approval = approvalById ?? await runtime.resolveApprovalRecord(options, session);
+    const sessionId = approval.sessionId;
+    const requestId = approval.requestId;
+    const activeAgentId = session.currentAgentId ?? session.entryAgentId;
+    const binding = runtime.getBinding(activeAgentId);
     if (!binding) {
-        throw new Error(`Unknown agent ${thread.agentId}`);
+        throw new Error(`Unknown agent ${activeAgentId}`);
     }
     const resumePayload = runtime.buildResumePayload(binding, approval, options);
     const cancelledBeforeResume = await finalizeIfCancellationRequested({
-        getRunCancellation: runtime.getRunCancellation,
-        finalizeCancelledRun: runtime.finalizeCancelledRun,
-        threadId,
-        runId,
-        previousState: thread.status,
+        getRequestCancellation: runtime.getRequestCancellation,
+        finalizeCancelledRequest: runtime.finalizeCancelledRequest,
+        sessionId,
+        requestId,
+        previousState: session.currentState,
     });
     if (cancelledBeforeResume) {
         return cancelledBeforeResume;
     }
-    const checkpointRef = `checkpoints/${threadId}/${runId}/cp-1`;
-    await runtime.setRunState(threadId, runId, "resuming", checkpointRef);
-    const releaseRunSlot = await runtime.acquireRunSlot(threadId, runId, "resuming", await runtime.resolvePersistedRunPriority(threadId, runId));
+    const checkpointRef = `checkpoints/${sessionId}/${requestId}/cp-1`;
+    await runtime.setRequestState(sessionId, requestId, "resuming", checkpointRef);
+    const releaseRequestSlot = await runtime.acquireRequestSlot(sessionId, requestId, "resuming", await runtime.resolvePersistedRequestPriority(sessionId, requestId));
     try {
-        await runtime.saveRecoveryIntent(threadId, runId, {
+        await runtime.saveRequestRecoveryIntent(sessionId, requestId, {
             kind: "approval-decision",
             savedAt: new Date().toISOString(),
             checkpointRef,
             resumePayload,
             attempts: 0,
         });
-        await runtime.emit(threadId, runId, 5, "run.resumed", {
+        await runtime.emit(sessionId, requestId, 5, "request.resumed", {
             resumeKind: "cross-restart",
             checkpointRef,
             state: "resuming",
             approvalId: approval.approvalId,
             pendingActionId: approval.pendingActionId,
         });
-        await runtime.resolveApproval(threadId, runId, approval.approvalId, options.decision === "reject" ? "rejected" : options.decision === "edit" ? "edited" : "approved");
-        await runtime.emit(threadId, runId, 6, "approval.resolved", {
+        await runtime.resolveApproval(sessionId, requestId, approval.approvalId, options.decision === "reject" ? "rejected" : options.decision === "edit" ? "edited" : "approved");
+        await runtime.emit(sessionId, requestId, 6, "approval.resolved", {
             approvalId: approval.approvalId,
             pendingActionId: approval.pendingActionId,
             decision: options.decision ?? "approve",
             toolName: approval.toolName,
         });
-        const history = await runtime.listThreadMessages(threadId);
-        const priorHistory = history.filter((message) => message.requestId !== runId);
-        const runInput = await runtime.loadRunInput(threadId, runId);
+        const history = await runtime.listSessionMessages(sessionId);
+        const priorHistory = history.filter((message) => message.requestId !== requestId);
+        const requestInput = await runtime.loadRequestInput(sessionId, requestId);
         const startedAt = Date.now();
         try {
-            const actual = await runtime.invoke(binding, "", threadId, runId, resumePayload, priorHistory);
+            const actual = await runtime.invoke(binding, "", sessionId, requestId, resumePayload, priorHistory);
             runtime.recordLlmSuccess(startedAt);
             const cancelledAfterInvoke = await finalizeIfCancellationRequested({
-                getRunCancellation: runtime.getRunCancellation,
-                finalizeCancelledRun: runtime.finalizeCancelledRun,
-                threadId,
-                runId,
+                getRequestCancellation: runtime.getRequestCancellation,
+                finalizeCancelledRequest: runtime.finalizeCancelledRequest,
+                sessionId,
+                requestId,
                 previousState: "resuming",
             });
             if (cancelledAfterInvoke) {
                 return cancelledAfterInvoke;
             }
-            await runtime.clearRecoveryIntent(threadId, runId);
-            const finalized = await runtime.finalizeContinuedRun(binding, threadId, runId, runInput, actual, {
+            await runtime.clearRequestRecoveryIntent(sessionId, requestId);
+            const finalized = await runtime.finalizeContinuedRequest(binding, sessionId, requestId, requestInput, actual, {
                 previousState: "resuming",
                 stateSequence: 7,
                 approvalSequence: 8,
@@ -97,95 +98,95 @@ export async function resumeRun(runtime, options) {
         }
     }
     finally {
-        await releaseRunSlot();
+        await releaseRequestSlot();
     }
 }
-export async function cancelRunOperation(runtime, options) {
-    const run = await runtime.getRun(options.requestId);
-    if (!run) {
-        throw new Error(`Unknown run ${options.requestId}`);
+export async function cancelRequestOperation(runtime, options) {
+    const request = await runtime.getRequest(options.requestId);
+    if (!request) {
+        throw new Error(`Unknown request ${options.requestId}`);
     }
-    if (isTerminalRunState(run.state)) {
+    if (isTerminalRequestState(request.state)) {
         return {
-            sessionId: run.sessionId,
-            requestId: run.requestId,
-            agentId: run.agentId,
-            state: run.state,
-            output: run.state,
+            sessionId: request.sessionId,
+            requestId: request.requestId,
+            agentId: request.agentId,
+            state: request.state,
+            output: request.state,
         };
     }
-    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.requestId);
+    await runtime.requestRequestCancel(request.requestId, options.reason);
+    if (request.state === "queued" || request.state === "waiting_for_approval" || request.state === "claimed") {
+        if (request.state === "queued") {
+            runtime.dropPendingRequestSlot(request.requestId);
         }
-        return runtime.finalizeCancelledRun(run.sessionId, run.requestId, run.state, options.reason);
+        return runtime.finalizeCancelledRequest(request.sessionId, request.requestId, request.state, options.reason);
     }
-    await runtime.setRunStateAndEmit(run.sessionId, run.requestId, 103, "cancelling", {
-        previousState: run.state,
+    await runtime.setRequestStateAndEmit(request.sessionId, request.requestId, 103, "cancelling", {
+        previousState: request.state,
         ...(options.reason ? { error: options.reason } : {}),
     });
     return {
-        sessionId: run.sessionId,
-        requestId: run.requestId,
-        agentId: run.agentId,
+        sessionId: request.sessionId,
+        requestId: request.requestId,
+        agentId: request.agentId,
         state: "cancelling",
         output: options.reason ? `cancelling: ${options.reason}` : "cancelling",
     };
 }
-export async function executeQueuedRunOperation(runtime, input) {
-    const { binding, message, threadId, runId, agentId } = input;
+export async function executeQueuedRequestOperation(runtime, input) {
+    const { binding, message, sessionId, requestId, agentId } = input;
     const options = input.options ?? {};
     const previousState = options.previousState ?? "running";
-    const currentRun = await runtime.persistence.getRun(runId);
-    if (currentRun?.state === "cancelled") {
+    const currentRequest = await runtime.persistence.getRequest(requestId);
+    if (currentRequest?.state === "cancelled") {
         return {
-            sessionId: threadId,
-            requestId: runId,
+            sessionId: sessionId,
+            requestId: requestId,
             agentId,
             state: "cancelled",
             output: "cancelled",
         };
     }
     const cancelledBeforeInvoke = await finalizeIfCancellationRequested({
-        getRunCancellation: runtime.getRunCancellation,
-        finalizeCancelledRun: runtime.finalizeCancelledRun,
-        threadId,
-        runId,
+        getRequestCancellation: runtime.getRequestCancellation,
+        finalizeCancelledRequest: runtime.finalizeCancelledRequest,
+        sessionId,
+        requestId,
         previousState,
     });
     if (cancelledBeforeInvoke) {
         return cancelledBeforeInvoke;
     }
     if (previousState === "queued") {
-        await runtime.emit(threadId, runId, 101, "run.dequeued", {
+        await runtime.emit(sessionId, requestId, 101, "request.dequeued", {
             queuePosition: 0,
-            activeRunCount: 0,
+            activeRequestCount: 0,
             maxConcurrentRuns: 0,
             recoveredOnStartup: true,
         });
-        await runtime.setRunStateAndEmit(threadId, runId, 102, "running", {
+        await runtime.setRequestStateAndEmit(sessionId, requestId, 102, "running", {
             previousState: "queued",
         });
     }
     const continuationState = normalizeContinuationState(previousState);
     try {
-        const actual = await runtime.invokeWithHistory(binding, message, threadId, runId, undefined, options.priorHistory, {
+        const actual = await runtime.invokeWithHistory(binding, message, sessionId, requestId, undefined, options.priorHistory, {
             context: options.context,
             state: options.state,
             files: options.files,
         });
         const cancelledAfterInvoke = await finalizeIfCancellationRequested({
-            getRunCancellation: runtime.getRunCancellation,
-            finalizeCancelledRun: runtime.finalizeCancelledRun,
-            threadId,
-            runId,
+            getRequestCancellation: runtime.getRequestCancellation,
+            finalizeCancelledRequest: runtime.finalizeCancelledRequest,
+            sessionId,
+            requestId,
             previousState: continuationState,
         });
         if (cancelledAfterInvoke) {
             return cancelledAfterInvoke;
         }
-        const finalized = await runtime.finalizeContinuedRun(binding, threadId, runId, message, actual, {
+        const finalized = await runtime.finalizeContinuedRequest(binding, sessionId, requestId, message, actual, {
             previousState: continuationState,
             stateSequence: options.stateSequence ?? 103,
             approvalSequence: options.approvalSequence ?? 104,
@@ -196,20 +197,20 @@ export async function executeQueuedRunOperation(runtime, input) {
         };
     }
     catch (error) {
-        await runtime.emitSyntheticFallback(threadId, runId, agentId, error);
-        await runtime.setRunStateAndEmit(threadId, runId, 104, "failed", {
+        await runtime.emitSyntheticFallback(sessionId, requestId, agentId, error);
+        await runtime.setRequestStateAndEmit(sessionId, requestId, 104, "failed", {
             previousState: continuationState,
             error: error instanceof Error ? error.message : String(error),
         });
         return {
-            sessionId: threadId,
-            requestId: runId,
+            sessionId: sessionId,
+            requestId: requestId,
             agentId,
             state: "failed",
             output: runtime.renderRuntimeFailure(error),
         };
     }
     finally {
-        await runtime.persistence.clearRunRequest(threadId, runId);
+        await runtime.persistence.clearRequestInput(sessionId, requestId);
     }
 }

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

@@ -1,17 +1,17 @@
-export type PendingRunSlot = {
-    threadId?: string;
-    runId?: string;
+export type PendingRequestSlot = {
+    sessionId?: string;
+    requestId?: string;
     priority: number;
     insertionOrder: number;
     activate: () => void | Promise<void>;
     abort: () => void;
 };
 export type QueuePositionChange = {
-    threadId: string;
-    runId: string;
+    sessionId: string;
+    requestId: string;
     priority: number;
     queuePosition: number;
 };
-export declare function enqueuePendingRunSlot(pendingRunSlots: PendingRunSlot[], entry: Omit<PendingRunSlot, "insertionOrder">, insertionOrder: number): QueuePositionChange[];
-export declare function shiftNextPendingRunSlot(pendingRunSlots: PendingRunSlot[]): PendingRunSlot | undefined;
-export declare function dropPendingRunSlot(pendingRunSlots: PendingRunSlot[], runId: string): boolean;
+export declare function enqueuePendingRequestSlot(pendingRequestSlots: PendingRequestSlot[], entry: Omit<PendingRequestSlot, "insertionOrder">, insertionOrder: number): QueuePositionChange[];
+export declare function shiftNextPendingRequestSlot(pendingRequestSlots: PendingRequestSlot[]): PendingRequestSlot | undefined;
+export declare function dropPendingRequestSlot(pendingRequestSlots: PendingRequestSlot[], requestId: string): boolean;

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

@@ -1,43 +1,43 @@
-export function enqueuePendingRunSlot(pendingRunSlots, entry, insertionOrder) {
-    const previousPositions = new Map(pendingRunSlots
-        .filter((candidate) => Boolean(candidate.threadId && candidate.runId))
-        .map((candidate, index) => [candidate.runId, index + 1]));
-    pendingRunSlots.push({
+export function enqueuePendingRequestSlot(pendingRequestSlots, entry, insertionOrder) {
+    const previousPositions = new Map(pendingRequestSlots
+        .filter((candidate) => Boolean(candidate.sessionId && candidate.requestId))
+        .map((candidate, index) => [candidate.requestId, index + 1]));
+    pendingRequestSlots.push({
         ...entry,
         insertionOrder,
     });
-    pendingRunSlots.sort((left, right) => {
+    pendingRequestSlots.sort((left, right) => {
         if (right.priority !== left.priority) {
             return right.priority - left.priority;
         }
         return left.insertionOrder - right.insertionOrder;
     });
-    return pendingRunSlots.flatMap((candidate, index) => {
-        if (!candidate.threadId || !candidate.runId) {
+    return pendingRequestSlots.flatMap((candidate, index) => {
+        if (!candidate.sessionId || !candidate.requestId) {
             return [];
         }
-        const previousPosition = previousPositions.get(candidate.runId);
+        const previousPosition = previousPositions.get(candidate.requestId);
         const queuePosition = index + 1;
         if (previousPosition === undefined || previousPosition === queuePosition) {
             return [];
         }
         return [{
-                threadId: candidate.threadId,
-                runId: candidate.runId,
+                sessionId: candidate.sessionId,
+                requestId: candidate.requestId,
                 priority: candidate.priority,
                 queuePosition,
             }];
     });
 }
-export function shiftNextPendingRunSlot(pendingRunSlots) {
-    return pendingRunSlots.shift();
+export function shiftNextPendingRequestSlot(pendingRequestSlots) {
+    return pendingRequestSlots.shift();
 }
-export function dropPendingRunSlot(pendingRunSlots, runId) {
-    const index = pendingRunSlots.findIndex((entry) => entry.runId === runId);
+export function dropPendingRequestSlot(pendingRequestSlots, requestId) {
+    const index = pendingRequestSlots.findIndex((entry) => entry.requestId === requestId);
     if (index < 0) {
         return false;
     }
-    const [entry] = pendingRunSlots.splice(index, 1);
+    const [entry] = pendingRequestSlots.splice(index, 1);
     entry?.abort();
     return true;
 }

package/dist/runtime/harness/run/run-slot-acquisition.d.ts

@@ -1,64 +1,64 @@
-import type { RunResult } from "../../../contracts/types.js";
-import { type PendingRunSlot } from "./run-queue.js";
-export type RunSlotConcurrencyConfig = {
+import type { RequestResult } from "../../../contracts/types.js";
+import { type PendingRequestSlot } from "./run-queue.js";
+export type RequestSlotConcurrencyConfig = {
     maxConcurrentRuns?: number;
     leaseMs: number;
     heartbeatIntervalMs: number;
 };
-type RunClaimPersistence = {
-    claimQueuedRun(payload: {
-        threadId: string;
-        runId: string;
+type RequestClaimPersistence = {
+    claimQueuedRequest(payload: {
+        sessionId: string;
+        requestId: string;
         workerId: string;
         claimedAt: string;
         leaseExpiresAt: string;
     }): Promise<unknown>;
-    renewRunLease(payload: {
-        runId: string;
+    renewRequestLease(payload: {
+        requestId: string;
         workerId: string;
         heartbeatAt: string;
         leaseExpiresAt: string;
     }): Promise<unknown>;
-    releaseRunClaim(runId: string): Promise<unknown>;
-    enqueueRun(payload: {
-        threadId: string;
-        runId: string;
+    releaseRequestClaim(requestId: string): Promise<unknown>;
+    enqueueRequest(payload: {
+        sessionId: string;
+        requestId: string;
         priority: number;
     }): Promise<unknown>;
-    getRun(runId: string): Promise<{
-        state: RunResult["state"];
+    getRequest(requestId: string): Promise<{
+        state: RequestResult["state"];
     } | null>;
 };
-type RunSlotRuntime = {
-    persistence: RunClaimPersistence;
+type RequestSlotRuntime = {
+    persistence: RequestClaimPersistence;
     workerId: string;
-    concurrencyConfig: RunSlotConcurrencyConfig;
-    pendingRunSlots: PendingRunSlot[];
-    getActiveRunSlots: () => number;
-    setActiveRunSlots: (count: number) => void;
-    enqueuePendingRunSlot: (entry: {
-        threadId?: string;
-        runId?: string;
+    concurrencyConfig: RequestSlotConcurrencyConfig;
+    pendingRequestSlots: PendingRequestSlot[];
+    getActiveRequestSlots: () => number;
+    setActiveRequestSlots: (count: number) => void;
+    enqueuePendingRequestSlot: (entry: {
+        sessionId?: string;
+        requestId?: string;
         priority: number;
         activate: () => void | Promise<void>;
         abort: () => void;
     }) => Array<{
-        threadId: string;
-        runId: string;
+        sessionId: string;
+        requestId: string;
         priority: number;
         queuePosition: number;
     }>;
-    emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
-    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+    emit: (sessionId: string, requestId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<unknown>;
+    setRequestStateAndEmit: (sessionId: string, requestId: string, sequence: number, state: RequestResult["state"], options: {
         previousState: string | null;
         checkpointRef?: string | null;
         error?: string;
     }) => Promise<unknown>;
 };
-export declare function acquireRunSlot(runtime: RunSlotRuntime, options?: {
-    threadId?: string;
-    runId?: string;
-    activeState?: RunResult["state"];
+export declare function acquireRequestSlot(runtime: RequestSlotRuntime, options?: {
+    sessionId?: string;
+    requestId?: string;
+    activeState?: RequestResult["state"];
     priority?: number;
 }): Promise<() => Promise<void>>;
 export {};