maka-agent 0.2.0-dev.23.20260906 → 0.2.0-dev.24.20260907

package/node_modules/@maka/runtime/dist/agent-run.js

@@ -17,6 +17,9 @@
  * under the License.
  */
 import { RUN_COMPOSITION_RECORDED_EVENT_TYPE } from '@maka/core/agent-run';
+import { isRuntimeHandoffPause } from '@maka/core/runtime-handoff';
+import { RunHandoffGate } from './run-handoff-gate.js';
+import { preserveHandoffOpening } from './runtime-resume.js';
 import { decodeRunCompositionSnapshot } from '@maka/core/run-composition';
 import { DurableStoreWriteError, RunSealedError } from '@maka/core/runtime-event-store';
 import { buildInvocationOpenedEvent, buildSyntheticTerminalRuntimeEvent, isSessionInlineInvocation, } from '@maka/core/runtime-invocation';
@@ -26,16 +29,18 @@ import { ToolLedgerCorruptionError, ToolLedgerRejectionError, } from '@maka/core
 import { Buffer } from 'node:buffer';
 import { isDeepStrictEqual } from 'node:util';
 import { redactSecrets } from '@maka/core/redaction';
+import { truncateUtf8 } from '@maka/core/diagnostic-log';
+import { MODEL_FAILURE_MESSAGE_MAX_BYTES } from '@maka/core/model-failure';
 import { MODEL_CALL_ATTEMPT_EVENT_TYPE, } from '@maka/core/model-call-attempt';
 import { resolveEffectiveOrchestration, } from '@maka/core/orchestration';
-import { messageContentsEqual } from '@maka/core/events';
 import { buildPriorRuntimeContext as buildPriorRuntimeContextProjection, } from './prior-run-context.js';
 import { buildStatusPatch, normalizeStopSessionSource, statusFromEvent, turnStatusFromEvent, } from './session-projection-helpers.js';
+import { admittedPromptEventId } from './message-authority.js';
 import { commitOrCreateTerminalRunFact } from './terminal-run-commit.js';
 import { createRuntimeContinuationStartAdmissionProof, } from './runtime-continuation-admission.js';
 import { DEFAULT_TOOL_MODE, isToolMode } from '@maka/core/tool-mode';
-import { materializeRuntimeEventTranscriptProjection } from './runtime-ledger-repair.js';
 import { cloneAndFreezeRuntimeSnapshot } from './runtime-snapshot.js';
+import { projectRuntimeEventUserMessage } from './runtime-event-read-model.js';
 export class ContinuationStartCommitError extends Error {
     storeCause;
     name = 'ContinuationStartCommitError';
@@ -65,6 +70,7 @@ export class AgentRun {
     runStoreAvailable = true;
     runtimeEventStoreAvailable = true;
     runtimeEventStoreFailure;
+    lastAssistantPreview;
     runtimePartialStreamKey;
     runtimePartialBuffer = [];
     runtimePartialBufferBytes = 0;
@@ -72,6 +78,7 @@ export class AgentRun {
     traceWriteError;
     runComposition;
     runCompositionWrite;
+    runCompositionCommitted = false;
     failureClass;
     failureMessage;
     lastTs = 0;
@@ -79,11 +86,16 @@ export class AgentRun {
     finalStatus;
     turnFailed = false;
     finalized = false;
+    handoffGate = new RunHandoffGate();
+    handoffRequest;
+    handoffPaused = false;
     terminalRunFactCommitted = false;
     continuationActive = false;
     providerStateIdentity;
     invocationOpening;
     invocationOpeningCommitted = false;
+    /** Set once `begin()` owes this run's prompt, cleared once the ledger has it. */
+    initialRuntimeEventPending = false;
     terminalClaim;
     constructor(input) {
         const acceptedInput = {
@@ -92,6 +104,9 @@ export class AgentRun {
             ...(input.effectiveOrchestration
                 ? { effectiveOrchestration: cloneAndFreezeRuntimeSnapshot(input.effectiveOrchestration) }
                 : {}),
+            ...(input.handoffSourceComposition
+                ? { handoffSourceComposition: decodeRunCompositionSnapshot(input.handoffSourceComposition) }
+                : {}),
         };
         this.input = acceptedInput;
         if (acceptedInput.runStore && !acceptedInput.runtimeEventStore) {
@@ -140,12 +155,121 @@ export class AgentRun {
             return false;
         this.terminalClaim = { owner: 'stop' };
         this.stopped = true;
+        this.handoffGate.close();
         this.abortSource = abortSource;
         return true;
     }
     isStopped() {
         return this.stopped;
     }
+    requestHandoff(pause, signal) {
+        if (this.handoffRequest ||
+            this.finalized ||
+            this.terminalClaim ||
+            this.input.runtimeEventStore?.durability !== 'canonical' ||
+            !this.toolBoundaryProtocol ||
+            Object.hasOwn(pause, 'remainingSteps') ||
+            !isRuntimeHandoffPause({ ...pause, remainingSteps: null }) ||
+            !this.invocationOpening ||
+            pause.rootRunId !==
+                (this.invocationOpening.source.kind === 'handoff'
+                    ? this.invocationOpening.source.rootRunId
+                    : this.runId)) {
+            throw new Error('Run cannot reserve a cooperative handoff');
+        }
+        let settle;
+        let fail;
+        const sealed = new Promise((resolve, reject) => {
+            settle = resolve;
+            fail = reject;
+        });
+        void sealed.catch(() => { });
+        const pending = {
+            pause: cloneAndFreezeRuntimeSnapshot(pause),
+            preview: undefined,
+            committed: false,
+            settle: (value) => {
+                signal.removeEventListener('abort', onAbort);
+                settle(value);
+            },
+            fail: (error) => {
+                signal.removeEventListener('abort', onAbort);
+                fail(error);
+            },
+        };
+        this.handoffRequest = pending;
+        const gate = this.handoffGate.request(signal);
+        const cancel = () => {
+            if (pending.committed || this.handoffRequest !== pending)
+                return;
+            gate.cancel();
+            this.handoffRequest = undefined;
+            pending.settle(false);
+        };
+        const onAbort = () => cancel();
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            cancel();
+        void gate.ready.then((ready) => {
+            if (!ready)
+                cancel();
+        });
+        return {
+            ready: gate.ready,
+            sealed,
+            cancel,
+            preview: () => {
+                if (this.handoffRequest !== pending ||
+                    this.stopped ||
+                    pending.committed ||
+                    !pending.preview) {
+                    throw new Error('Handoff preview requires the currently held Runtime boundary');
+                }
+                this.assertRunCompositionCommitted();
+                return pending.preview;
+            },
+            commit: () => {
+                this.assertRunCompositionCommitted();
+                if (this.handoffRequest !== pending || !gate.commit())
+                    return false;
+                pending.committed = true;
+                return true;
+            },
+        };
+    }
+    async reachHandoffBoundary(signal, remainingSteps) {
+        if (remainingSteps !== null && (!Number.isSafeInteger(remainingSteps) || remainingSteps <= 0)) {
+            throw new Error('Invalid handoff step budget');
+        }
+        const pending = this.handoffRequest;
+        if (pending) {
+            pending.preview = cloneAndFreezeRuntimeSnapshot({
+                id: this.input.newId(),
+                sessionId: this.sessionId,
+                runId: this.runId,
+                invocationId: this.invocationId,
+                turnId: this.turnId,
+                ts: this.input.now(),
+                partial: false,
+                role: 'system',
+                author: 'host',
+                modelVisibility: 'hidden',
+                actions: { endInvocation: true, handoffPause: { ...pending.pause, remainingSteps } },
+            });
+        }
+        const decision = await this.handoffGate.reachBoundary(signal);
+        if (decision === 'pause') {
+            this.handoffPaused = true;
+        }
+        return decision;
+    }
+    hasCommittedHandoff() {
+        return (this.handoffPaused &&
+            this.handoffRequest?.committed === true &&
+            !this.stopped &&
+            !this.failureClass &&
+            !this.terminalClaim);
+    }
     headerSnapshot() {
         return this.header;
     }
@@ -251,6 +375,15 @@ export class AgentRun {
             return Promise.reject(new Error('AgentRun store is not configured'));
         }
         const normalized = decodeRunCompositionSnapshot(snapshot);
+        const expected = this.input.handoffSourceComposition;
+        if (expected &&
+            (normalized.baseSystemPromptHash !== expected.baseSystemPromptHash ||
+                normalized.toolCatalogHash !== expected.toolCatalogHash ||
+                normalized.toolAvailabilityHash !== expected.toolAvailabilityHash ||
+                normalized.baseProviderOptionsHash !== expected.baseProviderOptionsHash ||
+                normalized.contextWindow !== expected.contextWindow)) {
+            return Promise.reject(new Error('Handoff Run Composition execution semantics changed'));
+        }
         if (this.runComposition && !isDeepStrictEqual(this.runComposition, normalized)) {
             return Promise.reject(new Error('AgentRun Run Composition changed after resolution'));
         }
@@ -266,7 +399,12 @@ export class AgentRun {
                 turnId: this.turnId,
                 ts: this.input.now(),
                 data: { runComposition: normalized },
-            }, { durable: this.requiresDurablePersistence() });
+            }, {
+                durable: this.requiresDurablePersistence() ||
+                    this.input.runtimeEventStore?.durability === 'canonical',
+            });
+        }).then(() => {
+            this.runCompositionCommitted = true;
         });
         this.runCompositionWrite = write;
         return write.catch((error) => {
@@ -275,6 +413,11 @@ export class AgentRun {
             throw error;
         });
     }
+    assertRunCompositionCommitted() {
+        if (!this.runCompositionCommitted) {
+            throw new Error('Cooperative handoff requires a durably committed Run Composition');
+        }
+    }
     /**
      * Canonical accounting record for one physical provider request (#1679).
      *
@@ -406,8 +549,10 @@ export class AgentRun {
                 requireTerminalWrite: options.requireTerminalWrite ?? Boolean(this.input.runtimeEventStore),
             });
             await this.recordSessionEvent(sessionEvent, options);
+            await this.commitMessageProjection(this.lastAssistantPreview);
             return;
         }
+        this.rememberAssistantPreview(runtimeEvent);
         if (this.requiresDurablePersistence() && isInteractionResumeAck(sessionEvent)) {
             // A hosted continuation may resume execution only after its identity-only
             // settlement fact is durable. Session status advances next, and the queue
@@ -435,48 +580,54 @@ export class AgentRun {
             // stays fail-open (a trace gap, not a correctness gap).
             const steering = runtimeEvent.content?.kind === 'text' && runtimeEvent.content.steering === true;
             await this.recordRuntimeEvents([runtimeEvent], steering ? { requireDurableWrite: true } : {});
-            await materializeRuntimeEventTranscriptProjection(this.input.store, this.sessionId, runtimeEvent);
+            if (steering) {
+                await this.commitMessageProjection(projectRuntimeEventUserMessage(runtimeEvent, runtimeEvent.id));
+            }
         }
     }
+    /**
+     * A user message is fail-CLOSED: it also takes the Session's connection lock,
+     * and no other path re-derives that latch now that the transcript is not a
+     * second authority. An assistant preview is fail-open — losing it costs a
+     * stale sidebar entry, never the turn.
+     */
+    async commitMessageProjection(message) {
+        const commit = this.input.hooks.commitMessageProjection;
+        if (!commit || !message)
+            return;
+        const committed = commit.call(this.input.hooks, this.sessionId, message);
+        if (message.type === 'user')
+            return committed;
+        await committed.catch(() => { });
+    }
+    /**
+     * The assistant text the Session list shows once the Turn ends.
+     *
+     * Kept as the run goes so the catalog costs one write per Turn rather than
+     * one per streamed step, and read only after the terminal fact is durable —
+     * a Turn that never spoke leaves the previous preview standing.
+     */
+    rememberAssistantPreview(event) {
+        if (event.role !== 'model' || event.content?.kind !== 'text')
+            return;
+        if (!event.content.text?.trim())
+            return;
+        this.lastAssistantPreview = {
+            type: 'assistant',
+            id: event.id,
+            turnId: event.turnId,
+            ts: event.ts,
+            text: event.content.text,
+            modelId: this.header.model,
+        };
+    }
     async begin() {
+        // Owed from here, not from after the opening: `openInvocation` can leave the
+        // invocation open and still throw, and `finalize` reopens what it can.
+        this.initialRuntimeEventPending = true;
         await this.openInvocation();
-        let initialRuntimeEventId;
-        const userMessageTs = this.input.now();
-        if (this.input.userMessageId === null) {
-            initialRuntimeEventId = this.input.newId();
-        }
-        else {
-            const userMessageId = this.input.userMessageId ?? this.input.newId();
-            initialRuntimeEventId = userMessageId;
-            const userMsg = cloneAndFreezeRuntimeSnapshot({
-                type: 'user',
-                id: userMessageId,
-                turnId: this.turnId,
-                ts: userMessageTs,
-                text: this.input.userInput.text,
-                ...(this.input.userInput.displayText !== undefined
-                    ? { displayText: this.input.userInput.displayText }
-                    : {}),
-                ...(this.input.userInput.attachments
-                    ? { attachments: this.input.userInput.attachments }
-                    : {}),
-                ...(this.input.userInput.directoryReferences
-                    ? { directoryReferences: this.input.userInput.directoryReferences }
-                    : {}),
-                ...(this.input.userInput.quotes ? { quotes: this.input.userInput.quotes } : {}),
-                ...(this.input.userInput.inlineReferences
-                    ? { inlineReferences: this.input.userInput.inlineReferences }
-                    : {}),
-                ...(this.input.userInput.origin ? { origin: this.input.userInput.origin } : {}),
-            });
-            await appendUserMessageOnce(this.input.store, this.sessionId, userMsg);
-        }
-        await this.input.hooks.appendTurnState(this.sessionId, this.turnId, 'running', this.lineage);
-        this.lastTs = userMessageTs;
-        const initialRuntimeEvent = cloneAndFreezeRuntimeSnapshot(this.buildInitialRuntimeEvent(initialRuntimeEventId, this.lastTs));
-        await this.recordRuntimeEvents([initialRuntimeEvent], {
-            requireDurableWrite: this.requiresDurablePersistence(),
-        });
+        this.lastTs = this.input.now();
+        const initialRuntimeEvent = await this.recordInitialRuntimeEvent(this.lastTs);
         this.active = await this.input.hooks.reserveRun(this.sessionId, this.header, this);
         await this.input.hooks.updateStatus(this.sessionId, 'running', undefined, this.lastTs);
         const priorRuntimeContext = await this.buildPriorRuntimeContext();
@@ -507,13 +658,23 @@ export class AgentRun {
             initialRuntimeEvent,
         };
     }
+    /** Say what this run was asked to do. */
+    async recordInitialRuntimeEvent(ts) {
+        const event = cloneAndFreezeRuntimeSnapshot(this.buildInitialRuntimeEvent(admittedPromptEventId(this.runId, this.input.userMessageId), ts));
+        await this.recordRuntimeEvents([event], {
+            requireDurableWrite: this.requiresDurablePersistence(),
+        });
+        // Owed until the catalog carries it too, not just until the ledger does:
+        // the projection is where the connection lock latches, and re-recording the
+        // event is free because its id is derived and the store dedupes it.
+        await this.commitMessageProjection(projectRuntimeEventUserMessage(event, event.id));
+        this.initialRuntimeEventPending = false;
+        return event;
+    }
     async beginOperation() {
         await this.openInvocation();
         const startedAt = this.input.now();
         this.lastTs = startedAt;
-        await this.input.hooks.appendTurnState(this.sessionId, this.turnId, 'running', this.lineage, {
-            ts: startedAt,
-        });
         this.active = await this.input.hooks.reserveRun(this.sessionId, this.header, this);
         await this.input.hooks.updateStatus(this.sessionId, 'running', undefined, startedAt);
         const priorRuntimeContext = await this.buildPriorRuntimeContext();
@@ -545,9 +706,6 @@ export class AgentRun {
             throw new ContinuationStartCommitError(error);
         }
         await this.input.continuationFailpoint?.('after_continuation_start_committed');
-        await this.input.hooks.appendTurnState(this.sessionId, this.turnId, 'running', this.lineage, {
-            ts: startedAt,
-        });
         this.active = await this.input.hooks.reserveRun(this.sessionId, this.header, this);
         await this.input.hooks.updateStatus(this.sessionId, 'running', undefined, startedAt);
         return {
@@ -603,10 +761,29 @@ export class AgentRun {
                 : {}),
         };
     }
-    async recordStoredSessionEvent(ev) {
-        if (ev.type === 'token_usage') {
-            await this.input.store.appendMessage(this.sessionId, { ...ev });
-        }
+    /**
+     * Record something the runtime needs to tell the reader about this turn.
+     *
+     * It is a fact of the invocation, so it goes where the invocation's facts go.
+     * Never model-visible: the note describes what happened to the conversation,
+     * it is not part of it.
+     */
+    async recordSystemNote(kind, data) {
+        await this.recordRuntimeEvents([
+            {
+                id: this.input.newId(),
+                invocationId: this.invocationId,
+                runId: this.runId,
+                sessionId: this.sessionId,
+                turnId: this.turnId,
+                ts: this.input.now(),
+                partial: false,
+                role: 'system',
+                author: 'system',
+                modelVisibility: 'hidden',
+                content: { kind: 'system_note', note: kind, ...(data !== undefined ? { data } : {}) },
+            },
+        ]);
     }
     async recordSessionEvent(ev, options = {}) {
         this.lastTs = ev.ts;
@@ -631,9 +808,9 @@ export class AgentRun {
                 this.markRunFailed(turnStatus.errorClass, `turn ended with stopReason=${ev.type === 'complete' ? ev.stopReason : 'unknown'}`);
             }
         }
-        if (transition && !this.stopped) {
+        if (transition && !this.stopped && ev.type !== 'error') {
             const updateSessionStatus = async () => {
-                if (terminalSessionEvent || ev.type === 'error') {
+                if (terminalSessionEvent) {
                     await this.input.hooks
                         .updateStatus(this.sessionId, transition.status, transition.blockedReason, ev.ts)
                         .catch((error) => this.enqueueTraceWriteFailure(error, 'terminal session projection'));
@@ -643,21 +820,6 @@ export class AgentRun {
             };
             await updateSessionStatus();
         }
-        if (turnStatus && !this.stopped) {
-            const appendTurnState = this.input.hooks.appendTurnState(this.sessionId, this.turnId, turnStatus.status, this.lineage, {
-                ts: ev.ts,
-                errorClass: turnStatus.errorClass,
-                ...(turnStatus.status === 'aborted' && this.abortSource
-                    ? { abortSource: this.abortSource }
-                    : {}),
-            });
-            if (terminalSessionEvent || ev.type === 'error') {
-                await appendTurnState.catch((error) => this.enqueueTraceWriteFailure(error, 'terminal session projection'));
-            }
-            else {
-                await appendTurnState;
-            }
-        }
         if (ev.type === 'error') {
             if (this.stopped) {
                 this.finalStatus = { status: 'aborted' };
@@ -665,12 +827,6 @@ export class AgentRun {
             else {
                 this.turnFailed = true;
                 this.finalStatus = transition ?? { status: 'blocked', blockedReason: 'unknown' };
-                await this.input.hooks
-                    .appendTurnState(this.sessionId, this.turnId, 'failed', this.lineage, {
-                    ts: ev.ts,
-                    errorClass: ev.reason ?? ev.code ?? 'unknown',
-                })
-                    .catch((error) => this.enqueueTraceWriteFailure(error, 'terminal session projection'));
                 this.markRunFailed(ev.reason ?? ev.code ?? 'unknown', ev.message);
             }
         }
@@ -766,17 +922,40 @@ export class AgentRun {
             return;
         }
         this.finalStatus = { status: 'blocked', blockedReason: 'unknown' };
-        await this.input.hooks
-            .appendTurnState(this.sessionId, this.turnId, 'failed', this.lineage, {
-            errorClass: error instanceof Error ? error.name : 'unknown',
-        })
-            .catch(() => { });
-        this.markRunFailed(error instanceof Error ? error.name : 'unknown', errorMessage(error));
+        this.markRunFailed(error instanceof Error ? error.name : 'unknown', error instanceof Error ? error.message : String(error));
     }
     async finalize() {
         if (this.finalized)
             return;
         this.finalized = true;
+        this.handoffGate.close();
+        const handoff = this.handoffRequest;
+        if (this.handoffPaused &&
+            handoff?.committed &&
+            !this.stopped &&
+            !this.failureClass &&
+            !this.terminalClaim) {
+            try {
+                await this.flushRuntimePartialBuffer(true);
+                // Stop may have claimed the logical outcome during the flush. Reserving
+                // the pause below is synchronous up to its first write, so only one wins.
+                if (!this.stopped && !this.failureClass && !this.terminalClaim) {
+                    this.assertRunCompositionCommitted();
+                    await this.recordRuntimeEvents([handoff.preview], { requireTerminalWrite: true });
+                    this.terminalRunFactCommitted = true;
+                    if (this.active)
+                        await this.input.hooks.unregisterRun(this.active, this);
+                    await this.traceQueue;
+                    handoff.settle(true);
+                    return;
+                }
+            }
+            catch (error) {
+                handoff.fail(error);
+                throw error;
+            }
+        }
+        handoff?.settle(false);
         // A run cannot end without having begun. Finalizing one that never reached
         // its start would otherwise leave a terminal event on an invocation the
         // inventory cannot see, because nothing opened it. A continuation is the
@@ -784,6 +963,13 @@ export class AgentRun {
         // and a continuation that never committed one has no invocation to end.
         if (!this.input.commitContinuationStart)
             await this.openInvocation().catch(() => { });
+        // A run also cannot end without saying what it was asked to do. `begin()`
+        // can fail between opening the invocation and recording its prompt, and
+        // the terminal event below seals the run against every later append —
+        // including the one crash recovery would use to repair the same shape.
+        if (this.initialRuntimeEventPending) {
+            await this.recordInitialRuntimeEvent(this.lastTs || this.input.now()).catch(() => { });
+        }
         await this.flushRuntimePartialBuffer(true);
         const lastTs = this.lastTs || this.input.now();
         if (this.stopped)
@@ -809,17 +995,6 @@ export class AgentRun {
         catch {
             // The user-visible turn already completed; preserve existing behavior.
         }
-        if (this.sawCompletion) {
-            await this.input.store
-                .appendMessage(this.sessionId, {
-                type: 'system_note',
-                id: this.input.newId(),
-                turnId: this.turnId,
-                ts: lastTs,
-                kind: 'session_resume',
-            })
-                .catch(() => { });
-        }
         await this.finishRun(this.finalStatus, lastTs);
     }
     async openInvocation(continuation) {
@@ -864,7 +1039,7 @@ export class AgentRun {
             ...(this.input.userInput.agentName ? { agentName: this.input.userInput.agentName } : {}),
             ...(continuation ? { parentRunId: continuation.sourceRunId } : {}),
         };
-        return {
+        const opening = {
             kind: 'invocation_opened',
             protocol: 'invocation_opened_v1',
             route: this.header.llmConnectionId === undefined
@@ -912,6 +1087,9 @@ export class AgentRun {
                 : { kind: 'fresh' },
             ...(Object.keys(lineage).length > 0 ? { lineage } : {}),
         };
+        return continuation
+            ? preserveHandoffOpening(continuation, opening, this.input.handoffSourceOpening)
+            : opening;
     }
     invocationRootAuthority() {
         const origin = this.input.userInput.origin;
@@ -976,12 +1154,13 @@ export class AgentRun {
     /**
      * Remember why this run is going to fail.
      *
+     * Preserve diagnostic text without trace redaction, within the byte budget.
      * Nothing is written here: the terminal RuntimeEvent carries the failure, and
      * it is committed once, at the end, by `commitTerminalRun`.
      */
     markRunFailed(failureClass, message) {
         this.failureClass = failureClass;
-        this.failureMessage = redactTraceString(message);
+        this.failureMessage = truncateUtf8(message, MODEL_FAILURE_MESSAGE_MAX_BYTES, '…');
     }
     /**
      * End the run by committing its terminal RuntimeEvent, and nothing else.
@@ -1394,18 +1573,6 @@ function redactTraceString(value) {
 function errorMessage(error) {
     return redactTraceString(error instanceof Error ? error.message : String(error));
 }
-async function appendUserMessageOnce(store, sessionId, message) {
-    const existing = (await store.readMessages(sessionId)).find((candidate) => candidate.id === message.id);
-    if (!existing) {
-        await store.appendMessage(sessionId, message);
-        return;
-    }
-    if (existing.type !== 'user' ||
-        existing.turnId !== message.turnId ||
-        !messageContentsEqual(existing, message)) {
-        throw new Error(`Durable UserMessage identity ${message.id} has conflicting content`);
-    }
-}
 function isInteractionResumeAck(event) {
     return (event.type === 'sandbox_boundary_decision_ack' ||
         event.type === 'user_question_answer_ack' ||

package/node_modules/@maka/runtime/dist/ai-sdk-backend.js

@@ -29,7 +29,7 @@ import { AiSdkTurn } from './ai-sdk-turn.js';
 import { buildInvalidMakaTool } from './ai-sdk-tool-repair.js';
 import { ToolAvailabilityRuntime } from './tool-availability.js';
 import { MEMORY_EXTRACT_TOOL_NAME, MEMORY_REMEMBER_TOOL_NAME, buildMemoryExtractionTriggerTools, } from './memory-extraction.js';
-import { modelUsesNativeOpenAiResponses, resolveModelRuntime } from './model-runtime.js';
+import { resolveModelRuntime } from './model-runtime.js';
 import { routeApplyPatchTools } from './apply-patch-profile.js';
 import { bindToolResultArchiveDecoder } from './tool-result-archive-capability.js';
 import { resolveSelectedModelContextWindow } from './context-budget-policy.js';
@@ -111,15 +111,17 @@ export class AiSdkBackend {
         // One resolved options value for every reader: the main call, the
         // auxiliary memory-extraction call, and the provider request all use the
         // same options value, so they cannot disagree on what was sent.
+        const runtime = resolveModelRuntime(input.connection, input.modelId);
         this.resolvedProviderOptions =
             input.providerOptions ??
-                buildProviderOptions(input.connection, input.modelId, input.header.thinkingLevel);
+                buildProviderOptions(input.connection, input.modelId, input.header.thinkingLevel, runtime);
         this.modelAdapter = new ModelAdapter({
             sessionId: input.sessionId,
             connection: input.connection,
             apiKey: input.apiKey,
             modelId: input.modelId,
             modelFactory: input.modelFactory,
+            resolvedRuntime: runtime,
             // `input.providerOptions` is an override escape hatch: when set it owns
             // the whole provider-options namespace (including reasoning effort), and
             // the computed defaults are dropped entirely. Keep providerOptions the
@@ -144,7 +146,6 @@ export class AiSdkBackend {
             assertModelCallAccountingReady: input.assertModelCallAccountingReady,
             beforeRunProviderDispatch: input.beforeRunProviderDispatch,
         });
-        const runtime = resolveModelRuntime(input.connection, input.modelId);
         const applyPatchProfile = runtime.applyPatchProfile;
         this.messageProjection = new AiSdkMessageProjection({
             modelAdapter: this.modelAdapter,
@@ -176,7 +177,7 @@ export class AiSdkBackend {
                     if (turn)
                         turn.memoryExtractRequested = true;
                 },
-                ...(modelUsesNativeOpenAiResponses(input.connection, input.modelId)
+                ...(input.connection.providerType === 'openai' && runtime.wire === 'openai-responses'
                     ? { unsupportedReason: 'provider_unsupported' }
                     : {}),
             })
@@ -206,11 +207,11 @@ export class AiSdkBackend {
     createToolRuntime(identity) {
         const input = this.input;
         return new ToolRuntime({
+            inheritedSandboxBoundaryDenied: identity.inheritedSandboxBoundaryDenied,
             sessionId: input.sessionId,
             header: input.header,
             connection: input.connection,
             modelId: input.modelId,
-            appendMessage: input.appendMessage,
             readExecutionBoundary: input.readExecutionBoundary,
             createSandboxBoundaryRequest: input.createSandboxBoundaryRequest,
             settleSandboxBoundaryRequest: input.settleSandboxBoundaryRequest,
@@ -241,6 +242,12 @@ export class AiSdkBackend {
     // --------------------------------------------------------------------------
     // send()
     // --------------------------------------------------------------------------
+    async prepareRunComposition(input) {
+        if (!this.input.beforeRunProviderDispatch) {
+            throw new Error('Backend has no durable Run Composition preparation authority');
+        }
+        await this.input.beforeRunProviderDispatch({ sessionId: this.sessionId, ...input });
+    }
     openTurnScope(input) {
         const turn = new AiSdkTurn({
             backend: this.input,
@@ -257,6 +264,7 @@ export class AiSdkBackend {
             maxSteps: this.maxSteps,
             providerRetrySleep: this.providerRetrySleep,
             createToolRuntime: (owner) => this.createToolRuntime({
+                inheritedSandboxBoundaryDenied: input.continuation?.sandboxBoundaryDenied === true,
                 turnId: owner.turnId,
                 runId: owner.runId,
                 invocationId: input.invocationId ?? input.runId,