maka-agent 0.2.0-dev.52.20260926 → 0.2.0-dev.53.20260927

package/node_modules/@maka/core/dist/events.js

@@ -56,6 +56,13 @@ export function isDirectoryReference(value) {
         value.path.length <= 4096 &&
         isCanonicalAbsolutePath(value.path));
 }
+/**
+ * Cap for {@link QuoteRef.comment}. A note about a quote carries intent, not
+ * content: long prose belongs in the message text, which has its own limit.
+ * The single authority for the IPC normalizer, the Runtime Host protocol and
+ * the composer's staging cap.
+ */
+export const QUOTE_COMMENT_MAX_LENGTH = 1000;
 const MESSAGE_CONTENT_SHAPE = defineObjectShape()(['text'], ['displayText', 'attachments', 'directoryReferences', 'quotes', 'inlineReferences']);
 /**
  * A Turn message is meaningful when at least one of its four content carriers
@@ -81,6 +88,7 @@ export function hasMeaningfulMessageContent(content) {
 const ATTACHMENT_REF_SHAPE = defineObjectShape()(['kind', 'name', 'mimeType', 'bytes', 'ref'], []);
 const QUOTE_REF_SHAPE = defineObjectShape()(['text'], [
     'label',
+    'comment',
     'sourceTurnId',
     'sourceSessionId',
     'sourceSessionName',
@@ -121,6 +129,7 @@ export function normalizeMessageContent(content) {
                 quotes: content.quotes.map((quote) => ({
                     text: quote.text,
                     ...(quote.label !== undefined ? { label: quote.label } : {}),
+                    ...(quote.comment !== undefined ? { comment: quote.comment } : {}),
                     ...(quote.sourceTurnId !== undefined ? { sourceTurnId: quote.sourceTurnId } : {}),
                     ...(quote.sourceSessionId !== undefined
                         ? { sourceSessionId: quote.sourceSessionId }
@@ -244,6 +253,7 @@ export function isQuoteRef(value) {
         hasExactShape(record, QUOTE_REF_SHAPE) &&
         typeof record.text === 'string' &&
         (record.label === undefined || typeof record.label === 'string') &&
+        (record.comment === undefined || typeof record.comment === 'string') &&
         (record.sourceTurnId === undefined || typeof record.sourceTurnId === 'string') &&
         (!hasSourceMetadata ||
             (typeof record.sourceSessionId === 'string' &&
@@ -386,6 +396,7 @@ function inlineReferencesEqual(left, right) {
 function quoteRefsEqual(left, right) {
     return (left.text === right.text &&
         left.label === right.label &&
+        left.comment === right.comment &&
         left.sourceTurnId === right.sourceTurnId &&
         left.sourceSessionId === right.sourceSessionId &&
         left.sourceSessionName === right.sourceSessionName &&

package/node_modules/@maka/core/dist/provider-registry.js

@@ -671,7 +671,7 @@ const providerRegistry = {
         label: 'MiniMax',
         baseUrl: 'https://api.minimax.io/anthropic/v1',
         authKind: 'api_key',
-        fallbackModels: ['MiniMax-M3'],
+        fallbackModels: ['MiniMax-M3', 'MiniMax-M2.7'],
         status: 'ready',
         runtimeAdapter: { kind: 'anthropic', auth: 'bearer', normalizeBaseUrl: false },
         modelDiscovery: { kind: 'protocol' },
@@ -684,7 +684,7 @@ const providerRegistry = {
         label: 'MiniMax 中国站',
         baseUrl: 'https://api.minimaxi.com/anthropic/v1',
         authKind: 'api_key',
-        fallbackModels: ['MiniMax-M3'],
+        fallbackModels: ['MiniMax-M3', 'MiniMax-M2.7'],
         status: 'ready',
         runtimeAdapter: { kind: 'anthropic', auth: 'bearer', normalizeBaseUrl: false },
         modelDiscovery: { kind: 'protocol' },
@@ -1438,5 +1438,14 @@ export function providerMenuLabel(providerType) {
 export function isRetiredProvider(providerType) {
     return providerDefaultsOf(providerType)?.retired === true;
 }
+/**
+ * Whether a request on this provider may carry an output-token limit. The
+ * ChatGPT Codex backend answers `max_output_tokens` with HTTP 400
+ * "Unsupported parameter", so no limit can be honoured there: Runtime must not
+ * send one, and settings must not offer one.
+ */
+export function providerAcceptsOutputTokenLimit(providerType) {
+    return providerDefaultsOf(providerType)?.runtimeAdapter.kind !== 'openai-codex';
+}
 export const CATALOG_PROVIDER_TYPES = providerTypesByOrder('catalogOrder');
 export const RECOMMENDED_PROVIDER_TYPES = providerTypesByOrder('recommendedOrder');

package/node_modules/@maka/core/dist/turn-origin.js

@@ -18,6 +18,7 @@
  */
 import { defineObjectShape, hasExactShape, isRecord } from './record-schema.js';
 const SCHEDULED_TASK_ORIGIN_SHAPE = defineObjectShape()(['kind', 'scheduledTaskId'], []);
+const CLOUD_ACTIVATION_ORIGIN_SHAPE = defineObjectShape()(['kind', 'activationId'], []);
 const LEGACY_AUTOMATION_ORIGIN_SHAPE = defineObjectShape()(['kind', 'automationId'], []);
 const GOAL_ORIGIN_SHAPE = defineObjectShape()(['kind', 'goalId'], []);
 const AGENT_GRAPH_ORIGIN_SHAPE = defineObjectShape()(['kind', 'graphId', 'wakeId', 'attemptId'], []);
@@ -44,6 +45,11 @@ export function decodeTurnOrigin(value) {
         typeof value.scheduledTaskId === 'string') {
         return { kind: 'scheduled_task', scheduledTaskId: value.scheduledTaskId };
     }
+    if (hasExactShape(value, CLOUD_ACTIVATION_ORIGIN_SHAPE) &&
+        value.kind === 'cloud_activation' &&
+        typeof value.activationId === 'string') {
+        return { kind: 'cloud_activation', activationId: value.activationId };
+    }
     if (hasExactShape(value, LEGACY_AUTOMATION_ORIGIN_SHAPE) &&
         (value.kind === 'automation' || value.kind === 'legacy_automation') &&
         typeof value.automationId === 'string') {

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

@@ -21,9 +21,8 @@ import { buildContextBudgetDiagnosticShell, mergeContextBudgetDiagnostic, mergeC
 import { isHistoryCompactContentEvent } from './history-compaction.js';
 import { canContinueHistoryCompactCheckpointForModel, canReplayHistoryCompactCheckpointForModel, historyCompactSourceDigest, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
 import { HistoryCompactSummarizerError, isMalformedHistoryCompactSummaryReason, } from './history-compact-error.js';
-import { createHash } from 'node:crypto';
 import { archiveToolResultAsTransition, collectToolResultArchiveCandidates, serializedToolResultProjection, } from './tool-result-archive-transition.js';
-import { estimateTokens } from './context-budget-helpers.js';
+import { estimateTokens, sha256 } from './context-budget-helpers.js';
 import { reduceEffectiveModelProjections, } from './model-projection-transition-ledger.js';
 import { buildRuntimeEventModelReplayPlan, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, } from './model-history.js';
 import { planHistoryCompaction } from './history-compaction.js';
@@ -969,9 +968,6 @@ function projectAcceptedMidTurnCompactionMessages(incomingMessages, acceptedProj
         ...incomingMessages.slice(acceptedProjection.sourceSignatures.length),
     ];
 }
-function sha256(text) {
-    return createHash('sha256').update(text).digest('hex');
-}
 function modelMessageSignature(message) {
     return sha256(stableStringifyForSignature(message));
 }

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

@@ -38,7 +38,7 @@ import { hasBlockingReplayDiagnostics } from './ai-sdk-compaction.js';
 import { portableApplyPatchTool } from './apply-patch-profile.js';
 import { RunTrace } from './run-trace.js';
 import { REQUEST_SANDBOX_BOUNDARY_TOOL_NAME, SANDBOX_BOUNDARY_DENIED_FOR_TURN, SANDBOX_BOUNDARY_FINALIZATION_PROMPT, } from './sandbox-boundary-tool.js';
-import { buildRuntimeEventModelReplayPlan, buildSteeringEnvelope, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, formatTextWithInlineRefs, steeringMessagesMissingFromBase, steeringModelMessage, } from './model-history.js';
+import { buildRuntimeEventModelReplayPlan, appendPriorUnknownToolResponses, buildSteeringEnvelope, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, formatTextWithInlineRefs, inspectPriorUnknownToolOutcomes, steeringMessagesMissingFromBase, steeringModelMessage, } from './model-history.js';
 import { toolSchemaCharsForDiagnostics, requestCompositionToolSchemas, stableHash, toolCatalogHash, } from './request-shape.js';
 import { toolAvailabilityHash } from './tool-availability.js';
 import { hasFinalizedReasoning } from './ai-sdk-message-projection.js';
@@ -584,7 +584,24 @@ export class AiSdkTurn {
         const maxSteps = input.maxSteps === null ? undefined : (input.maxSteps ?? this.deps.maxSteps);
         const toolRuntime = this.toolRuntime;
         const turnAbortController = this.abortController;
-        const midTurnState = this.deps.compaction.buildMidTurnCapacityCompactState(input);
+        const priorEvents = (input.runtimeContext ?? []).filter((event) => input.continuation !== undefined || event.turnId !== input.turnId);
+        const observedPriorUnknownProjection = !input.continuation
+            ? inspectPriorUnknownToolOutcomes(priorEvents, input.runtimeContextInvocations)
+            : { kind: 'none' };
+        if (observedPriorUnknownProjection.kind === 'blocked') {
+            throw new Error(`Cannot use prior tool history: ${observedPriorUnknownProjection.reason}`);
+        }
+        if (observedPriorUnknownProjection.kind === 'projected' &&
+            !input.allowPriorUnknownToolOutcomes) {
+            throw new Error('Cannot continue an automated turn while a prior tool outcome is unknown; an explicit user message is required');
+        }
+        const priorUnknownProjection = input.allowPriorUnknownToolOutcomes
+            ? observedPriorUnknownProjection
+            : { kind: 'none' };
+        const preservingUnknownHistory = priorUnknownProjection.kind === 'projected';
+        const midTurnState = preservingUnknownHistory
+            ? undefined
+            : this.deps.compaction.buildMidTurnCapacityCompactState(input);
         const queue = new AsyncEventQueue();
         const codeModeExecTool = this.createCodeModeExecTool(queue);
         // One AssistantMessage is flushed per provider step (not per turn), so the
@@ -844,7 +861,7 @@ export class AiSdkTurn {
         let resolvedSystemPrompt = { sourceRevisions: [] };
         let systemPrompt;
         // --- Build messages from RuntimeEvent history and its compatibility projection. ---
-        const priorReplayResult = await this.buildPriorMessages(input);
+        const priorReplayResult = await this.buildPriorMessages(input, priorUnknownProjection);
         if (this.aborted) {
             queue.push({
                 type: 'abort',
@@ -975,6 +992,10 @@ export class AiSdkTurn {
                 };
                 const loadDurableTurnProjection = async () => {
                     const turnEvents = await loadDurableTurnEvents();
+                    // Prior unknown call/result pairs are outside this current-turn event
+                    // set and are preserved separately in priorReplay. Continue pruning
+                    // new tool results from this turn so one unknown predecessor does not
+                    // make an unrelated large result permanently unprunable.
                     const pruned = await this.deps.compaction.pruneToolResults(turnEvents, turnId);
                     if (pruned.stats) {
                         contextBudgetForTelemetry = addToolResultPruneStats(contextBudgetForTelemetry ?? minimalContextBudgetDiagnostic(), pruned.stats);
@@ -1106,6 +1127,9 @@ export class AiSdkTurn {
                     }
                     const requestSystemPromptBase = joinPromptFragments([
                         systemPrompt,
+                        priorUnknownProjection.kind === 'projected'
+                            ? priorUnknownProjection.systemNotice
+                            : undefined,
                         finalChildSummaryStep ? CHILD_STEP_BUDGET_FINALIZATION_PROMPT : undefined,
                         toolRuntime.hasSandboxBoundaryDenial() ? SANDBOX_BOUNDARY_DENIED_FOR_TURN : undefined,
                         sandboxBoundaryFinalizationStep ? SANDBOX_BOUNDARY_FINALIZATION_PROMPT : undefined,
@@ -1542,7 +1566,8 @@ export class AiSdkTurn {
                             // more step; with the send-level budget already spent there is
                             // nothing left to grant it, so the error is terminal.
                             const stepBudgetRemains = maxSteps === undefined || runtimeSteps < maxSteps;
-                            const recovered = stepBudgetRemains &&
+                            const recovered = !preservingUnknownHistory &&
+                                stepBudgetRemains &&
                                 failure.kind === 'context_overflow' &&
                                 providerAttempt < MAX_PROVIDER_ATTEMPTS_PER_STEP &&
                                 attemptHasNoObservableOutput()
@@ -2218,7 +2243,7 @@ export class AiSdkTurn {
         return this.deps.modelAdapter.makeErrorEvent(turnId, err, reasonOverride);
     }
     /** Materialize canonical RuntimeEvent history into ai-sdk's message format. */
-    async buildPriorMessages(input) {
+    async buildPriorMessages(input, priorUnknownProjection) {
         if (!input.runtimeContext) {
             return {
                 status: 'ready',
@@ -2236,26 +2261,57 @@ export class AiSdkTurn {
         // the durable projection-transition reducer (#4283). Replay, budgeting and
         // compaction share one input, so no RuntimeEvent replay path can resurrect
         // content a committed transition removed.
-        const preparedContextBudget = await this.deps.compaction.prepareContextBudgetPolicy(rawPriorRuntimeContext, input.turnId);
-        const priorRuntimeContext = preparedContextBudget.events;
-        const providerReasoningReplayEventIds = compatibleProviderReasoningReplayEventIds(priorRuntimeContext, input.runtimeContextInvocations, this.deps.backend.providerStateIdentity, this.deps.backend.modelId);
-        let contextBudget = preparedContextBudget.policy;
-        // Match the durable checkpoint against the RAW ledger prefix: every
-        // creation path (standalone compactHistory and the mid-turn state) pins
-        // its coverage digest on raw events, so matching the folded view here
-        // lets any durable projection transition inside the covered prefix orphan
-        // the checkpoint and silently fail open into a full-history replay
-        // (#4842). The projected [block, tail] is then folded through the
-        // transition reducer before it becomes messages, so a committed
-        // transition still cannot resurrect content for the model (#4283).
-        const budgeted = applyRuntimeEventContextBudget(rawPriorRuntimeContext, contextBudget);
-        let runtimeContext = await this.deps.compaction.foldEffectiveModelHistory(budgeted?.events ?? rawPriorRuntimeContext, preparedContextBudget.projectionSnapshot);
-        let contextBudgetDiagnostic = budgeted?.diagnostic;
-        let projectedHistoryCompactCheckpoint = budgeted?.historyCompactCheckpoint;
-        if (preparedContextBudget.diagnosticPatch) {
-            contextBudgetDiagnostic = mergeContextBudgetDiagnostic(contextBudgetDiagnostic ??
-                buildContextBudgetDiagnosticShell(priorRuntimeContext, runtimeContext, contextBudget), preparedContextBudget.diagnosticPatch);
+        const preservingUnknownHistory = priorUnknownProjection.kind === 'projected';
+        let priorRuntimeContext;
+        let runtimeContext;
+        let contextBudget;
+        let contextBudgetDiagnostic;
+        let projectedHistoryCompactCheckpoint;
+        if (priorUnknownProjection.kind === 'projected') {
+            const preparedContextBudget = await this.deps.compaction.prepareContextBudgetPolicy(rawPriorRuntimeContext, input.turnId);
+            priorRuntimeContext = preparedContextBudget.events;
+            contextBudget = preparedContextBudget.policy;
+            const budgeted = applyRuntimeEventContextBudget(rawPriorRuntimeContext, contextBudget);
+            const budgetedEvents = budgeted?.events ?? rawPriorRuntimeContext;
+            const preservesUnknownCalls = priorUnknownProjection.outcomes.every((outcome) => budgetedEvents.some((event) => event.id === outcome.callEventId));
+            // Existing checkpoints and durable result pruning are safe when they
+            // leave every unknown call available to pair with its temporary result.
+            // Otherwise replay the full effective ledger: a summary that erases T1
+            // would make the request-local T2 orphaned or hide the uncertainty.
+            const selectedEvents = preservesUnknownCalls ? budgetedEvents : rawPriorRuntimeContext;
+            const effectiveEvents = await this.deps.compaction.foldEffectiveModelHistory(selectedEvents, preparedContextBudget.projectionSnapshot);
+            runtimeContext = appendPriorUnknownToolResponses(effectiveEvents, priorUnknownProjection);
+            if (preservesUnknownCalls) {
+                contextBudgetDiagnostic = budgeted?.diagnostic;
+                projectedHistoryCompactCheckpoint = budgeted?.historyCompactCheckpoint;
+            }
+            if (preparedContextBudget.diagnosticPatch) {
+                contextBudgetDiagnostic = mergeContextBudgetDiagnostic(contextBudgetDiagnostic ??
+                    buildContextBudgetDiagnosticShell(priorRuntimeContext, effectiveEvents, contextBudget), preparedContextBudget.diagnosticPatch);
+            }
+        }
+        else {
+            const preparedContextBudget = await this.deps.compaction.prepareContextBudgetPolicy(rawPriorRuntimeContext, input.turnId);
+            priorRuntimeContext = preparedContextBudget.events;
+            contextBudget = preparedContextBudget.policy;
+            // Match the durable checkpoint against the RAW ledger prefix: every
+            // creation path (standalone compactHistory and the mid-turn state) pins
+            // its coverage digest on raw events, so matching the folded view here
+            // lets any durable projection transition inside the covered prefix orphan
+            // the checkpoint and silently fail open into a full-history replay
+            // (#4842). The projected [block, tail] is then folded through the
+            // transition reducer before it becomes messages, so a committed
+            // transition still cannot resurrect content for the model (#4283).
+            const budgeted = applyRuntimeEventContextBudget(rawPriorRuntimeContext, contextBudget);
+            runtimeContext = await this.deps.compaction.foldEffectiveModelHistory(budgeted?.events ?? rawPriorRuntimeContext, preparedContextBudget.projectionSnapshot);
+            contextBudgetDiagnostic = budgeted?.diagnostic;
+            projectedHistoryCompactCheckpoint = budgeted?.historyCompactCheckpoint;
+            if (preparedContextBudget.diagnosticPatch) {
+                contextBudgetDiagnostic = mergeContextBudgetDiagnostic(contextBudgetDiagnostic ??
+                    buildContextBudgetDiagnosticShell(priorRuntimeContext, runtimeContext, contextBudget), preparedContextBudget.diagnosticPatch);
+            }
         }
+        const providerReasoningReplayEventIds = compatibleProviderReasoningReplayEventIds(priorRuntimeContext, input.runtimeContextInvocations, this.deps.backend.providerStateIdentity, this.deps.backend.modelId);
         // No pre-turn estimate gate: the turn's first request is judged by the
         // request-projection hook from the previous request's real usage, and by
         // the provider when it goes out (#4559).

package/node_modules/@maka/runtime/dist/bots/proxied-fetch.js

@@ -25,14 +25,14 @@ const DEFAULT_TIMEOUT_MS = 15_000;
 export async function proxiedFetch(input, init = {}) {
     const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
     const proxy = resolveActiveProxy();
+    const { timeoutMs = DEFAULT_TIMEOUT_MS, signal, ...fetchInit } = init;
+    const controller = new AbortController();
+    const requestSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
     let dispatcher;
     if (proxy && !matchesBypassList(new URL(url).hostname, proxy.bypassList)) {
-        dispatcher = buildProxyDispatcher(proxy);
+        dispatcher = buildProxyDispatcher(proxy, requestSignal);
     }
-    const { timeoutMs = DEFAULT_TIMEOUT_MS, signal, ...fetchInit } = init;
     const timeoutEnabled = timeoutMs > 0;
-    const controller = new AbortController();
-    const requestSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
     let timedOut = false;
     const disposeDispatcher = async (force = false) => {
         const disposable = dispatcher;
@@ -70,6 +70,7 @@ export async function proxiedFetch(input, init = {}) {
     catch (error) {
         if (timer)
             clearTimeout(timer);
+        controller.abort(error);
         await disposeDispatcher(timedOut);
         throw error;
     }