maka-agent 0.2.0-dev.12.20260901 → 0.2.0-dev.14.20260902

package/node_modules/@maka/core/dist/runtime-policy/connection-catalog-codec.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { isModelModality, isRelayProviderType, PROVIDER_REGISTRY, providerDefaultsOf, validateSlug, } from '../llm-connections.js';
+import { isModelModality, isRelayProviderType, effectiveBaseUrl, PROVIDER_REGISTRY, providerDefaultsOf, validateSlug, } from '../llm-connections.js';
 import { CONNECTION_MODEL_DESCRIPTION_MAX_LENGTH, CONNECTION_MODEL_DISPLAY_NAME_MAX_LENGTH, MAX_PREPENDED_FALLBACK_MODELS, } from '../model-catalog.js';
 import { DECLARABLE_RELAY_THINKING_LEVELS, isThinkingLevel, } from '../model-thinking.js';
 import { normalizeOptionalRequestBodyOverlay, RequestCustomizationValidationError, } from '../request-customization.js';
@@ -338,6 +338,55 @@ export function decodeConnectionVersionBasis(value) {
         revision: positiveRevisionValue(item.revision, 'connection revision'),
     };
 }
+export function canonicalConnectionEffectiveBaseUrl(connection) {
+    const endpoint = effectiveBaseUrl(connection);
+    try {
+        return new URL(endpoint).toString();
+    }
+    catch {
+        throw domainError('connection has an invalid effective base URL');
+    }
+}
+export function connectionCredentialTarget(connection) {
+    return {
+        connectionId: connection.connectionId,
+        revision: connection.revision,
+        slug: connection.slug,
+        providerType: connection.providerType,
+        effectiveBaseUrl: canonicalConnectionEffectiveBaseUrl(connection),
+    };
+}
+export function decodeConnectionCredentialTarget(value) {
+    const item = exactRecord(value, 'connection credential target', [
+        'connectionId',
+        'revision',
+        'slug',
+        'providerType',
+        'effectiveBaseUrl',
+    ]);
+    const version = decodeConnectionVersionBasis({
+        connectionId: item.connectionId,
+        revision: item.revision,
+    });
+    const providerType = decodeProviderType(item.providerType);
+    const effectiveBaseUrl = stringValue(item.effectiveBaseUrl, 'connection credential target effective base URL', 2_048);
+    let canonical;
+    try {
+        canonical = new URL(effectiveBaseUrl).toString();
+    }
+    catch {
+        throw domainError('connection credential target effective base URL must be valid');
+    }
+    if (canonical !== effectiveBaseUrl) {
+        throw domainError('connection credential target effective base URL must be canonical');
+    }
+    return {
+        ...version,
+        slug: decodeConnectionSlug(item.slug),
+        providerType,
+        effectiveBaseUrl,
+    };
+}
 export function decodeConnectionTarget(value) {
     const item = exactRecord(value, 'connection target', ['connectionId', 'modelId']);
     return {

package/node_modules/@maka/core/dist/runtime-policy/credential-vault-codec.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { decodeConnectionCredentialTarget } from './connection-catalog-codec.js';
 import { WEB_SEARCH_CREDENTIAL_PROVIDERS } from '../web-search.js';
 import { parseRequestHeaders, RequestCustomizationValidationError, serializeRequestHeaders, } from '../request-customization.js';
 import { domainError, entityIdValue, exactRecord, integerValue, positiveRevisionValue, } from './domain-codec.js';
@@ -96,7 +97,7 @@ export function decodeCredentialStatus(value) {
     throw domainError('credential status configured flag is invalid');
 }
 export function normalizeSetCredentialInput(value) {
-    const input = exactRecord(value, 'set credential input', ['locator', 'expected', 'secret']);
+    const input = exactRecord(value, 'set credential input', ['locator', 'expected', 'expectedConnection', 'secret'], ['locator', 'expected', 'secret']);
     let expected;
     if (input.expected === null) {
         expected = null;
@@ -112,10 +113,17 @@ export function normalizeSetCredentialInput(value) {
         };
     }
     const locator = decodeCredentialLocator(input.locator);
+    const expectedConnection = input.expectedConnection === undefined
+        ? undefined
+        : decodeConnectionCredentialTarget(input.expectedConnection);
+    if (expectedConnection && locator.scope !== 'connection') {
+        throw domainError('only connection credentials accept a connection target basis');
+    }
     const secret = normalizeCredentialSecret(input.secret);
     return {
         locator,
         expected,
+        ...(expectedConnection === undefined ? {} : { expectedConnection }),
         secret: locator.scope === 'connection' && locator.kind === 'request_headers'
             ? normalizeRequestHeadersSecret(secret)
             : secret,

package/node_modules/@maka/core/dist/runtime-policy/model-catalog-entry-codec.js

@@ -36,7 +36,15 @@ export function decodeModelCatalogEntry(value) {
         'thinkingLevels',
         'contextWindow',
         'knowledgeCutoff',
-    ], ['id', 'canUseAsChatDefault', 'isDefault', 'supportsVision', 'thinkingLevels']);
+        'describedByMetadata',
+    ], [
+        'id',
+        'canUseAsChatDefault',
+        'isDefault',
+        'supportsVision',
+        'thinkingLevels',
+        'describedByMetadata',
+    ]);
     // The fields an entry shares with a stored model row keep one decoder, so a
     // bound that moves moves for both. `decodeConnectionModel` rejects unknown
     // fields, so it is handed exactly the subset it owns.
@@ -50,6 +58,7 @@ export function decodeModelCatalogEntry(value) {
         isDefault: booleanValue(item.isDefault, 'entry default flag'),
         supportsVision: booleanValue(item.supportsVision, 'entry vision support'),
         thinkingLevels: decodeThinkingLevels(item.thinkingLevels),
+        describedByMetadata: booleanValue(item.describedByMetadata, 'entry metadata coverage'),
     };
 }
 function decodeThinkingLevels(value) {

package/node_modules/@maka/core/dist/runtime-policy/policy-codec.js

@@ -19,6 +19,7 @@
 import { isThinkingLevel } from '../model-thinking.js';
 import { CHAT_DEFAULT_PERMISSION_MODES } from '../settings.js';
 import { normalizeSubagentSettings } from '../subagent-settings.js';
+import { decodeCredentialVersionBasis, normalizeCredentialSecret, } from './credential-vault-codec.js';
 import { WEB_SEARCH_PROVIDERS } from '../web-search.js';
 import { assertCanonicalValue, booleanValue, domainError, exactRecord, integerValue, revisionValue, stringArrayValue, stringValue, } from './domain-codec.js';
 export function decodeCanonicalRuntimePolicy(value) {
@@ -50,6 +51,80 @@ export function normalizeRuntimePolicyMutation(value) {
         operation: normalizeMutationOperation(operation),
     };
 }
+export function normalizeNetworkProxyUpdate(value) {
+    const input = exactRecord(value, 'network proxy update', [
+        'expectedPolicyRevision',
+        'expectedCredential',
+        'networkProxy',
+        'credential',
+    ]);
+    const expectedCredential = input.expectedCredential === null
+        ? null
+        : decodeCredentialVersionBasis(input.expectedCredential);
+    if (expectedCredential !== null && expectedCredential.locator.scope !== 'network_proxy') {
+        throw domainError('network proxy update requires a network proxy credential basis');
+    }
+    const credential = normalizeNetworkProxyCredentialUpdate(input.credential);
+    const networkProxy = normalizeNetworkProxy(input.networkProxy);
+    if (!networkProxy.authEnabled && credential.kind !== 'delete') {
+        throw domainError('disabled proxy authentication requires credential deletion');
+    }
+    return {
+        expectedPolicyRevision: revisionValue(input.expectedPolicyRevision, 'network proxy expected policy revision'),
+        expectedCredential,
+        networkProxy,
+        credential,
+    };
+}
+function normalizeNetworkProxyCredentialUpdate(value) {
+    const base = exactRecord(value, 'network proxy credential update', ['kind', 'secret', 'expectedTarget'], ['kind']);
+    switch (base.kind) {
+        case 'keep':
+        case 'delete': {
+            exactRecord(value, `network proxy credential ${base.kind}`, ['kind']);
+            return { kind: base.kind };
+        }
+        case 'replace': {
+            const replacement = exactRecord(value, 'network proxy credential replacement', ['kind', 'secret', 'expectedTarget'], ['kind', 'secret']);
+            return {
+                kind: 'replace',
+                secret: normalizeCredentialSecret(replacement.secret),
+                ...(replacement.expectedTarget === undefined
+                    ? {}
+                    : {
+                        expectedTarget: normalizeNetworkProxyCredentialTarget(replacement.expectedTarget),
+                    }),
+            };
+        }
+        default:
+            throw domainError(`network proxy credential update '${String(base.kind)}' is unknown`);
+    }
+}
+export function normalizeNetworkProxyCredentialTarget(value) {
+    const item = exactRecord(value, 'network proxy credential target', [
+        'protocol',
+        'host',
+        'port',
+        'username',
+    ]);
+    if (item.protocol !== 'http' && item.protocol !== 'https' && item.protocol !== 'socks5') {
+        throw domainError('network proxy credential target protocol is invalid');
+    }
+    const rawHost = stringValue(item.host, 'network proxy credential target host', 255);
+    if (/[\u0000-\u001f\u007f-\u009f]/.test(rawHost)) {
+        throw domainError('network proxy credential target host must not contain control characters');
+    }
+    const host = rawHost.trim().toLowerCase();
+    if (host.length === 0) {
+        throw domainError('network proxy credential target host must not be empty');
+    }
+    return {
+        protocol: item.protocol,
+        host,
+        port: integerValue(item.port, 'network proxy credential target port', 1, 65_535),
+        username: stringValue(item.username, 'network proxy credential target username', 256),
+    };
+}
 function normalizeRuntimePolicy(value) {
     const policy = exactRecord(value, 'runtime policy', [
         'networkProxy',

package/node_modules/@maka/core/dist/runtime-policy.js

@@ -16,11 +16,13 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { networkProxyCredentialTarget, } from './settings.js';
 import { WEB_SEARCH_PROVIDERS, } from './web-search.js';
 export { WEB_SEARCH_PROVIDERS };
+export { networkProxyCredentialTarget };
 export { decodeRuntimePolicyEntityId, RuntimePolicyDomainDecodeError, } from './runtime-policy/domain-codec.js';
-export { decodeCanonicalRuntimePolicy, decodeRuntimePolicyV2, normalizeRuntimePolicyMutation, } from './runtime-policy/policy-codec.js';
-export { CONNECTION_CATALOG_MAX_CONNECTIONS, CONNECTION_CATALOG_MAX_ENABLED_MODEL_IDS, CONNECTION_CATALOG_MAX_ENTRIES_PER_CONNECTION, CONNECTION_CATALOG_MAX_MODELS_PER_CONNECTION, CONNECTION_MODEL_ID_MAX_LENGTH, CONNECTION_NAME_MAX_LENGTH, decodeCanonicalConnectionBaseUrl, decodeCanonicalConnectionCatalogEntry, decodeConnectionModelId, decodeRelayModelProfilesTable, decodeConnectionModel, decodeConnectionName, decodeConnectionSlug, decodeConnectionTarget, decodeConnectionTestSummary, decodeConnectionVersionBasis, decodeProviderType, normalizeCatalogConnectionBaseUrl, normalizeConnectionCatalogEntryDraft, normalizeConnectionCatalogEntryUpdate, normalizeConnectionCatalogEntryUpdateForProvider, normalizeConnectionModelDiscoveryResult, normalizeCreateCatalogConnectionInput, normalizeRemoveCatalogConnectionInput, normalizeSetDefaultConnectionTargetInput, normalizeUpdateCatalogConnectionInput, } from './runtime-policy/connection-catalog-codec.js';
+export { decodeCanonicalRuntimePolicy, normalizeNetworkProxyCredentialTarget, decodeRuntimePolicyV2, normalizeNetworkProxyUpdate, normalizeRuntimePolicyMutation, } from './runtime-policy/policy-codec.js';
+export { CONNECTION_CATALOG_MAX_CONNECTIONS, CONNECTION_CATALOG_MAX_ENABLED_MODEL_IDS, CONNECTION_CATALOG_MAX_ENTRIES_PER_CONNECTION, CONNECTION_CATALOG_MAX_MODELS_PER_CONNECTION, CONNECTION_MODEL_ID_MAX_LENGTH, CONNECTION_NAME_MAX_LENGTH, decodeCanonicalConnectionBaseUrl, decodeCanonicalConnectionCatalogEntry, decodeConnectionModelId, decodeConnectionCredentialTarget, decodeRelayModelProfilesTable, decodeConnectionModel, decodeConnectionName, decodeConnectionSlug, decodeConnectionTarget, decodeConnectionTestSummary, decodeConnectionVersionBasis, decodeProviderType, normalizeCatalogConnectionBaseUrl, normalizeConnectionCatalogEntryDraft, normalizeConnectionCatalogEntryUpdate, normalizeConnectionCatalogEntryUpdateForProvider, normalizeConnectionModelDiscoveryResult, canonicalConnectionEffectiveBaseUrl, connectionCredentialTarget, normalizeCreateCatalogConnectionInput, normalizeRemoveCatalogConnectionInput, normalizeSetDefaultConnectionTargetInput, normalizeUpdateCatalogConnectionInput, } from './runtime-policy/connection-catalog-codec.js';
 export { decodeModelCatalogEntry } from './runtime-policy/model-catalog-entry-codec.js';
 export { decodeCredentialLocator, decodeCredentialStatus, decodeCredentialVersionBasis, normalizeCredentialSecret, normalizeDeleteCredentialInput, normalizeSetCredentialInput, } from './runtime-policy/credential-vault-codec.js';
 export { normalizeRequestBodyOverlay, normalizeOptionalRequestBodyOverlay, normalizeRequestHeaderUpdates, normalizeRequestHeaders, parseRequestHeaders, REQUEST_BODY_OVERLAY_MAX_BYTES, REQUEST_HEADERS_MAX_BYTES, RequestCustomizationValidationError, serializeRequestHeaders, } from './request-customization.js';

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

@@ -348,6 +348,7 @@ const TOKEN_USAGE_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', '
     'promptSegments',
     'contextBudget',
     'providerRequestTraceId',
+    'lastRequestAnchor',
 ]);
 const TURN_STATE_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 'status', 'partialOutputRetained'], [
     'parentTurnId',

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

@@ -47,6 +47,14 @@ export const SETTINGS_SECTIONS = [
     'health',
     'about',
 ];
+export function networkProxyCredentialTarget(proxy) {
+    return {
+        protocol: proxy.protocol,
+        host: proxy.host.trim().toLowerCase(),
+        port: proxy.port,
+        username: proxy.username,
+    };
+}
 /** Palette ids shared with `[data-maka-theme]` CSS selectors. */
 export const THEME_PALETTES = [
     'default',
@@ -301,7 +309,6 @@ export function createDefaultSettings() {
                 port: 7890,
                 authEnabled: false,
                 username: '',
-                password: '',
                 bypassList: ['metaso.cn', 'baidu.com'],
                 autoBypassDomains: DEFAULT_PROXY_BYPASS_DOMAINS,
             },
@@ -357,6 +364,7 @@ export function createDefaultSettings() {
     };
 }
 export function mergeSettings(current, patch) {
+    const { credential: _credential, password: _legacyPassword, passwordConfigured: _derivedStatus, ...proxyPatch } = (patch.network?.proxy ?? {});
     return {
         ...current,
         network: {
@@ -364,7 +372,7 @@ export function mergeSettings(current, patch) {
             ...(patch.network ?? {}),
             proxy: {
                 ...current.network.proxy,
-                ...(patch.network?.proxy ?? {}),
+                ...proxyPatch,
             },
         },
         botChat: mergeBotChatSettings(current.botChat, patch.botChat),

package/node_modules/@maka/core/dist/usage-record-schema.js

@@ -213,6 +213,15 @@ const CONTEXT_NUMBERS = [
     'activeEstimatedTokensSaved',
 ];
 const CONTEXT_REASON_COUNTS = ['archivePlaceholderReasonCounts'];
+const LAST_REQUEST_ANCHOR_SHAPE = defineObjectShape()(['inputTokens', 'payloadChars'], []);
+export function isLastRequestAnchor(value) {
+    return (isRecord(value) &&
+        hasExactShape(value, LAST_REQUEST_ANCHOR_SHAPE) &&
+        isFiniteNumber(value.inputTokens) &&
+        isFiniteNumber(value.payloadChars) &&
+        value.inputTokens > 0 &&
+        value.payloadChars > 0);
+}
 export function isTokenUsageFields(value) {
     if (!isRecord(value))
         return false;
@@ -233,7 +242,8 @@ export function isTokenUsageFields(value) {
         (value.promptSegments === undefined ||
             (Array.isArray(value.promptSegments) &&
                 value.promptSegments.every(isPromptSegmentEstimate))) &&
-        (value.contextBudget === undefined || isContextBudgetDiagnostic(value.contextBudget)));
+        (value.contextBudget === undefined || isContextBudgetDiagnostic(value.contextBudget)) &&
+        (value.lastRequestAnchor === undefined || isLastRequestAnchor(value.lastRequestAnchor)));
 }
 export function isPromptSegmentEstimate(value) {
     return (isRecord(value) &&

package/node_modules/@maka/core/package.json

@@ -146,7 +146,8 @@
     "./tool-result-status": "./dist/tool-result-status.js",
     "./ui-locale": "./dist/ui-locale.js",
     "./unified-diff": "./dist/unified-diff.js",
-    "./dev-single-instance": "./dist/dev-single-instance.js"
+    "./dev-single-instance": "./dist/dev-single-instance.js",
+    "./maka-wordmark": "./dist/maka-wordmark.js"
   },
   "dependencies": {
     "intl-messageformat": "11.2.12"

package/node_modules/@maka/mcp/dist/index.js

@@ -31,6 +31,7 @@ import { McpToolCallPreparer } from './tool-output-validation.js';
 import { McpCredentialCoordinator } from './credential-coordinator.js';
 import { assertTransportSecurity, urlProvenance, } from './transport-security.js';
 import { McpAuthRequiredError, McpOAuthProvider, } from './oauth.js';
+export { formatMcpDiagnosticText } from './diagnostic-text.js';
 export { McpToolCallError } from './tool-call-error.js';
 export { createCredentialMcpOAuthStorage, } from './credential-oauth-storage.js';
 export { createMemoryMcpOAuthStorage, McpAuthRequiredError, McpOAuthProvider, } from './oauth.js';

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

@@ -38,6 +38,7 @@ import { persistedOpenAiResponsesStepMessages } from './openai-responses-continu
 import { composeRequestProjection, } from './request-projection.js';
 import { decodePlaintextResponsesReasoningState, replayPlaintextResponsesProviderOptions, responsesReasoningItemId, } from './responses-reasoning-state.js';
 import { toolResultOutput } from './tool-result-output.js';
+import { finitePositive } from './context-budget-helpers.js';
 import { contextDiagnosticsCompactionOf, } from './context-diagnostics.js';
 import { AiSdkCompaction, hasActiveToolResultPruneDiagnosticPatch, hasBlockingReplayDiagnostics, } from './ai-sdk-compaction.js';
 import { durableProjectionToToolResultOutput } from './durable-tool-result-projection.js';
@@ -59,7 +60,6 @@ import { applyPatchReplayFactText, normalizeApplyPatchReplayInput, routeApplyPat
 import { applyRuntimeEventContextBudget, buildContextBudgetDiagnosticShell, estimateRuntimeEventsTokens, mergeContextBudgetDiagnostic, mergeContextBudgetDiagnosticPatches, minimalContextBudgetDiagnostic, shouldAppendContextCompactedNote, shouldAppendContextCompactionFailedOpenNote, } from './context-budget.js';
 import { evaluateHistoryCompactCheckpointReplay, isHistoryCompactContentEvent, } from './history-compaction.js';
 import { canContinueHistoryCompactCheckpointForModel, historyCompactCheckpointToModelMessage, isProviderHistoryCompactCheckpoint, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
-import { isMalformedHistoryCompactSummaryReason } from './history-compact-error.js';
 import { resolveSelectedModelContextWindow } from './context-budget-policy.js';
 export { DEFAULT_PERMISSION_TIMEOUT_MS, MAX_ACTIVE_CHILD_AGENT_RUNS_PER_TURN, MAX_ACTIVE_SUBAGENT_TOOLS_PER_TURN, TOOL_ERROR_RESULT_MAX_CHARS, formatSyntheticToolErrorText, } from './tool-runtime.js';
 export { normalizeAiSdkUsage } from './model-adapter.js';
@@ -1142,7 +1142,7 @@ export class AiSdkBackend {
             return;
         }
         // --- Build messages from RuntimeEvent history and its compatibility projection. ---
-        const priorReplayResult = await this.buildPriorMessages(scope, input, this.automaticMemoryCompactionSupported() ? true : undefined);
+        const priorReplayResult = await this.buildPriorMessages(scope, input, midTurnState, this.automaticMemoryCompactionSupported() ? true : undefined);
         if (scope.aborted) {
             queue.push({
                 type: 'abort',
@@ -1162,20 +1162,6 @@ export class AiSdkBackend {
             yield* this.drain(queue);
             return;
         }
-        if (priorReplayResult.status === 'context_budget_exhausted') {
-            trace.modelStreamCompleted('context_budget_exhausted');
-            queue.push({
-                type: 'complete',
-                id: this.newId(),
-                turnId,
-                ts: this.now(),
-                stopReason: 'context_budget_exhausted',
-                contextBudgetExhaustedDetail: priorReplayResult.detail,
-            });
-            queue.close();
-            yield* this.drain(queue);
-            return;
-        }
         const priorReplay = priorReplayResult;
         if (input.continuation && priorReplay.messages.length === 0) {
             const replay = priorReplayFailureTrace(priorReplay);
@@ -1337,8 +1323,7 @@ export class AiSdkBackend {
                 const onMidTurnDiagnosticPatch = (patch) => {
                     midTurnCompactDiagnosticPatch = mergeContextBudgetDiagnosticPatches(midTurnCompactDiagnosticPatch, patch);
                 };
-                const midTurnSystemPromptChars = systemPrompt?.length ?? 0;
-                const midTurnCapacityHook = this.compaction.buildMidTurnCapacityCompactProjection(turnId, midTurnState, queue, providerTools, () => currentRepairToolNames(), midTurnSystemPromptChars, onMidTurnDiagnosticPatch, scope, this.automaticMemoryCompactionSupported()
+                const midTurnCapacityHook = this.compaction.buildMidTurnCapacityCompactProjection(turnId, midTurnState, queue, providerTools, onMidTurnDiagnosticPatch, scope, this.automaticMemoryCompactionSupported()
                     ? () => this.automaticMemoryCompactionDecision()
                     : undefined, this.automaticMemoryCompactionSupported()
                     ? (dispatch) => this.dispatchAutomaticMemoryCompaction(scope, dispatch)
@@ -1353,16 +1338,12 @@ export class AiSdkBackend {
                 // The verdict owner wraps the WHOLE shaping pipeline: hooks shape, one
                 // owner measures the final payload and decides pass/terminate.
                 const requestProjection = midTurnState && midTurnCapacityHook && shapedProjection
-                    ? this.compaction.buildMidTurnFinalRequestVerdict({
+                    ? this.compaction.buildMidTurnFinalRequestRescue({
                         shaped: shapedProjection,
                         reentry: composeRequestProjection(undefined, midTurnCapacityHook, activeToolResultPruneHook),
                         state: midTurnState,
                         providerTools,
-                        fallbackActiveTools: () => currentRepairToolNames(),
                         charsPerToken: this.input.contextBudget?.charsPerToken ?? 4,
-                        systemPromptChars: midTurnSystemPromptChars,
-                        onDiagnosticPatch: onMidTurnDiagnosticPatch,
-                        abortController: turnAbortController,
                     })
                     : shapedProjection;
                 const completedProviderSteps = [];
@@ -1382,18 +1363,10 @@ export class AiSdkBackend {
                         if (missingSteering.length > 0)
                             requestMessages = [...requestMessages, ...missingSteering];
                     }
-                    const shaped = requestProjection
-                        ? await requestProjection({
-                            completedSteps: completedProviderSteps,
-                            stepNumber: runtimeSteps,
-                            model,
-                            messages: requestMessages,
-                        })
-                        : undefined;
-                    if (midTurnState?.exhaustedDetail) {
-                        throw new Error(`context budget exhausted before provider dispatch: ${midTurnState.exhaustedDetail}`);
-                    }
-                    const projectedMessages = shaped?.messages ?? requestMessages;
+                    // Resolved BEFORE request projection so the capacity measurement and
+                    // the request that goes out are the same request: a finalization step
+                    // adds prompt fragments and sends no tool schemas, and an anchor
+                    // paired with the un-finalized shape describes a different payload.
                     const finalChildSummaryStep = this.input.header.collaborationMode === 'agent' &&
                         maxSteps !== undefined &&
                         maxSteps > 1 &&
@@ -1406,15 +1379,29 @@ export class AiSdkBackend {
                     if (sandboxBoundaryFinalizationStep) {
                         toolRuntime.forceSandboxBoundaryFinalization();
                     }
-                    const activeToolsForRequest = finalChildSummaryStep || sandboxBoundaryFinalizationStep
-                        ? []
-                        : boundaryAwareToolNames(shaped?.activeTools ?? plan.currentRepairToolNames());
                     const requestSystemPrompt = joinPromptFragments([
                         systemPrompt,
                         finalChildSummaryStep ? CHILD_STEP_BUDGET_FINALIZATION_PROMPT : undefined,
                         toolRuntime.hasSandboxBoundaryDenial() ? SANDBOX_BOUNDARY_DENIED_FOR_TURN : undefined,
                         sandboxBoundaryFinalizationStep ? SANDBOX_BOUNDARY_FINALIZATION_PROMPT : undefined,
                     ]);
+                    const resolveDispatch = (active) => ({
+                        systemPromptChars: requestSystemPrompt?.length ?? 0,
+                        activeTools: finalChildSummaryStep || sandboxBoundaryFinalizationStep
+                            ? []
+                            : boundaryAwareToolNames(active ?? plan.currentRepairToolNames()),
+                    });
+                    const shaped = requestProjection
+                        ? await requestProjection({
+                            completedSteps: completedProviderSteps,
+                            stepNumber: runtimeSteps,
+                            model,
+                            messages: requestMessages,
+                            resolveDispatch,
+                        })
+                        : undefined;
+                    const projectedMessages = shaped?.messages ?? requestMessages;
+                    const activeToolsForRequest = resolveDispatch(shaped?.activeTools).activeTools;
                     providerRequestTracker?.setStep(runtimeSteps);
                     let attemptMessages = projectedMessages;
                     let providerAttempt = 1;
@@ -1726,7 +1713,7 @@ export class AiSdkBackend {
                             !attemptSawContinuationMetadata;
                         const attemptFailure = settledWatchdogTimeout?.error ??
                             (providerOutcome.kind === 'completed' ? undefined : providerOutcome.failure);
-                        if (attemptFailure && !scope.aborted && !midTurnState?.exhaustedDetail) {
+                        if (attemptFailure && !scope.aborted) {
                             const failure = settledWatchdogTimeout || providerOutcome.kind === 'completed'
                                 ? this.modelAdapter.normalizeFailure(attemptFailure)
                                 : providerOutcome.failure;
@@ -1752,7 +1739,7 @@ export class AiSdkBackend {
                                     currentMessages: attemptMessages,
                                     providerTools,
                                     activeTools: activeToolsForRequest,
-                                    systemPromptChars: midTurnSystemPromptChars,
+                                    systemPromptChars: requestSystemPrompt?.length ?? 0,
                                     queue,
                                     onDiagnosticPatch: onMidTurnDiagnosticPatch,
                                     origin: scope,
@@ -1778,6 +1765,7 @@ export class AiSdkBackend {
                                         model,
                                         messages: recovered.messages,
                                         activeTools: activeToolsForRequest,
+                                        resolveDispatch,
                                     })
                                     : undefined;
                                 attemptMessages = recoveredProjection?.messages ?? recovered.messages;
@@ -1858,12 +1846,6 @@ export class AiSdkBackend {
                     if (scope.aborted) {
                         throw Object.assign(new Error('aborted'), { name: 'AbortError' });
                     }
-                    // Mid-turn exhaustion aborts the SDK stream, but streamText ends
-                    // gracefully on abort instead of throwing; route to the explicit
-                    // outcome regardless of how the stream wound down.
-                    if (midTurnState?.exhaustedDetail) {
-                        throw Object.assign(new Error(`mid-turn context budget exhausted: ${midTurnState.exhaustedDetail}`), { name: 'MidTurnContextBudgetExhaustedError' });
-                    }
                     // Catch-all: flush any residual step content if the provider closed the
                     // stream without a trailing `finish-step` for the last step.
                     const providerStepId = currentStepMessageId;
@@ -2048,6 +2030,13 @@ export class AiSdkBackend {
                             }
                             return undefined;
                         })();
+                        // The anchor the NEXT turn estimates its first request from — see
+                        // `LastRequestAnchor`. `input` below is the sum across this send's
+                        // steps and anchors nothing. Either half missing (no usable usage
+                        // sample, or no mid-turn seam to measure the payload) drops the
+                        // whole pair and the next turn cold starts.
+                        const anchorInputTokens = finitePositive(lastStepInputTokens);
+                        const anchorPayloadChars = finitePositive(midTurnState?.lastRequestPayloadChars);
                         // One shared usage payload for the durable message and the live
                         // event: twin per-field literals drifted before (#4019), so a field
                         // now has exactly one definition site.
@@ -2076,6 +2065,14 @@ export class AiSdkBackend {
                                 ? { contextRemaining: contextRemainingForUsage }
                                 : {}),
                             ...(providerRequestTraceId ? { providerRequestTraceId } : {}),
+                            ...(anchorInputTokens !== undefined && anchorPayloadChars !== undefined
+                                ? {
+                                    lastRequestAnchor: {
+                                        inputTokens: anchorInputTokens,
+                                        payloadChars: anchorPayloadChars,
+                                    },
+                                }
+                                : {}),
                         };
                         const tu = {
                             type: 'token_usage',
@@ -2162,21 +2159,7 @@ export class AiSdkBackend {
                 // BOTH exits — user stop and provider error / watchdog timeout — so
                 // partialOutputRetained reflects what the user actually saw.
                 await flushStep().catch(() => { });
-                if (!scope.aborted && midTurnState?.exhaustedDetail) {
-                    // Mid-turn compaction could not produce a provider-safe request: end
-                    // the turn with the explicit first-class outcome, not a raw error.
-                    streamErrorClass = 'ContextBudgetExhausted';
-                    trace.modelStreamCompleted('context_budget_exhausted');
-                    queue.push({
-                        type: 'complete',
-                        id: this.newId(),
-                        turnId,
-                        ts: this.now(),
-                        stopReason: 'context_budget_exhausted',
-                        contextBudgetExhaustedDetail: midTurnState.exhaustedDetail,
-                    });
-                }
-                else if (scope.aborted) {
+                if (scope.aborted) {
                     queue.push({
                         type: 'abort',
                         id: this.newId(),
@@ -2591,7 +2574,7 @@ export class AiSdkBackend {
      *  V0.1: text-only round-tripping. Tool calls / results within projected
      *  history are deliberately NOT replayed unless RuntimeEvent native replay
      *  is available for the provider. */
-    async buildPriorMessages(scope, input, automaticMemory) {
+    async buildPriorMessages(scope, input, midTurnState, automaticMemory) {
         const priorStored = input.context.filter((message) => message.turnId !== input.turnId);
         if (!input.runtimeContext) {
             return {
@@ -2622,9 +2605,14 @@ export class AiSdkBackend {
                 buildContextBudgetDiagnosticShell(priorRuntimeContext, runtimeContext, contextBudget), preparedContextBudget.diagnosticPatch);
         }
         const maxHistoryTokens = contextBudget?.maxHistoryEstimatedTokens;
-        const needsCompaction = maxHistoryTokens !== undefined &&
+        // FALLBACK, not a second authority: step 0's anchored estimate measures the
+        // whole outgoing payload against the real window, where this gate only
+        // weighs prior history events at chars/4. It stands in only where that
+        // estimate cannot reach — no anchor, no mid-turn seam, or no declared
+        // window — so an oversized history never goes out unshaped.
+        const needsCompaction = !(midTurnState?.capacity !== undefined && midTurnState.lastRequestInputTokens !== undefined) &&
+            maxHistoryTokens !== undefined &&
             estimateRuntimeEventsTokens(runtimeContext, contextBudget?.charsPerToken) > maxHistoryTokens;
-        let compactionFailure;
         if (needsCompaction &&
             contextBudget?.historyCompact?.enabled === true &&
             this.compaction.hasHistoryCompactCheckpointWriter()) {
@@ -2670,25 +2658,9 @@ export class AiSdkBackend {
                     });
                 }
             }
-            if (compactResult.outcome.kind === 'failed') {
-                compactionFailure =
-                    compactResult.outcome.reason === 'no_safe_completed_span'
-                        ? 'no_safe_completed_span'
-                        : isMalformedHistoryCompactSummaryReason(compactResult.outcome.reason)
-                            ? compactResult.outcome.reason
-                            : 'summarizer_failed';
-            }
             contextBudgetDiagnostic = mergeContextBudgetDiagnostic(contextBudgetDiagnostic ??
                 buildContextBudgetDiagnosticShell(priorRuntimeContext, runtimeContext, contextBudget), compactResult.contextBudget ?? {});
         }
-        if (maxHistoryTokens !== undefined &&
-            estimateRuntimeEventsTokens(runtimeContext, contextBudget?.charsPerToken) > maxHistoryTokens) {
-            return {
-                status: 'context_budget_exhausted',
-                detail: compactionFailure ?? 'no_safe_completed_span',
-                ...(contextBudgetDiagnostic ? { contextBudget: contextBudgetDiagnostic } : {}),
-            };
-        }
         // The boundary belongs to the runtime-event projection above. A gate that
         // falls back to the stored-message projection returns a prompt no
         // checkpoint shaped, so it reports none rather than one the request never