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

package/node_modules/@maka/runtime/dist/memory-extraction.js

@@ -369,7 +369,7 @@ export class MemoryExtractionEngine {
                     return undefined;
                 maximumSplitIndex = requestedTurnStart;
             }
-            const split = memoryRangeSplitCandidates(pendingEntries, maximumSplitIndex).find(({ first, second }) => {
+            const split = findMemoryRangeSplit(pendingEntries, maximumSplitIndex, ({ first, second }) => {
                 const firstThroughOrdinal = first.at(-1).ordinal;
                 const firstTrigger = 'extract';
                 const firstPrepared = this.prepareRange({
@@ -924,9 +924,9 @@ function memorySegmentOperationId(operationId, afterOrdinal, throughOrdinal, por
         .update(JSON.stringify({ operationId, afterOrdinal, throughOrdinal }))
         .digest('hex')}`;
 }
-function memoryRangeSplitCandidates(entries, maximumSplitIndex = entries.length - 1) {
+function findMemoryRangeSplit(entries, maximumSplitIndex = entries.length - 1, accepts) {
     if (entries.length < 2)
-        return [];
+        return undefined;
     const weights = entries.map(memoryRangeEventWeight);
     const total = weights.reduce((sum, weight) => sum + weight, 0);
     let prefix = 0;
@@ -942,11 +942,16 @@ function memoryRangeSplitCandidates(entries, maximumSplitIndex = entries.length
         };
     })
         .filter(({ index }) => index <= maximumSplitIndex);
-    return candidates
-        .sort((left, right) => Number(right.turnBoundary) - Number(left.turnBoundary) ||
+    candidates.sort((left, right) => Number(right.turnBoundary) - Number(left.turnBoundary) ||
         left.distance - right.distance ||
-        left.index - right.index)
-        .map(({ index }) => ({ first: entries.slice(0, index), second: entries.slice(index) }));
+        left.index - right.index);
+    // Keep only the candidate being checked; each pair copies the entire range.
+    for (const { index } of candidates) {
+        const split = { first: entries.slice(0, index), second: entries.slice(index) };
+        if (accepts(split))
+            return split;
+    }
+    return undefined;
 }
 function preparedMemoryRangeFits(prepared, trigger) {
     if (!prepared)
@@ -954,17 +959,6 @@ function preparedMemoryRangeFits(prepared, trigger) {
     return ((prepared.coverage.evidence.length === 0 && trigger !== 'remember') ||
         memoryRequestFits(prepared.snapshot, prepared.firstPrompt, 'proposal'));
 }
-function memoryRangeEventWeight({ event }) {
-    if (!event.partial &&
-        event.content?.kind === 'text' &&
-        ((event.role === 'user' && event.author === 'user') ||
-            (event.role === 'model' && event.author === 'agent'))) {
-        // Text appears once in the interpretation messages and, for user text, once
-        // more in the bounded evidence index when it cannot be referenced by position.
-        return Math.max(1, event.content.text.length * (event.role === 'user' ? 2 : 1));
-    }
-    return 1;
-}
 function memoryRequestFits(snapshot, prompt, stage) {
     const contextWindow = snapshot.sourceContextWindowTokens;
     if (contextWindow === undefined)
@@ -1026,6 +1020,17 @@ function safeJsonLength(value) {
         return Number.MAX_SAFE_INTEGER;
     }
 }
+function memoryRangeEventWeight({ event }) {
+    if (!event.partial &&
+        event.content?.kind === 'text' &&
+        ((event.role === 'user' && event.author === 'user') ||
+            (event.role === 'model' && event.author === 'agent'))) {
+        // Text appears once in the interpretation messages and, for user text, once
+        // more in the bounded evidence index when it cannot be referenced by position.
+        return Math.max(1, event.content.text.length * (event.role === 'user' ? 2 : 1));
+    }
+    return 1;
+}
 function memoryEvidenceContainsSensitiveText(evidence) {
     return evidence.some(({ events }) => events.some(({ content }) => content?.kind === 'text' && redactSecrets(content.text) !== content.text));
 }

package/node_modules/@maka/runtime/dist/message-authority.js

@@ -28,6 +28,15 @@ export function isRuntimeHostedRootAuthority(authority) {
 export class RuntimeMessageAuthorityInvariantError extends Error {
     name = 'RuntimeMessageAuthorityInvariantError';
 }
+/**
+ * The id a Root Turn's admitted prompt is durable under. A Root folded from
+ * several queued Messages carries no single Message identity, so the id comes
+ * from the Run instead — one rule, so the run that writes the prompt and the
+ * recovery that rewrites it derive the same id and the store dedupes.
+ */
+export function admittedPromptEventId(runId, userMessageId) {
+    return userMessageId ?? `${runId}-admitted-prompt`;
+}
 export class RuntimeHostedRootConflictError extends Error {
     name = 'RuntimeHostedRootConflictError';
     code = 'session_busy';

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

@@ -20,11 +20,11 @@ import { openai } from '@ai-sdk/openai';
 import { anthropic } from '@ai-sdk/anthropic';
 import { providerAuthRequiresSecret, } from '@maka/core/llm-connections';
 import { lookupModelMetadata } from '@maka/core/model-metadata';
-import { generalizedErrorMessage } from '@maka/core/redaction';
 import { rawFinishReasonString } from './model-protocol.js';
 import { resolveModelRuntime } from './model-runtime.js';
 import { plaintextResponsesReasoningProviderOptions, safePlaintextResponsesReasoningItemId, } from './responses-reasoning-state.js';
-import { classifyError, errorPresentationFromClass, providerFailureSummary, providerRetryMetadata, } from './provider-error-classification.js';
+import { classifyError, providerModelFailure } from './provider-error-classification.js';
+import { withProviderStreamTracking, } from './provider-request-telemetry.js';
 import { createOpenAiChatReasoningTransportState, openAiChatReasoningFieldProviderOptions, restoreOpenAiChatEmptyReasoning, } from './openai-chat-reasoning-transport.js';
 import { mergeOpenAiResponsesProviderOptions, planOpenAiResponsesContinuation, } from './openai-responses-continuation.js';
 import { createOpenAiResponsesTransportState, OPENAI_RESPONSES_LANE_HEADER, } from './openai-responses-websocket.js';
@@ -37,7 +37,7 @@ export class ModelAdapter {
     openAiResponsesTransportState;
     constructor(input) {
         this.input = input;
-        this.runtime = resolveModelRuntime(input.connection, input.modelId);
+        this.runtime = input.resolvedRuntime ?? resolveModelRuntime(input.connection, input.modelId);
         this.openAiChatReasoningTransportState = createOpenAiChatReasoningTransportState(this.runtime.reasoningReplay.kind === 'openai-chat-plaintext'
             ? this.runtime.reasoningReplay.requestField
             : 'observed');
@@ -79,6 +79,7 @@ export class ModelAdapter {
             throw new Error(`No API key stored for connection "${this.input.connection.slug}"`);
         }
         return this.input.modelFactory({
+            sessionId: this.input.sessionId,
             connection: this.input.connection,
             apiKey: this.input.apiKey,
             modelId: this.input.modelId,
@@ -101,20 +102,14 @@ export class ModelAdapter {
         const { streamText, wrapLanguageModel } = ai;
         const maxOutputTokens = selectedModelMaxOutputTokens(this.input.connection, this.input.modelId, this.input.providerOptions, this.runtime);
         const trackedModel = input.providerRequestTracker
-            ? wrapLanguageModel({
+            ? withProviderStreamTracking({
                 model: input.model,
-                middleware: {
-                    wrapStream: async ({ doStream, params, model }) => await input.providerRequestTracker.trackStream({
-                        providerId: model.provider,
-                        modelId: model.modelId,
-                        params,
-                        abortSignal: input.abortSignal,
-                        doStream,
-                        ...(input.historyCompactBoundary
-                            ? { historyCompactBoundary: input.historyCompactBoundary }
-                            : {}),
-                    }),
-                },
+                wrapLanguageModel,
+                tracker: input.providerRequestTracker,
+                abortSignal: input.abortSignal,
+                ...(input.historyCompactBoundary
+                    ? { historyCompactBoundary: input.historyCompactBoundary }
+                    : {}),
             })
             : input.model;
         const usesOpenAiResponsesAdapter = hasOpenAiResponsesAdapter(this.runtime);
@@ -344,7 +339,7 @@ export class ModelAdapter {
             : undefined, this.runtime);
     }
     makeErrorEvent(turnId, err, reasonOverride) {
-        const failure = normalizeModelFailure(err);
+        const failure = normalizeProviderFailure(err);
         return {
             type: 'error',
             id: this.input.newId(),
@@ -354,7 +349,7 @@ export class ModelAdapter {
             ...(failure.code !== undefined ? { code: failure.code } : {}),
             ...(reasonOverride !== undefined
                 ? { reason: reasonOverride }
-                : failure.kind !== 'abort' && failure.kind !== 'unknown'
+                : failure.kind !== 'abort'
                     ? { reason: failure.kind }
                     : {}),
             message: failure.message,
@@ -365,7 +360,7 @@ export class ModelAdapter {
     }
     classifyError(error) {
         if (isModelFailure(error))
-            return errorClassFromFailureKind(error.kind);
+            return error.kind;
         return classifyError(error);
     }
     /** Map a successfully settled provider step to its runtime stop reason. */
@@ -385,19 +380,20 @@ export class ModelAdapter {
 export function settleModelStepOutcome(evidence) {
     const { aborted, failure, sawFinish, finishReason, rawFinishReason, usage, request } = evidence;
     if (aborted || failure?.kind === 'abort') {
-        return failedStepOutcome('aborted', failure ?? normalizeModelFailure(Object.assign(new Error('aborted'), { name: 'AbortError' })), request, usage);
+        return failedStepOutcome('aborted', failure ??
+            normalizeProviderFailure(Object.assign(new Error('aborted'), { name: 'AbortError' })), request, usage);
     }
     if (failure) {
-        return failedStepOutcome(failure.retryable ? 'retryable-failure' : 'terminal-failure', failure, request, usage);
+        return failedStepOutcome('failed', failure, request, usage);
     }
     if (!sawFinish || finishReason === 'other' || finishReason === 'unknown') {
-        return failedStepOutcome('truncated', modelStepFailure('provider_unavailable', `Provider stream ended without finishing (${finishReason})`), request, usage);
+        return failedStepOutcome('truncated', modelStepFailure('stream_truncated', `Provider stream ended without finishing (${finishReason})`), request, usage);
     }
     if (finishReason === 'content-filter' || finishReason === 'error') {
         const terminalFailure = finishReason === 'error'
             ? providerFinishFailure(rawFinishReason)
             : modelStepFailure('unknown', 'Provider stopped the stream on a content filter');
-        return failedStepOutcome(terminalFailure.retryable ? 'retryable-failure' : 'terminal-failure', terminalFailure, request, usage);
+        return failedStepOutcome('failed', terminalFailure, request, usage);
     }
     return {
         kind: 'completed',
@@ -440,15 +436,25 @@ function failedStepOutcome(kind, failure, request, usage) {
 function selectedModelMaxOutputTokens(connection, modelId, providerOptions, runtime) {
     const anthropicMessages = runtime.wire === 'anthropic-messages';
     const kimiOpenAiChat = connection.providerType === 'kimi-coding-plan' && runtime.wire === 'openai-chat';
-    if (!anthropicMessages && !kimiOpenAiChat)
+    const requestedBudget = connection.modelOverrides?.[modelId]?.maxOutputTokens;
+    if (requestedBudget === undefined && !anthropicMessages && !kimiOpenAiChat)
         return undefined;
-    const wireOutputLimit = connection.models?.find((model) => model.id === modelId)?.maxOutputTokens ??
+    const capacity = connection.models?.find((model) => model.id === modelId)?.maxOutputTokens ??
         lookupModelMetadata(connection.providerType, modelId).maxOutputTokens;
+    const wireOutputLimit = requestedBudget === undefined
+        ? capacity
+        : capacity === undefined
+            ? requestedBudget
+            : Math.min(requestedBudget, capacity);
     if (wireOutputLimit === undefined)
         return undefined;
-    return anthropicMessages
+    const outputTokens = anthropicMessages
         ? wireOutputLimit - fixedAnthropicThinkingBudget(providerOptions)
         : wireOutputLimit;
+    if (outputTokens <= 0) {
+        throw new Error('Output budget must exceed the fixed thinking budget. Increase the output limit or reduce thinking.');
+    }
+    return outputTokens;
 }
 function usesNativeOpenAiResponses(connection, runtime) {
     return connection.providerType === 'openai' && runtime.wire === 'openai-responses';
@@ -513,6 +519,18 @@ function reasoningSignatureFromChunk(chunk) {
     const signature = anthropic.signature;
     return typeof signature === 'string' && signature.length > 0 ? signature : undefined;
 }
+function anthropicRedactedThinkingProviderOptionsFromChunk(chunk) {
+    const meta = chunk.providerMetadata;
+    if (!meta || typeof meta !== 'object' || Array.isArray(meta))
+        return undefined;
+    const anthropic = meta.anthropic;
+    if (!anthropic || typeof anthropic !== 'object' || Array.isArray(anthropic))
+        return undefined;
+    const redactedData = anthropic.redactedData;
+    return typeof redactedData === 'string'
+        ? meta
+        : undefined;
+}
 function openAiResponsesReasoningProviderOptionsFromChunk(chunk, runtime) {
     const meta = chunk.providerMetadata;
     if (runtime.reasoningReplay.kind === 'responses' &&
@@ -597,12 +615,10 @@ function plaintextSummaryTextFromChunk(chunk, runtime) {
         : undefined;
     return plaintextSummaryParts(provider)?.join('');
 }
-function plaintextSummaryItemIdFromChunk(chunk, runtime) {
-    if (runtime?.reasoningReplay.kind !== 'responses' ||
-        runtime.reasoningReplay.contract.reasoningReplay !== 'plaintext-summary') {
-        return undefined;
-    }
-    return safePlaintextResponsesReasoningItemId(chunk.id);
+function reasoningPartIdFromChunk(chunk) {
+    return typeof chunk.id === 'string' && chunk.id.length > 0 && chunk.id.length <= 512
+        ? chunk.id
+        : undefined;
 }
 /**
  * Translate one raw AI SDK stream chunk into zero or more Maka-owned
@@ -612,22 +628,48 @@ function plaintextSummaryItemIdFromChunk(chunk, runtime) {
 function translateChunk(chunk, openAiChatReasoningTransportState, runtime, runtimeToolName) {
     switch (chunk.type) {
         case 'reasoning-start': {
-            const reasoningItemId = plaintextSummaryItemIdFromChunk(chunk, runtime);
-            return reasoningItemId ? [{ kind: 'thinking', text: '', reasoningItemId }] : [];
+            const reasoningPartId = reasoningPartIdFromChunk(chunk);
+            const redactedThinkingProviderOptions = anthropicRedactedThinkingProviderOptionsFromChunk(chunk);
+            return [
+                {
+                    kind: 'thinking-start',
+                    ...(redactedThinkingProviderOptions
+                        ? { providerOptions: redactedThinkingProviderOptions }
+                        : {}),
+                    ...(reasoningPartId ? { reasoningPartId } : {}),
+                },
+            ];
+        }
+        case 'text-start': {
+            const providerOptions = chunk.providerMetadata && typeof chunk.providerMetadata === 'object'
+                ? chunk.providerMetadata
+                : undefined;
+            const providerItemBoundary = runtime !== undefined &&
+                hasOpenAiResponsesAdapter(runtime) &&
+                providerOptions !== undefined;
+            return [
+                {
+                    kind: 'text-start',
+                    ...(providerItemBoundary ? { providerItemBoundary: true } : {}),
+                },
+            ];
         }
-        case 'text-start':
-            return [{ kind: 'text-start' }];
         case 'text-delta': {
             const text = chunk.text ?? chunk.textDelta ?? chunk.delta ?? '';
             return text ? [{ kind: 'text', text }] : [];
         }
         case 'text-end': {
-            if (!chunk.providerMetadata || typeof chunk.providerMetadata !== 'object')
-                return [];
+            const providerOptions = chunk.providerMetadata && typeof chunk.providerMetadata === 'object'
+                ? chunk.providerMetadata
+                : undefined;
+            const providerItemBoundary = runtime !== undefined &&
+                hasOpenAiResponsesAdapter(runtime) &&
+                providerOptions !== undefined;
             return [
                 {
-                    kind: 'text-metadata',
-                    providerOptions: chunk.providerMetadata,
+                    kind: 'text-end',
+                    ...(providerOptions !== undefined ? { providerOptions } : {}),
+                    ...(providerItemBoundary ? { providerItemBoundary: true } : {}),
                 },
             ];
         }
@@ -644,11 +686,16 @@ function translateChunk(chunk, openAiChatReasoningTransportState, runtime, runti
             const responsesProviderOptions = runtime
                 ? openAiResponsesReasoningProviderOptionsFromChunk(chunk, runtime)
                 : undefined;
-            const reasoningItemId = plaintextSummaryItemIdFromChunk(chunk, runtime);
+            const reasoningPartId = reasoningPartIdFromChunk(chunk);
             const reasoningSummaryText = plaintextSummaryTextFromChunk(chunk, runtime);
             const events = [];
-            if (signature)
-                events.push({ kind: 'thinking-signature', signature });
+            if (signature) {
+                events.push({
+                    kind: 'thinking-signature',
+                    signature,
+                    ...(reasoningPartId ? { reasoningPartId } : {}),
+                });
+            }
             // The signed reasoning chunk arrives as a standalone delta with empty
             // text; preserve provider-authored empty reasoning, but do not surface a
             // signature-only carrier as an additional empty reasoning fragment.
@@ -664,7 +711,7 @@ function translateChunk(chunk, openAiChatReasoningTransportState, runtime, runti
                                 providerOptionsOrigin: 'maka_transport',
                             }
                             : {}),
-                    ...(reasoningItemId ? { reasoningItemId } : {}),
+                    ...(reasoningPartId ? { reasoningPartId } : {}),
                     ...(reasoningSummaryText !== undefined ? { reasoningSummaryText } : {}),
                 });
             }
@@ -675,17 +722,25 @@ function translateChunk(chunk, openAiChatReasoningTransportState, runtime, runti
             const responsesProviderOptions = runtime
                 ? openAiResponsesReasoningProviderOptionsFromChunk(chunk, runtime)
                 : undefined;
-            const reasoningItemId = plaintextSummaryItemIdFromChunk(chunk, runtime);
+            const reasoningPartId = reasoningPartIdFromChunk(chunk);
             const reasoningSummaryText = plaintextSummaryTextFromChunk(chunk, runtime);
             return [
-                ...(signature ? [{ kind: 'thinking-signature', signature }] : []),
+                ...(signature
+                    ? [
+                        {
+                            kind: 'thinking-signature',
+                            signature,
+                            ...(reasoningPartId ? { reasoningPartId } : {}),
+                        },
+                    ]
+                    : []),
                 ...(responsesProviderOptions
                     ? [
                         {
                             kind: 'thinking',
                             text: '',
                             providerOptions: responsesProviderOptions,
-                            ...(reasoningItemId ? { reasoningItemId } : {}),
+                            ...(reasoningPartId ? { reasoningPartId } : {}),
                             ...(reasoningSummaryText !== undefined ? { reasoningSummaryText } : {}),
                         },
                     ]
@@ -838,34 +893,8 @@ function compileProviderTool(tool) {
             });
     }
 }
-function normalizeModelFailure(error) {
-    if (isModelFailure(error))
-        return error;
-    const errorClass = classifyError(error);
-    const presentation = errorPresentationFromClass(errorClass);
-    const retry = providerRetryMetadata(error);
-    const code = error instanceof Error && 'code' in error
-        ? String(error.code)
-        : undefined;
-    return {
-        type: 'model_failure',
-        kind: modelFailureKind(errorClass),
-        retryable: retry.retryable,
-        ...(retry.retryAfterMs !== undefined ? { retryAfterMs: retry.retryAfterMs } : {}),
-        ...(code !== undefined ? { code } : {}),
-        message: presentation.message ?? generalizedErrorMessage(error),
-    };
-}
 function normalizeProviderFailure(error) {
-    if (isModelFailure(error))
-        return error;
-    const summary = providerFailureSummary(error);
-    const failure = normalizeModelFailure(error);
-    return {
-        ...failure,
-        ...(summary?.code !== undefined ? { code: summary.code } : {}),
-        ...(failure.kind === 'unknown' && summary !== undefined ? { message: summary.message } : {}),
-    };
+    return isModelFailure(error) ? error : providerModelFailure(error);
 }
 function isModelFailure(value) {
     return (typeof value === 'object' &&
@@ -874,54 +903,6 @@ function isModelFailure(value) {
         typeof value.kind === 'string' &&
         typeof value.message === 'string');
 }
-function modelFailureKind(errorClass) {
-    switch (errorClass) {
-        case 'Abort':
-            return 'abort';
-        case 'Auth':
-            return 'auth';
-        case 'ContextLength':
-            return 'context_overflow';
-        case 'Network':
-            return 'network';
-        case 'ProviderBilling':
-            return 'provider_billing';
-        case 'ProviderCapacity':
-            return 'provider_capacity';
-        case 'ProviderUnavailable':
-            return 'provider_unavailable';
-        case 'RateLimit':
-            return 'rate_limit';
-        case 'Timeout':
-            return 'timeout';
-        default:
-            return 'unknown';
-    }
-}
-function errorClassFromFailureKind(kind) {
-    switch (kind) {
-        case 'abort':
-            return 'Abort';
-        case 'auth':
-            return 'Auth';
-        case 'context_overflow':
-            return 'ContextLength';
-        case 'network':
-            return 'Network';
-        case 'provider_billing':
-            return 'ProviderBilling';
-        case 'provider_capacity':
-            return 'ProviderCapacity';
-        case 'provider_unavailable':
-            return 'ProviderUnavailable';
-        case 'rate_limit':
-            return 'RateLimit';
-        case 'timeout':
-            return 'Timeout';
-        case 'unknown':
-            return 'Other';
-    }
-}
 export function normalizeAiSdkUsage(usage, options = {}) {
     if (!usage)
         return undefined;