maka-agent 0.2.0-dev.31.20260913 → 0.2.0-dev.32.20260914

package/node_modules/@maka/runtime/dist/provider-request-telemetry.js

@@ -18,7 +18,7 @@
  */
 import { MODEL_CALL_ATTEMPT_SCHEMA_VERSION, } from '@maka/core/model-call-attempt';
 import { preparedPromptComposition } from './request-shape.js';
-import { rawFinishReasonString } from './model-protocol.js';
+import { rawFinishReasonString, } from './model-protocol.js';
 import { providerFailureDiagnostic } from './provider-error-classification.js';
 import { latestContextProjectionInput } from './latest-context-snapshot.js';
 import { computeCost } from './telemetry/cost.js';
@@ -147,6 +147,7 @@ export function withProviderStreamTracking(input) {
                 providerId: model.provider,
                 modelId: model.modelId,
                 params,
+                ...(input.onAttempt ? { onAttempt: input.onAttempt } : {}),
                 ...(input.abortSignal ? { abortSignal: input.abortSignal } : {}),
                 ...(input.historyCompactRoute ? { historyCompactRoute: input.historyCompactRoute } : {}),
                 ...(input.historyCompactBoundary
@@ -222,12 +223,30 @@ export class ProviderRequestTracker {
         throwIfAbortedBeforeDispatch(input.abortSignal);
         let sawOutput = false;
         const attempt = this.beginAttempt(step, composition, input);
+        let evidence = {};
+        input.onAttempt?.(async (outcome) => {
+            await attempt.finalize(outcome.kind === 'completed'
+                ? 'completed'
+                : outcome.failure.kind === 'abort'
+                    ? 'aborted'
+                    : 'failed', {
+                ...evidence,
+                ...(outcome.kind === 'completed'
+                    ? { reason: outcome.finishReason }
+                    : { failure: outcome.failure }),
+            });
+        });
+        const finalize = async (status, finish) => {
+            evidence = { ...evidence, ...finish };
+            if (!input.onAttempt)
+                await attempt.finalize(status, finish);
+        };
         let result;
         try {
             result = await input.doStream();
         }
         catch (error) {
-            await attempt.finalize(abortStatus(input.abortSignal, error), { error });
+            await finalize(abortStatus(input.abortSignal, error), { error });
             throw error;
         }
         const reader = result.stream.getReader();
@@ -236,7 +255,7 @@ export class ProviderRequestTracker {
                 try {
                     const next = await reader.read();
                     if (next.done) {
-                        await attempt.finalize(input.abortSignal?.aborted ? 'aborted' : 'interrupted');
+                        await finalize(input.abortSignal?.aborted ? 'aborted' : 'interrupted');
                         controller.close();
                         return;
                     }
@@ -246,18 +265,18 @@ export class ProviderRequestTracker {
                         attempt.observeOutput();
                     }
                     if (part?.type === 'finish') {
-                        await attempt.finalize(input.abortSignal?.aborted ? 'aborted' : 'completed', {
+                        await finalize(input.abortSignal?.aborted ? 'aborted' : 'completed', {
                             reason: rawFinishReasonString(part.finishReason),
                             usage: asUsage(part.usage),
                         });
                     }
                     else if (part?.type === 'error') {
-                        await attempt.finalize(input.abortSignal?.aborted ? 'aborted' : sawOutput ? 'interrupted' : 'failed', { error: part.error });
+                        await finalize(input.abortSignal?.aborted ? 'aborted' : sawOutput ? 'interrupted' : 'failed', { error: part.error });
                     }
                     controller.enqueue(next.value);
                 }
                 catch (error) {
-                    await attempt.finalize(input.abortSignal?.aborted
+                    await finalize(input.abortSignal?.aborted
                         ? 'aborted'
                         : sawOutput
                             ? 'interrupted'
@@ -270,7 +289,7 @@ export class ProviderRequestTracker {
                     await reader.cancel(reason);
                 }
                 finally {
-                    await attempt.finalize(input.abortSignal?.aborted ? 'aborted' : 'interrupted');
+                    await finalize(input.abortSignal?.aborted ? 'aborted' : 'interrupted');
                 }
             },
         });
@@ -335,7 +354,15 @@ export class ProviderRequestTracker {
             const completedAt = this.input.now();
             const usage = strictProviderRequestUsage(finish?.usage);
             const contextWindow = positiveInteger(this.input.contextWindow);
-            const failure = finish?.error !== undefined ? providerFailureDiagnostic(finish.error) : undefined;
+            const diagnostic = finish?.error !== undefined ? providerFailureDiagnostic(finish.error) : undefined;
+            const failure = finish?.failure
+                ? {
+                    ...diagnostic,
+                    errorClass: finish.failure.kind,
+                    retryable: finish.failure.retryable,
+                    ...(finish.failure.code ? { providerCode: finish.failure.code } : {}),
+                }
+                : diagnostic;
             const finishReason = finish?.reason;
             const firstTokenMs = timeToFirstTokenMs;
             accountingSettlement = accountingSettlement.then(async () => {

package/node_modules/@maka/runtime/dist/runtime-event-backfill.js

@@ -86,7 +86,12 @@ export function backfillRuntimeEventsFromStoredMessages(input) {
                         id: newId(),
                         role: 'model',
                         author: 'agent',
-                        content: { kind: 'text', text: message.text },
+                        ...(message.interrupted ? { modelVisibility: 'hidden' } : {}),
+                        content: {
+                            kind: 'text',
+                            text: message.text,
+                            ...(message.interrupted ? { interrupted: true } : {}),
+                        },
                         actions: { stateDelta: recoveryState(now, message) },
                         refs: { storedMessageId: message.id },
                     });
@@ -96,6 +101,7 @@ export function backfillRuntimeEventsFromStoredMessages(input) {
                     for (const part of parts) {
                         events.push({
                             ...base,
+                            ...(message.interrupted ? { modelVisibility: 'hidden' } : {}),
                             id: newId(),
                             role: 'model',
                             author: 'agent',

package/node_modules/@maka/runtime/dist/runtime-event-read-model.js

@@ -638,6 +638,7 @@ function projectText(event, state, messages) {
             turnId: event.turnId,
             ts: event.ts,
             text: event.content.text,
+            ...(event.content.interrupted ? { interrupted: true } : {}),
             ...(event.content.providerOptions !== undefined
                 ? { providerOptions: structuredClone(event.content.providerOptions) }
                 : {}),

package/node_modules/@maka/runtime/dist/runtime-invocation-route.js

@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { isExecutorId } from '@maka/core/executor-id';
+export function runtimeInvocationRouteForHeader(header, providerStateIdentity) {
+    if (header.backend === 'plugin-executor' &&
+        isExecutorId(header.executorId) &&
+        providerStateIdentity) {
+        return {
+            provenance: 'runtime',
+            backendKind: header.backend,
+            executorId: header.executorId,
+            llmConnectionSlug: header.llmConnectionSlug,
+            modelId: header.model,
+            providerStateIdentity,
+        };
+    }
+    if (header.backend !== 'plugin-executor' && header.llmConnectionId !== undefined) {
+        return {
+            provenance: 'runtime',
+            backendKind: header.backend,
+            llmConnectionId: header.llmConnectionId,
+            llmConnectionSlug: header.llmConnectionSlug,
+            modelId: header.model,
+            ...(providerStateIdentity ? { providerStateIdentity } : {}),
+        };
+    }
+    return {
+        provenance: 'unknown',
+        backendKind: header.backend,
+        llmConnectionSlug: header.llmConnectionSlug,
+        modelId: header.model,
+    };
+}

package/node_modules/@maka/runtime/dist/runtime-kernel.js

@@ -38,6 +38,7 @@ import { RuntimeInteractionFailStopError, RuntimeInteractionInvariantError, bind
 import { DeliveryAckQueue, isDeliveryAckQueueClosed } from './delivery-ack-queue.js';
 import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
 import { preserveHandoffOpening } from './runtime-resume.js';
+import { runtimeInvocationRouteForHeader } from './runtime-invocation-route.js';
 export class SessionQuiescentMutationBusyError extends Error {
     sessionIds;
     name = 'SessionQuiescentMutationBusyError';
@@ -833,9 +834,7 @@ export class RuntimeKernel {
     }
     async *runAgentTurn(sessionId, run, execution, options = {}) {
         const { steering = false, onRunStarted, initialHeader, prepareBackendActivation } = options;
-        const sessionEvents = new DeliveryAckQueue();
         const { abortController, release: releaseExecutionAbort } = this.inheritExecutionAbort(execution);
-        let flowDone = false;
         const owners = this.createRunOwnerScope(run, execution);
         let begin;
         try {
@@ -865,25 +864,15 @@ export class RuntimeKernel {
             await this.finalizeFailedRunStart(owners, run, execution, error);
             return;
         }
-        const interactionRun = owners.interactionRun;
-        const messageOwner = owners.messageOwner;
-        const stopBackend = this.stopBackendFor(begin.backend);
-        const eventContext = this.runtimeEventMapContext({
+        yield* this.streamAgentRun({
             sessionId,
-            invocationId: begin.initialRuntimeEvent.invocationId,
-            runId: run.runId,
-            turnId: run.turnId,
-        });
-        if (run.isStopped())
-            abortController.abort();
-        const streamResult = this.runBackendEventStream({
+            run,
+            owners,
             backend: begin.backend,
-            stopBackend,
-            beforeDispatch: () => this.assertRunCanDispatch(run, begin.backend),
-            hasCommittedHandoff: () => run.hasCommittedHandoff(),
-            ...(interactionRun ? { hostedInteraction: interactionRun } : {}),
-            abortSignal: abortController.signal,
-            eventContext,
+            abortController,
+            releaseExecutionAbort,
+            requireTerminalWrite: Boolean(this.deps.runtimeEventStore),
+            invocationId: begin.initialRuntimeEvent.invocationId,
             backendInput: {
                 invocationId: begin.initialRuntimeEvent.invocationId,
                 runId: run.runId,
@@ -892,90 +881,10 @@ export class RuntimeKernel {
                 handoffBoundary: (signal, remainingSteps) => run.reachHandoffBoundary(signal, remainingSteps),
                 ...runtimeSteeringInput(owners.messageOwner),
             },
-            onSessionEvent: async (sessionEvent, runtimeEvent) => {
-                this.assertInteractionPublication(interactionRun, sessionEvent);
-                await run.acceptMappedEvent(sessionEvent, runtimeEvent, {
-                    requireTerminalWrite: Boolean(this.deps.runtimeEventStore),
-                    allowInteractionResume: await interactionResumeAllowed(interactionRun, sessionEvent),
-                });
-                this.observeInteractionEvent(sessionId, begin.backend, sessionEvent);
-                await sessionEvents.push(sessionEvent);
-            },
-            onError: async (error) => {
-                if (!isDeliveryAckQueueClosed(error)) {
-                    await run.recordFailure(error);
-                    sessionEvents.fail(error);
-                }
-            },
-            onFinally: async () => {
-                flowDone = true;
-                try {
-                    await owners.finalize();
-                    // Release Runtime access BEFORE the event stream closes. Embedded
-                    // queues still emit their final steering → followup projection here;
-                    // a hosted owner is only sealed, then the Host performs that handoff
-                    // under its Session admission gate. The outer finally remains an
-                    // idempotent backstop for paths that never reach this hook.
-                    if (messageOwner)
-                        owners.releaseMessage();
-                    sessionEvents.close();
-                }
-                catch (error) {
-                    sessionEvents.fail(error);
-                    throw error;
-                }
-            },
-        }).then(async (result) => {
-            if (!flowDone) {
-                try {
-                    flowDone = true;
-                    await owners.finalize();
-                    owners.releaseMessage();
-                    sessionEvents.close();
-                }
-                catch (error) {
-                    sessionEvents.fail(error);
-                    throw error;
-                }
-            }
-            return result;
-        }, (error) => {
-            sessionEvents.fail(error);
-            throw error;
         });
-        try {
-            for await (const event of sessionEvents) {
-                yield event;
-            }
-            await streamResult;
-        }
-        finally {
-            try {
-                await this.cleanupRunExecution({
-                    run,
-                    stopBackend,
-                    flowDone,
-                    abortController,
-                    sessionEvents,
-                    streamResult,
-                    interactionRun,
-                    finalizeRun: () => owners.finalize(),
-                    releaseOwner: () => {
-                        if (messageOwner)
-                            owners.releaseMessage();
-                    },
-                });
-            }
-            finally {
-                this.clearInteractionRequestOwners(sessionId, run.turnId);
-                releaseExecutionAbort();
-            }
-        }
     }
     async *runAgentContinuation(continuation, admissionRoute, run, execution, messageOwner, options = {}, revalidateSafety, inheritedSandboxBoundaryDenied = false) {
-        const sessionEvents = new DeliveryAckQueue();
         const { abortController, release: releaseExecutionAbort } = this.inheritExecutionAbort(execution);
-        let flowDone = false;
         const owners = this.createRunOwnerScope(run, execution);
         let begin;
         try {
@@ -1014,7 +923,6 @@ export class RuntimeKernel {
             await this.finalizeFailedRunStart(owners, run, execution, error);
             return;
         }
-        const interactionRun = owners.interactionRun;
         let continuationMetadata;
         try {
             continuationMetadata = consumeAdmittedRuntimeContinuation({
@@ -1034,20 +942,16 @@ export class RuntimeKernel {
             await this.finalizeFailedRunStart(owners, run, execution, error);
             return;
         }
-        const stopBackend = this.stopBackendFor(begin.backend);
-        const eventContext = this.runtimeEventMapContext({
+        yield* this.streamAgentRun({
             sessionId: continuation.sessionId,
-            invocationId: continuation.invocationId,
-            runId: continuation.runId,
-            turnId: continuation.turnId,
-        });
-        if (run.isStopped())
-            abortController.abort();
-        let streamFailure;
-        const streamResult = this.runBackendEventStream({
+            run,
+            owners,
             backend: begin.backend,
-            stopBackend,
-            beforeDispatch: () => this.assertRunCanDispatch(run, begin.backend),
+            abortController,
+            releaseExecutionAbort,
+            requireTerminalWrite: true,
+            recordUnobservedStreamFailure: true,
+            invocationId: continuation.invocationId,
             ...(continuation.handoffRootRunId !== undefined
                 ? {
                     prepareBeforeDispatch: async () => {
@@ -1060,10 +964,6 @@ export class RuntimeKernel {
                     },
                 }
                 : {}),
-            hasCommittedHandoff: () => run.hasCommittedHandoff(),
-            ...(interactionRun ? { hostedInteraction: interactionRun } : {}),
-            abortSignal: abortController.signal,
-            eventContext,
             backendInput: {
                 invocationId: continuation.invocationId,
                 runId: continuation.runId,
@@ -1090,26 +990,57 @@ export class RuntimeKernel {
                     : {}),
                 handoffBoundary: (signal, remainingSteps) => run.reachHandoffBoundary(signal, remainingSteps),
             },
+        });
+    }
+    async *streamAgentRun(input) {
+        const sessionEvents = new DeliveryAckQueue();
+        const interactionRun = input.owners.interactionRun;
+        const stopBackend = this.stopBackendFor(input.backend);
+        let flowDone = false;
+        let streamFailure;
+        if (input.run.isStopped())
+            input.abortController.abort();
+        const streamResult = this.runBackendEventStream({
+            backend: input.backend,
+            stopBackend,
+            beforeDispatch: () => this.assertRunCanDispatch(input.run, input.backend),
+            ...(input.prepareBeforeDispatch
+                ? { prepareBeforeDispatch: input.prepareBeforeDispatch }
+                : {}),
+            hasCommittedHandoff: () => input.run.hasCommittedHandoff(),
+            ...(interactionRun ? { hostedInteraction: interactionRun } : {}),
+            abortSignal: input.abortController.signal,
+            eventContext: this.runtimeEventMapContext({
+                sessionId: input.sessionId,
+                invocationId: input.invocationId,
+                runId: input.run.runId,
+                turnId: input.run.turnId,
+            }),
+            backendInput: input.backendInput,
             onSessionEvent: async (sessionEvent, runtimeEvent) => {
                 this.assertInteractionPublication(interactionRun, sessionEvent);
-                await run.acceptMappedEvent(sessionEvent, runtimeEvent, {
-                    requireTerminalWrite: true,
+                await input.run.acceptMappedEvent(sessionEvent, runtimeEvent, {
+                    requireTerminalWrite: input.requireTerminalWrite,
                     allowInteractionResume: await interactionResumeAllowed(interactionRun, sessionEvent),
                 });
-                this.observeInteractionEvent(continuation.sessionId, begin.backend, sessionEvent);
+                this.observeInteractionEvent(input.sessionId, input.backend, sessionEvent);
                 await sessionEvents.push(sessionEvent);
             },
             onError: async (error) => {
                 if (!isDeliveryAckQueueClosed(error)) {
-                    await run.recordFailure(error);
+                    await input.run.recordFailure(error);
                     sessionEvents.fail(error);
                 }
             },
             onFinally: async () => {
                 flowDone = true;
                 try {
-                    await owners.finalize();
-                    owners.releaseMessage();
+                    await input.owners.finalize();
+                    // Release Runtime access before closing the event stream. Embedded
+                    // queues publish their final steering projection here; hosted owners
+                    // are only sealed, then the Host performs the handoff under its
+                    // Session admission gate.
+                    input.owners.releaseMessage();
                     sessionEvents.close();
                 }
                 catch (error) {
@@ -1121,8 +1052,8 @@ export class RuntimeKernel {
             if (!flowDone) {
                 try {
                     flowDone = true;
-                    await owners.finalize();
-                    owners.releaseMessage();
+                    await input.owners.finalize();
+                    input.owners.releaseMessage();
                     sessionEvents.close();
                 }
                 catch (error) {
@@ -1138,29 +1069,30 @@ export class RuntimeKernel {
             throw error;
         });
         try {
-            for await (const event of sessionEvents) {
+            for await (const event of sessionEvents)
                 yield event;
-            }
             await streamResult;
         }
         finally {
             try {
                 await this.cleanupRunExecution({
-                    run,
+                    run: input.run,
                     stopBackend,
                     flowDone,
-                    abortController,
+                    abortController: input.abortController,
                     sessionEvents,
                     streamResult,
                     interactionRun,
-                    ...(streamFailure !== undefined ? { streamFailure } : {}),
-                    finalizeRun: () => owners.finalize(),
-                    releaseOwner: () => owners.releaseMessage(),
+                    ...(input.recordUnobservedStreamFailure && streamFailure !== undefined
+                        ? { streamFailure }
+                        : {}),
+                    finalizeRun: () => input.owners.finalize(),
+                    releaseOwner: () => input.owners.releaseMessage(),
                 });
             }
             finally {
-                this.clearInteractionRequestOwners(continuation.sessionId, run.turnId);
-                releaseExecutionAbort();
+                this.clearInteractionRequestOwners(input.sessionId, input.run.turnId);
+                input.releaseExecutionAbort();
             }
         }
     }
@@ -1955,6 +1887,12 @@ export class RuntimeKernel {
         if (!header.subagentParent) {
             throw new Error('Subagent runtime snapshot requires a linked child session');
         }
+        if (header.backend === 'plugin-executor') {
+            return {
+                systemPrompt: snapshot.systemPrompt,
+                tools: [],
+            };
+        }
         const snapshotDefinition = {
             id: snapshot.agentId,
             permissionMode: header.permissionMode,
@@ -2318,23 +2256,7 @@ function continuationTargetOpeningForExecution(input) {
     const opening = {
         kind: 'invocation_opened',
         protocol: 'invocation_opened_v1',
-        route: sessionHeader.llmConnectionId === undefined
-            ? {
-                provenance: 'unknown',
-                backendKind: sessionHeader.backend,
-                llmConnectionSlug: sessionHeader.llmConnectionSlug,
-                modelId: sessionHeader.model,
-            }
-            : {
-                provenance: 'runtime',
-                backendKind: sessionHeader.backend,
-                llmConnectionId: sessionHeader.llmConnectionId,
-                llmConnectionSlug: sessionHeader.llmConnectionSlug,
-                modelId: sessionHeader.model,
-                ...(input.targetProviderStateIdentity
-                    ? { providerStateIdentity: input.targetProviderStateIdentity }
-                    : {}),
-            },
+        route: runtimeInvocationRouteForHeader(sessionHeader, input.targetProviderStateIdentity),
         configuration: {
             cwd: sessionHeader.cwd,
             permissionMode: sessionHeader.permissionMode,

package/node_modules/@maka/runtime/dist/runtime-read-model.js

@@ -19,7 +19,6 @@
 import { deriveTurnRecords } from '@maka/core/session';
 import { isSessionInlineInvocation } from '@maka/core/runtime-invocation';
 import { activePresentationRuntimeEvents, classifyRuntimeEventTerminalFact, isHardRuntimeEventReadModelDiagnostic, projectRuntimeEventsToStoredMessages, projectTranscriptToolResult, } from './runtime-event-read-model.js';
-import { buildRuntimeEventModelReplayPlan, } from './model-history.js';
 const CANONICAL_PERMISSION_READ_CONCURRENCY = 8;
 export class RuntimeReadModelError extends Error {
     diagnostics;
@@ -138,7 +137,6 @@ export class RuntimeReadModel {
             invocations: input.invocations,
             diagnostics,
             terminalFacts: input.terminalFacts ?? [],
-            replayPlan: buildRuntimeEventModelReplayPlan(input.events),
         };
     }
     async readCanonicalPermissionOutcomes(events) {

package/node_modules/@maka/runtime/dist/session-event-runtime-mapper.js

@@ -135,11 +135,13 @@ function mapBackendSessionEvent(event, ctx, memory) {
         case 'text_complete':
             return {
                 ...base,
+                ...(event.interrupted ? { modelVisibility: 'hidden' } : {}),
                 role: 'model',
                 author: 'agent',
                 content: {
                     kind: 'text',
                     text: event.text,
+                    ...(event.interrupted ? { interrupted: true } : {}),
                     ...(event.providerOptions !== undefined
                         ? { providerOptions: structuredClone(event.providerOptions) }
                         : {}),
@@ -159,6 +161,7 @@ function mapBackendSessionEvent(event, ctx, memory) {
         case 'thinking_complete':
             return {
                 ...base,
+                ...(event.interrupted ? { modelVisibility: 'hidden' } : {}),
                 role: 'model',
                 author: 'agent',
                 content: {