@botbotgo/agent-harness 0.0.290 → 0.0.291

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

@@ -40,16 +40,16 @@ function formatApprovalSection(approvals) {
     return lines;
 }
 function renderRunSummaryMarkdown(input) {
-    const sessionId = input.thread.sessionId ?? input.thread.threadId ?? "";
+    const sessionId = input.session.sessionId;
     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",
+        "# Request Memory Summary",
         "",
-        `- thread_id: ${sessionId}`,
-        `- run_id: ${input.runId}`,
+        `- session_id: ${sessionId}`,
+        `- request_id: ${input.requestId}`,
         `- agent_id: ${input.agentId}`,
-        `- status: ${input.thread.status}`,
+        `- status: ${input.session.status}`,
         `- trigger: ${input.trigger}`,
         `- captured_at: ${input.capturedAt}`,
         "",
@@ -58,16 +58,16 @@ function renderRunSummaryMarkdown(input) {
         ...formatApprovalSection(input.approvals),
     ].join("\n");
 }
-function renderThreadDigestMarkdown(input) {
-    const sessionId = input.thread.sessionId ?? input.thread.threadId ?? "";
+function renderSessionDigestMarkdown(input) {
+    const sessionId = input.session.sessionId;
     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",
+        "# Durable Session Digest",
         "",
-        `- thread_id: ${sessionId}`,
-        `- latest_run_id: ${input.runId}`,
-        `- status: ${input.thread.status}`,
+        `- session_id: ${sessionId}`,
+        `- latest_request_id: ${input.requestId}`,
+        `- status: ${input.session.status}`,
         `- last_memory_trigger: ${input.trigger}`,
         `- updated_at: ${input.capturedAt}`,
         "",
@@ -79,23 +79,26 @@ function renderThreadDigestMarkdown(input) {
         "",
     ].join("\n");
 }
-const RUNTIME_MEMORY_EVENT_TYPES = new Set(["run.state.changed", "approval.resolved"]);
+const RUNTIME_MEMORY_EVENT_TYPES = new Set([
+    "request.state.changed",
+    "approval.resolved",
+]);
 export function readRuntimeMemorySyncConfig(runtimeMemory) {
     if (runtimeMemory?.enabled !== true) {
         return undefined;
     }
     const ingestion = asRecord(runtimeMemory.ingestion);
     const writeOnApprovalResolution = asBoolean(ingestion?.writeOnApprovalResolution) ?? true;
-    const writeOnRunCompletion = asBoolean(ingestion?.writeOnRunCompletion) ?? true;
-    if (!writeOnApprovalResolution && !writeOnRunCompletion) {
+    const writeOnRequestCompletion = asBoolean(ingestion?.writeOnRequestCompletion) ?? true;
+    if (!writeOnApprovalResolution && !writeOnRequestCompletion) {
         return undefined;
     }
     return {
         enabled: true,
         writeOnApprovalResolution,
-        writeOnRunCompletion,
+        writeOnRequestCompletion,
         backgroundConsolidation: asBoolean(ingestion?.backgroundConsolidation) ?? true,
-        maxMessagesPerRun: asPositiveInteger(ingestion?.maxMessagesPerRun) ?? 40,
+        maxMessagesPerRequest: asPositiveInteger(ingestion?.maxMessagesPerRequest) ?? 40,
     };
 }
 export class RuntimeMemorySync {
@@ -119,15 +122,15 @@ export class RuntimeMemorySync {
         if (event.eventType === "approval.resolved") {
             return this.config.writeOnApprovalResolution;
         }
-        return this.config.writeOnRunCompletion && event.payload.state === "completed";
+        return this.config.writeOnRequestCompletion && event.payload.state === "completed";
     }
     async handleEvent(event) {
         if (!this.shouldHandle(event)) {
             return;
         }
-        const trigger = event.eventType === "approval.resolved" ? "approval.resolved" : "run.completed";
+        const trigger = event.eventType === "approval.resolved" ? "approval.resolved" : "request.completed";
         const task = this.syncChain
-            .then(() => this.syncRun(event.sessionId ?? event.threadId ?? "", event.requestId ?? event.runId ?? "", trigger, event.timestamp))
+            .then(() => this.syncRun(event.sessionId, event.requestId, trigger, event.timestamp))
             .catch(() => {
             // Fail open: runtime memory sync must not break the hot path.
         });
@@ -140,24 +143,24 @@ export class RuntimeMemorySync {
         });
         this.pending.add(task);
     }
-    async syncRun(threadId, runId, trigger, capturedAt) {
-        const [thread, run, allMessages, approvals] = await Promise.all([
-            this.persistence.getSession(threadId),
-            this.persistence.getRun(runId),
-            this.persistence.listThreadMessages(threadId, this.config.maxMessagesPerRun),
-            this.persistence.getRunApprovals(threadId, runId),
+    async syncRun(sessionId, requestId, trigger, capturedAt) {
+        const [session, run, allMessages, approvals] = await Promise.all([
+            this.persistence.getSession(sessionId),
+            this.persistence.getRequest(requestId),
+            this.persistence.listSessionMessages(sessionId, this.config.maxMessagesPerRequest),
+            this.persistence.getRequestApprovals(sessionId, requestId),
         ]);
-        if (!thread || !run) {
+        if (!session || !run) {
             return;
         }
-        const messages = allMessages.filter((message) => (message.requestId ?? message.runId) === runId);
+        const messages = allMessages.filter((message) => message.requestId === requestId);
         if (messages.length === 0) {
             return;
         }
-        const agentId = run.agentId ?? thread.agentId;
+        const agentId = run.agentId ?? session.agentId;
         const summaryMarkdown = renderRunSummaryMarkdown({
-            thread,
-            runId,
+            session,
+            requestId,
             agentId,
             trigger,
             capturedAt,
@@ -165,16 +168,16 @@ export class RuntimeMemorySync {
             approvals,
         });
         await Promise.all([
-            this.store.put(this.resolveRunNamespace(threadId), `${runId}.summary.md`, { content: `${summaryMarkdown}\n` }),
-            this.store.put(this.resolveRunNamespace(threadId), `${runId}.record.json`, {
+            this.store.put(this.resolveRequestNamespace(sessionId), `${requestId}.summary.md`, { content: `${summaryMarkdown}\n` }),
+            this.store.put(this.resolveRequestNamespace(sessionId), `${requestId}.record.json`, {
                 kind: "summary",
-                scope: "thread",
-                threadId,
-                runId,
+                scope: "session",
+                sessionId,
+                requestId,
                 agentId,
                 trigger,
                 capturedAt,
-                status: thread.status,
+                status: session.status,
                 messageCount: messages.length,
                 approvalCount: approvals.length,
             }),
@@ -182,20 +185,20 @@ export class RuntimeMemorySync {
         if (!this.config.backgroundConsolidation) {
             return;
         }
-        const digestMarkdown = renderThreadDigestMarkdown({
-            thread,
-            runId,
+        const digestMarkdown = renderSessionDigestMarkdown({
+            session,
+            requestId,
             trigger,
             capturedAt,
             messages,
         });
-        await this.store.put(this.resolveThreadNamespace(threadId), "durable-summary.md", { content: `${digestMarkdown}\n` });
+        await this.store.put(this.resolveSessionNamespace(sessionId), "durable-summary.md", { content: `${digestMarkdown}\n` });
     }
-    resolveThreadNamespace(threadId) {
-        return this.options.resolveThreadNamespace ? this.options.resolveThreadNamespace(threadId) : ["memories", "sessions", threadId];
+    resolveSessionNamespace(sessionId) {
+        return this.options.resolveSessionNamespace ? this.options.resolveSessionNamespace(sessionId) : ["memories", "sessions", sessionId];
     }
-    resolveRunNamespace(threadId) {
-        return this.options.resolveRunNamespace ? this.options.resolveRunNamespace(threadId) : ["memories", "requests", threadId];
+    resolveRequestNamespace(sessionId) {
+        return this.options.resolveRequestNamespace ? this.options.resolveRequestNamespace(sessionId) : ["memories", "requests", sessionId];
     }
     async close() {
         await Promise.allSettled(Array.from(this.pending));

package/dist/runtime/harness/system/{thread-memory-sync.d.ts → session-memory-sync.d.ts}

@@ -1,21 +1,21 @@
 import type { HarnessEvent, HarnessEventProjection } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
-type ThreadMemorySyncOptions = {
-    resolveThreadNamespace?: (threadId: string) => string[];
+type SessionMemorySyncOptions = {
+    resolveSessionNamespace?: (sessionId: string) => string[];
 };
-export declare class ThreadMemorySync implements HarnessEventProjection {
+export declare class SessionMemorySync implements HarnessEventProjection {
     private readonly persistence;
     private readonly store?;
     private readonly options;
     private readonly pending;
     private syncChain;
-    readonly name = "thread-memory-sync";
+    readonly name = "session-memory-sync";
     constructor(persistence: RuntimePersistence, store?: {
         put: (namespace: string[], key: string, value: Record<string, any>) => Promise<void>;
-    } | undefined, options?: ThreadMemorySyncOptions);
+    } | undefined, options?: SessionMemorySyncOptions);
     shouldHandle(event: HarnessEvent): boolean;
     handleEvent(event: HarnessEvent): Promise<void>;
-    private syncThread;
+    private syncSession;
     close(): Promise<void>;
 }
-export { ThreadMemorySync as MemoryWorker };
+export { SessionMemorySync as MemoryWorker };

package/dist/runtime/harness/system/{thread-memory-sync.js → session-memory-sync.js}

@@ -6,19 +6,19 @@ function excerpt(message) {
     const normalized = extractMessageText(message.content).replace(/\s+/g, " ").trim();
     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 ?? "";
+function renderSessionSnapshotMarkdown(session, messages, approvals) {
+    const sessionId = session.sessionId;
+    const latestRequestId = session.latestRequestId;
     const userMessages = messages.filter((message) => message.role === "user");
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     return [
-        "# Thread Snapshot",
+        "# Session Snapshot",
         "",
-        `- thread_id: ${sessionId}`,
-        `- latest_run_id: ${latestRequestId}`,
-        `- agent_id: ${thread.agentId}`,
-        `- status: ${thread.status}`,
-        `- updated_at: ${thread.updatedAt}`,
+        `- session_id: ${sessionId}`,
+        `- latest_request_id: ${latestRequestId}`,
+        `- agent_id: ${session.agentId}`,
+        `- status: ${session.status}`,
+        `- updated_at: ${session.updatedAt}`,
         "",
         "## Recent User Message",
         excerpt(userMessages.at(-1)),
@@ -39,44 +39,44 @@ function formatOpenApprovalsSection(approvals) {
         lines.push(`### ${approval.approvalId}`);
         lines.push(`- pending_action_id: ${approval.pendingActionId}`);
         lines.push(`- tool: ${approval.toolName}`);
-        lines.push(`- run_id: ${approval.requestId ?? approval.runId}`);
+        lines.push(`- request_id: ${approval.requestId}`);
         lines.push(`- requested_at: ${approval.requestedAt}`);
         lines.push(`- allowed: ${approval.allowedDecisions.join(", ")}`);
         lines.push("");
     }
     return lines;
 }
-function resolveThreadNamespace(threadId, resolver) {
-    return resolver ? resolver(threadId) : ["memories", "sessions", threadId];
+function resolveSessionNamespace(sessionId, resolver) {
+    return resolver ? resolver(sessionId) : ["memories", "sessions", sessionId];
 }
-const THREAD_MEMORY_EVENT_TYPES = new Set([
-    "run.state.changed",
-    "run.queued",
-    "run.dequeued",
+const SESSION_MEMORY_EVENT_TYPES = new Set([
+    "request.state.changed",
+    "request.queued",
+    "request.dequeued",
     "approval.resolved",
     "approval.requested",
 ]);
-export class ThreadMemorySync {
+export class SessionMemorySync {
     persistence;
     store;
     options;
     pending = new Set();
     syncChain = Promise.resolve();
-    name = "thread-memory-sync";
+    name = "session-memory-sync";
     constructor(persistence, store, options = {}) {
         this.persistence = persistence;
         this.store = store;
         this.options = options;
     }
     shouldHandle(event) {
-        return THREAD_MEMORY_EVENT_TYPES.has(event.eventType);
+        return SESSION_MEMORY_EVENT_TYPES.has(event.eventType);
     }
     async handleEvent(event) {
         if (!this.shouldHandle(event)) {
             return;
         }
         const task = this.syncChain
-            .then(() => this.syncThread(event.sessionId ?? event.threadId ?? ""))
+            .then(() => this.syncSession(event.sessionId))
             .catch(() => {
             // Fail open: background memory digestion must not break the hot path.
         });
@@ -89,25 +89,25 @@ export class ThreadMemorySync {
         });
         this.pending.add(task);
     }
-    async syncThread(threadId) {
-        const thread = await this.persistence.getSession(threadId);
-        if (!thread) {
+    async syncSession(sessionId) {
+        const session = await this.persistence.getSession(sessionId);
+        if (!session) {
             return;
         }
         const [messages, approvals] = await Promise.all([
-            this.persistence.listThreadMessages(threadId, 24),
+            this.persistence.listSessionMessages(sessionId, 24),
             this.persistence.listApprovals(),
         ]);
-        const pendingApprovals = approvals.filter((approval) => (approval.sessionId ?? approval.threadId) === threadId && approval.status === "pending");
+        const pendingApprovals = approvals.filter((approval) => approval.sessionId === sessionId && approval.status === "pending");
         if (!this.store) {
             return;
         }
-        await this.store.put(resolveThreadNamespace(threadId, this.options.resolveThreadNamespace), "snapshot.md", {
-            content: `${renderThreadSnapshotMarkdown(thread, messages, pendingApprovals)}\n`,
+        await this.store.put(resolveSessionNamespace(sessionId, this.options.resolveSessionNamespace), "snapshot.md", {
+            content: `${renderSessionSnapshotMarkdown(session, messages, pendingApprovals)}\n`,
         });
     }
     async close() {
         await Promise.allSettled(Array.from(this.pending));
     }
 }
-export { ThreadMemorySync as MemoryWorker };
+export { SessionMemorySync as MemoryWorker };

package/dist/runtime/harness.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, RuntimeOperatorOverview, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeArtifactWriteInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, RuntimeRunPackage, RuntimeRunPackageInput, RuntimeSessionPackage, RuntimeSessionPackageInput, ResumeOptions, RunOptions, RunResult, RunSummary, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, SessionSummary, ThreadSummary, ThreadRecord, SessionRecord, RequestRecord, RequestSummary, SessionListSummary, WorkspaceBundle } from "../contracts/types.js";
+import type { ApprovalRecord, ArtifactListing, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, RuntimeOperatorOverview, ListMemoriesInput, ListMemoriesResult, MessageContent, RemoveMemoryInput, RequestOptions, RequestRecord, RequestResult, RequestSummary, RequestStartOptions, RestartConversationOptions, RuntimeAdapterOptions, RuntimeArtifactWriteInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, RuntimeRequestPackage, RuntimeRequestPackageInput, RuntimeSessionPackage, RuntimeSessionPackageInput, ResumeOptions, MemoryRecord, MemorizeInput, MemorizeResult, RecallInput, RecallResult, UpdateMemoryInput, SessionSummary, SessionRecord, SessionListSummary, WorkspaceBundle } from "../contracts/types.js";
 import { type RuntimeMcpServerOptions, type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./harness/system/skill-requirements.js";
@@ -16,15 +16,15 @@ export declare class AgentHarnessRuntime {
     private readonly vectorStores;
     private readonly runtimeEntryBindings;
     private readonly defaultRuntimeEntryBinding?;
-    private readonly defaultRunRootValue;
+    private readonly defaultRuntimeRootValue;
     private readonly defaultStore;
     private readonly runtimeMemoryStore;
     private readonly runtimeMemoryPolicy;
     private readonly runtimeMemoryMaintenanceConfig;
     private readonly routingRules;
     private readonly routingDefaultAgentId?;
-    private readonly threadMemorySync;
-    private readonly unregisterThreadMemorySync;
+    private readonly sessionMemorySync;
+    private readonly unregisterSessionMemorySync;
     private readonly runtimeMemorySync;
     private readonly unregisterRuntimeMemorySync;
     private readonly mem0IngestionSync;
@@ -41,16 +41,16 @@ export declare class AgentHarnessRuntime {
     private readonly concurrencyConfig;
     private readonly backgroundTasks;
     private readonly workerId;
-    private activeRunSlots;
+    private activeRequestSlots;
     private pendingRunInsertionOrder;
-    private readonly pendingRunSlots;
+    private readonly pendingRequestSlots;
     private runtimeEventSequence;
     private initialized;
     private closed;
     private readonly backgroundEventRuntime;
     private readonly runtimeEventOperations;
     private resolveRuntimeMemoryVectorStore;
-    private defaultRunRoot;
+    private defaultRuntimeRoot;
     private getDefaultRuntimeEntryAgentId;
     private resolveSelectedAgentId;
     private createPrepareRunStartRuntime;
@@ -70,43 +70,33 @@ export declare class AgentHarnessRuntime {
     listSessionSummaries(filter?: {
         agentId?: string;
     }): Promise<SessionListSummary[]>;
-    listThreads(filter?: {
-        agentId?: string;
-    }): Promise<ThreadSummary[]>;
     listRequests(filter?: {
         agentId?: string;
         sessionId?: string;
         state?: RequestSummary["state"];
     }): Promise<RequestSummary[]>;
-    listRuns(filter?: {
-        agentId?: string;
-        threadId?: string;
-        state?: RunSummary["state"];
-    }): Promise<RunSummary[]>;
     memorize(input: MemorizeInput): Promise<MemorizeResult>;
     recall(input: RecallInput): Promise<RecallResult>;
     listMemories(input?: ListMemoriesInput): Promise<ListMemoriesResult>;
     updateMemory(input: UpdateMemoryInput): Promise<MemoryRecord>;
     removeMemory(input: RemoveMemoryInput): Promise<MemoryRecord>;
     getRequest(requestId: string): Promise<RequestRecord | null>;
-    getRun(runId: string): Promise<RunRecord | null>;
     private getSessionSummary;
-    private getSession;
+    private getSessionSummaryRecord;
+    getSession(sessionId: string): Promise<SessionRecord | null>;
     getSessionRecord(sessionId: string): Promise<SessionRecord | null>;
-    getThread(threadId: string): Promise<ThreadRecord | null>;
     listApprovals(filter?: {
         status?: ApprovalRecord["status"];
         sessionId?: string;
         requestId?: string;
     }): Promise<ApprovalRecord[]>;
     getApproval(approvalId: string): Promise<ApprovalRecord | null>;
-    listArtifacts(threadId: string, runId: string): Promise<ArtifactListing>;
-    readArtifact(threadId: string, runId: string, artifactPath: string): Promise<unknown>;
+    listRequestArtifacts(sessionId: string, requestId: string): Promise<ArtifactListing>;
     recordArtifact(input: RuntimeArtifactWriteInput): Promise<import("../contracts/types.js").ArtifactRecord>;
+    readRequestArtifact(sessionId: string, requestId: string, artifactPath: string): Promise<unknown>;
     listRequestEvents(sessionId: string, requestId: string): Promise<HarnessEvent[]>;
-    listRunEvents(threadId: string, runId: string): Promise<HarnessEvent[]>;
-    exportRequestPackage(input: RuntimeRunPackageInput): Promise<RuntimeRunPackage>;
-    exportRunPackage(input: RuntimeRunPackageInput): Promise<RuntimeRunPackage>;
+    exportRequestPackage(input: RuntimeRequestPackageInput): Promise<RuntimeRequestPackage>;
+    exportRunPackage(input: RuntimeRequestPackageInput): Promise<RuntimeRequestPackage>;
     exportSessionPackage(input: RuntimeSessionPackageInput): Promise<RuntimeSessionPackage>;
     exportEvaluationBundle(input: RuntimeEvaluationExportInput): Promise<RuntimeEvaluationExport>;
     replayEvaluationBundle(input: RuntimeEvaluationReplayInput): Promise<RuntimeEvaluationReplayResult>;
@@ -116,50 +106,48 @@ export declare class AgentHarnessRuntime {
         workspaceRoot: string;
         agents: InventoryAgentRecord[];
     };
-    private deleteThreadCheckpoints;
+    private deleteSessionCheckpoints;
     deleteSession(sessionId: string): Promise<boolean>;
-    deleteThread(threadId: string): Promise<boolean>;
-    deleteThreadLegacy(threadId: string): Promise<boolean>;
     createToolMcpServer(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
     serveToolsOverStdio(options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
     createRuntimeMcpServer(options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
     serveRuntimeMcpOverStdio(options?: RuntimeMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp").McpServer>;
     routeAgent(input: MessageContent, options?: {
-        threadId?: string;
+        sessionId?: string;
     }): Promise<string>;
     private emit;
     private trackBackgroundTask;
     private scheduleBackgroundStartupTask;
     private resolveToolMcpServerTools;
     private loadPriorHistory;
-    private loadRunInput;
-    private getRunCancellation;
-    private finalizeCancelledRun;
+    private loadRequestInput;
+    private getRequestCancellation;
+    private finalizeCancelledRequest;
     private invokeWithHistory;
     private resolveMemoryNamespace;
     private getWorkspaceId;
     private buildRuntimeMemoryContext;
     private persistRuntimeMemoryCandidates;
-    private resolvePersistedRunPriority;
-    private enqueuePendingRunSlot;
-    private executeQueuedRun;
-    private finalizeContinuedRun;
-    private setRunStateAndEmit;
+    private resolvePersistedRequestPriority;
+    private enqueuePendingRequestSlot;
+    private executeQueuedRequest;
+    private finalizeContinuedRequest;
+    private setRequestStateAndEmit;
     private requestApprovalAndEmit;
     private isDecisionRun;
     private notifyListener;
-    private acquireRunSlot;
-    private dropPendingRunSlot;
-    run(options: RunOptions): Promise<RunResult>;
-    streamEvents(options: RunStartOptions): AsyncGenerator<HarnessStreamItem>;
-    resume(options: ResumeOptions): Promise<RunResult>;
-    restartConversation(options: RestartConversationOptions): Promise<RunResult & {
+    private acquireRequestSlot;
+    private dropPendingRequestSlot;
+    run(options: RequestOptions): Promise<RequestResult>;
+    streamEvents(options: RequestStartOptions): AsyncGenerator<HarnessStreamItem>;
+    resume(options: ResumeOptions): Promise<RequestResult>;
+    restartConversation(options: RestartConversationOptions): Promise<RequestResult & {
         restart: Record<string, string>;
     }>;
     close(): Promise<void>;
     stop(): Promise<void>;
-    cancelRun(options: CancelOptions): Promise<RunResult>;
-    private recoverStartupRuns;
-    private reclaimExpiredClaimedRuns;
-    private isStaleRunningRun;
+    cancelRequest(options: CancelOptions): Promise<RequestResult>;
+    private recoverStartupRequests;
+    private reclaimExpiredClaimedRequests;
+    private isStaleRunningRequest;
 }