maka-agent 0.2.2-dev.92.20261019 → 0.2.2-dev.97.20261024

package/node_modules/@maka/runtime/dist/event-wait-tool.js

@@ -23,11 +23,11 @@ const receipts = new WeakSet();
 export function isEventWaitYieldReceipt(value) {
     return typeof value === 'object' && value !== null && receipts.has(value);
 }
-/** Internal composition seam. Never added to the production builtin tool catalog. */
+/** Host composition seam; exposed only with supported sources and valid Goal control. */
 export function buildEventWaitTool(register) {
     return {
         name: EVENT_WAIT_TOOL_NAME,
-        description: 'Register a supported condition on an authorized resource and end this Turn. Host continues the Goal once a result or timeout is available.',
+        description: 'Wait for a background Bash task in this Session and end this Turn. Requires an active Goal and direct tools. Use resource {providerId: "shell_run", connectionId: null, resourceType: "background_task", resourceId: the canonical maka://runtime/background-tasks/... ref}, condition {typeId: "terminal", version: 1, parameters: {}} and an explicit timeoutMs. Host continues the existing Goal when the task becomes terminal or the wait expires. Terminal does not mean command success or Goal achievement: inspect the result with Read. Expiry or cancelling the wait does not stop the task.',
         parameters: z
             .object({
             resource: z

package/node_modules/@maka/runtime/dist/history-compact-checkpoint.js

@@ -329,6 +329,27 @@ export function canReplaceHistoryCompactCheckpoint(current, candidate) {
         (!current.source || sameHistoryCompactSourceCoverage(current.source, candidate.source)));
 }
 export function matchHistoryCompactCheckpointPrefix(checkpoint, events) {
+    const match = matchHistoryCompactCheckpointPrefixExactly(checkpoint, events);
+    if (match.reason === undefined ||
+        match.reason === 'invalid_checkpoint' ||
+        checkpoint.source?.policyVersion !== 'maka.compactable_runtime_event_projection.v3')
+        return match;
+    // v3 checkpoints written before #6263 did not count encrypted-only thinking.
+    // Locate that sealed boundary by identity, then verify the historical source
+    // exactly. Never trim the successor tail using the historical event count.
+    const throughIndex = events.findIndex((event) => event.id === checkpoint.coverage.through.runtimeEventId);
+    if (throughIndex < 0)
+        return match;
+    const prefix = events.slice(0, throughIndex + 1);
+    const historical = prefix.filter((event) => event.content?.kind !== 'thinking' || event.content.text.length > 0);
+    if (historical.length === prefix.length)
+        return match;
+    const historicalMatch = matchHistoryCompactCheckpointPrefixExactly(checkpoint, historical);
+    return historicalMatch.reason === undefined
+        ? { ...historicalMatch, successorRuntimeEvents: events.slice(throughIndex + 1) }
+        : match;
+}
+function matchHistoryCompactCheckpointPrefixExactly(checkpoint, events) {
     if (!validateHistoryCompactCheckpointShape(checkpoint)) {
         return {
             coveredEventCount: 0,
@@ -542,7 +563,17 @@ function effectiveDigestEvent(event) {
 }
 /** True when the event carries model-visible content the compact projection counts. */
 export function isHistoryCompactContentEvent(event) {
-    return event.modelVisibility !== 'hidden' && estimateRuntimeEventChars(event) > 0;
+    if (event.modelVisibility === 'hidden')
+        return false;
+    // A Responses reasoning item can carry only encrypted content. Text sizing
+    // does not decide whether that payload exists; route admission still runs
+    // when the compacted history is materialized for the selected model.
+    if (event.content?.kind === 'thinking') {
+        const openai = event.content.providerOptions?.openai;
+        if (nonEmpty(openai?.itemId) && nonEmpty(openai?.reasoningEncryptedContent))
+            return true;
+    }
+    return estimateRuntimeEventChars(event) > 0;
 }
 function validHistoryCompactProviderState(value) {
     if (!value || typeof value !== 'object')

package/node_modules/@maka/runtime/dist/history-compaction.js

@@ -180,6 +180,13 @@ export async function planHistoryCompaction(input) {
         if (!boundary.ok || !hasSafeCoverage)
             return noSafeSpan();
         const coveredRuntimeEvents = input.orderedEvents.slice(0, boundary.coveredCount);
+        // The live context is reattached after a fold. Summarizing just that
+        // metadata and the pinned user anchor cannot free useful history.
+        if (phase === 'mid_turn' &&
+            !coveredRuntimeEvents.some((event) => event.id !== input.headAnchor?.runtimeEventId &&
+                !(event.content?.kind === 'text' && event.content.runtimeContextName !== undefined))) {
+            return noSafeSpan();
+        }
         const tailRuntimeEvents = input.orderedEvents.slice(boundary.coveredCount);
         // One transition view per pass: the same loaded snapshot judges the
         // previous checkpoint's currency and produces the effective view the

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

@@ -337,12 +337,13 @@ function claudeThinkingOptions(modelId, level) {
  * those paths an omitted parameter already means no extended thinking, while
  * the lowest effort would switch adaptive thinking on. That holds for Claude,
  * not for every Anthropic Messages route: Kimi's K3 and kimi-for-coding think
- * by default when no level is sent.
+ * by default when no level is sent. K3 can declare an explicit `none` effort;
+ * when it does, the provider builder maps `'off'` to disabled thinking.
  *
- * Everywhere else a dropped `'off'` omits the effort parameter, and the
- * provider then runs its default reasoning (medium on GPT-5, GPT-6 and o3,
- * dynamic on Gemini 3). So this returns the model's lowest declared level
- * instead, which the wire builders send explicitly.
+ * When a model declares effort levels but no `none`, a dropped `'off'` omits
+ * the effort parameter and the provider runs its default reasoning (medium on
+ * GPT-5, GPT-6 and o3, dynamic on Gemini 3). So this returns the model's
+ * lowest declared level instead, which the wire builders send explicitly.
  */
 export function leastReasoningThinkingLevel(connection, modelId, runtime = resolveModelRuntime(connection, modelId)) {
     const variants = thinkingVariantsForConnection(connection, modelId);
@@ -376,8 +377,18 @@ function buildThinkingProviderOptions(connection, modelId, thinkingLevel, runtim
             }
             return buildFamilyWire(connection, modelId, level, thinkingOptions, runtime);
         case 'kimi-coding-plan': {
-            if (!level || level === 'off' || level === 'on')
+            if (!level || level === 'on')
                 return {};
+            if (level === 'off') {
+                // A refreshed Kimi Code catalog may declare `none`. Omitting the
+                // control leaves K3 at its default reasoning level, so send the
+                // provider's explicit disabled-thinking wire when that choice exists.
+                if (!thinkingOptions?.efforts?.includes('none'))
+                    return {};
+                return runtime.wire === 'openai-chat'
+                    ? { kimiCodingPlan: { reasoningEffort: 'none' } }
+                    : { anthropic: { thinking: { type: 'disabled' } } };
+            }
             if (runtime.wire === 'openai-chat') {
                 // The kimiCodingPlan provider-options namespace is the
                 // openai-compatible adapter name; ai-sdk resolves its camelCase
@@ -418,6 +429,15 @@ function buildThinkingProviderOptions(connection, modelId, thinkingLevel, runtim
             if (level === 'off' && thinkingOptions?.offBehavior === 'anthropic-thinking-disabled') {
                 reasoning = { thinking: { type: 'disabled' } };
             }
+            else if ((connection.providerType === 'MiniMax' || connection.providerType === 'MiniMax-cn') &&
+                (modelId === 'MiniMax-M3.1-Flash' || (modelId === 'MiniMax-M3' && level === 'on'))) {
+                reasoning = {
+                    thinking: { type: 'adaptive' },
+                    ...(modelId === 'MiniMax-M3.1-Flash'
+                        ? { effort: level && level !== 'off' && level !== 'on' ? level : 'max' }
+                        : {}),
+                };
+            }
             else if (summarizedThinking) {
                 reasoning = summarizedThinking;
             }

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

@@ -550,9 +550,10 @@ function toModelInfo(model) {
     assertOptionalArray(model.input_modalities, 'model input_modalities');
     assertOptionalArray(model.output_modalities, 'model output_modalities');
     assertOptionalArray(model.tags, 'model tags');
+    assertOptionalArray(model.supported_features, 'model supported_features');
     const providers = providerObjectArray(model.providers, 'model providers');
     const contextWindow = providerTokenLimit(model.context_length) ?? providerTokenLimit(model.context_window);
-    const maxOutputTokens = providerTokenLimit(model.max_tokens);
+    const maxOutputTokens = providerTokenLimit(model.max_output_length) ?? providerTokenLimit(model.max_tokens);
     const capabilities = {};
     if (model.input_modalities?.includes('image'))
         capabilities.vision = true;
@@ -568,6 +569,9 @@ function toModelInfo(model) {
         capabilities.reasoning = true;
     if (model.tags?.includes('tool-use'))
         capabilities.functionCalling = true;
+    if (model.supported_features) {
+        capabilities.functionCalling = model.supported_features.includes('tools');
+    }
     // `output_modalities` was validated above and then dropped, so a relay that
     // advertised an image-only model handed back a row indistinguishable from a
     // chat model's. Declared output that names modalities but not text is the
@@ -593,6 +597,9 @@ function toModelInfo(model) {
         ...(model.display_name || model.name ? { displayName: model.display_name ?? model.name } : {}),
         ...(contextWindow === undefined ? {} : { contextWindow }),
         ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+        ...(model.supported_features
+            ? { structuredOutput: model.supported_features.includes('structured_outputs') }
+            : {}),
         ...(Object.keys(capabilities).length ? { capabilities } : {}),
     };
 }

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

@@ -611,13 +611,16 @@ export function buildRuntimeEventModelReplayPlan(events, options = {}) {
             diagnostics.push(diagnostic(event, 'unsupported_content', 'RuntimeEvent content kind is not model-replayable', { kind: event.content.kind }));
             continue;
         }
-        if (event.role === 'system' && !includeSystemEvents) {
+        const runtimeContextName = event.role === 'system' && event.author === 'host' && event.content.kind === 'text'
+            ? event.content.runtimeContextName
+            : undefined;
+        if (event.role === 'system' && !includeSystemEvents && runtimeContextName === undefined) {
             diagnostics.push(diagnostic(event, 'system_runtime_fact_diagnostic_only', 'system RuntimeEvent content is diagnostic-only unless system replay is enabled'));
             continue;
         }
         switch (event.content.kind) {
             case 'text': {
-                const role = modelTextRole(event.role);
+                const role = runtimeContextName !== undefined ? 'user' : modelTextRole(event.role);
                 if (!role) {
                     diagnostics.push(diagnostic(event, 'unsupported_role', 'text RuntimeEvent role is not model-replayable', {
                         role: event.role,
@@ -636,6 +639,7 @@ export function buildRuntimeEventModelReplayPlan(events, options = {}) {
                         ? buildSteeringEnvelope(formatTextWithInlineRefs(event.content))
                         : formatTextWithInlineRefs(event.content),
                     ...(steeringReplay ? { steering: { eventId: event.id } } : {}),
+                    ...(runtimeContextName !== undefined ? { runtimeContextName } : {}),
                     ...(event.content.attachments ? { attachments: event.content.attachments } : {}),
                     ...(event.content.providerOptions !== undefined
                         ? {
@@ -807,7 +811,13 @@ export function buildRuntimeEventModelReplayPlan(events, options = {}) {
             content: item.content,
             providerOptions: steeringProviderOptions(item.steering.eventId),
         }
-        : { role: item.role, content: item.content });
+        : {
+            role: item.role,
+            content: item.content,
+            ...(item.runtimeContextName !== undefined
+                ? { providerOptions: runtimeContextProviderOptions(item.runtimeContextName) }
+                : {}),
+        });
     return {
         items,
         textMessages,
@@ -815,6 +825,9 @@ export function buildRuntimeEventModelReplayPlan(events, options = {}) {
         hasProviderNativeSemantics: items.some((item) => item.kind !== 'text'),
     };
 }
+export function runtimeContextProviderOptions(name) {
+    return { makaRuntimeContext: { name } };
+}
 function modelTextRole(role) {
     switch (role) {
         case 'user':

package/node_modules/@maka/runtime/dist/openai-codex-history-compactor.js

@@ -48,7 +48,10 @@ export function buildOpenAiCodexHistoryCompactor(options) {
             // Codex: summarize the portable checkpoint plus its tail, without
             // resurrecting the already-folded source history (#6154).
             const replayEvents = canContinuePrevious && !isProviderHistoryCompactCheckpoint(previous)
-                ? projectHistoryCompactCheckpointReplay(previous, input.source.foldedRuntimeEvents.slice(0, previous.coverage.eventCount), events)
+                ? projectHistoryCompactCheckpointReplay(previous, 
+                // The projection finds a mid-turn head anchor by identity. A
+                // historical event count can cut it off after reasoning admission.
+                input.source.foldedRuntimeEvents, events)
                 : events;
             const providerReasoningReplayEventIds = compatibleProviderReasoningReplayEventIds(events, input.source.invocations, options.providerStateIdentity, options.modelId, input.runId);
             const projectedMessages = openAiCodexCompactionMessages(replayEvents, providerReasoningReplayEventIds);
@@ -127,7 +130,9 @@ export function shouldFallbackFromOpenAiCodexHistoryCompaction(error, abortSigna
         return false;
     if (!(error instanceof HistoryCompactSummarizerError))
         return false;
-    if (error.reason === 'input_too_large' || error.reason === 'invalid_provider_state')
+    // Capacity errors must reach the planner's same-route accepted-prefix
+    // retry, which preserves native compaction and the uncovered tail.
+    if (error.reason === 'invalid_provider_state')
         return true;
     if (error.reason !== 'provider_error')
         return false;

package/node_modules/@maka/runtime/dist/plugin-executor-backend.js

@@ -17,8 +17,10 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
+import { truncateUtf8 } from '@maka/core/diagnostic-log';
 import { redactSecrets } from '@maka/core/redaction';
 import { AsyncEventQueue } from './async-queue.js';
+import { MAX_EXECUTOR_COMPLETION_TEXT_BYTES } from './plugin-executor-service.js';
 /** Converts a small plugin executor contract into Maka's existing Run event stream. */
 export class PluginExecutorBackend {
     kind = 'plugin-executor';
@@ -51,7 +53,7 @@ export class PluginExecutorBackend {
         const queue = new AsyncEventQueue();
         const messageId = this.#newId();
         const producer = this.#produce(input, messageId, abort.signal, queue).finally(() => queue.close());
-        const active = { abort, settled: producer.then(() => undefined) };
+        const active = { abort, settled: producer.then(() => undefined), queue };
         this.#active.add(active);
         let acknowledged = false;
         try {
@@ -90,11 +92,22 @@ export class PluginExecutorBackend {
             this.#active.delete(active);
         }
     }
+    /**
+     * Cancel execution and wait for its queued events to be consumed or the consumer
+     * to detach. Keep consuming send() while stopping: awaiting stop() inside that
+     * consumer loop prevents progress. Start it without awaiting in the loop, then
+     * await it after the loop exits.
+     */
     async stop(reason) {
         const active = [...this.#active];
         for (const execution of active)
             execution.abort.abort(new Error(reason));
-        await Promise.allSettled(active.map((execution) => execution.settled));
+        await Promise.allSettled(active.map(async (execution) => {
+            await execution.settled;
+            // Runtime may seal the ledger when stop returns. Provider settlement
+            // alone does not mean its queued final updates have been persisted.
+            await execution.queue.waitUntilConsumedThroughCurrent();
+        }));
     }
     async respondToSandboxBoundary(_response) {
         throw new Error('Plugin executor does not expose Maka sandbox-boundary requests');
@@ -111,6 +124,9 @@ export class PluginExecutorBackend {
     async #produce(input, messageId, signal, queue) {
         const turnId = input.turnId;
         let thinkingText = '';
+        let outputText = '';
+        let outputBytes = 0;
+        let outputTruncated = false;
         const toolUseIds = new Map();
         const toolOutputSequences = new Map();
         let result;
@@ -140,6 +156,21 @@ export class PluginExecutorBackend {
                 onEvent: (event) => {
                     if (event.type === 'thinking_delta')
                         thinkingText += event.text;
+                    if (event.type === 'output_delta' && !outputTruncated) {
+                        // Bound even a single oversized delta before retaining it. Live
+                        // delivery and the provider's final result remain authoritative.
+                        const chunk = event.text.slice(0, MAX_EXECUTOR_COMPLETION_TEXT_BYTES + 1);
+                        outputText += chunk;
+                        outputBytes += Buffer.byteLength(chunk, 'utf8');
+                        if (outputBytes > MAX_EXECUTOR_COMPLETION_TEXT_BYTES) {
+                            // A surrogate pair split across deltas uses fewer bytes joined.
+                            outputBytes = Buffer.byteLength(outputText, 'utf8');
+                            if (outputBytes > MAX_EXECUTOR_COMPLETION_TEXT_BYTES) {
+                                outputText = truncateUtf8(outputText, MAX_EXECUTOR_COMPLETION_TEXT_BYTES, '\n[Response truncated]');
+                                outputTruncated = true;
+                            }
+                        }
+                    }
                     this.#publishOutputEvent(turnId, messageId, event, toolUseIds, toolOutputSequences, queue);
                 },
                 onPermissionRequest: (request) => this.#requestPermission(input, request, signal, toolUseIds, queue),
@@ -150,6 +181,22 @@ export class PluginExecutorBackend {
             failure = error;
         }
         this.#closeOptionalOutput(turnId, messageId, thinkingText, toolUseIds, queue);
+        // Deltas are only live presentation. Close the interrupted text before the
+        // terminal event seals the ledger, including updates drained during cancel.
+        // Successful results keep their provider-authoritative completion text.
+        // Like successful completions, history stores one text block after tool
+        // results; it does not preserve the live text/tool interleaving.
+        if (outputText && (failed || result?.status !== 'completed')) {
+            queue.push({
+                type: 'text_complete',
+                id: this.#newId(),
+                turnId,
+                ts: this.#now(),
+                messageId,
+                text: outputText,
+                interrupted: true,
+            });
+        }
         if (failed) {
             if (signal.aborted)
                 this.#publishCancellation(turnId, { status: 'cancelled', source: 'caller' }, queue);

package/node_modules/@maka/runtime/dist/plugin-executor-service.js

@@ -23,7 +23,7 @@ import { isExecutorId } from '@maka/core/executor-id';
 import { Service } from './plugin-kernel.js';
 import { MakaPluginRuntimeError, pluginIdentity, registerPluginContribution, } from './plugin-runtime.js';
 import { PluginScopeRegistry } from './plugin-scope-registry.js';
-const MAX_EXECUTOR_COMPLETION_TEXT_BYTES = 256 * 1024;
+export const MAX_EXECUTOR_COMPLETION_TEXT_BYTES = 256 * 1024;
 class ExecutorRetiredAbort extends Error {
     constructor(executorId) {
         super(`Executor was retired: ${executorId}`);
@@ -127,6 +127,15 @@ export class PluginExecutorService extends Service {
             ? [...this.registry.visible(scopeSessionId).values()]
             : [...this.registry.entries('profile')];
         const selected = entries.filter((entry) => !entry.retired && (!input.executorId || entry.provider.id === input.executorId));
+        if (input.listOnly)
+            return selected.map(({ provider }) => ({
+                id: provider.id,
+                displayName: provider.displayName?.trim() || provider.id,
+                readiness: 'unavailable',
+                models: [],
+                supportsAttachments: false,
+                supportsModelChange: false,
+            }));
         if (input.executorId && !selected.length)
             return [
                 {
@@ -170,9 +179,9 @@ export class PluginExecutorService extends Service {
             }
         })));
     }
-    invalidateCatalog() {
+    invalidateCatalog(executorId) {
         for (const entry of this.registry.entries('profile')) {
-            if (!entry.retired)
+            if (!entry.retired && (!executorId || entry.provider.id === executorId))
                 entry.provider.invalidateCatalog?.();
         }
     }

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

@@ -0,0 +1,53 @@
+/*
+ * 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 { runtimeContextProviderOptions } from './model-history.js';
+/** Compare only host-tagged context still present in the effective model history.
+ * Compaction may remove a snapshot; in that case the current value is sent again.
+ */
+export function changedRuntimeContexts(contexts, messages) {
+    const latest = new Map();
+    for (const message of messages) {
+        const name = message.providerOptions?.makaRuntimeContext?.name;
+        if (message.role !== 'user' || typeof name !== 'string')
+            continue;
+        const text = typeof message.content === 'string'
+            ? message.content
+            : message.content
+                .filter((part) => part.type === 'text')
+                .map((part) => part.text)
+                .join('');
+        latest.set(name, text);
+    }
+    const changes = [];
+    for (const context of contexts) {
+        const text = `Runtime context (${context.name}; host metadata, not a user request; later updates supersede earlier values):\n${context.text}`;
+        if (latest.get(context.name) === text)
+            continue;
+        changes.push({ name: context.name, text });
+        latest.set(context.name, text);
+    }
+    return changes;
+}
+export function runtimeContextMessage(context) {
+    return {
+        role: 'user',
+        content: context.text,
+        providerOptions: runtimeContextProviderOptions(context.name),
+    };
+}

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

@@ -638,6 +638,9 @@ export function classifyRuntimeEventTerminalFact(invocation, events) {
 function projectText(event, state, messages) {
     if (event.content?.kind !== 'text')
         return false;
+    // Claimed by model replay only; internal context has no transcript row.
+    if (event.role === 'system' && event.content.runtimeContextName !== undefined)
+        return true;
     if (event.role === 'user') {
         const message = projectRuntimeEventUserMessage(event, stableMessageId(event, state, 'user'));
         if (!message)