maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@maka/runtime/dist/goal-continuation.js

@@ -194,7 +194,7 @@ export class GoalContinuationCoordinator {
             return this.settleDiscardedRegistration(registration);
         }
         if (registration.checkpoint &&
-            !this.deps.goalManager.matchesActive(sessionId, registration.checkpoint)) {
+            !this.matchesExecutionCheckpoint(sessionId, turnId, registration.checkpoint, controlLease)) {
             return this.settleDiscardedRegistration(registration);
         }
         return this.enqueueTurn(outcome, controlLease, registration);
@@ -205,6 +205,14 @@ export class GoalContinuationCoordinator {
             ? this.deps.durability.settleCurrentExecution(registration.lane.sessionId, registration.turnId)
             : Promise.resolve();
     }
+    gateEventWait(sessionId) {
+        const lane = this.lanes.get(sessionId);
+        if (!lane)
+            return;
+        lane.intent = undefined;
+        this.clearWaitingTimer(lane);
+        this.abortEvaluation(lane, 'Explicit event wait registered');
+    }
     /** Revoke the current lane while allowing later turns in the same session. */
     invalidateSession(sessionId) {
         const lane = this.lanes.get(sessionId);
@@ -232,7 +240,7 @@ export class GoalContinuationCoordinator {
         if (this.disposed) {
             return { kind: 'unavailable', reason: 'Goal continuation is disposed.' };
         }
-        if (!this.deps.goalManager.matchesActive(sessionId, current.checkpoint) ||
+        if (!this.matchesExecutionCheckpoint(sessionId, turnId, current.checkpoint, current.controlLease) ||
             !this.deps.goalManager.matchesControlLease(sessionId, current.controlLease)) {
             return { kind: 'unavailable', reason: 'Durable Goal execution no longer owns the Goal.' };
         }
@@ -265,7 +273,7 @@ export class GoalContinuationCoordinator {
      * at each door.
      */
     restoreDrive(lane, goal, controlLease, evaluation) {
-        if (!isDrivingGoal(goal))
+        if (!isDrivingGoal(goal) || this.deps.eventWait?.isGated(lane.sessionId))
             return;
         lane.intent = { checkpoint: goalCheckpoint(goal), controlLease, evaluation };
         this.scheduleDrain(lane);
@@ -304,13 +312,16 @@ export class GoalContinuationCoordinator {
             return;
         }
         const lane = this.laneFor(sessionId);
-        if (lane.intent || lane.turns.size > 0)
+        if (lane.turns.size > 0)
+            return;
+        if (lane.intent && (!pending.eventWait || !lane.intent.eventWait))
             return;
         lane.intent = {
             checkpoint: pending.checkpoint,
             controlLease: pending.controlLease,
             ...(pending.triggeringTurnId ? { triggeringTurnId: pending.triggeringTurnId } : {}),
             recoveredPrompt: pending.prompt,
+            ...(pending.eventWait ? { eventWait: pending.eventWait } : {}),
             evaluation: {
                 met: false,
                 impossible: false,
@@ -476,7 +487,9 @@ export class GoalContinuationCoordinator {
                     await this.processQueuedTurn(lane, item);
                 }
                 catch (error) {
-                    this.pauseCurrentGoal(lane, `Goal continuation coordinator failed: ${errorMessage(error)}`);
+                    if (this.deps.goalManager.matchesControlLease(lane.sessionId, item.controlLease)) {
+                        this.pauseCurrentGoal(lane, `Goal continuation coordinator failed: ${errorMessage(error)}`);
+                    }
                 }
                 finally {
                     if (lane.processing === item)
@@ -512,11 +525,25 @@ export class GoalContinuationCoordinator {
             }
         }
     }
+    matchesExecutionCheckpoint(sessionId, turnId, checkpoint, controlLease) {
+        return (this.deps.goalManager.matchesActive(sessionId, checkpoint) ||
+            this.deps.eventWait?.ownsSource(sessionId, turnId, controlLease) === true);
+    }
     async processQueuedTurn(lane, item) {
         if (!this.deps.goalManager.matchesControlLease(lane.sessionId, item.controlLease)) {
             return;
         }
-        if (item.checkpoint && !this.deps.goalManager.matchesActive(lane.sessionId, item.checkpoint)) {
+        if (item.checkpoint &&
+            !this.matchesExecutionCheckpoint(lane.sessionId, item.turnId, item.checkpoint, item.controlLease)) {
+            return;
+        }
+        if (this.deps.eventWait?.isGated(lane.sessionId)) {
+            if (item.outcome.kind === 'completed') {
+                await this.deps.eventWait.settleCompleted(lane.sessionId, item.turnId, item.controlLease);
+            }
+            else {
+                this.pauseCurrentGoal(lane, turnFailureReason(item.outcome));
+            }
             return;
         }
         if (sameGoalControlLease(lane.intent?.controlLease, item.controlLease)) {
@@ -539,13 +566,23 @@ export class GoalContinuationCoordinator {
         }
         await this.processCompletion(lane, item.controlLease, goal, item.turnId);
     }
+    commitGoalMutation(operation) {
+        return this.deps.mutateGoal ? this.deps.mutateGoal(operation) : operation(this.deps.durability);
+    }
     async processCompletion(lane, controlLease, initialGoal, turnId) {
         let goal = initialGoal;
-        if (goal.status === 'waiting') {
-            const woken = this.deps.goalManager.wakeWaiting(lane.sessionId, goalCheckpoint(goal));
-            if (!woken)
+        await this.commitGoalMutation(async () => {
+            if (this.deps.eventWait?.isGated(lane.sessionId))
                 return;
-            goal = woken;
+            if (goal.status === 'waiting') {
+                const woken = this.deps.goalManager.wakeWaiting(lane.sessionId, goalCheckpoint(goal));
+                if (woken)
+                    goal = woken;
+            }
+        });
+        if (this.deps.eventWait?.isGated(lane.sessionId)) {
+            await this.deps.eventWait.settleCompleted(lane.sessionId, turnId, controlLease);
+            return;
         }
         if (goal.status !== 'active')
             return;
@@ -555,98 +592,120 @@ export class GoalContinuationCoordinator {
             context = await this.deps.getRecentContext(lane.sessionId);
         }
         catch (error) {
-            this.pauseAtCheckpoint(lane, checkpoint, `Unable to read Goal evaluation context: ${errorMessage(error)}`);
+            await this.commitGoalMutation(async () => this.pauseAtCheckpoint(lane, checkpoint, `Unable to read Goal evaluation context: ${errorMessage(error)}`));
             return;
         }
-        if (!this.isCurrent(lane) || !this.deps.goalManager.matchesActive(lane.sessionId, checkpoint)) {
+        // Ordinary evaluator settlement uses this context read's usage snapshot.
+        // Explicit waits instead read persisted usage at the completed Turn boundary.
+        const tokensNow = this.deps.getTokenCount?.(lane.sessionId);
+        const evaluationAbort = new AbortController();
+        let evaluationTask;
+        let gated = false;
+        await this.commitGoalMutation(async () => {
+            if (!this.isCurrent(lane) || !this.deps.goalManager.matchesActive(lane.sessionId, checkpoint))
+                return;
+            if (this.deps.eventWait?.isGated(lane.sessionId)) {
+                gated = true;
+                return;
+            }
+            lane.evaluationAbort = evaluationAbort;
+            evaluationTask = evaluateGoal(this.deps.evaluator, goal.condition, context, lane.sessionId, evaluationAbort.signal);
+        });
+        if (!evaluationTask) {
+            if (gated)
+                await this.deps.eventWait.settleCompleted(lane.sessionId, turnId, controlLease);
             return;
         }
-        const evaluationAbort = new AbortController();
-        lane.evaluationAbort = evaluationAbort;
         let evaluation;
         try {
-            evaluation = await evaluateGoal(this.deps.evaluator, goal.condition, context, lane.sessionId, evaluationAbort.signal);
+            evaluation = await evaluationTask;
         }
         finally {
             if (lane.evaluationAbort === evaluationAbort)
                 lane.evaluationAbort = undefined;
         }
-        if (!this.isCurrent(lane) || !this.deps.goalManager.matchesActive(lane.sessionId, checkpoint)) {
-            return;
-        }
-        const tokensNow = this.deps.getTokenCount?.(lane.sessionId);
-        const settlementBase = {
-            checkpoint,
-            reason: evaluation.reason,
-        };
-        let settled;
-        if (evaluation.met || evaluation.impossible) {
-            settled = this.deps.goalManager.settleTurn(lane.sessionId, {
-                ...settlementBase,
-                verdict: evaluation.met ? 'achieved' : 'impossible',
-            });
-        }
-        else if (evaluation.waiting) {
-            settled = this.deps.goalManager.settleTurn(lane.sessionId, {
-                ...settlementBase,
-                verdict: 'continue',
-                waiting: true,
-                ...(tokensNow !== undefined ? { tokensNow } : {}),
-            });
-        }
-        else {
-            settled = this.deps.goalManager.settleTurn(lane.sessionId, {
-                ...settlementBase,
-                verdict: 'continue',
-                ...(!evaluation.evaluatorFailed ? { madeProgress: evaluation.progress } : {}),
-                ...(tokensNow !== undefined ? { tokensNow } : {}),
-            });
-        }
-        if (!settled)
-            return;
-        if (settled.status === 'achieved' || settled.status === 'impossible') {
-            lane.intent = undefined;
-            this.resetWaitingBackoff(lane);
-            this.taskGatePolicy.record({
-                sessionId: lane.sessionId,
-                turnId,
-                goalId: goal.id,
-                decision: 'evaluator_terminal',
-                taskKeys: [],
+        await this.commitGoalMutation(async (durability) => {
+            if (!this.isCurrent(lane) || !this.deps.goalManager.matchesActive(lane.sessionId, checkpoint))
+                return;
+            if (this.deps.eventWait?.isGated(lane.sessionId)) {
+                gated = true;
+                return;
+            }
+            const settlementBase = {
+                checkpoint,
+                reason: evaluation.reason,
+            };
+            let settled;
+            if (evaluation.met || evaluation.impossible) {
+                settled = this.deps.goalManager.settleTurn(lane.sessionId, {
+                    ...settlementBase,
+                    verdict: evaluation.met ? 'achieved' : 'impossible',
+                });
+            }
+            else if (evaluation.waiting) {
+                settled = this.deps.goalManager.settleTurn(lane.sessionId, {
+                    ...settlementBase,
+                    verdict: 'continue',
+                    waiting: true,
+                    ...(tokensNow !== undefined ? { tokensNow } : {}),
+                });
+            }
+            else {
+                settled = this.deps.goalManager.settleTurn(lane.sessionId, {
+                    ...settlementBase,
+                    verdict: 'continue',
+                    ...(!evaluation.evaluatorFailed ? { madeProgress: evaluation.progress } : {}),
+                    ...(tokensNow !== undefined ? { tokensNow } : {}),
+                });
+            }
+            if (!settled)
+                return;
+            if (settled.status === 'achieved' || settled.status === 'impossible') {
+                lane.intent = undefined;
+                this.resetWaitingBackoff(lane);
+                this.taskGatePolicy.record({
+                    sessionId: lane.sessionId,
+                    turnId,
+                    goalId: goal.id,
+                    decision: 'evaluator_terminal',
+                    taskKeys: [],
+                });
+                return;
+            }
+            if (settled.status !== 'active' && settled.status !== 'waiting') {
+                lane.intent = undefined;
+                this.resetWaitingBackoff(lane);
+                const taskKeys = await this.taskGatePolicy.listActionable(lane.sessionId);
+                this.taskGatePolicy.record({
+                    sessionId: lane.sessionId,
+                    turnId,
+                    goalId: goal.id,
+                    decision: 'goal_stopped',
+                    taskKeys,
+                });
+                return;
+            }
+            lane.intent = {
+                checkpoint: goalCheckpoint(settled),
+                controlLease,
+                triggeringTurnId: turnId,
+                evaluation,
+            };
+            const pendingPrompt = truncateGoalText(buildContinuationPrompt(settled, evaluation, undefined), GOAL_PENDING_PROMPT_TEXT_LIMIT);
+            await durability.recordPendingContinuation({
+                checkpoint: lane.intent.checkpoint,
+                controlLease,
+                prompt: pendingPrompt,
+                triggeringTurnId: turnId,
             });
-            return;
-        }
-        if (settled.status !== 'active' && settled.status !== 'waiting') {
-            lane.intent = undefined;
+            if (settled.status === 'waiting') {
+                lane.consecutiveWaits++;
+                return;
+            }
             this.resetWaitingBackoff(lane);
-            const taskKeys = await this.taskGatePolicy.listActionable(lane.sessionId);
-            this.taskGatePolicy.record({
-                sessionId: lane.sessionId,
-                turnId,
-                goalId: goal.id,
-                decision: 'goal_stopped',
-                taskKeys,
-            });
-            return;
-        }
-        lane.intent = {
-            checkpoint: goalCheckpoint(settled),
-            controlLease,
-            triggeringTurnId: turnId,
-            evaluation,
-        };
-        const pendingPrompt = truncateGoalText(buildContinuationPrompt(settled, evaluation, undefined), GOAL_PENDING_PROMPT_TEXT_LIMIT);
-        await this.deps.durability.recordPendingContinuation({
-            checkpoint: lane.intent.checkpoint,
-            controlLease,
-            prompt: pendingPrompt,
-            triggeringTurnId: turnId,
         });
-        if (settled.status === 'waiting') {
-            lane.consecutiveWaits++;
-            return;
-        }
-        this.resetWaitingBackoff(lane);
+        if (gated)
+            await this.deps.eventWait.settleCompleted(lane.sessionId, turnId, controlLease);
     }
     async tryAdmitIntent(lane, intent) {
         if (this.handoffHeld ||
@@ -655,6 +714,11 @@ export class GoalContinuationCoordinator {
             lane.intent !== intent) {
             return;
         }
+        if (this.deps.eventWait?.isGated(lane.sessionId) && !intent.eventWait) {
+            lane.intent = undefined;
+            this.clearWaitingTimer(lane);
+            return;
+        }
         if (!this.ownedGoal(lane, intent)) {
             lane.intent = undefined;
             return;
@@ -671,10 +735,12 @@ export class GoalContinuationCoordinator {
             lane.intent = undefined;
             return;
         }
-        const prompt = intent.recoveredPrompt
-            ? attachTaskReminder(intent.recoveredPrompt, taskPlan.reminder)
-            : buildContinuationPrompt(goal, intent.evaluation, taskPlan.reminder);
-        const admission = this.deps.admitTurn(lane.sessionId, prompt, intent.checkpoint, intent.controlLease);
+        const prompt = intent.eventWait && intent.recoveredPrompt
+            ? intent.recoveredPrompt
+            : intent.recoveredPrompt
+                ? attachTaskReminder(intent.recoveredPrompt, taskPlan.reminder)
+                : buildContinuationPrompt(goal, intent.evaluation, taskPlan.reminder);
+        const admission = this.deps.admitTurn(lane.sessionId, prompt, intent.checkpoint, intent.controlLease, intent.eventWait);
         if (admission.kind === 'busy') {
             this.watchBusyLane(lane, admission.whenIdle);
             return;
@@ -692,11 +758,12 @@ export class GoalContinuationCoordinator {
             controlLease: intent.controlLease,
         };
         lane.turns.set(admission.turnId, registration);
-        await this.deps.durability.recordCurrentExecution({
-            execution: admission.execution,
-            checkpoint: intent.checkpoint,
-            controlLease: intent.controlLease,
-        });
+        if (!intent.eventWait)
+            await this.deps.durability.recordCurrentExecution({
+                execution: admission.execution,
+                checkpoint: intent.checkpoint,
+                controlLease: intent.controlLease,
+            });
         let completion;
         try {
             completion = admission.start();
@@ -710,6 +777,12 @@ export class GoalContinuationCoordinator {
             return;
         }
         void completion.then((outcome) => {
+            if (outcome.kind === 'deferred') {
+                // No Root was admitted. The durable event outbox owns the retry;
+                // authorization waiting must not settle or charge a work Turn.
+                this.consumeTurnRegistration(registration);
+                return;
+            }
             void this.settleRegisteredTurn(registration, outcome).catch(() => undefined);
         }, (error) => {
             void this.settleRegisteredTurn(registration, {
@@ -750,7 +823,11 @@ export class GoalContinuationCoordinator {
         return this.deps.goalManager.get(lane.sessionId);
     }
     scheduleWaitingRetry(lane, goal) {
-        if (this.handoffHeld || !this.isCurrent(lane) || lane.waitingTimer || !lane.intent)
+        if (this.handoffHeld ||
+            !this.isCurrent(lane) ||
+            lane.waitingTimer ||
+            !lane.intent ||
+            this.deps.eventWait?.isGated(lane.sessionId))
             return;
         if (!this.deps.goalManager.matches(lane.sessionId, lane.intent.checkpoint)) {
             lane.intent = undefined;
@@ -761,25 +838,26 @@ export class GoalContinuationCoordinator {
         const delayMs = waitBackoffMs(lane.consecutiveWaits);
         const handle = this.scheduler.setTimeout(() => {
             lane.waitingTimer = undefined;
-            if (!this.isCurrent(lane))
-                return;
-            if (lane.queue.length > 0) {
-                this.scheduleDrain(lane);
-                return;
-            }
-            const woken = this.deps.goalManager.wakeWaiting(lane.sessionId, checkpoint);
-            if (!woken || !lane.intent)
-                return;
-            lane.intent = { ...lane.intent, checkpoint: goalCheckpoint(woken) };
-            void this.deps.durability
-                .recordPendingContinuation({
-                checkpoint: lane.intent.checkpoint,
-                controlLease: lane.intent.controlLease,
-                prompt: lane.intent.recoveredPrompt ??
-                    buildContinuationPrompt(woken, lane.intent.evaluation, undefined),
-                ...(lane.intent.triggeringTurnId
-                    ? { triggeringTurnId: lane.intent.triggeringTurnId }
-                    : {}),
+            void this.commitGoalMutation(async (durability) => {
+                if (!this.isCurrent(lane) || this.deps.eventWait?.isGated(lane.sessionId))
+                    return;
+                if (lane.queue.length > 0) {
+                    this.scheduleDrain(lane);
+                    return;
+                }
+                const woken = this.deps.goalManager.wakeWaiting(lane.sessionId, checkpoint);
+                if (!woken || !lane.intent)
+                    return;
+                lane.intent = { ...lane.intent, checkpoint: goalCheckpoint(woken) };
+                await durability.recordPendingContinuation({
+                    checkpoint: lane.intent.checkpoint,
+                    controlLease: lane.intent.controlLease,
+                    prompt: lane.intent.recoveredPrompt ??
+                        buildContinuationPrompt(woken, lane.intent.evaluation, undefined),
+                    ...(lane.intent.triggeringTurnId
+                        ? { triggeringTurnId: lane.intent.triggeringTurnId }
+                        : {}),
+                });
             })
                 .then(() => this.deps.durability.flush(lane.sessionId))
                 .then(() => this.scheduleDrain(lane))

package/node_modules/@maka/runtime/dist/goal-state.js

@@ -184,6 +184,14 @@ export class GoalManager {
             controlLease: Object.freeze({ ...controlLease }),
         });
     }
+    adoptAuthority(goal, controlLease) {
+        if (goal.id !== controlLease.goalId)
+            throw new Error('Invalid Goal authority');
+        this.goals.set(goal.sessionId, {
+            state: Object.freeze({ ...goal }),
+            controlLease: Object.freeze({ ...controlLease }),
+        });
+    }
     matchesControlLease(sessionId, lease) {
         return sameGoalControlLease(this.goals.get(sessionId)?.controlLease, lease);
     }

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

@@ -214,9 +214,8 @@ export function canReplayHistoryCompactCheckpointForModel(checkpoint, connection
 }
 /** Whether this model's configured compactor can roll forward from this checkpoint value. */
 export function canContinueHistoryCompactCheckpointForModel(checkpoint, connection, connectionId, modelId) {
-    if (isTextHistoryCompactCheckpoint(checkpoint)) {
-        return connection.providerType !== 'openai-codex';
-    }
+    // Portable text is ordinary model context for both replay and compaction.
+    // Only opaque provider state needs a matching route.
     return canReplayHistoryCompactCheckpointForModel(checkpoint, connection, connectionId, modelId);
 }
 export function historyCompactCheckpointToRuntimeEvent(checkpoint) {
@@ -330,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,
@@ -543,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/memory-extraction.js

@@ -95,7 +95,6 @@ export function buildMemoryExtractionTriggerTools(input) {
             description: 'Use only when the user explicitly asks you to remember long-term information. It stores the requested memory and returns exactly what was saved.',
             parameters: noArguments,
             executionSemantics: 'exclusive_step',
-            recoveryMode: 'idempotent',
             impl: async (_args, context) => {
                 const gate = await input.capabilities.gate();
                 if (!gate.allowed)
@@ -117,7 +116,6 @@ export function buildMemoryExtractionTriggerTools(input) {
             name: MEMORY_EXTRACT_TOOL_NAME,
             description: 'Use when the conversation contains durable long-term information worth preserving and the user did not explicitly ask to remember it. The extraction runs after this turn.',
             parameters: noArguments,
-            recoveryMode: 'idempotent',
             impl: async (_args, context) => {
                 const gate = await input.capabilities.gate();
                 if (!gate.allowed)

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 } : {}),
     };
 }