@botbotgo/agent-harness 0.0.290 → 0.0.291

package/dist/runtime/harness/events/events.js

@@ -1,7 +1,13 @@
 import { extractMessageText } from "../../../utils/message-content.js";
 import { createHarnessEvent, createPendingApproval } from "../../support/harness-support.js";
-export async function emitHarnessEvent(runtime, threadId, runId, sequence, eventType, payload, source = "runtime") {
-    const event = createHarnessEvent(threadId, runId, sequence, eventType, payload, source);
+async function updateInspection(persistence, sessionId, requestId, patch) {
+    await persistence.updateRequestInspection(sessionId, requestId, patch);
+}
+async function setRequestState(persistence, sessionId, requestId, state, checkpointRef) {
+    await persistence.setRequestState(sessionId, requestId, state, checkpointRef);
+}
+export async function emitHarnessEvent(runtime, sessionId, requestId, sequence, eventType, payload, source = "runtime") {
+    const event = createHarnessEvent(sessionId, requestId, sequence, eventType, payload, source);
     if (runtime.backgroundEventTypes.has(event.eventType)) {
         runtime.trackBackgroundTask(runtime.persistence.appendEvent(event).catch(() => {
             // Fail open for telemetry-style event persistence.
@@ -13,42 +19,42 @@ export async function emitHarnessEvent(runtime, threadId, runId, sequence, event
     runtime.publishEvent(event);
     return event;
 }
-export async function emitRunCreatedEvent(runtime, threadId, runId, payload) {
-    return emitHarnessEvent(runtime, threadId, runId, 1, "run.created", payload);
+export async function emitRequestCreatedEvent(runtime, sessionId, requestId, payload) {
+    return emitHarnessEvent(runtime, sessionId, requestId, 1, "request.created", payload);
 }
-export async function setRunStateAndEmitEvent(runtime, threadId, runId, sequence, state, options) {
-    await runtime.persistence.setRunState(threadId, runId, state, options.checkpointRef ?? null);
+export async function setRequestStateAndEmitEvent(runtime, sessionId, requestId, sequence, state, options) {
+    await setRequestState(runtime.persistence, sessionId, requestId, state, options.checkpointRef ?? null);
     const now = new Date(Date.now()).toISOString();
-    await runtime.persistence.updateRunInspection(threadId, runId, {
+    await updateInspection(runtime.persistence, sessionId, requestId, {
         lastActivityAt: now,
         ...(state === "completed" || state === "failed" || state === "cancelled" ? { endedAt: now } : {}),
     });
-    return emitHarnessEvent(runtime, threadId, runId, sequence, "run.state.changed", {
+    return emitHarnessEvent(runtime, sessionId, requestId, sequence, "request.state.changed", {
         previousState: options.previousState,
         state,
         checkpointRef: options.checkpointRef ?? null,
         ...(options.error ? { error: options.error } : {}),
     });
 }
-export async function persistApproval(runtime, threadId, runId, checkpointRef, input, interruptContent) {
-    const approval = createPendingApproval(threadId, runId, checkpointRef, extractMessageText(input), interruptContent);
+export async function persistApproval(runtime, sessionId, requestId, checkpointRef, input, interruptContent) {
+    const approval = createPendingApproval(sessionId, requestId, checkpointRef, extractMessageText(input), interruptContent);
     await runtime.persistence.createApproval(approval);
-    const artifact = await runtime.persistence.createArtifact(threadId, runId, {
-        artifactId: `artifact-approval-${runId}`,
+    const artifact = await runtime.persistence.createRequestArtifact(sessionId, requestId, {
+        artifactId: `artifact-approval-${requestId}`,
         kind: "approval-packet",
-        path: `artifacts/approval-${runId}.json`,
+        path: `artifacts/approval-${requestId}.json`,
         createdAt: approval.requestedAt,
     }, approval);
-    await emitHarnessEvent(runtime, threadId, runId, 5, "artifact.created", {
+    await emitHarnessEvent(runtime, sessionId, requestId, 5, "artifact.created", {
         artifactId: artifact.artifactId,
         kind: artifact.kind,
         path: artifact.path,
     });
     return approval;
 }
-export async function requestApprovalAndEmitEvent(runtime, threadId, runId, input, interruptContent, checkpointRef, sequence) {
-    const approval = await persistApproval(runtime, threadId, runId, checkpointRef, input, interruptContent);
-    const event = await emitHarnessEvent(runtime, threadId, runId, sequence, "approval.requested", {
+export async function requestApprovalAndEmitEvent(runtime, sessionId, requestId, input, interruptContent, checkpointRef, sequence) {
+    const approval = await persistApproval(runtime, sessionId, requestId, checkpointRef, input, interruptContent);
+    const event = await emitHarnessEvent(runtime, sessionId, requestId, sequence, "approval.requested", {
         approvalId: approval.approvalId,
         pendingActionId: approval.pendingActionId,
         toolName: approval.toolName,
@@ -58,7 +64,7 @@ export async function requestApprovalAndEmitEvent(runtime, threadId, runId, inpu
     });
     return { approval, event };
 }
-export async function emitSyntheticFallbackEvent(runtime, threadId, runId, selectedAgentId, error, sequence = 3) {
+export async function emitSyntheticFallbackEvent(runtime, sessionId, requestId, selectedAgentId, error, sequence = 3) {
     const payload = typeof error === "object" && error !== null && "reason" in error
         ? {
             ...error,
@@ -68,7 +74,7 @@ export async function emitSyntheticFallbackEvent(runtime, threadId, runId, selec
             reason: error instanceof Error ? error.message : String(error),
             selectedAgentId,
         };
-    await emitHarnessEvent(runtime, threadId, runId, sequence, "runtime.synthetic_fallback", {
+    await emitHarnessEvent(runtime, sessionId, requestId, sequence, "runtime.synthetic_fallback", {
         ...payload,
     });
 }

package/dist/runtime/harness/events/listener-runtime.d.ts

@@ -1,9 +1,9 @@
-import type { RunListeners, RunResult } from "../../../contracts/types.js";
+import type { RequestListeners, RequestResult } from "../../../contracts/types.js";
 import { type InternalHarnessStreamItem } from "./streaming.js";
 export declare function createListenerDispatchRuntime(input: {
     notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
-    getThread: (threadId: string) => Promise<{
-        currentState: RunResult["state"];
+    getSession: (sessionId: string) => Promise<{
+        currentState: RequestResult["state"];
         latestRequestId: string;
         entryAgentId: string;
         currentAgentId?: string;
@@ -16,5 +16,6 @@ export declare function createListenerDispatchRuntime(input: {
         };
     } | null>;
 }): {
-    dispatchRunListeners: (stream: AsyncGenerator<InternalHarnessStreamItem>, listeners: RunListeners) => Promise<RunResult>;
+    dispatchRequestListeners: (stream: AsyncGenerator<InternalHarnessStreamItem>, listeners: RequestListeners) => Promise<RequestResult>;
+    dispatchRunListeners: (stream: AsyncGenerator<InternalHarnessStreamItem>, listeners: RequestListeners) => Promise<RequestResult>;
 };

package/dist/runtime/harness/events/listener-runtime.js

@@ -1,9 +1,13 @@
-import { dispatchRunListeners as dispatchStreamingRunListeners } from "./streaming.js";
+import { dispatchRequestListeners as dispatchStreamingRequestListeners } from "./streaming.js";
 export function createListenerDispatchRuntime(input) {
     return {
-        dispatchRunListeners: (stream, listeners) => dispatchStreamingRunListeners(stream, listeners, {
+        dispatchRequestListeners: (stream, listeners) => dispatchStreamingRequestListeners(stream, listeners, {
             notifyListener: (listener, value) => input.notifyListener(listener, value),
-            getThread: (threadId) => input.getThread(threadId),
+            getSession: (sessionId) => input.getSession(sessionId),
+        }),
+        dispatchRunListeners: (stream, listeners) => dispatchStreamingRequestListeners(stream, listeners, {
+            notifyListener: (listener, value) => input.notifyListener(listener, value),
+            getSession: (sessionId) => input.getSession(sessionId),
         }),
     };
 }

package/dist/runtime/harness/events/runtime-event-operations.d.ts

@@ -1,17 +1,17 @@
-import type { HarnessEvent, MessageContent, RunResult } from "../../../contracts/types.js";
-import { emitRunCreatedEvent } from "./events.js";
-type EventRuntime = Parameters<typeof emitRunCreatedEvent>[0];
+import type { HarnessEvent, MessageContent, RequestResult } from "../../../contracts/types.js";
+import { emitRequestCreatedEvent } from "./events.js";
+type EventRuntime = Parameters<typeof emitRequestCreatedEvent>[0];
 export declare function createRuntimeEventOperations(runtime: EventRuntime): {
-    emitRunCreated: (threadId: string, runId: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;
-    setRunStateAndEmit: (threadId: string, runId: string, sequence: number, state: RunResult["state"], options: {
+    emitRequestCreated: (sessionId: string, requestId: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;
+    setRequestStateAndEmit: (sessionId: string, requestId: string, sequence: number, state: RequestResult["state"], options: {
         previousState: string | null;
         checkpointRef?: string | null;
         error?: string;
     }) => Promise<HarnessEvent>;
-    requestApprovalAndEmit: (threadId: string, runId: string, input: MessageContent, interruptContent: string | undefined, checkpointRef: string, sequence: number) => Promise<{
+    requestApprovalAndEmit: (sessionId: string, requestId: string, input: MessageContent, interruptContent: string | undefined, checkpointRef: string, sequence: number) => Promise<{
         approval: import("../../../contracts/runtime.js").InternalApprovalRecord;
         event: HarnessEvent;
     }>;
-    emitSyntheticFallback: (threadId: string, runId: string, selectedAgentId: string, error: unknown, sequence?: number) => Promise<void>;
+    emitSyntheticFallback: (sessionId: string, requestId: string, selectedAgentId: string, error: unknown, sequence?: number) => Promise<void>;
 };
 export {};

package/dist/runtime/harness/events/runtime-event-operations.js

@@ -1,9 +1,9 @@
-import { emitRunCreatedEvent, emitSyntheticFallbackEvent, requestApprovalAndEmitEvent, setRunStateAndEmitEvent } from "./events.js";
+import { emitRequestCreatedEvent, emitSyntheticFallbackEvent, requestApprovalAndEmitEvent, setRequestStateAndEmitEvent } from "./events.js";
 export function createRuntimeEventOperations(runtime) {
     return {
-        emitRunCreated: (threadId, runId, payload) => emitRunCreatedEvent(runtime, threadId, runId, payload),
-        setRunStateAndEmit: (threadId, runId, sequence, state, options) => setRunStateAndEmitEvent(runtime, threadId, runId, sequence, state, options),
-        requestApprovalAndEmit: (threadId, runId, input, interruptContent, checkpointRef, sequence) => requestApprovalAndEmitEvent(runtime, threadId, runId, input, interruptContent, checkpointRef, sequence),
-        emitSyntheticFallback: (threadId, runId, selectedAgentId, error, sequence) => emitSyntheticFallbackEvent(runtime, threadId, runId, selectedAgentId, error, sequence),
+        emitRequestCreated: (sessionId, requestId, payload) => emitRequestCreatedEvent(runtime, sessionId, requestId, payload),
+        setRequestStateAndEmit: (sessionId, requestId, sequence, state, options) => setRequestStateAndEmitEvent(runtime, sessionId, requestId, sequence, state, options),
+        requestApprovalAndEmit: (sessionId, requestId, input, interruptContent, checkpointRef, sequence) => requestApprovalAndEmitEvent(runtime, sessionId, requestId, input, interruptContent, checkpointRef, sequence),
+        emitSyntheticFallback: (sessionId, requestId, selectedAgentId, error, sequence) => emitSyntheticFallbackEvent(runtime, sessionId, requestId, selectedAgentId, error, sequence),
     };
 }

package/dist/runtime/harness/events/streaming.d.ts

@@ -1,4 +1,4 @@
-import type { HarnessEvent, HarnessStreamItem, RunListeners, RunResult } from "../../../contracts/types.js";
+import type { HarnessEvent, HarnessStreamItem, RequestListeners, RequestResult } from "../../../contracts/types.js";
 export type InternalHarnessStreamItem = HarnessStreamItem | {
     type: "content";
     sessionId: string;
@@ -20,13 +20,13 @@ export type InternalHarnessStreamItem = HarnessStreamItem | {
     output: unknown;
     isError?: boolean;
 };
-export declare function emitOutputDeltaAndCreateItem(emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>, threadId: string, runId: string, agentId: string, content: string): Promise<InternalHarnessStreamItem>;
-export declare function createContentBlocksItem(threadId: string, runId: string, agentId: string, contentBlocks: unknown[]): InternalHarnessStreamItem;
+export declare function emitOutputDeltaAndCreateItem(emit: (sessionId: string, requestId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>, sessionId: string, requestId: string, agentId: string, content: string): Promise<InternalHarnessStreamItem>;
+export declare function createContentBlocksItem(sessionId: string, requestId: string, agentId: string, contentBlocks: unknown[]): InternalHarnessStreamItem;
 export declare function createToolResultKey(toolName: string, output: unknown, isError?: boolean): string;
-export declare function dispatchRunListeners(stream: AsyncGenerator<InternalHarnessStreamItem>, listeners: RunListeners, options: {
+export declare function dispatchRequestListeners(stream: AsyncGenerator<InternalHarnessStreamItem>, listeners: RequestListeners, options: {
     notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
-    getThread: (threadId: string) => Promise<{
-        currentState: RunResult["state"];
+    getSession: (sessionId: string) => Promise<{
+        currentState: RequestResult["state"];
         latestRequestId: string;
         entryAgentId: string;
         currentAgentId?: string;
@@ -38,4 +38,5 @@ export declare function dispatchRunListeners(stream: AsyncGenerator<InternalHarn
             pendingActionId?: string;
         };
     } | null>;
-}): Promise<RunResult>;
+}): Promise<RequestResult>;
+export declare const dispatchRunListeners: typeof dispatchRequestListeners;

package/dist/runtime/harness/events/streaming.js

@@ -1,21 +1,21 @@
-import { createFallbackRunResultFromLatestEvent, mergeRunResultOutput } from "../run/helpers.js";
-export async function emitOutputDeltaAndCreateItem(emit, threadId, runId, agentId, content) {
-    await emit(threadId, runId, 3, "output.delta", {
+import { createFallbackRequestResultFromLatestEvent, mergeRequestResultOutput } from "../run/helpers.js";
+export async function emitOutputDeltaAndCreateItem(emit, sessionId, requestId, agentId, content) {
+    await emit(sessionId, requestId, 3, "output.delta", {
         content,
     });
     return {
         type: "content",
-        sessionId: threadId,
-        requestId: runId,
+        sessionId,
+        requestId,
         agentId,
         content,
     };
 }
-export function createContentBlocksItem(threadId, runId, agentId, contentBlocks) {
+export function createContentBlocksItem(sessionId, requestId, agentId, contentBlocks) {
     return {
         type: "content-blocks",
-        sessionId: threadId,
-        requestId: runId,
+        sessionId,
+        requestId,
         agentId,
         contentBlocks,
     };
@@ -30,7 +30,7 @@ export function createToolResultKey(toolName, output, isError) {
     }
     return JSON.stringify([toolName, serializedOutput, isError === true]);
 }
-export async function dispatchRunListeners(stream, listeners, options) {
+export async function dispatchRequestListeners(stream, listeners, options) {
     let latestEvent;
     let latestResult;
     let output = "";
@@ -65,20 +65,21 @@ export async function dispatchRunListeners(stream, listeners, options) {
         throw new Error("run did not emit any events");
     }
     if (latestResult) {
-        return mergeRunResultOutput(latestResult, output);
+        return mergeRequestResultOutput(latestResult, output);
     }
-    const thread = await options.getThread(latestEvent.sessionId);
-    if (!thread) {
+    const session = await options.getSession(latestEvent.sessionId);
+    if (!session) {
         throw new Error(`Unknown session ${latestEvent.sessionId}`);
     }
-    return createFallbackRunResultFromLatestEvent({
+    return createFallbackRequestResultFromLatestEvent({
         latestEvent,
-        currentState: thread.currentState,
-        latestRunId: thread.latestRequestId,
-        entryAgentId: thread.entryAgentId,
-        latestAgentId: thread.currentAgentId ?? thread.requests[0]?.agentId,
-        approvalId: thread.pendingDecision?.approvalId,
-        pendingActionId: thread.pendingDecision?.pendingActionId,
+        currentState: session.currentState,
+        latestRequestId: session.latestRequestId,
+        entryAgentId: session.entryAgentId,
+        latestAgentId: session.currentAgentId ?? session.requests[0]?.agentId,
+        approvalId: session.pendingDecision?.approvalId,
+        pendingActionId: session.pendingDecision?.pendingActionId,
         output,
     });
 }
+export const dispatchRunListeners = dispatchRequestListeners;

package/dist/runtime/harness/events/timeline.js

@@ -1,18 +1,18 @@
 function classifyTimelineItem(event) {
     switch (event.eventType) {
-        case "run.queued":
-        case "run.dequeued":
+        case "request.queued":
+        case "request.dequeued":
             return "queue";
         case "approval.requested":
         case "approval.resolved":
             return "approval";
-        case "run.resumed":
+        case "request.resumed":
             return "recovery";
         case "artifact.created":
             return "artifact";
-        case "run.created":
-        case "run.state.changed":
-            return "run";
+        case "request.created":
+        case "request.state.changed":
+            return "request";
         default:
             return "other";
     }

package/dist/runtime/harness/index.d.ts

@@ -16,4 +16,4 @@ export * from "./run/run-queue.js";
 export * from "./system/skill-requirements.js";
 export * from "./system/store.js";
 export * from "./events/streaming.js";
-export * from "./system/thread-memory-sync.js";
+export * from "./system/session-memory-sync.js";

package/dist/runtime/harness/index.js

@@ -16,4 +16,4 @@ export * from "./run/run-queue.js";
 export * from "./system/skill-requirements.js";
 export * from "./system/store.js";
 export * from "./events/streaming.js";
-export * from "./system/thread-memory-sync.js";
+export * from "./system/session-memory-sync.js";

package/dist/runtime/harness/run/helpers.d.ts

@@ -1,13 +1,13 @@
-import type { ApprovalRecord, HarnessEvent, InternalApprovalRecord, InvocationEnvelope, RunListeners, RunOptions, RunResult, RunStartOptions, MessageContent } from "../../../contracts/types.js";
+import type { ApprovalRecord, HarnessEvent, InternalApprovalRecord, InvocationEnvelope, RequestListeners, RequestOptions, RequestResult, RequestStartOptions, MessageContent } from "../../../contracts/types.js";
 export declare function toInspectableApprovalRecord(approval: InternalApprovalRecord): ApprovalRecord;
-export declare function normalizeInvocationEnvelope(options: RunStartOptions): {
+export declare function normalizeInvocationEnvelope(options: RequestStartOptions): {
     context?: Record<string, unknown>;
     state?: Record<string, unknown>;
     files?: Record<string, unknown>;
     invocation?: InvocationEnvelope;
 };
-export declare function isTerminalRunState(state: RunResult["state"]): boolean;
-export declare function buildPersistedRunRequest(input: MessageContent, invocation: {
+export declare function isTerminalRequestState(state: RequestResult["state"]): boolean;
+export declare function buildPersistedRequestInput(input: MessageContent, invocation: {
     context?: Record<string, unknown>;
     state?: Record<string, unknown>;
     files?: Record<string, unknown>;
@@ -18,16 +18,19 @@ export declare function buildPersistedRunRequest(input: MessageContent, invocati
     invocation?: InvocationEnvelope;
     savedAt: string;
 };
-export declare function normalizeRunPriority(priority?: number): number;
-export declare function resolveRunListeners(options: RunOptions): RunListeners | undefined;
-export declare function mergeRunResultOutput(result: RunResult, streamedOutput: string): RunResult;
-export declare function createFallbackRunResultFromLatestEvent(input: {
+export declare function normalizeRequestPriority(priority?: number): number;
+export declare function resolveRequestListeners(options: RequestOptions): RequestListeners | undefined;
+export declare const resolveRunListeners: typeof resolveRequestListeners;
+export declare function mergeRequestResultOutput(result: RequestResult, streamedOutput: string): RequestResult;
+export declare const mergeRunResultOutput: typeof mergeRequestResultOutput;
+export declare function createFallbackRequestResultFromLatestEvent(input: {
     latestEvent: HarnessEvent;
-    currentState: RunResult["state"];
-    latestRunId: string;
+    currentState: RequestResult["state"];
+    latestRequestId: string;
     entryAgentId: string;
     latestAgentId?: string;
     approvalId?: string;
     pendingActionId?: string;
     output: string;
-}): RunResult;
+}): RequestResult;
+export declare const createFallbackRunResultFromLatestEvent: typeof createFallbackRequestResultFromLatestEvent;

package/dist/runtime/harness/run/helpers.js

@@ -12,10 +12,10 @@ export function normalizeInvocationEnvelope(options) {
         invocation,
     };
 }
-export function isTerminalRunState(state) {
+export function isTerminalRequestState(state) {
     return state === "completed" || state === "failed";
 }
-export function buildPersistedRunRequest(input, invocation, priority) {
+export function buildPersistedRequestInput(input, invocation, priority) {
     const envelope = invocation.invocation ?? {
         ...(invocation.context ? { context: invocation.context } : {}),
         ...(invocation.state ? { inputs: invocation.state } : {}),
@@ -35,30 +35,32 @@ export function buildPersistedRunRequest(input, invocation, priority) {
         savedAt: new Date().toISOString(),
     };
 }
-export function normalizeRunPriority(priority) {
+export function normalizeRequestPriority(priority) {
     if (!Number.isFinite(priority)) {
         return 0;
     }
     return Math.trunc(priority);
 }
-export function resolveRunListeners(options) {
+export function resolveRequestListeners(options) {
     const listeners = options.listeners;
     if (!listeners) {
         return undefined;
     }
     return listeners;
 }
-export function mergeRunResultOutput(result, streamedOutput) {
+export const resolveRunListeners = resolveRequestListeners;
+export function mergeRequestResultOutput(result, streamedOutput) {
     return {
         ...result,
         output: result.output || streamedOutput,
         finalMessageText: result.finalMessageText ?? result.output ?? streamedOutput,
     };
 }
-export function createFallbackRunResultFromLatestEvent(input) {
+export const mergeRunResultOutput = mergeRequestResultOutput;
+export function createFallbackRequestResultFromLatestEvent(input) {
     return {
         sessionId: input.latestEvent.sessionId,
-        requestId: input.latestRunId,
+        requestId: input.latestRequestId,
         agentId: input.latestAgentId ?? input.entryAgentId,
         state: input.currentState,
         output: input.output,
@@ -66,3 +68,4 @@ export function createFallbackRunResultFromLatestEvent(input) {
         pendingActionId: input.pendingActionId,
     };
 }
+export const createFallbackRunResultFromLatestEvent = createFallbackRequestResultFromLatestEvent;

package/dist/runtime/harness/run/inspection.d.ts

@@ -1,6 +1,7 @@
 import type { CompiledAgentBinding, RuntimeSnapshot, RuntimeSurfaceItem } from "../../../contracts/types.js";
-export declare function buildRunRuntimeSnapshot(binding: CompiledAgentBinding, options?: {
-    runId?: string;
+export declare function buildRequestRuntimeSnapshot(binding: CompiledAgentBinding, options?: {
+    requestId?: string;
+    legacyRequestId?: string;
 }): RuntimeSnapshot;
 export declare function consumeRunInspectionUpstreamEvent(input: {
     event: unknown;

package/dist/runtime/harness/run/inspection.js

@@ -28,7 +28,7 @@ function readTracingConfig(binding) {
         asObject(legacyDeepAgentTracing) ??
         null);
 }
-function buildRuntimeSnapshotTracing(binding, runId) {
+function buildRuntimeSnapshotTracing(binding, requestId) {
     const tracing = readTracingConfig(binding);
     const observability = asObject(binding.harnessRuntime.observability);
     const runtimeTracing = asObject(observability?.tracing);
@@ -41,12 +41,12 @@ function buildRuntimeSnapshotTracing(binding, runId) {
         }))
         : [];
     if (!tracing) {
-        if (!runtimeTracing || runId === undefined || runtimeTracing.enabled === false) {
+        if (!runtimeTracing || requestId === undefined || runtimeTracing.enabled === false) {
             return undefined;
         }
         return {
             enabled: true,
-            correlationId: runId,
+            correlationId: requestId,
             metadata: {
                 ...(typeof runtimeTracing.propagation === "string" ? { propagation: runtimeTracing.propagation } : {}),
                 ...(exporters.length > 0 ? { exporters } : {}),
@@ -54,14 +54,14 @@ function buildRuntimeSnapshotTracing(binding, runId) {
         };
     }
     const enabled = tracing.enabled !== false;
-    if (!enabled || !runId) {
+    if (!enabled || !requestId) {
         return undefined;
     }
     const tags = readStringArray(tracing.tags);
     const metadata = asObject(tracing.metadata);
     return {
         enabled: true,
-        correlationId: runId,
+        correlationId: requestId,
         ...(tags.length > 0 ? { tags } : {}),
         ...((metadata && Object.keys(metadata).length > 0) || exporters.length > 0 || typeof runtimeTracing?.propagation === "string"
             ? {
@@ -74,9 +74,9 @@ function buildRuntimeSnapshotTracing(binding, runId) {
             : {}),
     };
 }
-export function buildRunRuntimeSnapshot(binding, options) {
+export function buildRequestRuntimeSnapshot(binding, options) {
     const model = getBindingPrimaryModel(binding);
-    const tracing = buildRuntimeSnapshotTracing(binding, options?.runId);
+    const tracing = buildRuntimeSnapshotTracing(binding, options?.requestId ?? options?.legacyRequestId);
     const init = typeof model?.init === "object" && model.init ? model.init : {};
     const baseUrl = typeof init.baseUrl === "string" && init.baseUrl.trim().length > 0
         ? init.baseUrl.trim()

package/dist/runtime/harness/run/operator-overview.d.ts

@@ -1,7 +1,7 @@
-import type { ApprovalRecord, RunSummary, RuntimeOperatorOverview, RuntimeHealthSnapshot } from "../../../contracts/types.js";
+import type { ApprovalRecord, RequestSummary, RuntimeOperatorOverview, RuntimeHealthSnapshot } from "../../../contracts/types.js";
 export declare function projectOperatorOverview(input: {
     health: RuntimeHealthSnapshot;
-    runs: RunSummary[];
+    requests: RequestSummary[];
     approvals: ApprovalRecord[];
     limit?: number;
 }): RuntimeOperatorOverview;

package/dist/runtime/harness/run/operator-overview.js

@@ -1,5 +1,5 @@
 import { projectQueueDiagnostics } from "./queue-diagnostics.js";
-const ACTIVE_RUN_STATES = new Set([
+const ACTIVE_REQUEST_STATES = new Set([
     "queued",
     "claimed",
     "running",
@@ -14,19 +14,19 @@ function sortNewestFirst(items, selectTimestamp) {
         return rightTs.localeCompare(leftTs);
     });
 }
-function summarizeStates(runs) {
+function summarizeRequestStates(requests) {
     const states = {};
-    for (const run of runs) {
-        states[run.state] = (states[run.state] ?? 0) + 1;
+    for (const request of requests) {
+        states[request.state] = (states[request.state] ?? 0) + 1;
     }
     return states;
 }
-function collectGovernanceToolPolicies(runs) {
-    return runs.flatMap((run) => run.runtimeSnapshot?.governance?.bundles ?? [])
+function collectGovernanceToolPolicies(requests) {
+    return requests.flatMap((request) => request.runtimeSnapshot?.governance?.bundles ?? [])
         .flatMap((bundle) => bundle.toolPolicies);
 }
-function projectGovernanceDiagnostics(runs) {
-    const toolPolicies = collectGovernanceToolPolicies(runs);
+function projectGovernanceDiagnostics(requests) {
+    const toolPolicies = collectGovernanceToolPolicies(requests);
     const highRiskTools = toolPolicies.filter((tool) => tool.risk === "high").length;
     const approvalRequiredTools = toolPolicies.filter((tool) => tool.requiresApproval).length;
     const autoApprovedTools = toolPolicies.filter((tool) => tool.decisionMode === "auto-approve").length;
@@ -35,7 +35,7 @@ function projectGovernanceDiagnostics(runs) {
     const crossTenantTools = toolPolicies.filter((tool) => tool.tenantScope === "cross-tenant").length;
     const writeAccessMcpTools = toolPolicies.filter((tool) => tool.category === "mcp" && tool.mcpAccess === "read-write").length;
     return {
-        runsWithGovernance: runs.filter((run) => (run.runtimeSnapshot?.governance?.bundles?.length ?? 0) > 0).length,
+        runsWithGovernance: requests.filter((request) => (request.runtimeSnapshot?.governance?.bundles?.length ?? 0) > 0).length,
         highRiskTools,
         approvalRequiredTools,
         autoApprovedTools,
@@ -53,15 +53,20 @@ function projectGovernanceDiagnostics(runs) {
 }
 export function projectOperatorOverview(input) {
     const limit = typeof input.limit === "number" && Number.isFinite(input.limit) && input.limit > 0 ? Math.floor(input.limit) : 5;
-    const activeRuns = sortNewestFirst(input.runs.filter((run) => ACTIVE_RUN_STATES.has(run.state)), (run) => run.lastActivityAt ?? run.updatedAt);
+    const activeRequests = sortNewestFirst(input.requests.filter((request) => ACTIVE_REQUEST_STATES.has(request.state)), (request) => request.lastActivityAt ?? request.updatedAt);
     const pendingApprovals = sortNewestFirst(input.approvals.filter((approval) => approval.status === "pending"), (approval) => approval.requestedAt);
     const queue = projectQueueDiagnostics(input.health, []);
-    const governance = projectGovernanceDiagnostics(activeRuns);
+    const governance = projectGovernanceDiagnostics(activeRequests);
+    const requestOverview = {
+        total: activeRequests.length,
+        states: summarizeRequestStates(activeRequests),
+        items: activeRequests.slice(0, limit),
+    };
     return {
         updatedAt: input.health.updatedAt,
         summary: `${queue.summary} ` +
             `pendingApprovals=${pendingApprovals.length} ` +
-            `activeRuns=${activeRuns.length} ` +
+            `activeRequests=${activeRequests.length} ` +
             `${governance.summary}`,
         health: input.health,
         queue,
@@ -69,11 +74,7 @@ export function projectOperatorOverview(input) {
             total: pendingApprovals.length,
             items: pendingApprovals.slice(0, limit),
         },
-        runs: {
-            total: activeRuns.length,
-            states: summarizeStates(activeRuns),
-            items: activeRuns.slice(0, limit),
-        },
+        requests: requestOverview,
         governance,
     };
 }

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

@@ -1,14 +1,14 @@
 export function projectQueueDiagnostics(snapshot, timeline) {
     const queueEvents = timeline.filter((item) => item.kind === "queue" || item.kind === "recovery");
-    const summary = `active=${snapshot.stats.activeRunSlots} ` +
-        `pending=${snapshot.stats.pendingRunSlots} ` +
-        `stuck=${snapshot.stats.stuckRuns} ` +
+    const summary = `active=${snapshot.stats.activeRequestSlots} ` +
+        `pending=${snapshot.stats.pendingRequestSlots} ` +
+        `stuck=${snapshot.stats.stuckRequests} ` +
         `workload=${snapshot.checks.workload.status}`;
     return {
         status: snapshot.checks.workload.status,
-        activeRunSlots: snapshot.stats.activeRunSlots,
-        pendingRunSlots: snapshot.stats.pendingRunSlots,
-        stuckRuns: snapshot.stats.stuckRuns,
+        activeRequestSlots: snapshot.stats.activeRequestSlots,
+        pendingRequestSlots: snapshot.stats.pendingRequestSlots,
+        stuckRequests: snapshot.stats.stuckRequests,
         queueEvents,
         summary,
     };