maka-agent 0.2.0-dev.22.20260905 → 0.2.0-dev.24.20260907

package/node_modules/@maka/core/dist/slash-command-catalog.js

@@ -24,6 +24,7 @@ export const SLASH_COMMAND_CATALOG = [
     { id: 'goal', session: 'required', surfaces: ['tui'] },
     { id: 'graph', session: 'none', surfaces: ['desktop', 'tui'] },
     { id: 'help', session: 'none', surfaces: ['tui'] },
+    { id: 'host', session: 'none', surfaces: ['tui'] },
     { id: 'mcp', session: 'none', surfaces: ['tui'] },
     { id: 'model', session: 'required', surfaces: ['tui'] },
     { id: 'move', session: 'required', surfaces: ['tui'] },
@@ -40,6 +41,7 @@ export const SLASH_COMMAND_CATALOG = [
     { id: 'swarm', session: 'none', surfaces: ['desktop', 'tui'] },
     { id: 'thinking', session: 'required', surfaces: ['tui'] },
     { id: 'transcript', session: 'required', surfaces: ['tui'] },
+    { id: 'update', session: 'none', surfaces: ['tui'] },
 ];
 export function slashCommandsForSurface(surface) {
     return SLASH_COMMAND_CATALOG.filter((command) => command.surfaces.includes(surface));

package/node_modules/@maka/core/dist/tool-result-archive-evidence.js

@@ -0,0 +1,20 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export const TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_TRANSITIONS = 64;
+export const TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_BYTES = 2 * 1024 * 1024;

package/node_modules/@maka/core/dist/usage-ledger-merge.js

@@ -16,7 +16,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { projectModelCallUsageBuckets, projectModelCallUsageLogs, projectModelCallUsageSummary, } from './model-call-usage-projection.js';
 /**
  * The cost to present for a usage total, or `undefined` when it cannot be shown
  * honestly. Trust the total only when at least one canonical attempt was priced;
@@ -66,8 +65,8 @@ export function legacyUsageProvenance(legacyRecords) {
         pendingRepairs: 0,
     };
 }
-export function mergeUsageSummary(legacy, canonical, query, now) {
-    const projected = projectModelCallUsageSummary(canonical.attempts, query, now);
+export function mergeUsageSummary(legacy, canonical) {
+    const projected = canonical.projection;
     return {
         range: projected.range,
         totalRequests: legacy.totalRequests + projected.totalRequests,
@@ -95,17 +94,16 @@ export function mergeUsageSummary(legacy, canonical, query, now) {
         },
     };
 }
-export function mergeUsageBuckets(legacy, canonical, query, groupBy, now) {
-    const projected = projectModelCallUsageBuckets(canonical.attempts, query, groupBy, now);
+export function mergeUsageBuckets(legacy, canonical) {
     const merged = new Map();
-    for (const bucket of [...legacy, ...projected]) {
+    for (const bucket of [...legacy, ...canonical.projection.buckets]) {
         const existing = merged.get(bucket.key);
         merged.set(bucket.key, existing ? combineBuckets(existing, bucket) : { ...bucket });
     }
     return {
         buckets: [...merged.values()].sort((left, right) => right.requests - left.requests),
         provenance: {
-            coverage: projectModelCallUsageSummary(canonical.attempts, query, now).coverage,
+            coverage: canonical.projection.coverage,
             legacyRecords: legacy.reduce((total, bucket) => total + bucket.requests, 0),
             unreadableRecords: canonical.unreadableRecords,
             pendingRepairs: canonical.pendingRepairs,
@@ -117,8 +115,8 @@ export function mergeUsageBuckets(legacy, canonical, query, groupBy, now) {
  * the merged order can only come from the first `offset + limit` rows of each —
  * callers may bound their reads to that prefix and still page exactly.
  */
-export function mergeUsageLogs(legacy, canonical, query, now, offset, limit) {
-    const projected = projectModelCallUsageLogs(canonical.attempts, query, now, 0, offset + limit);
+export function mergeUsageLogs(legacy, canonical, offset, limit) {
+    const projected = canonical.projection;
     const rows = [];
     let left = 0;
     let right = 0;

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

@@ -44,30 +44,6 @@ const COMPACTION_DECISION_SHAPE = defineObjectShape()(['stage', 'sourceKind', 'd
     'skippedReasonCounts',
     'validationReasonCounts',
 ]);
-const CURRENT_CONTEXT_BUDGET_SHAPE = defineObjectShape()([
-    'enabled',
-    'estimatedTokensBefore',
-    'estimatedTokensAfter',
-    'keptTurns',
-    'droppedTurns',
-    'keptEvents',
-    'droppedEvents',
-], [
-    'policyName',
-    'prunedToolResults',
-    'prunedToolResultEstimatedTokensBefore',
-    'prunedToolResultEstimatedTokensAfter',
-    'archivePlaceholders',
-    'archiveWriteFailures',
-    'unarchivedToolResults',
-    'archivePlaceholderReasonCounts',
-    'activePrunedToolResults',
-    'activeSupersededToolResults',
-    'activeDuplicateToolResults',
-    'activeArchiveFailures',
-    'activeEstimatedTokensSaved',
-    'compactionDecisions',
-]);
 /**
  * Keys written by retired context-budget implementations. They remain
  * accepted only so persisted usage records stay readable; current code cannot
@@ -145,10 +121,30 @@ const RETIRED_CONTEXT_BUDGET_KEYS = [
     'historyRewriteResetReason',
     'historyRewriteGate',
 ];
-const CONTEXT_BUDGET_SHAPE = {
-    required: CURRENT_CONTEXT_BUDGET_SHAPE.required,
-    allowed: new Set([...CURRENT_CONTEXT_BUDGET_SHAPE.allowed, ...RETIRED_CONTEXT_BUDGET_KEYS]),
-};
+const CONTEXT_BUDGET_SHAPE = defineObjectShape()([
+    'enabled',
+    'estimatedTokensBefore',
+    'estimatedTokensAfter',
+    'keptTurns',
+    'droppedTurns',
+    'keptEvents',
+    'droppedEvents',
+], [
+    'policyName',
+    'prunedToolResults',
+    'prunedToolResultEstimatedTokensBefore',
+    'prunedToolResultEstimatedTokensAfter',
+    'archivePlaceholders',
+    'archiveWriteFailures',
+    'unarchivedToolResults',
+    'archivePlaceholderReasonCounts',
+    'activePrunedToolResults',
+    'activeSupersededToolResults',
+    'activeDuplicateToolResults',
+    'activeArchiveFailures',
+    'activeEstimatedTokensSaved',
+    'compactionDecisions',
+], RETIRED_CONTEXT_BUDGET_KEYS);
 const PROMPT_SEGMENT_KINDS = new Set([
     'system_prompt',
     'tool_schema',
@@ -213,15 +209,10 @@ const CONTEXT_NUMBERS = [
     'activeEstimatedTokensSaved',
 ];
 const CONTEXT_REASON_COUNTS = ['archivePlaceholderReasonCounts'];
-const LAST_REQUEST_ANCHOR_SHAPE = defineObjectShape()(['inputTokens'], ['outputTokens', 'modelId', 'connectionId']);
-const RETIRED_LAST_REQUEST_ANCHOR_KEYS = ['payloadChars'];
-const LAST_REQUEST_ANCHOR_DECODE_SHAPE = {
-    required: LAST_REQUEST_ANCHOR_SHAPE.required,
-    allowed: new Set([...LAST_REQUEST_ANCHOR_SHAPE.allowed, ...RETIRED_LAST_REQUEST_ANCHOR_KEYS]),
-};
+const LAST_REQUEST_ANCHOR_SHAPE = defineObjectShape()(['inputTokens'], ['outputTokens', 'modelId', 'connectionId'], ['payloadChars']);
 export function isLastRequestAnchor(value) {
     return (isRecord(value) &&
-        hasExactShape(value, LAST_REQUEST_ANCHOR_DECODE_SHAPE) &&
+        hasExactShape(value, LAST_REQUEST_ANCHOR_SHAPE) &&
         isFiniteNumber(value.inputTokens) &&
         value.inputTokens > 0 &&
         (value.outputTokens === undefined ||

package/node_modules/@maka/core/dist/workhub-creation-intent.js

@@ -74,7 +74,9 @@ const DIRECT_STOP_REQUEST = /^\s*(?:(?:please|kindly)\s+)?(?:stop|cancel|termina
 // which is usually work to do inside a Session, and English admits no
 // equivalent either.
 const DIRECT_CHINESE_STOP_REQUEST = /^\s*(?:(?:请|请帮我|帮我|麻烦你?)\s*)?(?:停止|停掉|停下|取消|终止|中止)\s*(?:(?:这个|该)?(?:会话|工作|任务)\s*)?(.+?)\s*[。！]?\s*$/iu;
-const UNSAFE_STOP_TARGET = /^(?:it|this|that|one|everything|all|current|session|work|task|job|(?:this|that|current)\s+(?:session|work|task|job)|它|这个|那个|全部|当前|会话|工作|任务|(?:这个|那个|当前)(?:会话|工作|任务))$/iu;
+const DIRECT_RESUME_REQUEST = /^\s*(?:(?:please|kindly)\s+)?resume\s+(?:(?:the|this)\s+)?(?:(?:session|work|task|job)\s+)?(.+?)\s*[.!。！]?\s*$/iu;
+const DIRECT_CHINESE_RESUME_REQUEST = /^\s*(?:(?:请|请帮我|帮我|麻烦你?)\s*)?(?:恢复|恢復|接着跑|接著跑)\s*(?:(?:这个|该)?(?:会话|工作|任务)\s*)?(.+?)\s*[。！]?\s*$/iu;
+const UNSAFE_NAMED_ACTION_TARGET = /^(?:it|this|that|one|everything|all|current|session|work|task|job|(?:this|that|current)\s+(?:session|work|task|job)|它|这个|那个|全部|当前|会话|工作|任务|(?:这个|那个|当前)(?:会话|工作|任务))$/iu;
 /**
  * Whether trusted user text affirmatively asks WorkHub to create a new Session.
  *
@@ -219,8 +221,14 @@ export function readWorkHubRequestIntent(value) {
             : { kind: 'unusable' };
     const correctionCue = hasWorkHubCorrectionCue(source);
     const existingTarget = affirmativeWorkHubExistingCorrectionTarget(source);
-    const stopCue = directWorkHubStopCue(source, literalMask.malformed);
-    const stopTarget = stopCue ? directWorkHubStopTarget(source, false) : undefined;
+    const stop = directWorkHubNamedAction(source, literalMask.malformed, [
+        DIRECT_STOP_REQUEST,
+        DIRECT_CHINESE_STOP_REQUEST,
+    ]);
+    const resume = directWorkHubNamedAction(source, literalMask.malformed, [
+        DIRECT_RESUME_REQUEST,
+        DIRECT_CHINESE_RESUME_REQUEST,
+    ]);
     const actions = allMatches(masked, EXECUTION_ACTION);
     const execution = literalMask.malformed || naming.kind === 'unusable' || hasDominatingDeliberation(masked)
         ? 'non_executable'
@@ -237,9 +245,14 @@ export function readWorkHubRequestIntent(value) {
             ...(existingTarget ? { existingTarget } : {}),
         },
         stop: {
-            cue: stopCue,
-            imperative: Boolean(stopTarget),
-            ...(stopTarget ? { target: stopTarget } : {}),
+            cue: stop.cue,
+            imperative: Boolean(stop.target),
+            ...(stop.target ? { target: stop.target } : {}),
+        },
+        resume: {
+            cue: resume.cue,
+            imperative: Boolean(resume.target),
+            ...(resume.target ? { target: resume.target } : {}),
         },
     };
 }
@@ -331,6 +344,14 @@ export function matchWorkHubSessionName(reference, sessionName) {
     }
     return { kind: 'named', remainder: normalizedTarget.slice(matchedName.length).trim() };
 }
+/** Whether a direct stop/resume reference names exactly this Session. */
+export function workHubNamedDelegationActionTargetsSession(action, sessionName) {
+    if (!action.imperative || !action.target)
+        return false;
+    const match = matchWorkHubSessionName(action.target, sessionName);
+    return (match.kind === 'elided_name_punctuation' ||
+        (match.kind === 'named' && /^[.!?。！？]*$/u.test(match.remainder)));
+}
 /**
  * The correction policy's tail rule. A correction may name its target and then
  * say what to do with it, but a withdrawal anywhere in the reference retracts
@@ -355,24 +376,17 @@ export function workHubCorrectionAdmitsReference(reference, match) {
 function correctionTargetMatchesSession(target, sessionName) {
     return workHubCorrectionAdmitsReference(target, matchWorkHubSessionName(target, sessionName));
 }
-function directWorkHubStopTarget(value, malformedLiteral) {
+function directWorkHubNamedAction(value, malformedLiteral, patterns) {
     if (malformedLiteral || /[?？]\s*$/u.test(value))
-        return undefined;
-    const match = DIRECT_STOP_REQUEST.exec(value) ?? DIRECT_CHINESE_STOP_REQUEST.exec(value);
+        return { cue: false };
+    const match = patterns[0].exec(value) ?? patterns[1].exec(value);
     const rawTarget = match?.[1]?.trim();
     if (!rawTarget)
-        return undefined;
-    const target = stripMatchingStopQuotes(rawTarget.replace(/[.!。！]+\s*$/u, '').trim());
-    if (!target || UNSAFE_STOP_TARGET.test(target))
-        return undefined;
-    return target;
-}
-function directWorkHubStopCue(value, malformedLiteral) {
-    if (malformedLiteral || /[?？]\s*$/u.test(value))
-        return false;
-    return Boolean(DIRECT_STOP_REQUEST.test(value) || DIRECT_CHINESE_STOP_REQUEST.test(value));
+        return { cue: Boolean(match) };
+    const target = stripMatchingActionQuotes(rawTarget.replace(/[.!。！]+\s*$/u, '').trim());
+    return !target || UNSAFE_NAMED_ACTION_TARGET.test(target) ? { cue: true } : { cue: true, target };
 }
-function stripMatchingStopQuotes(value) {
+function stripMatchingActionQuotes(value) {
     const pairs = new Map([
         ['"', '"'],
         ["'", "'"],

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

@@ -10,6 +10,8 @@
     "./model-projection-transition": "./dist/model-projection-transition.js",
     "./canonical-runtime-event": "./dist/canonical-runtime-event.js",
     "./runtime-boundary": "./dist/runtime-boundary.js",
+    "./runtime-handoff": "./dist/runtime-handoff.js",
+    "./runtime-logical-execution": "./dist/runtime-logical-execution.js",
     "./runtime-event": "./dist/runtime-event.js",
     "./tool-args-identity": "./dist/tool-args-identity.js",
     "./tool-ledger-scanner": "./dist/tool-ledger-scanner.js",
@@ -34,6 +36,7 @@
     "./plan": "./dist/plan.js",
     "./agent-run": "./dist/agent-run.js",
     "./subagent-workspace": "./dist/subagent-workspace.js",
+    "./model-failure": "./dist/model-failure.js",
     "./model-call-attempt": "./dist/model-call-attempt.js",
     "./model-call-usage-projection": "./dist/model-call-usage-projection.js",
     "./usage-ledger-merge": "./dist/usage-ledger-merge.js",
@@ -51,6 +54,7 @@
     "./user-question": "./dist/user-question.js",
     "./connections": "./dist/connections.js",
     "./context-offload": "./dist/context-offload.js",
+    "./tool-result-archive-evidence": "./dist/tool-result-archive-evidence.js",
     "./attachments": "./dist/attachments.js",
     "./artifacts": "./dist/artifacts.js",
     "./pet": "./dist/pet.js",

package/node_modules/@maka/eval/harbor/egress-proxy/entrypoint.sh

@@ -59,4 +59,5 @@ exec mitmdump \
   --set block_global=false \
   --set rawtcp=false \
   --set confdir="$STATE_DIR" \
-  --scripts /opt/maka-eval/egress_filter.py
+  --scripts /opt/maka-eval/egress_filter.py \
+  "$@"

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

@@ -20,6 +20,7 @@ import { randomBytes } from 'node:crypto';
 import { auth, Client, extractWWWAuthenticateParams, LATEST_PROTOCOL_VERSION, SdkErrorCode, SdkHttpError, SSEClientTransport, StreamableHTTPClientTransport, } from '@modelcontextprotocol/client';
 import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
 import { redactSecrets } from '@maka/core/redaction';
+import { serializedByteLength } from '@maka/core/serialized-byte-length';
 import { deepScrubMcpSecrets, EMPTY_MCP_SECRET_INVENTORY, MCP_SECRET_MIN_SUBSTITUTION_LENGTH, mcpSecretInventory, scrubKnownMcpSecrets, } from '@maka/core/mcp-secrets';
 import { isMcpStdioConfig, mcpConfigChangeRetiresCredentials, resolveMcpProtocolPreference, } from '@maka/core/mcp';
 import { formatMcpDiagnosticText, MCP_DIAGNOSTIC_INPUT_CODE_UNITS, MCP_ERROR_DIAGNOSTIC_CODE_POINTS, } from './diagnostic-text.js';
@@ -47,6 +48,10 @@ const STDERR_OVERSIZED_LINE = '[stderr line omitted: exceeds diagnostic limit]';
 const STDERR_CONTINUATION = '[stderr continuation omitted]';
 const MAX_SUMMARIZED_ERROR_BLOCKS = 100;
 const OVERSIZED_TOOL_ERROR_CONTENT = 'server returned oversized error content';
+const MAX_SUCCESS_TOOL_RESULT_CONTENT_BLOCKS = 256;
+const MAX_SUCCESS_TOOL_RESULT_BYTES = 24 * 1024 * 1024;
+const MAX_SUCCESS_TOOL_RESULT_JSON_DEPTH = 32;
+const MAX_SUCCESS_TOOL_RESULT_JSON_NODES = 8_192;
 const MAX_TOOL_REFRESH_PASSES = 3;
 const TOOL_REFRESH_BURST_IDLE_MS = 1_000;
 // Recency-bounded per-server scrub material: enough to cover every value a
@@ -573,6 +578,7 @@ export class McpClientManager {
             // The server writes this text; it can echo a secret it was sent.
             throw new McpToolCallError(serverId, toolName, scrubKnownSecrets(redactSecrets(summarizeErrorContent(result.content)), inventory));
         }
+        assertSuccessfulToolResultBudget(serverId, toolName, result, { raw: true });
         const validateOutput = preparation.value.validateOutput;
         if (validateOutput) {
             if (result.structuredContent === undefined) {
@@ -595,10 +601,12 @@ export class McpClientManager {
         }
         // Success payloads cross toward the renderer and the transcript too; a
         // server can embed the credential it was just sent into a result.
-        return {
+        const published = {
             content: deepScrub(result.content.map(normalizeContent), inventory),
             structuredContent: deepScrub(result.structuredContent, inventory),
         };
+        assertSuccessfulToolResultBudget(serverId, toolName, published);
+        return published;
     }
     async test(serverId) {
         const started = this.now();
@@ -1852,6 +1860,128 @@ function normalizeContent(value) {
     }
     return { type: 'unknown', value };
 }
+function assertSuccessfulToolResultBudget(serverId, toolName, result, options = {}) {
+    if (result.content.length > MAX_SUCCESS_TOOL_RESULT_CONTENT_BLOCKS) {
+        throw successfulToolResultBudgetError(serverId, toolName, 'content block');
+    }
+    const budget = {
+        bytes: 0,
+        nodes: 0,
+        active: new WeakSet(),
+    };
+    try {
+        // Bound the untrusted content before normalization and then the exact
+        // result that crosses the public boundary. Known-block metadata may be
+        // discarded later, but it must not provide a path around the first pass.
+        countSuccessfulToolResultValue(result.structuredContent === undefined
+            ? { content: result.content }
+            : { content: result.content, structuredContent: result.structuredContent }, budget, 0, options.raw === true);
+    }
+    catch (error) {
+        if (error instanceof SuccessfulToolResultBudgetViolation) {
+            throw successfulToolResultBudgetError(serverId, toolName, error.limit);
+        }
+        throw new McpToolCallError(serverId, toolName, 'server returned an invalid tool result');
+    }
+}
+class SuccessfulToolResultBudgetViolation extends Error {
+    limit;
+    constructor(limit) {
+        super(limit);
+        this.limit = limit;
+    }
+}
+function countSuccessfulToolResultValue(value, budget, depth, rejectUndefined = false) {
+    budget.nodes += 1;
+    if (budget.nodes > MAX_SUCCESS_TOOL_RESULT_JSON_NODES) {
+        throw new SuccessfulToolResultBudgetViolation('JSON node');
+    }
+    if (depth > MAX_SUCCESS_TOOL_RESULT_JSON_DEPTH) {
+        throw new SuccessfulToolResultBudgetViolation('JSON depth');
+    }
+    if (value === null) {
+        countSuccessfulToolResultBytes(budget, 4);
+        return;
+    }
+    if (typeof value === 'string') {
+        countSuccessfulToolResultJsonStringBytes(budget, value);
+        return;
+    }
+    if (typeof value === 'boolean') {
+        countSuccessfulToolResultBytes(budget, value ? 4 : 5);
+        return;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new Error('non-finite number');
+        countSuccessfulToolResultBytes(budget, JSON.stringify(value).length);
+        return;
+    }
+    if (typeof value !== 'object')
+        throw new Error('unsupported JSON value');
+    if (budget.active.has(value))
+        throw new Error('cyclic JSON value');
+    if (typeof value.toJSON === 'function') {
+        throw new Error('custom JSON serializer');
+    }
+    if (!Array.isArray(value)) {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new Error('non-plain JSON object');
+        }
+    }
+    budget.active.add(value);
+    try {
+        if (Array.isArray(value)) {
+            countSuccessfulToolResultBytes(budget, 1);
+            for (let index = 0; index < value.length; index += 1) {
+                if (index > 0)
+                    countSuccessfulToolResultBytes(budget, 1);
+                countSuccessfulToolResultValue(value[index], budget, depth + 1, rejectUndefined);
+            }
+            countSuccessfulToolResultBytes(budget, 1);
+            return;
+        }
+        countSuccessfulToolResultBytes(budget, 1);
+        let emitted = 0;
+        for (const key in value) {
+            if (!Object.hasOwn(value, key))
+                continue;
+            const item = value[key];
+            if (item === undefined) {
+                if (rejectUndefined)
+                    throw new Error('unsupported JSON value');
+                continue;
+            }
+            if (emitted > 0)
+                countSuccessfulToolResultBytes(budget, 1);
+            countSuccessfulToolResultJsonStringBytes(budget, key);
+            countSuccessfulToolResultBytes(budget, 1);
+            countSuccessfulToolResultValue(item, budget, depth + 1, rejectUndefined);
+            emitted += 1;
+        }
+        countSuccessfulToolResultBytes(budget, 1);
+    }
+    finally {
+        budget.active.delete(value);
+    }
+}
+function countSuccessfulToolResultJsonStringBytes(budget, value) {
+    const remainingBytes = MAX_SUCCESS_TOOL_RESULT_BYTES - budget.bytes;
+    const bytes = serializedByteLength(value, remainingBytes);
+    if (bytes > remainingBytes)
+        throw new SuccessfulToolResultBudgetViolation('byte');
+    budget.bytes += bytes;
+}
+function countSuccessfulToolResultBytes(budget, bytes) {
+    if (budget.bytes > MAX_SUCCESS_TOOL_RESULT_BYTES - bytes) {
+        throw new SuccessfulToolResultBudgetViolation('byte');
+    }
+    budget.bytes += bytes;
+}
+function successfulToolResultBudgetError(serverId, toolName, limit) {
+    return new McpToolCallError(serverId, toolName, `server returned a tool result that exceeds the ${limit} limit`);
+}
 function summarizeErrorContent(content) {
     if (content.length > MAX_SUMMARIZED_ERROR_BLOCKS)
         return OVERSIZED_TOOL_ERROR_CONTENT;