@ouro.bot/cli 0.1.0-alpha.729 → 0.1.0-alpha.730

package/dist/heart/core.js

@@ -7,6 +7,7 @@ exports.getProvider = getProvider;
 exports.createSummarize = createSummarize;
 exports.getProviderDisplayLabel = getProviderDisplayLabel;
 exports.createHabitCallbackBuffer = createHabitCallbackBuffer;
+exports.resumeApprovalContinuation = resumeApprovalContinuation;
 exports.isChatStyleChannel = isChatStyleChannel;
 exports.buildPonderResult = buildPonderResult;
 exports.isExternalStateQuery = isExternalStateQuery;
@@ -17,6 +18,8 @@ exports.runAgent = runAgent;
 const config_1 = require("./config");
 const identity_1 = require("./identity");
 const tools_1 = require("../repertoire/tools");
+const tool_arguments_1 = require("../repertoire/tool-arguments");
+const session_events_1 = require("./session-events");
 const friends_1 = require("@ouro.bot/friends");
 const tools_2 = require("../repertoire/tools");
 const streaming_1 = require("./streaming");
@@ -244,6 +247,84 @@ function createHabitCallbackBuffer(callbacks) {
 function createFinalOnlyTextBuffer(callbacks) {
     return createCallbackBuffer(callbacks, "text-only");
 }
+function continuationCallbacks(callbacks, text) {
+    const noop = () => undefined;
+    return {
+        onModelStart: callbacks.onModelStart ?? noop,
+        onModelStreamStart: callbacks.onModelStreamStart ?? noop,
+        onTextChunk: (chunk) => {
+            text.value += chunk;
+            callbacks.onTextChunk?.(chunk);
+        },
+        onReasoningChunk: callbacks.onReasoningChunk ?? noop,
+        onToolStart: callbacks.onToolStart ?? noop,
+        onToolEnd: callbacks.onToolEnd ?? noop,
+        onError: callbacks.onError ?? noop,
+        ...(callbacks.onClearText ? { onClearText: callbacks.onClearText } : {}),
+        ...(callbacks.flushNow ? { flushNow: callbacks.flushNow } : {}),
+        ...(callbacks.settleOutputMode ? { settleOutputMode: callbacks.settleOutputMode } : {}),
+    };
+}
+async function resumeApprovalContinuation(options) {
+    const claim = options.claimContinuation();
+    if (!claim.claimed) {
+        if (claim.interruptedAfterAttempt) {
+            const notice = "the approval continuation was interrupted after provider work began; its outcome is indeterminate and it will not be retried automatically";
+            await options.deliver(notice);
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "engine",
+                event: "engine.approval_continuation_indeterminate",
+                message: "approval continuation interrupted after provider attempt",
+                meta: { approvalId: options.record.approvalId, continuationState: claim.record.continuationState },
+            });
+            return { outcome: "terminal_notice", messages: structuredClone(options.sessionMessages) };
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.approval_continuation_duplicate",
+            message: "approval continuation was already consumed",
+            meta: { approvalId: options.record.approvalId },
+        });
+        return { outcome: "already_continued", messages: structuredClone(options.sessionMessages) };
+    }
+    const materialized = (0, session_events_1.materializeApprovalTerminal)({
+        messages: options.sessionMessages,
+        checkpoint: options.checkpoint,
+        record: options.record,
+        currentSessionRevision: options.currentSessionRevision,
+        materializedApprovalIds: options.materializedApprovalIds,
+    });
+    const recoveredMaterialization = claim.record.continuationState === "materialized";
+    if (!recoveredMaterialization) {
+        await options.persist(materialized.messages);
+        await options.markContinuationMaterialized();
+    }
+    if (!materialized.resumeProvider) {
+        await options.deliver(materialized.directNotice);
+        await options.completeContinuation();
+        return { outcome: "terminal_notice", messages: materialized.messages };
+    }
+    const outward = { value: "" };
+    const callbacks = continuationCallbacks(options.callbacks, outward);
+    await options.markContinuationAttempted();
+    const result = await options.runAgent(materialized.messages, callbacks, options.channel, options.signal, options.runAgentOptions);
+    if (result.outcome === "suspended") {
+        await options.completeContinuation();
+        return { outcome: result.outcome, messages: materialized.messages, suspension: result.suspension };
+    }
+    await options.persist(materialized.messages, result);
+    if (outward.value)
+        await options.deliver(outward.value);
+    await options.completeContinuation();
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.approval_continuation_completed",
+        message: "approval continuation completed through existing provider loop",
+        meta: { approvalId: options.record.approvalId, outcome: result.outcome },
+    });
+    return { outcome: result.outcome, messages: materialized.messages };
+}
 /**
  * Strip <think>...</think> blocks for the violation-detection check at the
  * end of a streaming turn. Used to tell legitimate text-only responses
@@ -932,6 +1013,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let overflowRetried = false;
     let outcome = "settled";
     let completion;
+    let suspension;
     let terminalError;
     let terminalErrorClassification;
     let sawSteeringFollowUp = false;
@@ -1623,6 +1705,100 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     done = true;
                     continue;
                 }
+                const preCallMessages = structuredClone(messages.filter((message) => message.role !== "system"));
+                const validatedCalls = options?.approvalCoordinator
+                    ? result.toolCalls.map((call) => {
+                        const advertised = activeTools.find((tool) => tool.function.name === call.name);
+                        if (!advertised || !advertised.function.parameters || typeof advertised.function.parameters !== "object") {
+                            return { call, error: "tool was not advertised with a valid argument schema" };
+                        }
+                        const validated = (0, tool_arguments_1.validateAdvertisedToolArguments)(call.arguments, advertised.function.parameters);
+                        return validated.ok
+                            ? { call, advertised, validated: validated.value }
+                            : { call, error: validated.reason };
+                    })
+                    : null;
+                const invalidApprovalCall = validatedCalls?.find((entry) => "error" in entry);
+                if (invalidApprovalCall) {
+                    await streamCallbackBuffer?.flush();
+                    pushGenerated(msg);
+                    for (const entry of validatedCalls) {
+                        const detail = "error" in entry ? entry.error : "another call in this batch had invalid arguments";
+                        const rejection = `invalid tool arguments: ${detail}`;
+                        pushGenerated({ role: "tool", tool_call_id: entry.call.id, content: rejection });
+                        providerRuntime.appendToolOutput(entry.call.id, rejection);
+                    }
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "engine",
+                        event: "engine.tool_arguments_rejected",
+                        message: "tool batch rejected before execution because arguments were invalid",
+                        meta: { toolCallId: invalidApprovalCall.call.id, toolName: invalidApprovalCall.call.name },
+                    });
+                    continue;
+                }
+                const approvalCalls = validatedCalls?.map((entry) => ({
+                    ...entry,
+                    policy: (0, tools_1.approvalPolicyForToolName)(entry.call.name, entry.validated.arguments),
+                })) ?? [];
+                const protectedCall = approvalCalls.find((entry) => entry.policy.kind === "required");
+                if (protectedCall && result.toolCalls.length !== 1) {
+                    streamCallbackBuffer?.discard();
+                    pushGenerated(msg);
+                    for (const call of result.toolCalls) {
+                        const rejection = "rejected: approval-eligible tool must be the sole call; no call in this batch was executed.";
+                        pushGenerated({ role: "tool", tool_call_id: call.id, content: rejection });
+                        providerRuntime.appendToolOutput(call.id, rejection);
+                    }
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "engine",
+                        event: "engine.approval_mixed_batch_rejected",
+                        message: "protected tool batch rejected before every handler",
+                        meta: { toolCallCount: result.toolCalls.length, protectedToolName: protectedCall.call.name },
+                    });
+                    continue;
+                }
+                if (protectedCall && protectedCall.policy.kind === "required") {
+                    streamCallbackBuffer?.discard();
+                    pushGenerated(msg);
+                    const toolDigest = (0, tool_arguments_1.digestJson)({
+                        name: protectedCall.call.name,
+                        schemaDigest: protectedCall.validated.schemaDigest,
+                        policyId: protectedCall.policy.policyId,
+                    });
+                    const policyDigest = (0, tool_arguments_1.digestJson)({
+                        policyId: protectedCall.policy.policyId,
+                        actionClass: protectedCall.policy.actionClass,
+                        classification: "required",
+                    });
+                    const committed = await options.approvalCoordinator.propose({
+                        toolCall: structuredClone(msg.tool_calls[0]),
+                        arguments: structuredClone(protectedCall.validated.arguments),
+                        preCallMessages,
+                        frozenAssistantMessage: structuredClone(msg),
+                        schemaDigest: protectedCall.validated.schemaDigest,
+                        toolDigest,
+                        policyDigest,
+                        policyId: protectedCall.policy.policyId,
+                        actionClass: protectedCall.policy.actionClass,
+                    });
+                    suspension = {
+                        approvalId: committed.approvalId,
+                        toolCallId: protectedCall.call.id,
+                        checkpointDigest: committed.checkpointDigest,
+                        suspendedSessionRevision: committed.suspendedSessionRevision,
+                    };
+                    outcome = "suspended";
+                    done = true;
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "engine",
+                        event: "engine.approval_turn_suspended",
+                        message: "agent turn suspended before protected tool execution",
+                        meta: { approvalId: committed.approvalId, toolCallId: protectedCall.call.id },
+                    });
+                    continue;
+                }
                 const containsSoleCallOnlyViolation = result.toolCalls.length > 1
                     && result.toolCalls.some((call) => {
                         const terminalProjection = (0, tools_1.resolveToolDefinition)(call.name)?.terminalProjection;
@@ -1975,6 +2151,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         usage: lastUsage,
         outcome,
         completion,
+        ...(suspension ? { suspension } : {}),
         ...(terminalError ? { error: terminalError, errorClassification: terminalErrorClassification } : {}),
     };
 }

package/dist/heart/session-events.js

@@ -34,6 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVENT_CONTENT_MAX_CHARS = void 0;
+exports.materializeApprovalTerminal = materializeApprovalTerminal;
+exports.attachApprovalSuspensionCheckpoint = attachApprovalSuspensionCheckpoint;
+exports.listApprovalSuspensionCheckpoints = listApprovalSuspensionCheckpoints;
+exports.removeApprovalSuspensionCheckpoint = removeApprovalSuspensionCheckpoint;
 exports.truncateLargeEventContent = truncateLargeEventContent;
 exports.capStructuredRecordString = capStructuredRecordString;
 exports.capStructuredRecordStringArray = capStructuredRecordStringArray;
@@ -59,8 +63,169 @@ exports.loadSessionEnvelopeFile = loadSessionEnvelopeFile;
 exports.buildCanonicalSessionEnvelope = buildCanonicalSessionEnvelope;
 exports.appendSyntheticAssistantEvent = appendSyntheticAssistantEvent;
 const fs = __importStar(require("fs"));
+const node_crypto_1 = require("node:crypto");
 const runtime_1 = require("../nerves/runtime");
 const structured_output_1 = require("./structured-output");
+const APPROVAL_TERMINAL_TEXT = {
+    denied: "approval denied by requester; the protected action was not executed",
+    expired: "approval expired before execution; the protected action was not executed",
+    drifted: "approval became invalid before execution; the protected action was not executed",
+    abandoned_before_attempt: "approval was abandoned before execution; the protected action was not executed; request a fresh approval",
+    attempted_indeterminate: "execution may have occurred; do not retry automatically",
+};
+function messagesRevision(messages) {
+    return (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(messages), "utf8").digest("hex");
+}
+function hasExactMaterializedApprovalPair(messages, checkpoint, toolCallId, content) {
+    if (messages.length < 2)
+        return false;
+    const assistant = messages.at(-2);
+    const tool = messages.at(-1);
+    const expectedTool = {
+        role: "tool",
+        tool_call_id: toolCallId,
+        content,
+    };
+    return assistant.role === "assistant"
+        && tool.role === "tool"
+        && messageFingerprint(assistant) === messageFingerprint(checkpoint.frozenAssistantMessage)
+        && messageFingerprint(tool) === messageFingerprint(expectedTool);
+}
+function materializeApprovalTerminal(input) {
+    const messages = structuredClone(input.messages);
+    if (input.record.state === "session_head_changed") {
+        return {
+            messages,
+            materialized: false,
+            resumeProvider: false,
+            directNotice: "the session changed before this approval could be applied; the protected action was not executed",
+            revision: messagesRevision(messages),
+        };
+    }
+    const content = input.record.state === "succeeded" || input.record.state === "failed"
+        ? input.record.result
+        : APPROVAL_TERMINAL_TEXT[input.record.state];
+    if (!content)
+        throw new Error(`approval state ${input.record.state} cannot be materialized`);
+    const resumeProvider = input.record.state === "succeeded" || input.record.state === "failed" || input.record.state === "denied";
+    const exactPair = hasExactMaterializedApprovalPair(messages, input.checkpoint, input.record.toolCallId, content);
+    if (exactPair) {
+        return {
+            messages,
+            materialized: false,
+            resumeProvider,
+            ...(resumeProvider ? {} : { directNotice: content }),
+            ...(input.record.state === "attempted_indeterminate" ? { severity: "high" } : {}),
+            revision: messagesRevision(messages),
+        };
+    }
+    const advanced = input.currentSessionRevision !== input.checkpoint.suspendedSessionRevision;
+    if (advanced) {
+        return {
+            messages,
+            materialized: false,
+            resumeProvider: false,
+            directNotice: "the session changed before this approval could be applied; the protected action was not executed",
+            revision: messagesRevision(messages),
+        };
+    }
+    if (input.materializedApprovalIds?.includes(input.record.approvalId)) {
+        return {
+            messages,
+            materialized: false,
+            resumeProvider,
+            ...(resumeProvider ? {} : { directNotice: content }),
+            ...(input.record.state === "attempted_indeterminate" ? { severity: "high" } : {}),
+            revision: messagesRevision(messages),
+        };
+    }
+    const frozen = structuredClone(input.checkpoint.frozenAssistantMessage);
+    messages.push(frozen, { role: "tool", tool_call_id: input.record.toolCallId, content });
+    const directNotice = resumeProvider ? undefined : content;
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.approval_terminal_materialized",
+        message: "materialized approval terminal transcript pair",
+        meta: { approvalId: input.record.approvalId, state: input.record.state, resumeProvider },
+    });
+    return {
+        messages,
+        materialized: true,
+        resumeProvider,
+        ...(directNotice ? { directNotice } : {}),
+        ...(input.record.state === "attempted_indeterminate" ? { severity: "high" } : {}),
+        revision: messagesRevision(messages),
+    };
+}
+const APPROVAL_HASH = /^[a-f0-9]{64}$/;
+function normalizeApprovalSuspensions(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return [];
+        const record = item;
+        if (typeof record.approvalId !== "string"
+            || typeof record.checkpointDigest !== "string"
+            || !APPROVAL_HASH.test(record.checkpointDigest)
+            || typeof record.baseSessionRevision !== "string"
+            || !APPROVAL_HASH.test(record.baseSessionRevision)
+            || typeof record.suspendedSessionRevision !== "string"
+            || !APPROVAL_HASH.test(record.suspendedSessionRevision)
+            || typeof record.argumentDigest !== "string"
+            || !APPROVAL_HASH.test(record.argumentDigest)
+            || typeof record.schemaDigest !== "string"
+            || !APPROVAL_HASH.test(record.schemaDigest)
+            || typeof record.toolDigest !== "string"
+            || !APPROVAL_HASH.test(record.toolDigest)
+            || typeof record.policyDigest !== "string"
+            || !APPROVAL_HASH.test(record.policyDigest)
+            || typeof record.preCallDigest !== "string"
+            || !APPROVAL_HASH.test(record.preCallDigest)
+            || !Array.isArray(record.preCallMessages)
+            || !record.frozenAssistantMessage
+            || typeof record.frozenAssistantMessage !== "object"
+            || Array.isArray(record.frozenAssistantMessage))
+            return [];
+        return [{
+                approvalId: record.approvalId,
+                checkpointDigest: record.checkpointDigest,
+                baseSessionRevision: record.baseSessionRevision,
+                suspendedSessionRevision: record.suspendedSessionRevision,
+                argumentDigest: record.argumentDigest,
+                schemaDigest: record.schemaDigest,
+                toolDigest: record.toolDigest,
+                policyDigest: record.policyDigest,
+                preCallDigest: record.preCallDigest,
+                preCallMessages: structuredClone(record.preCallMessages),
+                frozenAssistantMessage: structuredClone(record.frozenAssistantMessage),
+            }];
+    });
+}
+function attachApprovalSuspensionCheckpoint(envelope, checkpoint) {
+    const existing = envelope.approvalSuspensions ?? [];
+    const retained = existing.filter((item) => item.approvalId !== checkpoint.approvalId);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.approval_checkpoint_attached",
+        message: "approval suspension checkpoint attached outside provider projection",
+        meta: { approvalId: checkpoint.approvalId },
+    });
+    return { ...envelope, approvalSuspensions: [...retained, structuredClone(checkpoint)] };
+}
+function listApprovalSuspensionCheckpoints(envelope) {
+    return structuredClone(envelope.approvalSuspensions ?? []);
+}
+function removeApprovalSuspensionCheckpoint(envelope, approvalId) {
+    const approvalSuspensions = (envelope.approvalSuspensions ?? []).filter((item) => item.approvalId !== approvalId);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.approval_checkpoint_removed",
+        message: "approval suspension checkpoint removed",
+        meta: { approvalId },
+    });
+    return { ...envelope, approvalSuspensions };
+}
 exports.EVENT_CONTENT_MAX_CHARS = 256 * 1024;
 function truncateLargeEventContent(content, maxChars) {
     if (typeof content !== "string") {
@@ -972,6 +1137,7 @@ function parseSessionEnvelope(raw, options = {}) {
             : (0, structured_output_1.normalizeStructuredOutputs)(record.structuredOutputs),
         lastUsage: normalizeUsage(record.lastUsage),
         state: normalizeContinuityState(record.state),
+        approvalSuspensions: normalizeApprovalSuspensions(record.approvalSuspensions),
     };
 }
 function loadSessionEnvelopeFile(filePath) {
@@ -1109,6 +1275,7 @@ function buildCanonicalSessionEnvelope(options) {
             structuredOutputs: (0, structured_output_1.extractStructuredOutputsFromEvents)(prunedEvents),
             lastUsage: normalizeUsage(options.lastUsage),
             state: normalizeContinuityState(options.state),
+            approvalSuspensions: structuredClone(options.existing?.approvalSuspensions ?? []),
         },
         evictedEvents,
     };