@abot-ai/runtime 1.2.0 → 1.3.0

package/README.md

@@ -13,6 +13,7 @@ hardcoded defaults.
 - Configurable local and hosted model providers
 - Persistent conversations, request events, and replay
 - Optional passive long-term memory across sessions
+- Local scheduled requests bound to their conversations
 - Planning, execution, and review workflows
 - Manifest-based tools and plugins with explicit runtime boundaries
 - Workspace, file, skill, and memory capabilities
@@ -34,11 +35,24 @@ The Web UI supports:
 - steering an active request or queuing the next message
 - editing runtime configuration
 - configuring passive long-term memory with a consumer-selected embedding model
+- managing schedules, their saved models, and run history in the Schedules workspace
 - inspecting runtime status, logs, and health
 
 The UI is a client of the runtime; persisted sessions, events, and request state
 remain owned by the runtime.
 
+Schedules can also be managed through the model's built-in `schedules` capability.
+Every Job belongs to a conversation and runs there with its saved model and FULL
+tool permissions. The chat shows a compact run card; expand it to read the exact
+historical prompt. ABot must be running at the scheduled time. Missed offline
+occurrences and failed runs are not retried. Cancelling a Job or deleting its
+conversation prevents pending starts; an already-started run continues.
+
+Timers, one-time requests, intervals, and daily/weekly/monthly schedules are
+supported. Calendar schedules require an exact time and IANA time zone. Jobs and
+run history are stored locally under the environment's runtime directory.
+Scheduling uses the Runtime directly and requires no plugin or external bridge.
+
 ## Requirements
 
 - Node.js `^20.19.0` or `>=22.12.0` (Node.js 21 is not supported)

package/dist/src/bridge/request-steering.d.ts

@@ -1,8 +1,9 @@
 import type WebSocket from "ws";
+import type { RuntimeRequestHandler } from "../runtime/composition.js";
 import { type RequestSteeringInbox } from "../runtime/request/request-steering.js";
 export type BridgeRequestSteeringRegistry = Readonly<{
     close(requestId: string, inbox: RequestSteeringInbox): Promise<void>;
     handleMessage(ws: WebSocket, message: Record<string, unknown>): Promise<boolean>;
     open(requestId: string): RequestSteeringInbox;
 }>;
-export declare function createBridgeRequestSteeringRegistry(): BridgeRequestSteeringRegistry;
+export declare function createBridgeRequestSteeringRegistry(steer?: RuntimeRequestHandler["steer"]): BridgeRequestSteeringRegistry;

package/dist/src/bridge/request-steering.js

@@ -1,7 +1,7 @@
 import { traceDebug } from "../runtime/observability/debug-logger.js";
 import { createRequestSteeringInbox, } from "../runtime/request/request-steering.js";
 const LOG_SCOPE = "agent-bridge.request_steering";
-export function createBridgeRequestSteeringRegistry() {
+export function createBridgeRequestSteeringRegistry(steer) {
     const active = new Map();
     return Object.freeze({
         async close(requestId, inbox) {
@@ -23,7 +23,9 @@ export function createBridgeRequestSteeringRegistry() {
             const steerId = readString(message.steerId).trim();
             const text = readString(message.text).trim();
             const current = active.get(requestId);
-            const result = current?.inbox.append({ steerId, text }) ??
+            const result = (steer && current
+                ? await steer(requestId, { steerId, text })
+                : current?.inbox.append({ steerId, text })) ??
                 Object.freeze({
                     ok: false,
                     reason: "request_not_active",

package/dist/src/bridge/runtime-replay.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { clearSessionMessages, deleteMessageWithStats, deleteSessionWithStats, getRequestReplayById, getSessionSnapshot, listSessions, } from "../sessions/index.js";
 import { DEFAULT_MAX_ATTACHMENT_BYTES, } from "../runtime/attachments/store.js";
+import { deleteSessionWithAttachments, deleteSessionAttachmentsIfSupported, } from "../runtime/session/session-attachment-deletion.js";
 import { resolveRuntimeAttachmentMimeType } from "../shared/attachments.js";
 const defaultRuntimeReplaySessionStore = {
     clearSessionMessages,
@@ -344,10 +345,7 @@ async function handleSessionDeleteRequest(ws, msg, sessionStore, attachmentStore
         return;
     }
     try {
-        const result = await sessionStore.deleteSessionWithStats(sessionId);
-        if (result.deleted) {
-            await deleteSessionAttachmentsIfSupported(attachmentStore, sessionId);
-        }
+        const result = await deleteSessionWithAttachments(sessionStore, attachmentStore, sessionId);
         sendRuntimeReplayResponse(ws, {
             type: "session.delete.response",
             correlationId,
@@ -402,21 +400,6 @@ async function handleSessionMessagesClearRequest(ws, msg, sessionStore, attachme
         }, error instanceof Error ? error.message : String(error));
     }
 }
-async function deleteSessionAttachmentsIfSupported(attachmentStore, sessionId) {
-    if (!attachmentStore) {
-        return;
-    }
-    try {
-        await attachmentStore.deleteSessionAttachments(sessionId);
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            error.message === "attachment_owner_invalid") {
-            return;
-        }
-        throw error;
-    }
-}
 async function deleteAttachmentIfSupported(attachmentStore, attachment, sessionId) {
     if (!attachmentStore?.deleteAttachment) {
         return;

package/dist/src/bridge/start-agent-bridge.js

@@ -109,7 +109,7 @@ export function startAgentBridge(options = {}) {
     let lastMessageAt;
     let lastPongAt;
     const pendingToolApprovals = new Map();
-    const requestSteering = createBridgeRequestSteeringRegistry();
+    const requestSteering = createBridgeRequestSteeringRegistry(requestHandler.steer);
     function getStatus() {
         return {
             runtimeId,

package/dist/src/capabilities/normal-invocation/validator.js

@@ -1,5 +1,5 @@
 import { TOOL_NORMAL_INVOCATION_IDENTIFIER_MAX_LENGTH, TOOL_NORMAL_INVOCATION_PAYLOAD_MAX_BYTES, TOOL_NORMAL_INVOCATION_VERSION, } from "./contracts.js";
-const MAX_OPERATIONS = 16;
+const MAX_OPERATIONS = 32;
 const MAX_SUMMARY_LENGTH = 512;
 const MAX_INSTRUCTIONS_LENGTH = 1_024;
 const MAX_PROPERTIES = 16;

package/dist/src/capabilities/tool-definition-validator/event-presentation.js

@@ -1,4 +1,5 @@
 import { isToolDefinitionRecordValue } from "./definition-shape.js";
+import { parseEventResultMetadata } from "./event-result-metadata.js";
 const EVENT_PROJECTION_KINDS = [
     "string",
     "number",
@@ -16,8 +17,10 @@ export function parseEventPresentation(toolName, raw) {
     }
     const metadata = Object.fromEntries(Object.entries(raw.metadata).map(([key, projection]) => parseEventMetadataProjection(toolName, key, projection)));
     const lifecycle = parseEventLifecycle(toolName, raw.lifecycle);
+    const resultMetadata = parseEventResultMetadata(raw.resultMetadata, `eventPresentation.resultMetadata (${toolName})`);
     return {
         metadata,
+        ...(resultMetadata ? { resultMetadata } : {}),
         ...(lifecycle ? { lifecycle } : {}),
     };
 }

package/dist/src/capabilities/tool-definition-validator/event-result-metadata.d.ts

@@ -0,0 +1,2 @@
+import type { ToolEventPresentation } from "../tool-types.js";
+export declare function parseEventResultMetadata(raw: unknown, path: string): ToolEventPresentation["resultMetadata"];

package/dist/src/capabilities/tool-definition-validator/event-result-metadata.js

@@ -0,0 +1,74 @@
+import { isToolDefinitionRecordValue } from "./definition-shape.js";
+const RESULT_METADATA_LIMIT = 16;
+const RESULT_PATH_SEGMENT_LIMIT = 4;
+const RESULT_PROJECTION_KINDS = ["preview", "number", "boolean"];
+const FORBIDDEN_PATH_SEGMENTS = new Set([
+    "__proto__",
+    "prototype",
+    "constructor",
+]);
+export function parseEventResultMetadata(raw, path) {
+    if (raw === undefined)
+        return undefined;
+    if (!isToolDefinitionRecordValue(raw)) {
+        throw new Error(`${path} must be an object`);
+    }
+    const entries = Object.entries(raw);
+    if (entries.length > RESULT_METADATA_LIMIT) {
+        throw new Error(`${path} exceeds ${RESULT_METADATA_LIMIT} projections`);
+    }
+    const result = Object.fromEntries(entries.map(([key, value]) => {
+        if (!hasSupportedResultMetadataKey(key)) {
+            throw new Error(`${path} contains an invalid metadata key`);
+        }
+        if (!isToolDefinitionRecordValue(value)) {
+            throw new Error(`${path}.${key} must be an object`);
+        }
+        if (hasUnknownResultProjectionFields(value)) {
+            throw new Error(`${path}.${key} contains an unknown field`);
+        }
+        if (!hasSupportedResultMetadataPath(value.path)) {
+            throw new Error(`${path}.${key}.path must select output or data`);
+        }
+        if (!isResultProjectionKind(value.kind)) {
+            throw new Error(`${path}.${key}.kind is not supported`);
+        }
+        return [key, { path: value.path, kind: value.kind }];
+    }));
+    for (const [key, projection] of Object.entries(result)) {
+        if (projection.kind !== "preview")
+            continue;
+        if (Object.hasOwn(result, `${key}Truncated`)) {
+            throw new Error(`${path}.${key} conflicts with its truncation metadata`);
+        }
+    }
+    return result;
+}
+function hasSupportedResultMetadataKey(key) {
+    if (!/^[a-zA-Z][a-zA-Z0-9]{0,63}$/u.test(key))
+        return false;
+    return !FORBIDDEN_PATH_SEGMENTS.has(key);
+}
+function hasSupportedResultMetadataPath(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value === "output")
+        return true;
+    const segments = value.split(".");
+    if (segments[0] !== "data")
+        return false;
+    if (segments.length < 2 || segments.length > RESULT_PATH_SEGMENT_LIMIT)
+        return false;
+    return segments.every(isSupportedResultPathSegment);
+}
+function hasUnknownResultProjectionFields(value) {
+    return Object.keys(value).some((field) => field !== "path" && field !== "kind");
+}
+function isSupportedResultPathSegment(segment) {
+    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/u.test(segment))
+        return false;
+    return !FORBIDDEN_PATH_SEGMENTS.has(segment);
+}
+function isResultProjectionKind(value) {
+    return RESULT_PROJECTION_KINDS.includes(value);
+}

package/dist/src/capabilities/tool-event-metadata.js

@@ -1,3 +1,4 @@
+import { projectToolResultEventMetadata } from "./tool-result-event-projection.js";
 function safeTrim(value) {
     return typeof value === "string" ? value.trim() : "";
 }
@@ -177,5 +178,7 @@ export function buildToolCompletedEventMetadata(call, result, definition) {
         ...(buildCallMeta(call, definition) || {}),
         ...toolResultData,
         ...(buildResultMeta(result, actions) || {}),
+        // Explicit result mappings override generic display fallbacks when present.
+        ...projectToolResultEventMetadata(result, definition?.eventPresentation?.resultMetadata),
     });
 }

package/dist/src/capabilities/tool-result-event-projection.d.ts

@@ -0,0 +1,3 @@
+import type { ToolEventMetadata, ToolEventPresentation, ToolExecutionResult } from "./tool-types.js";
+/** Derive display metadata without changing canonical tool evidence. */
+export declare function projectToolResultEventMetadata(result: ToolExecutionResult, projections: ToolEventPresentation["resultMetadata"]): ToolEventMetadata | undefined;

package/dist/src/capabilities/tool-result-event-projection.js

@@ -0,0 +1,82 @@
+const PREVIEW_CHARACTER_LIMIT = 1_200;
+const PREVIEW_LINE_LIMIT = 20;
+const EVENT_PREVIEW_CHARACTER_LIMIT = 2_400;
+/** Derive display metadata without changing canonical tool evidence. */
+export function projectToolResultEventMetadata(result, projections) {
+    if (!projections)
+        return undefined;
+    const metadata = {};
+    let remainingCharacters = EVENT_PREVIEW_CHARACTER_LIMIT;
+    for (const [key, projection] of Object.entries(projections)) {
+        const value = readProjectedResultValue(result, projection);
+        if (value === undefined)
+            continue;
+        if (typeof value !== "string") {
+            metadata[key] = value;
+            continue;
+        }
+        const preview = boundResultPreview(value, remainingCharacters);
+        metadata[key] = preview.text;
+        metadata[`${key}Truncated`] = preview.truncated;
+        remainingCharacters -= preview.text.length;
+    }
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+function readProjectedResultValue(result, projection) {
+    const value = readOwnResultPath(result, projection.path);
+    if (projection.kind === "number") {
+        return isFiniteResultNumber(value) ? value : undefined;
+    }
+    if (projection.kind === "boolean") {
+        return typeof value === "boolean" ? value : undefined;
+    }
+    return typeof value === "string" ? value : undefined;
+}
+function readOwnResultPath(result, path) {
+    let value = result;
+    for (const segment of path.split(".")) {
+        if (!isOwnResultContainer(value, segment))
+            return undefined;
+        value = value[segment];
+    }
+    return value;
+}
+function isOwnResultContainer(value, key) {
+    if (value === null || typeof value !== "object")
+        return false;
+    if (Array.isArray(value))
+        return false;
+    return Object.hasOwn(value, key);
+}
+function isFiniteResultNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function boundResultPreview(value, remainingCharacters) {
+    const characterLimit = Math.min(PREVIEW_CHARACTER_LIMIT, remainingCharacters);
+    let end = Math.min(value.length, characterLimit);
+    let lineCount = 1;
+    for (let index = 0; index < end; index += 1) {
+        if (!startsPreviewLine(value, index))
+            continue;
+        lineCount += 1;
+        if (lineCount <= PREVIEW_LINE_LIMIT)
+            continue;
+        end = index;
+        break;
+    }
+    if (splitsSurrogatePair(value, end))
+        end -= 1;
+    return { text: value.slice(0, end), truncated: end < value.length };
+}
+function startsPreviewLine(value, index) {
+    if (value[index] === "\r")
+        return true;
+    return value[index] === "\n" && value[index - 1] !== "\r";
+}
+function splitsSurrogatePair(value, end) {
+    if (end <= 0 || end >= value.length)
+        return false;
+    const before = value.charCodeAt(end - 1);
+    const after = value.charCodeAt(end);
+    return (before >= 0xd800 && before <= 0xdbff && after >= 0xdc00 && after <= 0xdfff);
+}

package/dist/src/capabilities/tool-types.d.ts

@@ -18,8 +18,13 @@ export type ToolEventLifecycleCopy = Readonly<{
     status: string;
     message: string;
 }>;
+export type ToolEventResultMetadataProjection = Readonly<{
+    path: string;
+    kind: "preview" | "number" | "boolean";
+}>;
 export type ToolEventPresentation = Readonly<{
     metadata: Readonly<Record<string, ToolEventMetadataProjection>>;
+    resultMetadata?: Readonly<Record<string, ToolEventResultMetadataProjection>>;
     lifecycle?: Readonly<{
         started?: ToolEventLifecycleCopy;
         completed?: ToolEventLifecycleCopy;

package/dist/src/cli/abot.js

@@ -4,6 +4,7 @@ import { runInitRuntime } from "../../scripts/init-runtime.js";
 import { runConfigureLongTermMemory } from "../../scripts/configure-long-term-memory.js";
 import { createModelGatewayServer, resolveProviderAdapters, resolveModelGatewayPort, } from "../model-gateway/server.js";
 import { loadDotEnvFile } from "../shared/load-dotenv.js";
+import { closeHttpServerImmediately } from "../shared/http-server-shutdown.js";
 import { startWebUiServer } from "../web-ui/server.js";
 import { resolveWebUiAddress } from "../web-ui/web-ui-address.js";
 function printHelp() {
@@ -23,16 +24,6 @@ function printHelp() {
         "  start      Start the local model gateway and Web UI.",
     ].join("\n"));
 }
-function closeServer(server) {
-    return new Promise((resolveClose, reject) => {
-        server.close((error) => {
-            if (error)
-                reject(error);
-            else
-                resolveClose();
-        });
-    });
-}
 async function runStart(args) {
     if (args.includes("--help") || args.includes("-h")) {
         console.log("Usage: abot start");
@@ -75,7 +66,7 @@ async function runStart(args) {
             closing = true;
             void Promise.all([
                 webUi.close(),
-                ...(gateway ? [closeServer(gateway)] : []),
+                ...(gateway ? [closeHttpServerImmediately(gateway)] : []),
             ]).then(() => resolveExit(), rejectExit);
         };
         process.once("SIGINT", shutdown);

package/dist/src/runtime/adapters/in-memory-session-store.js

@@ -175,6 +175,7 @@ class InMemorySessionStore {
                 taskType: options.taskType,
                 requestId: options.requestId,
                 cronJobId: options.cronJobId,
+                ...(options.schedule ? { schedule: options.schedule } : {}),
                 cronTitle: options.cronTitle,
                 triggerType: options.triggerType,
                 attachments: options.attachments,

package/dist/src/runtime/adapters/long-term-memory/file-lock/acquisition.js

@@ -3,6 +3,7 @@ import { removeEmptyLockTree, removeObservedOwner } from "./cleanup.js";
 import { fileSystemErrorCode, INCOMPLETE_LOCK_GRACE_MS, LOCK_ACQUIRE_TIMEOUT_MS, LOCK_RETRY_DELAY_MS, ownerFileName, } from "./contracts.js";
 import { installLockDirectory } from "./install.js";
 import { readLockSnapshot } from "./snapshot.js";
+import { removeObservedOwnerSynchronously } from "./synchronous-release.js";
 export async function acquireFileLock(lockPath, options) {
     const waitMs = options.waitMs ?? LOCK_ACQUIRE_TIMEOUT_MS;
     const retryDelayMs = options.retryDelayMs ?? LOCK_RETRY_DELAY_MS;
@@ -12,7 +13,7 @@ export async function acquireFileLock(lockPath, options) {
         const token = randomUUID();
         try {
             await installLockDirectory(lockPath, token);
-            return createRelease(lockPath, token);
+            return createRelease(lockPath, token, options.releaseMode);
         }
         catch (error) {
             if (!isLockContention(error))
@@ -27,15 +28,23 @@ export async function acquireFileLock(lockPath, options) {
         }
     }
 }
-function createRelease(lockPath, token) {
+function createRelease(lockPath, token, releaseMode) {
     let released = false;
     return async () => {
         if (released)
             return;
+        if (requiresSynchronousRelease(releaseMode)) {
+            removeObservedOwnerSynchronously(lockPath, ownerFileName(token));
+            released = true;
+            return;
+        }
         await removeObservedOwner(lockPath, ownerFileName(token));
         released = true;
     };
 }
+function requiresSynchronousRelease(mode) {
+    return mode === "synchronous";
+}
 async function removeAbandonedLock(lockPath, processIsAlive) {
     const snapshot = await readLockSnapshot(lockPath);
     if (!snapshot)

package/dist/src/runtime/adapters/long-term-memory/file-lock/contracts.d.ts

@@ -8,6 +8,8 @@ export type FileLockOptions = Readonly<{
     waitMs?: number;
     retryDelayMs?: number;
     processIsAlive?: (pid: number) => boolean;
+    /** Long-lived host leases must finish physical cleanup before process.exit. */
+    releaseMode?: "asynchronous" | "synchronous";
 }>;
 export type LockRecord = Readonly<{
     pid: number;

package/dist/src/runtime/adapters/long-term-memory/file-lock/synchronous-release.d.ts

@@ -0,0 +1,2 @@
+/** Keep token removal and directory cleanup indivisible by JavaScript exit. */
+export declare function removeObservedOwnerSynchronously(lockPath: string, observedOwnerFileName: string): boolean;

package/dist/src/runtime/adapters/long-term-memory/file-lock/synchronous-release.js

@@ -0,0 +1,40 @@
+import { rmdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { fileSystemErrorCode, LEASE_DIRECTORY_NAME } from "./contracts.js";
+/** Keep token removal and directory cleanup indivisible by JavaScript exit. */
+export function removeObservedOwnerSynchronously(lockPath, observedOwnerFileName) {
+    try {
+        unlinkSync(join(lockPath, LEASE_DIRECTORY_NAME, observedOwnerFileName));
+    }
+    catch (error) {
+        if (fileSystemErrorCode(error) === "ENOENT")
+            return false;
+        throw error;
+    }
+    if (!removeReleasedDirectory(join(lockPath, LEASE_DIRECTORY_NAME)))
+        return false;
+    return removeReleasedDirectory(lockPath);
+}
+function removeReleasedDirectory(path) {
+    try {
+        rmdirSync(path);
+        return true;
+    }
+    catch (error) {
+        if (fileSystemErrorCode(error) === "ENOENT")
+            return true;
+        if (hasReplacementDirectoryContent(error))
+            return false;
+        throw error;
+    }
+}
+function hasReplacementDirectoryContent(error) {
+    switch (fileSystemErrorCode(error)) {
+        case "EEXIST":
+        case "ENOTEMPTY":
+        case "ENOTDIR":
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/approval.d.ts

@@ -1,7 +1,10 @@
 import type { ToolCall } from "../../../../capabilities/tool-types.js";
+import { type ToolEventExecutorIdentity } from "../shared/event-metadata.js";
 import type { ToolApprovalController, ToolPermissionMode } from "../../../ports.js";
 import type { RegisteredToolNormalInvocationRejection } from "../shared/contracts.js";
 export declare function requestNormalInvocationApproval(params: {
+    executionId?: string;
+    executorIdentity?: ToolEventExecutorIdentity;
     requestId: string;
     abortSignal: AbortSignal;
     toolPermissionMode: ToolPermissionMode;

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/approval.js

@@ -1,3 +1,4 @@
+import { buildToolExecutorEventMetadata, } from "../shared/event-metadata.js";
 import { rejectNormalInvocation } from "../shared/rejection.js";
 export async function requestNormalInvocationApproval(params) {
     if (!params.force && params.toolPermissionMode !== "ask") {
@@ -5,6 +6,8 @@ export async function requestNormalInvocationApproval(params) {
     }
     const approvalId = params.nextApprovalId();
     params.onEvent?.("tool.approval.required", {
+        ...buildToolExecutorEventMetadata(params.executorIdentity),
+        ...(params.executionId ? { executionId: params.executionId } : {}),
         approvalId,
         tool: params.call.tool,
         ...(params.eventMeta ? { meta: params.eventMeta } : {}),
@@ -12,6 +15,8 @@ export async function requestNormalInvocationApproval(params) {
     if (!params.toolApprovalController) {
         const message = "Tool approval is required, but no approval controller is configured.";
         params.onEvent?.("tool.approval.rejected", {
+            ...buildToolExecutorEventMetadata(params.executorIdentity),
+            ...(params.executionId ? { executionId: params.executionId } : {}),
             approvalId,
             tool: params.call.tool,
             reason: message,
@@ -29,6 +34,8 @@ export async function requestNormalInvocationApproval(params) {
     }, { abortSignal: params.abortSignal });
     if (decision.approved) {
         params.onEvent?.("tool.approval.granted", {
+            ...buildToolExecutorEventMetadata(params.executorIdentity),
+            ...(params.executionId ? { executionId: params.executionId } : {}),
             approvalId,
             tool: params.call.tool,
         });
@@ -36,6 +43,8 @@ export async function requestNormalInvocationApproval(params) {
     }
     const message = decision.reason?.trim() || "Tool execution was rejected.";
     params.onEvent?.("tool.approval.rejected", {
+        ...buildToolExecutorEventMetadata(params.executorIdentity),
+        ...(params.executionId ? { executionId: params.executionId } : {}),
         approvalId,
         tool: params.call.tool,
         reason: message,

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/rejection-event.d.ts

@@ -0,0 +1,13 @@
+import type { BoundOperation, RegisteredToolNormalInvocationExecutor, RegisteredToolNormalInvocationExecutorParams, RegisteredToolPreparedNormalInvocation } from "../shared/contracts.js";
+/** Projects source controls only; rejected calls are never prepared again. */
+export declare function prepareNormalInvocationRejectionEvent(params: {
+    operationByHandle: WeakMap<object, BoundOperation>;
+    input: Parameters<RegisteredToolNormalInvocationExecutor["prepareRejectionEvent"]>[0];
+    onEvent: RegisteredToolNormalInvocationExecutorParams["onEvent"];
+}): ReturnType<RegisteredToolNormalInvocationExecutor["prepareRejectionEvent"]>;
+/** Reports an admitted invocation rejected before the external tool ran. */
+export declare function createPreparedInvocationRejectionEmitter(params: {
+    tool: string;
+    eventMeta: Record<string, unknown> | undefined;
+    onEvent: RegisteredToolNormalInvocationExecutorParams["onEvent"];
+}): RegisteredToolPreparedNormalInvocation["emitRejection"];

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/rejection-event.js

@@ -0,0 +1,25 @@
+import { buildToolExecutorEventMetadata, buildToolIntentEventMetadata, } from "../shared/event-metadata.js";
+/** Projects source controls only; rejected calls are never prepared again. */
+export function prepareNormalInvocationRejectionEvent(params) {
+    const source = params.operationByHandle.get(params.input.handle);
+    if (!source)
+        return undefined;
+    return createPreparedInvocationRejectionEmitter({
+        tool: source.registration.toolName,
+        eventMeta: buildToolIntentEventMetadata({ tool: source.registration.toolName, params: params.input.controls }, params.input.intent, source.registration.definition),
+        onEvent: params.onEvent,
+    });
+}
+/** Reports an admitted invocation rejected before the external tool ran. */
+export function createPreparedInvocationRejectionEmitter(params) {
+    return ({ executionId, executorIdentity, errorCode }) => {
+        params.onEvent?.("tool.failed", {
+            ...buildToolExecutorEventMetadata(executorIdentity),
+            executionId,
+            tool: params.tool,
+            stage: "before_external_execution",
+            error: errorCode,
+            ...(params.eventMeta ? { meta: params.eventMeta } : {}),
+        });
+    };
+}

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/run.js

@@ -1,8 +1,9 @@
 import { buildToolCompletedEventActions, buildToolCompletedEventMetadata, buildToolLifecycleEventCopy, } from "../../../../capabilities/tool-event-metadata.js";
 import { requestNormalInvocationApproval } from "./approval.js";
+import { createPreparedInvocationRejectionEmitter } from "./rejection-event.js";
 import { captureToolCall, materializeCall, resolveExactTargetOperation, validateCompleteCall, } from "./call-binding.js";
 import { createRegisteredToolActionFingerprint } from "../shared/action-fingerprint.js";
-import { buildToolIntentEventMetadata } from "../shared/event-metadata.js";
+import { buildToolExecutorEventMetadata, buildToolIntentEventMetadata, } from "../shared/event-metadata.js";
 import { prepareCompleteInvocationInput } from "../payload/input-preparation.js";
 import { rejectNormalInvocation } from "../shared/rejection.js";
 export async function executeNormalInvocation(params) {
@@ -59,7 +60,14 @@ export function prepareNormalInvocation(params) {
         status: "prepared",
         actionFingerprint,
         acceptedControls: preparedInput.controls,
-        execute: () => executePreparedNormalInvocation({
+        emitRejection: createPreparedInvocationRejectionEmitter({
+            tool: source.registration.toolName,
+            eventMeta,
+            onEvent: executor.onEvent,
+        }),
+        execute: (executionId, executorIdentity) => executePreparedNormalInvocation({
+            ...(executionId ? { executionId } : {}),
+            ...(executorIdentity ? { executorIdentity } : {}),
             executor,
             source,
             target: target.binding,
@@ -71,6 +79,10 @@ export function prepareNormalInvocation(params) {
 }
 async function executePreparedNormalInvocation(params) {
     const approval = await requestNormalInvocationApproval({
+        ...(params.executorIdentity
+            ? { executorIdentity: params.executorIdentity }
+            : {}),
+        ...(params.executionId ? { executionId: params.executionId } : {}),
         requestId: params.executor.requestId,
         abortSignal: params.executor.abortSignal,
         toolPermissionMode: params.executor.toolPermissionMode,
@@ -89,6 +101,8 @@ async function executePreparedNormalInvocation(params) {
     params.executor.abortSignal.throwIfAborted();
     const startedCopy = buildToolLifecycleEventCopy(params.target.registration.definition, "started");
     params.executor.onEvent?.("tool.started", {
+        ...buildToolExecutorEventMetadata(params.executorIdentity),
+        ...(params.executionId ? { executionId: params.executionId } : {}),
         tool: params.call.tool,
         ...(params.input.intent
             ? { intent: params.input.intent, intentSource: "model" }
@@ -106,6 +120,8 @@ async function executePreparedNormalInvocation(params) {
     const completedMeta = buildToolCompletedEventMetadata(params.call, result, params.target.registration.definition);
     const completedCopy = buildToolLifecycleEventCopy(params.target.registration.definition, result.ok ? "completed" : "failed");
     params.executor.onEvent?.("tool.completed", {
+        ...buildToolExecutorEventMetadata(params.executorIdentity),
+        ...(params.executionId ? { executionId: params.executionId } : {}),
         tool: params.source.registration.toolName,
         ok: result.ok,
         actions: completionActions,

package/dist/src/runtime/adapters/registered-tool-normal-invocations/executor.js

@@ -4,6 +4,7 @@ import { projectRuntimePathBindings } from "./catalog/runtime-path-bindings.js";
 import { executeNormalInvocation, prepareNormalInvocation, } from "./execution/run.js";
 import { emitNormalInvocationPayloadLifecycle } from "./payload/lifecycle.js";
 import { prepareNormalInvocationPayloadLifecycle } from "./payload/lifecycle.js";
+import { prepareNormalInvocationRejectionEvent } from "./execution/rejection-event.js";
 /**
  * Captures one selected ToolRegistry snapshot and executes its ordinary
  * invocation contracts. Normalization may only resolve another operation from
@@ -36,6 +37,13 @@ export function createRegisteredToolNormalInvocationExecutor(params) {
     })));
     return Object.freeze({
         operations,
+        prepareRejectionEvent(input) {
+            return prepareNormalInvocationRejectionEvent({
+                operationByHandle,
+                input,
+                onEvent: params.onEvent,
+            });
+        },
         emitPayloadLifecycle(input) {
             return emitNormalInvocationPayloadLifecycle({
                 operationByHandle,