@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/heart/frontend-approval-runtime.js

@@ -0,0 +1,506 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settleFrontendApproval = settleFrontendApproval;
+exports.createFrontendApprovalRuntime = createFrontendApprovalRuntime;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const friends_1 = require("@ouro.bot/friends");
+const approval_files_1 = require("./approval-files");
+const approval_store_1 = require("./approval-store");
+const tool_approval_1 = require("./tool-approval");
+const core_1 = require("./core");
+const identity_1 = require("./identity");
+const turn_execution_lease_1 = require("./turn-execution-lease");
+const context_1 = require("../mind/context");
+const session_transaction_1 = require("../mind/session-transaction");
+const tools_1 = require("../repertoire/tools");
+const mcp_manager_1 = require("../repertoire/mcp-manager");
+const runtime_1 = require("../nerves/runtime");
+const PERMISSION_OPTIONS = [
+    { optionId: "allow-once", name: "Allow once", kind: "allow_once" },
+    { optionId: "reject-once", name: "Reject", kind: "reject_once" },
+];
+async function defaultReleaseRuntimeMcpServers(owner) {
+    const manager = await Promise.resolve().then(() => __importStar(require("../repertoire/mcp-manager")));
+    await manager.releaseRuntimeMcpServers(owner);
+}
+const DEFAULT_SETTLEMENT_DEPENDENCIES = {
+    withTurnExecutionLease: turn_execution_lease_1.withTurnExecutionLease,
+    setAgentName: identity_1.setAgentName,
+    withSessionTurnLease: session_transaction_1.withSessionTurnLease,
+    readSessionTransaction: session_transaction_1.readSessionTransaction,
+    executeApprovalDecision: tool_approval_1.executeApprovalDecision,
+    resolveToolDefinition: tools_1.resolveToolDefinition,
+    approvalPolicyForInvocation: tools_1.approvalPolicyForInvocation,
+    executeTool: tools_1.executeTool,
+    preflightToolCall: tools_1.preflightToolCall,
+    selectToolsForChannel: tools_1.selectToolsForChannel,
+    getProviderRuntime: core_1.getProviderRuntime,
+    getSharedMcpManager: mcp_manager_1.getSharedMcpManager,
+    releaseRuntimeMcpServers: defaultReleaseRuntimeMcpServers,
+    loadSession: context_1.loadSession,
+    postTurnTrim: context_1.postTurnTrim,
+    postTurnPersist: context_1.postTurnPersist,
+    resumeApprovalContinuation: core_1.resumeApprovalContinuation,
+    runAgent: core_1.runAgent,
+    randomUUID: node_crypto_1.randomUUID,
+};
+async function settleFrontendApproval(input, dependencies = DEFAULT_SETTLEMENT_DEPENDENCIES) {
+    const token = input.tokenStore.get(input.suspension.approvalId);
+    if (!token)
+        throw new Error(`frontend approval decision token is unavailable: ${input.suspension.approvalId}`);
+    const checkpoint = input.checkpointStore.read(input.suspension.approvalId);
+    if (!checkpoint)
+        throw new Error(`frontend approval checkpoint is unavailable: ${input.suspension.approvalId}`);
+    const record = input.approvalStore.read(input.suspension.approvalId);
+    if (!record)
+        throw new Error(`frontend approval record is unavailable: ${input.suspension.approvalId}`);
+    const owner = Object.freeze({ agentName: input.request.agent, agentRoot: input.agentRoot });
+    const toolsDisabled = input.request.disableTools === true;
+    const runtimeServers = input.request.runtimeMcpServers;
+    return dependencies.withTurnExecutionLease(async () => {
+        dependencies.setAgentName(owner.agentName);
+        try {
+            return await dependencies.withSessionTurnLease(record.sessionPath, async (lease) => {
+                const currentRevision = dependencies.readSessionTransaction(record.sessionPath, lease).revision;
+                const continuationSignal = input.optionId === "cancelled" ? AbortSignal.abort() : input.signal;
+                const liveToolContext = input.approvalRequest.liveToolContext ?? {
+                    signin: async () => undefined,
+                    agentName: owner.agentName,
+                    agentRoot: input.agentRoot,
+                    currentSession: {
+                        friendId: input.request.friendId,
+                        channel: input.request.channel,
+                        key: input.request.sessionKey,
+                        sessionPath: record.sessionPath,
+                    },
+                    currentUserMessage: input.request.message,
+                };
+                const currentOptions = async () => {
+                    try {
+                        if ((liveToolContext.agentName !== undefined && liveToolContext.agentName !== owner.agentName)
+                            || (liveToolContext.agentRoot !== undefined && liveToolContext.agentRoot !== owner.agentRoot)) {
+                            throw new Error("approval context owner coordinates changed");
+                        }
+                        let context = { ...liveToolContext, ...owner };
+                        const original = liveToolContext.relationshipAuthorization;
+                        if (original) {
+                            if (liveToolContext.agentName !== owner.agentName || liveToolContext.agentRoot !== owner.agentRoot) {
+                                throw new Error("approval context owner coordinates changed");
+                            }
+                            const current = await original.resolveCurrent?.();
+                            if (!current?.actor || current.actor.friendId !== input.request.friendId
+                                || current.actor.trustLevel !== original.actor?.trustLevel || current.profileId !== original.profileId
+                                || original.authorizedContextScopes.some((scope) => !current.authorizedContextScopes.includes(scope))) {
+                                throw new Error("current approval relationship authority is unavailable");
+                            }
+                            context = { ...context, relationshipAuthorization: current };
+                        }
+                        const providerRuntime = await dependencies.getProviderRuntime((0, friends_1.channelToFacing)(input.request.channel), owner);
+                        const mcpManager = toolsDisabled ? undefined : await dependencies.getSharedMcpManager({ ...owner, runtimeServers }) ?? undefined;
+                        const selectCurrentTools = () => toolsDisabled
+                            ? Object.freeze({ ordinary: Object.freeze([]), engine: Object.freeze([]) })
+                            : dependencies.selectToolsForChannel((0, friends_1.getChannelCapabilities)(input.request.channel), context.context?.friend.toolPreferences, context.context, providerRuntime.capabilities, mcpManager, providerRuntime.model, context);
+                        return {
+                            providerRuntimeOverride: providerRuntime, mcpManager,
+                            ...(toolsDisabled ? { tools: [], hardDisableTools: true } : {}),
+                            toolContext: { ...context, toolSelection: selectCurrentTools(), selectCurrentTools },
+                        };
+                    }
+                    catch (error) {
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn", component: "heart", event: "heart.frontend_approval_authority_unavailable",
+                            message: "current approval authority could not be reconstructed; execution remains disabled",
+                            meta: { approvalId: record.approvalId, category: error instanceof Error ? error.name : "unknown" },
+                        });
+                        return null;
+                    }
+                };
+                let definition;
+                const terminal = await dependencies.executeApprovalDecision({
+                    approvalStore: input.approvalStore,
+                    checkpointStore: input.checkpointStore,
+                    decision: {
+                        approvalId: record.approvalId,
+                        decisionToken: token,
+                        decision: input.optionId === "allow-once" ? "approve" : "deny",
+                        requesterId: input.request.friendId,
+                        transport: "frontend",
+                        transportUserId: input.request.friendId,
+                        transportChatId: input.request.sessionKey,
+                        transportMessageId: record.approvalId,
+                        sessionKey: input.request.sessionKey,
+                        ...(input.optionId === "expired" ? { decisionAt: Date.parse(record.expiresAt) } : {}),
+                    },
+                    ownerId: `frontend-decision-${dependencies.randomUUID()}`,
+                    currentSessionRevision: currentRevision,
+                    resolveTool: async (name) => {
+                        const current = await currentOptions();
+                        definition = current ? dependencies.resolveToolDefinition(name, current.toolContext.toolSelection) : undefined;
+                        return definition;
+                    },
+                    resolveApprovalPolicy: async (name, args) => {
+                        const current = await currentOptions();
+                        return current ? dependencies.approvalPolicyForInvocation(name, args, current.toolContext) : { kind: "not_required" };
+                    },
+                    liveGuard: async () => ({ ok: true }),
+                    liveRisk: async () => ({ ok: true }),
+                    preflight: async (context) => {
+                        const current = await currentOptions();
+                        if (!current)
+                            return { ok: false, reason: "current tool authority is unavailable" };
+                        const result = await dependencies.preflightToolCall(context.record.toolName, context.arguments, {
+                            ...current.toolContext,
+                            toolSelection: Object.freeze({ ordinary: Object.freeze([context.definition]), engine: Object.freeze([]) }),
+                        });
+                        return result.kind === "ready" ? { ok: true } : { ok: false, reason: result.text };
+                    },
+                    execute: async (name, args) => {
+                        const current = await currentOptions();
+                        if (!current || !definition)
+                            return { kind: "rejected_before_handler", text: "current approved tool authority is unavailable" };
+                        return dependencies.executeTool(name, args, {
+                            ...current.toolContext,
+                            toolSelection: Object.freeze({ ordinary: Object.freeze([definition]), engine: Object.freeze([]) }),
+                        });
+                    },
+                });
+                input.tokenStore.remove(record.approvalId);
+                const existing = dependencies.loadSession(record.sessionPath);
+                const existingStructuredOutputIds = new Set(existing?.structuredOutputs.map((output) => output.id) ?? []);
+                const deliveries = [];
+                let response = "";
+                const emit = input.frontendEventSink.onEvent;
+                const callbacks = {
+                    settleOutputMode: "retractable_buffer",
+                    onModelStart: () => emit({ type: "model_started", data: {} }),
+                    onModelStreamStart: () => emit({ type: "model_stream_started", data: {} }),
+                    onTextChunk: (text) => {
+                        response += text;
+                        emit({ type: "text_delta", data: { text } });
+                    },
+                    onReasoningChunk: (text) => emit({ type: "reasoning_delta", data: { text } }),
+                    onToolStart: (name, args) => emit({ type: "tool_started", data: { name, args } }),
+                    onToolEnd: (name, summary, success) => emit({ type: "tool_completed", data: { name, summary, success } }),
+                    onError: (error, severity) => emit({ type: "error", data: { message: error.message, severity } }),
+                    onClearText: () => {
+                        response = "";
+                        emit({ type: "text_cleared", data: {} });
+                    },
+                };
+                let continuationEpoch = 0;
+                const continuationOwnerId = `frontend-continuation-${dependencies.randomUUID()}`;
+                const nestedCoordinator = {
+                    propose: (request) => input.approvalCoordinatorFactory({
+                        request: input.request,
+                        publish: input.publish,
+                    })({
+                        sessionPath: record.sessionPath,
+                        baseSessionRevision: dependencies.readSessionTransaction(record.sessionPath, lease).revision,
+                    }).propose(request),
+                };
+                const persist = (messages, result) => {
+                    const expectedRevision = dependencies.readSessionTransaction(record.sessionPath, lease).revision;
+                    const prepared = dependencies.postTurnTrim(messages, result?.usage);
+                    dependencies.postTurnPersist(record.sessionPath, prepared, result?.usage, existing?.state, lease, expectedRevision);
+                };
+                const continuation = await dependencies.resumeApprovalContinuation({
+                    record: terminal,
+                    checkpoint,
+                    currentSessionRevision: dependencies.readSessionTransaction(record.sessionPath, lease).revision,
+                    sessionMessages: checkpoint.preCallMessages,
+                    callbacks,
+                    channel: input.request.channel,
+                    claimContinuation: () => {
+                        const claim = input.approvalStore.claimContinuation({
+                            approvalId: record.approvalId,
+                            ownerId: continuationOwnerId,
+                        });
+                        continuationEpoch = claim.record.continuationEpoch;
+                        return claim;
+                    },
+                    markContinuationMaterialized: () => {
+                        input.approvalStore.markContinuationMaterialized({
+                            approvalId: record.approvalId,
+                            ownerId: continuationOwnerId,
+                            epoch: continuationEpoch,
+                        });
+                    },
+                    markContinuationAttempted: () => {
+                        input.approvalStore.markContinuationAttempted({
+                            approvalId: record.approvalId,
+                            ownerId: continuationOwnerId,
+                            epoch: continuationEpoch,
+                        });
+                    },
+                    completeContinuation: () => {
+                        input.approvalStore.completeContinuation({
+                            approvalId: record.approvalId,
+                            ownerId: continuationOwnerId,
+                            epoch: continuationEpoch,
+                        });
+                    },
+                    runAgent: dependencies.runAgent,
+                    runAgentOptions: {
+                        toolContext: liveToolContext,
+                        approvalCoordinator: nestedCoordinator,
+                    },
+                    revalidate: async () => {
+                        const current = await currentOptions();
+                        return current ? { ...current, approvalCoordinator: nestedCoordinator } : null;
+                    },
+                    persist,
+                    deliver: async (text) => {
+                        response = text;
+                        deliveries.push({ kind: "text", text });
+                        emit({ type: "assistant_delivery", data: { kind: "text", text } });
+                    },
+                    signal: continuationSignal,
+                });
+                const persisted = dependencies.loadSession(record.sessionPath);
+                for (const output of persisted?.structuredOutputs ?? []) {
+                    if (!existingStructuredOutputIds.has(output.id)) {
+                        emit({ type: "structured_output", data: { output } });
+                    }
+                }
+                const turnOutcome = continuation.outcome === "terminal_notice"
+                    ? "settled"
+                    : continuation.outcome === "already_continued"
+                        ? "superseded"
+                        : continuation.outcome;
+                if (turnOutcome === "suspended" && !continuation.suspension) {
+                    throw new Error("frontend approval continuation omitted its nested suspension");
+                }
+                return {
+                    response,
+                    ponderDeferred: false,
+                    deliveries,
+                    deliveryFailures: [],
+                    sessionPath: record.sessionPath,
+                    turnOutcome,
+                    ...(continuation.suspension ? { suspension: continuation.suspension } : {}),
+                };
+            });
+        }
+        finally {
+            if (runtimeServers && !toolsDisabled) {
+                await dependencies.releaseRuntimeMcpServers(owner);
+            }
+        }
+    });
+}
+function createFrontendApprovalRuntime(options) {
+    const agentRoot = options.agentRoot ?? identity_1.getAgentRoot;
+    const now = options.now ?? Date.now;
+    const approvalTimeoutMs = options.approvalTimeoutMs ?? 300_000;
+    const settleApproval = options.settleApproval ?? settleFrontendApproval;
+    if (!Number.isSafeInteger(approvalTimeoutMs) || approvalTimeoutMs < 1) {
+        throw new Error("approvalTimeoutMs must be a positive integer");
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.frontend_approval_runtime_ready",
+        message: "frontend approval runtime ready",
+    });
+    const states = new Map();
+    const pending = new Map();
+    let closed = false;
+    function closeStatesWhenIdle() {
+        if (!closed || pending.size > 0)
+            return;
+        for (const state of states.values())
+            state.approvalStore.close();
+        states.clear();
+    }
+    function stateFor(agent) {
+        let state = states.get(agent);
+        if (state)
+            return state;
+        const stateRoot = path.join(agentRoot(agent), "state", "approvals");
+        state = {
+            approvalStore: (0, approval_store_1.openApprovalStore)({ databasePath: path.join(stateRoot, "approvals.sqlite") }),
+            checkpointStore: new approval_files_1.FileApprovalCheckpointStore(path.join(stateRoot, "checkpoints.json")),
+            tokenStore: new approval_files_1.FileApprovalTokenStore(path.join(stateRoot, "tokens.json")),
+        };
+        states.set(agent, state);
+        return state;
+    }
+    function settlePending(item, optionId) {
+        if (item.settled)
+            return false;
+        item.settled = true;
+        item.resolve(optionId);
+        item.publish("permission_resolved", { requestId: item.requestId, optionId }, "permission_resolved");
+        return true;
+    }
+    const runtime = {
+        approvalCoordinatorFactory(input) {
+            return (context) => ({
+                propose: async (request) => {
+                    if (closed)
+                        throw new Error("frontend approval runtime is closed");
+                    if (request.toolCall.type !== "function")
+                        throw new Error("frontend approval requires a function tool call");
+                    const state = stateFor(input.request.agent);
+                    const committed = (0, tool_approval_1.commitApprovalProposal)({
+                        approvalStore: state.approvalStore,
+                        checkpointStore: state.checkpointStore,
+                        tokenStore: state.tokenStore,
+                        proposal: {
+                            toolCallId: request.toolCall.id,
+                            toolName: request.toolCall.function.name,
+                            arguments: request.arguments,
+                            schemaDigest: request.schemaDigest,
+                            toolDigest: request.toolDigest,
+                            policyDigest: request.policyDigest,
+                            policyId: request.policyId,
+                            sessionKey: input.request.sessionKey,
+                            sessionPath: context.sessionPath,
+                            baseSessionRevision: context.baseSessionRevision,
+                            checkpointDigest: "0".repeat(64),
+                            requesterId: input.request.friendId,
+                            transport: "frontend",
+                            transportUserId: input.request.friendId,
+                            transportChatId: input.request.sessionKey,
+                            expiresAt: new Date(now() + approvalTimeoutMs).toISOString(),
+                            frozenAssistantMessage: request.frozenAssistantMessage,
+                        },
+                        preCallMessages: request.preCallMessages,
+                    });
+                    const decision = Promise.withResolvers();
+                    state.approvalStore.bindPrompt({
+                        approvalId: committed.record.approvalId,
+                        transport: "frontend",
+                        transportChatId: input.request.sessionKey,
+                        transportMessageId: committed.record.approvalId,
+                    });
+                    const item = {
+                        requestId: committed.record.approvalId,
+                        toolCallId: request.toolCall.id,
+                        title: `Approve ${request.toolCall.function.name}`,
+                        request: input.request,
+                        approvalRequest: request,
+                        expiresAt: Date.parse(committed.record.expiresAt),
+                        publish: input.publish,
+                        decision: decision.promise,
+                        resolve: decision.resolve,
+                        settled: false,
+                    };
+                    pending.set(committed.record.approvalId, item);
+                    input.publish("permission_requested", {
+                        requestId: committed.record.approvalId,
+                        toolCallId: request.toolCall.id,
+                        title: `Approve ${request.toolCall.function.name}`,
+                        options: PERMISSION_OPTIONS,
+                    }, "permission_requested");
+                    return {
+                        approvalId: committed.record.approvalId,
+                        checkpointDigest: committed.record.checkpointDigest,
+                        suspendedSessionRevision: committed.record.suspendedSessionRevision,
+                    };
+                },
+            });
+        },
+        async resumeApproval(input) {
+            const item = pending.get(input.suspension.approvalId);
+            if (!item || item.request.turnId !== input.request.turnId) {
+                throw new Error(`frontend approval ${input.suspension.approvalId} does not own turn ${input.request.turnId}`);
+            }
+            const abort = () => settlePending(item, "cancelled");
+            if (input.signal.aborted)
+                abort();
+            else
+                input.signal.addEventListener("abort", abort, { once: true });
+            const timeout = setTimeout(() => settlePending(item, "expired"), Math.max(0, item.expiresAt - now()));
+            try {
+                const optionId = await item.decision;
+                const state = stateFor(input.request.agent);
+                return await settleApproval({
+                    ...input,
+                    approvalRequest: item.approvalRequest,
+                    optionId,
+                    publish: item.publish,
+                    agentRoot: agentRoot(input.request.agent),
+                    ...state,
+                    approvalCoordinatorFactory: runtime.approvalCoordinatorFactory,
+                });
+            }
+            finally {
+                clearTimeout(timeout);
+                input.signal.removeEventListener("abort", abort);
+                pending.delete(input.suspension.approvalId);
+                closeStatesWhenIdle();
+            }
+        },
+        resolvePermission(requestId, optionId) {
+            if (closed || (optionId !== "allow-once" && optionId !== "reject-once" && optionId !== "cancelled"))
+                return false;
+            const item = pending.get(requestId);
+            return item ? settlePending(item, optionId) : false;
+        },
+        cancelTurn(turnId) {
+            for (const item of pending.values()) {
+                if (item.request.turnId === turnId)
+                    settlePending(item, "cancelled");
+            }
+        },
+        pendingPermissions(ref) {
+            return [...pending.values()].flatMap((item) => {
+                if (item.settled
+                    || item.request.agent !== ref.agent
+                    || item.request.friendId !== ref.friendId
+                    || item.request.sessionKey !== ref.sessionKey)
+                    return [];
+                return [{
+                        requestId: item.requestId,
+                        turnId: item.request.turnId,
+                        toolCallId: item.toolCallId,
+                        title: item.title,
+                        options: [...PERMISSION_OPTIONS],
+                    }];
+            });
+        },
+        close() {
+            if (closed)
+                return;
+            for (const item of pending.values())
+                settlePending(item, "cancelled");
+            closed = true;
+            closeStatesWhenIdle();
+        },
+    };
+    return runtime;
+}