@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/runtime/config/schema.js

@@ -1,3 +1,4 @@
+import { modelPluginConfigSchema } from "./model-plugin-config.js";
 import { DEFAULT_MEMORY_RECALL_CALL_LIMIT } from "../long-term-memory/recall-policy.js";
 import { PATH_CONFIG_FIELDS, STRING_CONFIG_FIELDS, TIMEOUT_CONFIG_FIELDS, } from "./fields.js";
 import { DEFAULT_RUNTIME_LOGGING_ENABLED, DEFAULT_RUNTIME_LOG_ROTATION_CONFIG, } from "./constants.js";
@@ -269,6 +270,7 @@ function pluginsSchema() {
                 default: ["*"],
             },
             deny: stringArraySchema("Installed plugin or capability ids denied after applying the allow-list."),
+            disabledPluginIds: stringArraySchema("Exact plugin ids disabled independently of tool selectors. Entries are literal ids, not wildcards."),
         },
         additionalProperties: false,
     };
@@ -310,8 +312,9 @@ export function createRuntimeConfigJsonSchema() {
             },
             webUi: {
                 type: "object",
-                description: "Local Web UI startup behavior.",
+                description: "Local Web UI behavior.",
                 properties: {
+                    pageSize: { type: "integer", minimum: 1, default: 20, description: "Sessions and messages per Web UI history page, including SPARK." },
                     openOnRuntimeServiceStart: {
                         type: "boolean",
                         default: false,
@@ -456,6 +459,7 @@ export function createRuntimeConfigJsonSchema() {
                                 },
                                 generation: modelGenerationSchema(),
                                 context: modelContextSchema(),
+                                plugins: modelPluginConfigSchema(),
                                 execution: {
                                     type: "object",
                                     description: "Runtime-only request execution policy for this model profile. Omission selects supervisor-worker-v1; execution-agent-v1 is an explicit per-profile opt-in. This metadata is not forwarded to the model gateway.",

package/dist/src/runtime/config/validation/model-profile-validation.js

@@ -1,3 +1,4 @@
+import { validateModelPluginConfig } from "../model-plugin-config.js";
 import { isRequestExecutionPolicyId, REQUEST_EXECUTION_POLICY_IDS, } from "../model-execution-policy.js";
 import { hasOwnValue, isRecord } from "../utils.js";
 import { validateModelContextConfig, validateModelGenerationConfig, } from "./model-invocation-config-validation.js";
@@ -79,6 +80,7 @@ export function validateModelProfileConfig(issues, profile, displayKey, options
     if (context) {
         validateModelContextConfig(issues, context, `${displayKey}.context`);
     }
+    validateModelPluginConfig(issues, profile, displayKey);
     const execution = validateOptionalObject(issues, profile, "execution", `${displayKey}.execution`);
     if (execution) {
         validateModelExecutionPolicy(issues, execution, `${displayKey}.execution`);

package/dist/src/runtime/config/validation/runtime-config-validation-contract.d.ts

@@ -1,9 +1,11 @@
+import type { ModelContextCapacityIssue } from "../model-context-capacity.js";
 export type RuntimeConfigValidationOptions = Readonly<{
     /** Inspection-only mode. Canonical runtime loading always omits this flag. */
     allowIncompleteSetup?: boolean;
 }>;
 export declare class RuntimeConfigValidationError extends Error {
+    readonly capacityIssues: readonly ModelContextCapacityIssue[];
     readonly configPath: string;
     readonly issues: string[];
-    constructor(configPath: string, issues: string[]);
+    constructor(configPath: string, issues: string[], capacityIssues?: readonly ModelContextCapacityIssue[]);
 }

package/dist/src/runtime/config/validation/runtime-config-validation-contract.js

@@ -1,11 +1,13 @@
 export class RuntimeConfigValidationError extends Error {
+    capacityIssues;
     configPath;
     issues;
-    constructor(configPath, issues) {
+    constructor(configPath, issues, capacityIssues = []) {
         super([
             `Invalid runtime config at ${configPath}:`,
             ...issues.map((issue) => `- ${issue}`),
         ].join("\n"));
+        this.capacityIssues = capacityIssues;
         this.name = "RuntimeConfigValidationError";
         this.configPath = configPath;
         this.issues = issues;

package/dist/src/runtime/config/validation/runtime-root-section-validation.js

@@ -15,11 +15,18 @@ export function validatePluginConfig(issues, plugins) {
     validateOptionalBoolean(issues, plugins, "enabled", "plugins.enabled");
     validateOptionalStringArray(issues, plugins, "allow", "plugins.allow");
     validateOptionalStringArray(issues, plugins, "deny", "plugins.deny");
+    validateOptionalStringArray(issues, plugins, "disabledPluginIds", "plugins.disabledPluginIds");
+    const supportedPluginFields = [
+        "enabled",
+        "allow",
+        "deny",
+        "disabledPluginIds",
+    ];
     for (const key of Object.keys(plugins)) {
-        const isUnsupportedPluginField = key !== "enabled" && key !== "allow" && key !== "deny";
-        if (isUnsupportedPluginField) {
-            issues.push(`plugins.${key} is not a supported configuration field`);
-        }
+        const isSupportedPluginField = supportedPluginFields.includes(key);
+        if (isSupportedPluginField)
+            continue;
+        issues.push(`plugins.${key} is not a supported configuration field`);
     }
 }
 function hasInvalidRuntimeTimeout(value) {

package/dist/src/runtime/config/validation/web-ui-config-validation.js

@@ -1,10 +1,11 @@
-import { validateOptionalBoolean, validateOptionalObject, } from "./runtime-config-field-validation.js";
+import { validateOptionalBoolean, validateOptionalPositiveInteger, validateOptionalObject, } from "./runtime-config-field-validation.js";
 import { RuntimeConfigValidationError } from "./runtime-config-validation-contract.js";
 function isUnsupportedWebUiField(key) {
-    return key !== "openOnRuntimeServiceStart";
+    return !["openOnRuntimeServiceStart", "pageSize"].includes(key);
 }
 function validateWebUiConfig(issues, webUi) {
     validateOptionalBoolean(issues, webUi, "openOnRuntimeServiceStart", "webUi.openOnRuntimeServiceStart");
+    validateOptionalPositiveInteger(issues, webUi, "pageSize", "webUi.pageSize");
     for (const key of Object.keys(webUi)) {
         if (isUnsupportedWebUiField(key)) {
             issues.push(`webUi.${key} is not a supported configuration field`);

package/dist/src/runtime/config/web-ui.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeConfigFile } from "./types.js";
+export declare const DEFAULT_WEB_UI_PAGE_SIZE = 20;
+export declare function buildWebUiConfig(config: RuntimeConfigFile): {
+    pageSize: number;
+};

package/dist/src/runtime/config/web-ui.js

@@ -0,0 +1,5 @@
+export const DEFAULT_WEB_UI_PAGE_SIZE = 20;
+export function buildWebUiConfig(config) {
+    const webUi = config.webUi;
+    return { pageSize: webUi?.pageSize ?? DEFAULT_WEB_UI_PAGE_SIZE };
+}

package/dist/src/runtime/config.js

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { buildWebUiConfig } from "./config/web-ui.js";
 import { DEFAULT_RUNTIME_ID, DEFAULT_MODEL_GATEWAY_URL, } from "../shared/constants.js";
 import { loadDotEnvFile } from "../shared/load-dotenv.js";
 import { buildFeatureFlags, buildLoggingConfig, buildRuntimeModelConfiguration, buildPluginConfig, compactTimeouts, } from "./config/builders.js";
@@ -155,6 +156,7 @@ export function loadRuntimeConfig(options = {}) {
             compiledDir,
             traceFile,
         },
+        webUi: buildWebUiConfig(fileConfig),
         logging: loggingConfig,
         ...(timeouts ? { timeouts } : {}),
         ...(pluginConfig ? { plugins: pluginConfig } : {}),

package/dist/src/runtime/local-application.d.ts

@@ -124,6 +124,7 @@ export declare function createLocalRuntimeApplication(config?: RuntimeConfig, op
                     operationId: string;
                     contractVersion: number;
                     label: string;
+                    outputChannels?: import("../capabilities/tool-types.js").ToolNormalInvocationOperation["outputChannels"];
                     pluginName?: string;
                     catalogGroups: readonly import("../capabilities/tool-types.js").ToolCatalogGroup[];
                     toolDescription?: string;
@@ -141,6 +142,7 @@ export declare function createLocalRuntimeApplication(config?: RuntimeConfig, op
                     operationId: string;
                     contractVersion: number;
                     label: string;
+                    outputChannels?: import("../capabilities/tool-types.js").ToolNormalInvocationOperation["outputChannels"];
                     pluginName?: string;
                     catalogGroups: readonly import("../capabilities/tool-types.js").ToolCatalogGroup[];
                     toolDescription?: string;

package/dist/src/runtime/local-host/app-owner.js

@@ -6,7 +6,8 @@ import { LocalRuntimeOwnerActivity } from "./owner-activity.js";
 import { dispatchLocalLearningCall } from "./app-learning-dispatch.js";
 import { projectLearningChangedEvent } from "./learning-events.js";
 import { SavedRequestApprovals } from "./saved-approvals.js";
-import { isLocalNativePermissionMethod, LocalNativePermissions } from "./app-native-permissions.js";
+import { isLocalNativePermissionMethod, LocalNativePermissions, } from "./app-native-permissions.js";
+import { steeringInputDiagnosticFields, steeringResultDiagnosticFields, traceLocalRequest, traceLocalRequestFailure, } from "./local-request-diagnostics.js";
 export async function createLocalRuntimeOwner(config, overrides = {}) {
     const listeners = new Set();
     const publish = (event) => {
@@ -31,7 +32,7 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
     const unsubscribe = application.subscribeScheduledEvents((event) => {
         publish({ type: "scheduled.event", event });
         if (event.type === "completed" || event.type === "failed")
-            controls.finish(String(event.requestId));
+            controls.finish(String(event.requestId), event.type === "completed" ? "scheduled_completed" : "scheduled_failed");
     });
     const unsubscribeLearning = application.services.passiveLearning?.subscribe((change) => {
         const event = projectLearningChangedEvent(change);
@@ -74,9 +75,28 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
                 }
                 if (method === "request.steer") {
                     const sessionId = controls.activeSessionId(args[0]);
-                    if (sessionId)
-                        await application.services.sessions.assertInteractiveSession?.(sessionId);
-                    return controls.steer(args[0], args[1]);
+                    const fields = {
+                        ...steeringInputDiagnosticFields(args[0], args[1]),
+                        sessionId,
+                        peerId: peer.id,
+                        ownerEpoch: savedApprovals.ownerEpoch,
+                        environmentId: config.runtimeId,
+                    };
+                    traceLocalRequest("steer.owner_received", fields);
+                    try {
+                        if (sessionId)
+                            await application.services.sessions.assertInteractiveSession?.(sessionId);
+                        const result = controls.steer(args[0], args[1]);
+                        traceLocalRequest("steer.owner_result", {
+                            ...fields,
+                            ...steeringResultDiagnosticFields(result),
+                        });
+                        return result;
+                    }
+                    catch (error) {
+                        traceLocalRequestFailure("steer.owner_failed", fields, error);
+                        throw error;
+                    }
                 }
                 if (method === "request.cancel") {
                     if (await savedApprovals.cancel(args[0], args[1], args[2]))
@@ -136,25 +156,49 @@ async function runPeerRequest(application, controls, activity, savedApprovals, a
     const message = args[0];
     if (!message || typeof message.requestId !== "string")
         throw new Error("local_runtime_request_invalid");
+    const diagnosticFields = {
+        requestId: message.requestId,
+        sessionId: typeof message.sessionId === "string" ? message.sessionId : undefined,
+        peerId: peer.id,
+        ownerEpoch: savedApprovals.ownerEpoch,
+        environmentId: application.services.config.runtimeId,
+    };
+    traceLocalRequest("run.received", diagnosticFields);
     if (typeof message.sessionId === "string")
         await application.services.sessions.assertInteractiveSession?.(message.sessionId);
     const options = controls.ordinary(message.requestId, peer, (args[1] ?? {}), typeof message.sessionId === "string" ? message.sessionId : "");
     const durable = args[1]?.durableApprovals === true;
     if (durable)
         options.approvalExecution = { activation: savedApprovals.activation() };
+    traceLocalRequest("run.control_ready", {
+        ...diagnosticFields,
+        activationId: options.approvalExecution?.activation.activationId,
+    });
     const socket = {
         send(data) {
             controls.send(message.requestId, JSON.parse(data));
         },
     };
+    let diagnosticStage = "acceptance";
     try {
         await peer.callClient("request.accepted", [message.requestId]);
         activity.assertAcceptingRequests();
+        diagnosticStage = "execution";
+        traceLocalRequest("run.execution_started", diagnosticFields);
         const result = await application.requests.handle(socket, message, options);
+        traceLocalRequest("run.handler_settled", {
+            ...diagnosticFields,
+            awaitingApproval: result?.kind === "awaiting_approval",
+        });
+        diagnosticStage = "delivery_drain";
         await controls.drain(message.requestId);
         return result;
     }
+    catch (error) {
+        traceLocalRequestFailure("run.failed", { ...diagnosticFields, stage: diagnosticStage }, error);
+        throw error;
+    }
     finally {
-        controls.finish(message.requestId);
+        controls.finish(message.requestId, "ordinary_handler_finally");
     }
 }

package/dist/src/runtime/local-host/app-request-control.d.ts

@@ -4,6 +4,7 @@ import { type RequestCancellationResult } from "../request/cancellation.js";
 import { type RequestSteeringUpdate } from "../request/request-steering.js";
 import type { SchedulerRun } from "../scheduler/contracts.js";
 import type { LocalRuntimePeer } from "./contracts.js";
+import { type LocalRequestFinishSource } from "./local-request-diagnostics.js";
 import type { LocalPendingToolApproval, LocalToolApprovalDecisionResult } from "./request-approval-contracts.js";
 export type LocalRequestRunOptions = {
     approvalAvailable?: boolean;
@@ -22,12 +23,13 @@ export declare class LocalRequestControls {
     scheduled(run: SchedulerRun): RuntimeRequestOptions;
     steer(requestId: unknown, update: unknown): unknown;
     activeSessionId(requestId: unknown): string | undefined;
-    finish(requestId: string): void;
+    finish(requestId: string, source?: LocalRequestFinishSource): void;
     cancel(requestId: unknown, sessionId: unknown, wait?: unknown): RequestCancellationResult;
     private matchesResumedWaitCancellation;
     private claimFinalization;
     stop(): void;
     private open;
+    private diagnosticFields;
     hasActiveRequest(requestId: unknown, sessionId: unknown): boolean;
     listApprovals(sessionId?: unknown): LocalPendingToolApproval[];
     decideApproval(input: unknown, peer: LocalRuntimePeer): LocalToolApprovalDecisionResult;

package/dist/src/runtime/local-host/app-request-control.js

@@ -3,6 +3,8 @@ import { createRequestCancellationError, } from "../request/cancellation.js";
 import { createRequestSteeringInbox, } from "../request/request-steering.js";
 import { hasApprovalDecisionIdentity, LocalRequestApprovals, } from "./app-request-approvals.js";
 import { LocalRequestDelivery } from "./app-request-delivery.js";
+import { createRequestControlDiagnosticId } from "../observability/request-control-diagnostics.js";
+import { steeringInputDiagnosticFields, steeringResultDiagnosticFields, traceLocalRequest, } from "./local-request-diagnostics.js";
 export class LocalRequestControls {
     publish;
     active = new Map();
@@ -31,16 +33,23 @@ export class LocalRequestControls {
             }
         }
         catch (error) {
-            this.finish(requestId);
+            this.finish(requestId, "initial_steering_rejected");
             throw error;
         }
         const control = this.active.get(requestId);
         control.resumedWait = resumedWait;
         control.peer = peer;
         control.delivery.attach(peer);
+        traceLocalRequest("control.attached", {
+            ...this.diagnosticFields(requestId, control),
+            peerId: peer.id,
+            generation: resumedWait?.generation,
+            waitId: resumedWait?.waitId,
+            revision: resumedWait?.revision,
+        });
         return {
             abortSignal: control.abort.signal,
-            claimFinalization: () => this.claimFinalization(control),
+            claimFinalization: () => this.claimFinalization(requestId, control),
             requestSteering: steering,
             ...(options.approvalAvailable
                 ? { toolApprovalController: this.approvals(requestId, control) }
@@ -54,7 +63,7 @@ export class LocalRequestControls {
         const peer = this.controlPeers.values().next().value;
         return {
             abortSignal: control.abort.signal,
-            claimFinalization: () => this.claimFinalization(control),
+            claimFinalization: () => this.claimFinalization(run.requestId, control),
             requestSteering: steering,
             ...(peer
                 ? { toolApprovalController: this.approvals(run.requestId, control) }
@@ -62,29 +71,70 @@ export class LocalRequestControls {
         };
     }
     steer(requestId, update) {
-        if (typeof requestId !== "string")
+        const inputFields = steeringInputDiagnosticFields(requestId, update);
+        if (typeof requestId !== "string") {
+            traceLocalRequest("steer.rejected", {
+                ...inputFields,
+                diagnosticReason: "invalid_request_id",
+                reason: "request_not_active",
+            });
             return { ok: false, reason: "request_not_active" };
+        }
         const control = this.active.get(requestId);
-        if (!control || control.abort.signal.aborted)
+        const fields = {
+            ...inputFields,
+            ...this.diagnosticFields(requestId, control),
+        };
+        if (!control || control.abort.signal.aborted) {
+            traceLocalRequest("steer.rejected", {
+                ...fields,
+                diagnosticReason: control ? "control_aborted" : "control_missing",
+                reason: "request_not_active",
+            });
             return { ok: false, reason: "request_not_active" };
-        if (!update || typeof update !== "object")
+        }
+        if (!update || typeof update !== "object") {
+            traceLocalRequest("steer.rejected", {
+                ...fields,
+                diagnosticReason: "invalid_update_shape",
+                reason: "invalid_steer_request",
+            });
             return { ok: false, reason: "invalid_steer_request" };
+        }
         const input = update;
-        if (typeof input.steerId !== "string" || typeof input.text !== "string")
+        if (typeof input.steerId !== "string" || typeof input.text !== "string") {
+            traceLocalRequest("steer.rejected", {
+                ...fields,
+                diagnosticReason: "invalid_update_shape",
+                reason: "invalid_steer_request",
+            });
             return { ok: false, reason: "invalid_steer_request" };
-        return control.steering.append({
+        }
+        const result = control.steering.append({
             steerId: input.steerId,
             text: input.text,
         });
+        traceLocalRequest("steer.result", {
+            ...fields,
+            diagnosticReason: "inbox_result",
+            ...steeringResultDiagnosticFields(result),
+        });
+        return result;
     }
     activeSessionId(requestId) {
         return typeof requestId === "string"
             ? this.active.get(requestId)?.sessionId
             : undefined;
     }
-    finish(requestId) {
+    finish(requestId, source = "unspecified") {
         const entry = this.active.get(requestId);
         this.active.delete(requestId);
+        traceLocalRequest("control.finished", {
+            ...this.diagnosticFields(requestId, entry),
+            controlPresent: false,
+            removed: Boolean(entry),
+            source,
+        });
         this.pendingApprovals.cancel(requestId);
         entry?.delivery.finish();
         void entry?.steering.close();
@@ -102,6 +152,7 @@ export class LocalRequestControls {
         if (!this.matchesResumedWaitCancellation(control, wait))
             return { accepted: false, reason: "request_not_active" };
         control.abort.abort(createRequestCancellationError());
+        traceLocalRequest("cancel.accepted", this.diagnosticFields(String(requestId), control));
         return { accepted: true };
     }
     matchesResumedWaitCancellation(control, input) {
@@ -121,16 +172,18 @@ export class LocalRequestControls {
             return false;
         return command.revision === wait.revision;
     }
-    claimFinalization(control) {
+    claimFinalization(requestId, control) {
         // In-flight requests retain this exact control until canonical finalization.
         control.abort.signal.throwIfAborted();
         control.finalizing = true;
+        traceLocalRequest("finalization.claimed", this.diagnosticFields(requestId, control));
     }
     stop() {
         this.stopped = true;
         this.controlPeers.clear();
         for (const [requestId, control] of this.active) {
             control.abort.abort(createRequestInterruptionError());
+            traceLocalRequest("control.interrupted", this.diagnosticFields(requestId, control));
         }
         // Accepted requests retain their controls and inboxes until finalization.
     }
@@ -139,8 +192,13 @@ export class LocalRequestControls {
             throw new Error("local_runtime_owner_stopped");
         if (!requestId || this.active.has(requestId))
             throw new Error("local_runtime_request_already_active");
-        const steering = createRequestSteeringInbox({ requestId });
+        const inboxId = createRequestControlDiagnosticId("owner_inbox");
+        const steering = createRequestSteeringInbox({
+            requestId,
+            diagnostics: { inboxId, origin: "local_owner" },
+        });
         this.active.set(requestId, {
+            inboxId,
             steering,
             sessionId,
             abort: new AbortController(),
@@ -148,8 +206,30 @@ export class LocalRequestControls {
             delivery: new LocalRequestDelivery(requestId),
             ...(run ? { run } : {}),
         });
+        traceLocalRequest("control.opened", {
+            requestId,
+            sessionId,
+            inboxId,
+            scheduled: Boolean(run),
+            activeControlCount: this.active.size,
+        });
         return steering;
     }
+    diagnosticFields(requestId, control) {
+        return {
+            requestId,
+            sessionId: control?.sessionId,
+            inboxId: control?.inboxId,
+            controlPresent: Boolean(control),
+            aborted: control?.abort.signal.aborted,
+            finalizing: control?.finalizing,
+            ownerStopped: this.stopped,
+            activeControlCount: this.active.size,
+            generation: control?.resumedWait?.generation,
+            waitId: control?.resumedWait?.waitId,
+            revision: control?.resumedWait?.revision,
+        };
+    }
     hasActiveRequest(requestId, sessionId) {
         if (typeof requestId !== "string")
             return false;

package/dist/src/runtime/local-host/client-requests.js

@@ -1,3 +1,4 @@
+import { steeringInputDiagnosticFields, steeringResultDiagnosticFields, traceLocalRequest, traceLocalRequestFailure, } from "./local-request-diagnostics.js";
 import { PendingClientRequest, hasLiveApprovalAttachment, hasApprovalEndedBeforeAttachment, isApprovalTransportLoss, shouldRetainDetachedRequest, } from "./pending-client-request.js";
 /** Client projections only. The owner validates and commits every steering update. */
 export class LocalRuntimeClientRequests {
@@ -55,11 +56,37 @@ export class LocalRuntimeClientRequests {
             return outcome;
         },
         steer: async (requestId, input) => {
-            await this.active.get(requestId)?.accepted;
-            return (await this.call("request.steer", [
-                requestId,
-                input,
-            ]));
+            const state = this.active.get(requestId);
+            const fields = {
+                ...steeringInputDiagnosticFields(requestId, input),
+                sessionId: state?.sessionId,
+                clientStatePresentAtEntry: Boolean(state),
+                detachedAtEntry: state?.detached,
+            };
+            traceLocalRequest("steer.client_requested", fields);
+            await state?.accepted;
+            const current = this.active.get(requestId);
+            const dispatchFields = {
+                ...fields,
+                clientStatePresentAtDispatch: Boolean(current),
+                clientStateUnchanged: current === state,
+            };
+            traceLocalRequest("steer.client_dispatch_attempted", dispatchFields);
+            try {
+                const result = (await this.call("request.steer", [
+                    requestId,
+                    input,
+                ]));
+                traceLocalRequest("steer.client_result", {
+                    ...dispatchFields,
+                    ...steeringResultDiagnosticFields(result),
+                });
+                return result;
+            }
+            catch (error) {
+                traceLocalRequestFailure("steer.client_failed", dispatchFields, error);
+                throw error;
+            }
         },
     };
     approvals = {

package/dist/src/runtime/local-host/client-services.d.ts

@@ -119,6 +119,7 @@ export declare function createLocalServiceClients(call: LocalRuntimeCallHandler)
                 operationId: string;
                 contractVersion: number;
                 label: string;
+                outputChannels?: import("../../capabilities/tool-types.js").ToolNormalInvocationOperation["outputChannels"];
                 pluginName?: string;
                 catalogGroups: readonly import("../../capabilities/tool-types.js").ToolCatalogGroup[];
                 toolDescription?: string;
@@ -136,6 +137,7 @@ export declare function createLocalServiceClients(call: LocalRuntimeCallHandler)
                 operationId: string;
                 contractVersion: number;
                 label: string;
+                outputChannels?: import("../../capabilities/tool-types.js").ToolNormalInvocationOperation["outputChannels"];
                 pluginName?: string;
                 catalogGroups: readonly import("../../capabilities/tool-types.js").ToolCatalogGroup[];
                 toolDescription?: string;

package/dist/src/runtime/local-host/local-request-diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { RequestSteeringAppendResult } from "../request/request-steering.js";
+import { type RequestControlDiagnosticFields } from "../observability/request-control-diagnostics.js";
+export type LocalRequestDiagnosticFields = RequestControlDiagnosticFields;
+export type LocalRequestFinishSource = "unspecified" | "initial_steering_rejected" | "ordinary_handler_finally" | "resumed_handler_finally" | "scheduled_completed" | "scheduled_failed";
+/** Unknown transport values are observed without invoking user-supplied getters. */
+export declare function steeringInputDiagnosticFields(requestId: unknown, input: unknown): LocalRequestDiagnosticFields;
+export declare function steeringResultDiagnosticFields(result: RequestSteeringAppendResult): LocalRequestDiagnosticFields;
+export declare function traceLocalRequest(event: string, fields: LocalRequestDiagnosticFields): void;
+export declare function traceLocalRequestFailure(event: string, fields: LocalRequestDiagnosticFields, error: unknown): void;

package/dist/src/runtime/local-host/local-request-diagnostics.js

@@ -0,0 +1,47 @@
+import { diagnosticErrorType, traceRequestControl, } from "../observability/request-control-diagnostics.js";
+/** Unknown transport values are observed without invoking user-supplied getters. */
+export function steeringInputDiagnosticFields(requestId, input) {
+    const fields = {
+        requestId: typeof requestId === "string" ? requestId : undefined,
+        requestIdType: typeof requestId,
+    };
+    try {
+        if (!input || typeof input !== "object")
+            return fields;
+        const steerId = Object.getOwnPropertyDescriptor(input, "steerId")?.value;
+        const text = Object.getOwnPropertyDescriptor(input, "text")?.value;
+        return {
+            ...fields,
+            steerId: typeof steerId === "string" ? steerId : undefined,
+            textLength: typeof text === "string" ? text.length : undefined,
+        };
+    }
+    catch {
+        // An uninspectable diagnostic value must not change transport validation.
+    }
+    return fields;
+}
+export function steeringResultDiagnosticFields(result) {
+    try {
+        if (result.ok) {
+            return {
+                accepted: true,
+                duplicate: result.duplicate,
+                acceptedSequence: result.update.sequence,
+            };
+        }
+        return { accepted: false, reason: result.reason };
+    }
+    catch {
+        return { resultInspectable: false };
+    }
+}
+export function traceLocalRequest(event, fields) {
+    traceRequestControl("runtime.local_request_control", event, fields);
+}
+export function traceLocalRequestFailure(event, fields, error) {
+    traceLocalRequest(event, {
+        ...fields,
+        errorType: diagnosticErrorType(error),
+    });
+}

package/dist/src/runtime/local-host/saved-approvals.js

@@ -3,6 +3,7 @@ import { REQUEST_APPROVAL_SNAPSHOT, } from "../request/approval-wait/snapshot.js
 import { validateApprovalResume } from "../request/approval-wait/preflight.js";
 import { hasApprovalDecisionIdentity } from "./app-request-approvals.js";
 import { traceDebug } from "../observability/debug-logger.js";
+import { traceLocalRequest, traceLocalRequestFailure, } from "./local-request-diagnostics.js";
 function hasDurableIdentity(input) {
     return (typeof input.generation === "string" &&
         input.generation.length > 0 &&
@@ -250,6 +251,18 @@ export class SavedRequestApprovals {
     }
     async resume(snapshot, current, consumedWait, peer) {
         const { requestId, sessionId } = current;
+        const diagnosticFields = {
+            requestId,
+            sessionId,
+            ownerEpoch: current.activation?.ownerEpoch,
+            environmentId: this.application.services.config.runtimeId,
+            activationId: current.activation?.activationId,
+            generation: consumedWait.generation,
+            waitId: consumedWait.waitId,
+            revision: consumedWait.revision,
+            peerId: peer.id,
+        };
+        traceLocalRequest("run.resume_attempted", diagnosticFields);
         const options = this.controls.ordinary(requestId, peer, { approvalAvailable: true }, sessionId, consumedWait);
         const decisions = snapshot.runner.preparedGroup.entries.flatMap((entry) => {
             // The consumed wait has been removed; exact approval IDs bind its saved actions.
@@ -273,7 +286,7 @@ export class SavedRequestApprovals {
             send: (data) => this.emit([JSON.parse(data)], sessionId),
         };
         try {
-            await this.application.requests.handle(ws, {
+            const outcome = await this.application.requests.handle(ws, {
                 type: "run_request",
                 requestId,
                 sessionId,
@@ -288,9 +301,17 @@ export class SavedRequestApprovals {
                     resume: { snapshot, current, decisions },
                 },
             });
+            traceLocalRequest("run.resumed_handler_settled", {
+                ...diagnosticFields,
+                awaitingApproval: outcome?.kind === "awaiting_approval",
+            });
+        }
+        catch (error) {
+            traceLocalRequestFailure("run.resumed_failed", diagnosticFields, error);
+            throw error;
         }
         finally {
-            this.controls.finish(requestId);
+            this.controls.finish(requestId, "resumed_handler_finally");
         }
     }
     emit(events, sessionId) {