@abot-ai/runtime 1.0.0

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

@@ -0,0 +1,475 @@
+import { assertValidSessionArtifactPathInputs, upsertSessionArtifactPaths, } from "../../sessions/artifact-paths.js";
+import { clientVisibleMessages, compactRequestEvents, filterMessagesAfter, getRequestFinalState, getSessionRequest, isSameMessageId, normalizeAfterSeq, normalizeCursor, normalizeLimit, normalizeSessionTitle, toClientReplayEvent, toEpochMs, toSessionListItem, toSnapshotMessage, toSnapshotRequest, } from "../../sessions/record/projection.js";
+import { assertValidRequestId, assertValidSessionId, createContextEntryId, defaultCreateMessageId, pruneSupersededContextEntries, } from "../../sessions/record/rules.js";
+import { resolveSessionMemoryCheckpointCommit } from "../../sessions/memory/rules.js";
+export function createInMemorySessionStore(options = {}) {
+    const store = new InMemorySessionStore(options);
+    return {
+        getOrCreateSession: store.getOrCreateSession.bind(store),
+        getAllSessions: store.getAllSessions.bind(store),
+        listSessions: store.listSessions.bind(store),
+        getSessionById: store.getSessionById.bind(store),
+        getSessionSnapshot: store.getSessionSnapshot.bind(store),
+        getRequestReplayById: store.getRequestReplayById.bind(store),
+        updateSessionTitle: store.updateSessionTitle.bind(store),
+        updateSessionRuntimeMode: store.updateSessionRuntimeMode.bind(store),
+        appendMessage: store.appendMessage.bind(store),
+        appendContextEntry: store.appendContextEntry.bind(store),
+        upsertArtifactPaths: store.upsertArtifactPaths.bind(store),
+        startRequestStream: store.startRequestStream.bind(store),
+        appendRequestEvent: store.appendRequestEvent.bind(store),
+        compareAndSwapSessionMemoryCheckpoint: store.compareAndSwapSessionMemoryCheckpoint.bind(store),
+        deleteSession: store.deleteSession.bind(store),
+        deleteSessionWithStats: store.deleteSessionWithStats.bind(store),
+        resetSession: store.resetSession.bind(store),
+        clearSessionMessages: store.clearSessionMessages.bind(store),
+        deleteMessage: store.deleteMessage.bind(store),
+        deleteMessageWithStats: store.deleteMessageWithStats.bind(store),
+    };
+}
+class InMemorySessionStore {
+    sessions = new Map();
+    mutationQueues = new Map();
+    now;
+    createMessageId;
+    constructor(options = {}) {
+        this.now = options.now ?? (() => new Date());
+        this.createMessageId = options.createMessageId ?? defaultCreateMessageId;
+        for (const session of options.initialSessions ?? []) {
+            assertValidSessionId(session.id);
+            this.sessions.set(session.id, cloneSession(session));
+        }
+    }
+    async getOrCreateSession(sessionId) {
+        assertValidSessionId(sessionId);
+        const existing = this.sessions.get(sessionId);
+        if (existing) {
+            return cloneSession(existing);
+        }
+        const timestamp = toIso(this.now);
+        const session = {
+            id: sessionId,
+            title: sessionId,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            lastAgentMode: "reasoning",
+            messageCount: 0,
+            messages: [],
+        };
+        this.sessions.set(sessionId, cloneSession(session));
+        return cloneSession(session);
+    }
+    async getAllSessions() {
+        return [...this.sessions.values()]
+            .map(cloneSession)
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    async listSessions(params = {}) {
+        const limit = normalizeLimit(params.limit);
+        const offset = normalizeCursor(params.cursor);
+        const sessions = await this.getAllSessions();
+        const selected = sessions.slice(offset, offset + limit);
+        const nextOffset = offset + selected.length;
+        return {
+            sessions: selected.map(toSessionListItem),
+            nextCursor: nextOffset < sessions.length ? String(nextOffset) : null,
+        };
+    }
+    async getSessionById(sessionId) {
+        assertValidSessionId(sessionId);
+        const session = this.sessions.get(sessionId);
+        return session ? cloneSession(session) : null;
+    }
+    async getSessionSnapshot(sessionId, options = {}) {
+        const session = await this.getSessionById(sessionId);
+        if (!session) {
+            return null;
+        }
+        return {
+            sessionId,
+            title: session.title,
+            messages: filterMessagesAfter(clientVisibleMessages(session.messages), options.afterMessageId).map((message) => toSnapshotMessage(sessionId, message, session.requests ?? [])),
+            requests: options.includeRequests === false
+                ? []
+                : (session.requests ?? []).map(toSnapshotRequest),
+            nextCursor: null,
+        };
+    }
+    async getRequestReplayById(requestId, afterSeq = 0) {
+        assertValidRequestId(requestId);
+        const normalizedAfterSeq = normalizeAfterSeq(afterSeq);
+        for (const session of this.sessions.values()) {
+            const request = getSessionRequest(session, requestId);
+            if (!request) {
+                continue;
+            }
+            return {
+                requestId,
+                sessionId: request.sessionId,
+                events: request.events
+                    .filter((event) => event.seqNo > normalizedAfterSeq)
+                    .map(toClientReplayEvent),
+                finalState: getRequestFinalState(request),
+            };
+        }
+        return null;
+    }
+    async updateSessionTitle(sessionId, title) {
+        assertValidSessionId(sessionId);
+        const normalizedTitle = normalizeSessionTitle(title);
+        if (!normalizedTitle) {
+            return this.getSessionById(sessionId);
+        }
+        return this.runSessionMutation(sessionId, async () => {
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                return null;
+            }
+            const nextSession = cloneSession(session);
+            if (nextSession.title === normalizedTitle) {
+                return nextSession;
+            }
+            nextSession.title = normalizedTitle;
+            nextSession.updatedAt = toIso(this.now);
+            this.saveSession(nextSession);
+            return cloneSession(nextSession);
+        });
+    }
+    async updateSessionRuntimeMode(sessionId, runtimeModeId) {
+        assertValidSessionId(sessionId);
+        const normalizedModeId = typeof runtimeModeId === "string" ? runtimeModeId.trim() : "";
+        return this.runSessionMutation(sessionId, async () => {
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                return null;
+            }
+            const nextSession = cloneSession(session);
+            if (normalizedModeId) {
+                if (nextSession.runtimeModeId === normalizedModeId) {
+                    return nextSession;
+                }
+                nextSession.runtimeModeId = normalizedModeId;
+            }
+            else {
+                if (!nextSession.runtimeModeId) {
+                    return nextSession;
+                }
+                delete nextSession.runtimeModeId;
+            }
+            nextSession.updatedAt = toIso(this.now);
+            this.saveSession(nextSession);
+            return cloneSession(nextSession);
+        });
+    }
+    async appendMessage(sessionId, role, content, options = {}) {
+        assertValidSessionId(sessionId);
+        return this.runSessionMutation(sessionId, async () => {
+            const session = await this.getWritableSession(sessionId);
+            const createdAt = toIso(this.now);
+            session.messages.push({
+                id: this.createMessageId(session),
+                role,
+                content,
+                createdAt,
+                source: options.source,
+                taskType: options.taskType,
+                requestId: options.requestId,
+                cronJobId: options.cronJobId,
+                cronTitle: options.cronTitle,
+                triggerType: options.triggerType,
+                attachments: options.attachments,
+                grounding: options.grounding,
+                observationMeta: options.observationMeta,
+                observationContent: options.observationContent,
+                thinkingTrace: options.thinkingTrace,
+            });
+            session.messageCount = session.messages.length;
+            session.updatedAt = createdAt;
+            if (options.lastAgentMode) {
+                session.lastAgentMode = options.lastAgentMode;
+            }
+            this.saveSession(session);
+            return cloneSession(session);
+        });
+    }
+    async appendContextEntry(sessionId, options) {
+        assertValidSessionId(sessionId);
+        return this.runSessionMutation(sessionId, async () => {
+            const session = await this.getWritableSession(sessionId);
+            const createdAt = toIso(this.now);
+            const nextEntry = {
+                id: createContextEntryId(session),
+                kind: options.kind,
+                content: options.content,
+                createdAt,
+                requestId: options.requestId,
+                observationMeta: options.observationMeta,
+            };
+            session.contextEntries = [
+                ...pruneSupersededContextEntries(session.contextEntries ?? [], nextEntry.observationMeta),
+                nextEntry,
+            ];
+            session.updatedAt = createdAt;
+            this.saveSession(session);
+            return cloneSession(session);
+        });
+    }
+    async compareAndSwapSessionMemoryCheckpoint(sessionId, command) {
+        assertValidSessionId(sessionId);
+        return this.runSessionMutation(sessionId, async () => {
+            const session = await this.getWritableSession(sessionId);
+            const result = resolveSessionMemoryCheckpointCommit(session, command);
+            if (!result.committed) {
+                return result;
+            }
+            session.sessionMemoryCheckpoint = result.checkpoint;
+            session.updatedAt = toIso(this.now);
+            this.saveSession(session);
+            return result;
+        });
+    }
+    async upsertArtifactPaths(sessionId, inputs) {
+        assertValidSessionId(sessionId);
+        assertValidSessionArtifactPathInputs(inputs);
+        if (inputs.length === 0) {
+            return this.getOrCreateSession(sessionId);
+        }
+        return this.runSessionMutation(sessionId, async () => {
+            const session = await this.getWritableSession(sessionId);
+            const updatedAt = toIso(this.now);
+            session.artifactPaths = upsertSessionArtifactPaths(session.artifactPaths ?? [], inputs, updatedAt);
+            session.updatedAt = updatedAt;
+            this.saveSession(session);
+            return cloneSession(session);
+        });
+    }
+    async startRequestStream(sessionId, requestId) {
+        assertValidSessionId(sessionId);
+        assertValidRequestId(requestId);
+        return this.runSessionMutation(sessionId, async () => {
+            const session = await this.getWritableSession(sessionId);
+            const timestamp = toIso(this.now);
+            const existing = getSessionRequest(session, requestId);
+            if (existing) {
+                existing.status = "streaming";
+                existing.updatedAt = timestamp;
+                existing.events = compactRequestEvents(existing.events);
+                session.updatedAt = timestamp;
+                this.saveSession(session);
+                return cloneSession(session);
+            }
+            const request = {
+                requestId,
+                sessionId,
+                status: "streaming",
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                lastSeqNo: 0,
+                events: [],
+            };
+            session.requests = [...(session.requests ?? []), request];
+            session.updatedAt = timestamp;
+            this.saveSession(session);
+            return cloneSession(session);
+        });
+    }
+    async appendRequestEvent(sessionId, requestId, payload) {
+        assertValidSessionId(sessionId);
+        assertValidRequestId(requestId);
+        return this.runSessionMutation(sessionId, async () => {
+            const session = await this.getWritableSession(sessionId);
+            const timestamp = toIso(this.now);
+            let request = getSessionRequest(session, requestId);
+            if (!request) {
+                request = {
+                    requestId,
+                    sessionId,
+                    status: "streaming",
+                    createdAt: timestamp,
+                    updatedAt: timestamp,
+                    lastSeqNo: 0,
+                    events: [],
+                };
+                session.requests = [...(session.requests ?? []), request];
+            }
+            const type = typeof payload.type === "string" ? payload.type : "event";
+            const seqNo = request.lastSeqNo + 1;
+            const eventPayload = {
+                ...payload,
+                type,
+                requestId,
+                seqNo,
+                timestamp,
+            };
+            request.lastSeqNo = seqNo;
+            request.updatedAt = timestamp;
+            const event = {
+                seqNo,
+                type,
+                requestId,
+                timestamp,
+                payload: eventPayload,
+            };
+            request.events.push(event);
+            request.events = compactRequestEvents(request.events);
+            if (type === "completed") {
+                request.status = "completed";
+            }
+            else if (type === "failed") {
+                request.status = "failed";
+            }
+            else if (request.status !== "failed" &&
+                request.status !== "completed") {
+                request.status = "streaming";
+            }
+            session.updatedAt = timestamp;
+            this.saveSession(session);
+            return cloneSession(session);
+        });
+    }
+    async deleteSession(sessionId) {
+        const result = await this.deleteSessionWithStats(sessionId);
+        return result.deleted;
+    }
+    async deleteSessionWithStats(sessionId) {
+        assertValidSessionId(sessionId);
+        const session = this.sessions.get(sessionId);
+        const deleted = this.sessions.delete(sessionId);
+        return {
+            sessionId,
+            deleted,
+            deletedMessages: deleted ? (session?.messages.length ?? 0) : 0,
+            deletedRequests: deleted ? (session?.requests?.length ?? 0) : 0,
+        };
+    }
+    async resetSession(sessionId) {
+        const result = await this.clearSessionMessages(sessionId);
+        if (!result) {
+            return null;
+        }
+        return this.getSessionById(sessionId);
+    }
+    async clearSessionMessages(sessionId) {
+        assertValidSessionId(sessionId);
+        return this.runSessionMutation(sessionId, async () => {
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                return null;
+            }
+            const nextSession = cloneSession(session);
+            const deletedMessages = nextSession.messages.length;
+            const deletedRequests = nextSession.requests?.length ?? 0;
+            const updatedAt = toIso(this.now);
+            nextSession.messages = [];
+            nextSession.messageCount = 0;
+            nextSession.requests = [];
+            nextSession.contextEntries = [];
+            nextSession.artifactPaths = [];
+            delete nextSession.sessionMemoryCheckpoint;
+            delete nextSession.runtimeModeId;
+            nextSession.updatedAt = updatedAt;
+            this.saveSession(nextSession);
+            return {
+                sessionId,
+                cleared: deletedMessages > 0 || deletedRequests > 0,
+                deletedMessages,
+                deletedRequests,
+                updatedAt: toEpochMs(updatedAt),
+            };
+        });
+    }
+    async deleteMessage(sessionId, messageId) {
+        await this.deleteMessageWithStats(sessionId, messageId);
+        return this.getSessionById(sessionId);
+    }
+    async deleteMessageWithStats(sessionId, messageId) {
+        assertValidSessionId(sessionId);
+        return this.runSessionMutation(sessionId, async () => {
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                return null;
+            }
+            const nextSession = cloneSession(session);
+            const targetMessage = nextSession.messages.find((message) => isSameMessageId(message.id, messageId));
+            const updatedAt = toIso(this.now);
+            if (!targetMessage) {
+                return {
+                    sessionId,
+                    messageId,
+                    deleted: false,
+                    updatedAt: toEpochMs(updatedAt),
+                };
+            }
+            const nextMessages = nextSession.messages.filter((message) => !isSameMessageId(message.id, messageId));
+            if (nextMessages.length === nextSession.messages.length) {
+                return {
+                    sessionId,
+                    messageId,
+                    deleted: false,
+                    updatedAt: toEpochMs(updatedAt),
+                };
+            }
+            const requestId = targetMessage.requestId;
+            let deletedRequestId;
+            let deletedRequestEvents;
+            if (requestId) {
+                const requests = nextSession.requests ?? [];
+                const request = requests.find((item) => item.requestId === requestId);
+                if (request) {
+                    deletedRequestId = requestId;
+                    deletedRequestEvents = request.events.length;
+                    nextSession.requests = requests.filter((item) => item.requestId !== requestId);
+                }
+                nextSession.contextEntries = (nextSession.contextEntries ?? []).filter((entry) => entry.requestId !== requestId);
+            }
+            nextSession.messages = nextMessages;
+            nextSession.messageCount = nextMessages.length;
+            delete nextSession.sessionMemoryCheckpoint;
+            if (nextMessages.length === 0) {
+                delete nextSession.runtimeModeId;
+            }
+            nextSession.updatedAt = updatedAt;
+            this.saveSession(nextSession);
+            return {
+                sessionId,
+                messageId,
+                deleted: true,
+                updatedAt: toEpochMs(updatedAt),
+                ...(deletedRequestId ? { deletedRequestId } : {}),
+                ...(typeof deletedRequestEvents === "number"
+                    ? { deletedRequestEvents }
+                    : {}),
+            };
+        });
+    }
+    async getWritableSession(sessionId) {
+        const existing = this.sessions.get(sessionId);
+        if (existing) {
+            return cloneSession(existing);
+        }
+        return this.getOrCreateSession(sessionId);
+    }
+    saveSession(session) {
+        this.sessions.set(session.id, cloneSession(session));
+    }
+    async runSessionMutation(sessionId, mutation) {
+        const previous = this.mutationQueues.get(sessionId) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(mutation);
+        const queued = current.then(() => undefined, () => undefined);
+        this.mutationQueues.set(sessionId, queued);
+        try {
+            return await current;
+        }
+        finally {
+            if (this.mutationQueues.get(sessionId) === queued) {
+                this.mutationQueues.delete(sessionId);
+            }
+        }
+    }
+}
+function cloneSession(session) {
+    return JSON.parse(JSON.stringify(session));
+}
+function toIso(now) {
+    return now().toISOString();
+}

package/dist/src/runtime/adapters/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./configured-skill-provider.js";
+export * from "./compiled-workspace-provider.js";
+export * from "./file-session-store.js";
+export * from "./in-memory-session-store.js";
+export * from "./multi-workspace-provider.js";
+export * from "./registered-tool-normal-invocations.js";
+export * from "./registered-tool-worker-capabilities.js";
+export * from "./source-workspace-provider.js";

package/dist/src/runtime/adapters/index.js

@@ -0,0 +1,8 @@
+export * from "./configured-skill-provider.js";
+export * from "./compiled-workspace-provider.js";
+export * from "./file-session-store.js";
+export * from "./in-memory-session-store.js";
+export * from "./multi-workspace-provider.js";
+export * from "./registered-tool-normal-invocations.js";
+export * from "./registered-tool-worker-capabilities.js";
+export * from "./source-workspace-provider.js";

package/dist/src/runtime/adapters/multi-workspace-provider.d.ts

@@ -0,0 +1,7 @@
+import type { WorkspaceProvider } from "../ports.js";
+export type MultiWorkspaceProviderOptions = {
+    workspaces: Record<string, WorkspaceProvider>;
+    defaultWorkspace: string;
+    resolveWorkspace?: () => string | undefined | null;
+};
+export declare function createMultiWorkspaceProvider(options: MultiWorkspaceProviderOptions): WorkspaceProvider;

package/dist/src/runtime/adapters/multi-workspace-provider.js

@@ -0,0 +1,14 @@
+export function createMultiWorkspaceProvider(options) {
+    const workspaces = { ...options.workspaces };
+    const defaultProvider = workspaces[options.defaultWorkspace];
+    if (!defaultProvider) {
+        throw new Error(`default workspace provider not found: ${options.defaultWorkspace}`);
+    }
+    return {
+        getSystemSummary() {
+            const workspaceKey = options.resolveWorkspace?.() ?? options.defaultWorkspace;
+            const provider = workspaces[workspaceKey] ?? defaultProvider;
+            return provider.getSystemSummary();
+        },
+    };
+}

package/dist/src/runtime/adapters/registered-tool-normal-invocations/catalog/registrations.d.ts

@@ -0,0 +1,2 @@
+import type { RegisteredToolNormalInvocation } from "../../../../capabilities/tool-types.js";
+export declare function captureNormalInvocationRegistrations(registrations: readonly RegisteredToolNormalInvocation[]): readonly RegisteredToolNormalInvocation[];

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

@@ -0,0 +1,39 @@
+import { parseToolNormalInvocationForDefinition } from "../../../../capabilities/normal-invocation/index.js";
+export function captureNormalInvocationRegistrations(registrations) {
+    const names = new Set();
+    const captured = registrations.map((registration) => {
+        if (names.has(registration.toolName)) {
+            throw new TypeError(`Duplicate ordinary invocation registration: ${registration.toolName}`);
+        }
+        names.add(registration.toolName);
+        if (registration.toolName !== registration.definition.name) {
+            throw new TypeError(`Ordinary invocation registration name mismatch: ${registration.toolName}`);
+        }
+        const contract = parseToolNormalInvocationForDefinition(registration.definition, registration.contract);
+        if (!contract) {
+            throw new TypeError(`Ordinary invocation registration is missing a contract: ${registration.toolName}`);
+        }
+        const adapter = captureAdapter(registration.toolName, registration.adapter);
+        return Object.freeze({
+            toolName: registration.toolName,
+            definition: registration.definition,
+            contract,
+            ...(adapter ? { adapter } : {}),
+        });
+    });
+    return Object.freeze(captured);
+}
+function captureAdapter(toolName, adapter) {
+    if (!adapter)
+        return undefined;
+    const normalizeCall = adapter.normalizeCall;
+    const validateCall = adapter.validateCall;
+    if ((normalizeCall !== undefined && typeof normalizeCall !== "function") ||
+        (validateCall !== undefined && typeof validateCall !== "function")) {
+        throw new TypeError(`Invalid ordinary invocation adapter registration: ${toolName}`);
+    }
+    return Object.freeze({
+        ...(normalizeCall ? { normalizeCall } : {}),
+        ...(validateCall ? { validateCall } : {}),
+    });
+}

package/dist/src/runtime/adapters/registered-tool-normal-invocations/catalog/runtime-path-bindings.d.ts

@@ -0,0 +1,5 @@
+import type { ToolDefinition, ToolNormalInvocationOperation } from "../../../../capabilities/tool-types.js";
+export declare function projectRuntimePathBindings(definition: ToolDefinition, operation: ToolNormalInvocationOperation): readonly Readonly<{
+    param: string;
+    default?: ".";
+}>[];

package/dist/src/runtime/adapters/registered-tool-normal-invocations/catalog/runtime-path-bindings.js

@@ -0,0 +1,18 @@
+export function projectRuntimePathBindings(definition, operation) {
+    const bindings = new Map();
+    for (const binding of definition.runtimePathBindings ?? []) {
+        if (binding.operationId === operation.operationId) {
+            bindings.set(binding.param, Object.freeze({
+                param: binding.param,
+                ...(binding.default ? { default: binding.default } : {}),
+            }));
+        }
+    }
+    const operationTargetParam = definition.payloadChannelSpec?.targetRole === "operation_target"
+        ? definition.payloadChannelSpec.targetParam
+        : undefined;
+    if (operationTargetParam) {
+        bindings.set(operationTargetParam, Object.freeze({ param: operationTargetParam }));
+    }
+    return Object.freeze([...bindings.values()]);
+}

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

@@ -0,0 +1,19 @@
+import type { ToolCall } from "../../../../capabilities/tool-types.js";
+import type { ToolApprovalController, ToolPermissionMode } from "../../../ports.js";
+import type { RegisteredToolNormalInvocationRejection } from "../shared/contracts.js";
+export declare function requestNormalInvocationApproval(params: {
+    requestId: string;
+    abortSignal: AbortSignal;
+    toolPermissionMode: ToolPermissionMode;
+    toolApprovalController?: ToolApprovalController;
+    nextApprovalId(): string;
+    onEvent?(name: string, payload: Record<string, unknown>): void;
+    call: ToolCall;
+    eventMeta?: Record<string, unknown>;
+    force: boolean;
+}): Promise<Readonly<{
+    ok: true;
+}> | Readonly<{
+    ok: false;
+    rejection: RegisteredToolNormalInvocationRejection;
+}>>;

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

@@ -0,0 +1,47 @@
+import { rejectNormalInvocation } from "../shared/rejection.js";
+export async function requestNormalInvocationApproval(params) {
+    if (!params.force && params.toolPermissionMode !== "ask") {
+        return Object.freeze({ ok: true });
+    }
+    const approvalId = params.nextApprovalId();
+    params.onEvent?.("tool.approval.required", {
+        approvalId,
+        tool: params.call.tool,
+        ...(params.eventMeta ? { meta: params.eventMeta } : {}),
+    });
+    if (!params.toolApprovalController) {
+        const message = "Tool approval is required, but no approval controller is configured.";
+        params.onEvent?.("tool.approval.rejected", {
+            approvalId,
+            tool: params.call.tool,
+            reason: message,
+        });
+        return {
+            ok: false,
+            rejection: rejectNormalInvocation("tool_approval_unavailable", message),
+        };
+    }
+    const decision = await params.toolApprovalController.requestToolApproval({
+        requestId: params.requestId,
+        approvalId,
+        call: params.call,
+        ...(params.eventMeta ? { meta: params.eventMeta } : {}),
+    }, { abortSignal: params.abortSignal });
+    if (decision.approved) {
+        params.onEvent?.("tool.approval.granted", {
+            approvalId,
+            tool: params.call.tool,
+        });
+        return Object.freeze({ ok: true });
+    }
+    const message = decision.reason?.trim() || "Tool execution was rejected.";
+    params.onEvent?.("tool.approval.rejected", {
+        approvalId,
+        tool: params.call.tool,
+        reason: message,
+    });
+    return {
+        ok: false,
+        rejection: rejectNormalInvocation("tool_approval_rejected", message),
+    };
+}

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

@@ -0,0 +1,23 @@
+import type { RegisteredToolNormalInvocation, ToolCall, ToolCallAdapter } from "../../../../capabilities/tool-types.js";
+import type { BoundOperation, RegisteredToolNormalInvocationRejection } from "../shared/contracts.js";
+export declare function materializeCall(binding: BoundOperation, controls: Readonly<Record<string, unknown>>, payload: string | undefined): ToolCall;
+export declare function resolveExactTargetOperation(registrations: readonly RegisteredToolNormalInvocation[], call: ToolCall): Readonly<{
+    ok: true;
+    binding: BoundOperation;
+}> | Readonly<{
+    ok: false;
+    rejection: RegisteredToolNormalInvocationRejection;
+}>;
+export declare function captureToolCall(value: unknown): ToolCall | undefined;
+export declare function validateCompleteCall(params: {
+    adapter: ToolCallAdapter | undefined;
+    call: ToolCall;
+    rejectedCode: string;
+    failedCode: string;
+    failedMessage: string;
+}): Readonly<{
+    ok: true;
+}> | Readonly<{
+    ok: false;
+    rejection: RegisteredToolNormalInvocationRejection;
+}>;