@agent-wire/terminal 1.7.7 → 1.7.10

package/dist/tool-projection.js

@@ -15,6 +15,37 @@
  */
 import { createHash } from 'crypto';
 import { z } from 'zod';
+export const CHAIN_RETRY_HELP = 'Reuse the same key to retry safely; a replay returns the first run and charges nothing.';
+/** REST run controls shared by hosted, terminal, and generated chain tools. */
+export function chainRunInputShape() {
+    return {
+        mode: z.enum(['quote', 'trusted', 'auto']),
+        input: z.record(z.unknown()).optional(),
+        idempotency_key: z.string().trim().min(1).max(256).optional().describe(CHAIN_RETRY_HELP),
+        chain_id: z.string().uuid().optional(),
+        quote_id: z.string().optional(),
+        max_credits: z.number().int().positive().safe().optional(),
+        entry_mode: z.enum(['start', 'direct']).optional(),
+        entry: z.object({ mode: z.enum(['start', 'direct']).optional() }).optional(),
+        include_steps: z.boolean().optional(),
+        async_ack: z.boolean().optional(),
+        timeout_ms: z.number().optional(),
+    };
+}
+export function toolDefinitionInputShape(def) {
+    const shape = jsonSchemaToZodShape(def.parameterSchema);
+    if (['wire_poll_chain_run', 'wire_run_chain_poll'].includes(def.toolName)) {
+        return { ...shape, chain: z.string().optional(), run_id: z.string().optional(),
+            run_handle_path: z.string().optional().describe('The run_handle_path returned by wire_run_chain.'), include_steps: z.boolean().optional() };
+    }
+    return isChainRunBinding(def.binding)
+        ? { chain: z.string().min(1), ...chainRunInputShape(), ...shape }
+        : shape;
+}
+function isChainRunBinding(binding) {
+    return (binding.kind === 'api_method' && binding.method === 'runChain')
+        || (binding.kind === 'http_api' && /^\/(?:api\/v1\/)?wire\/chains\/run$/.test(binding.path ?? ''));
+}
 /**
  * JSON Schema → zod raw shape, degrade-open.
  *
@@ -85,7 +116,7 @@ export function parseToolDefinition(item) {
     const toolName = typeof data.tool_name === 'string' ? data.tool_name.trim() : '';
     if (!/^[a-z][a-z0-9_]*$/.test(toolName))
         return null;
-    const parameterSchema = data.parameter_schema && typeof data.parameter_schema === 'object' && !Array.isArray(data.parameter_schema)
+    let parameterSchema = data.parameter_schema && typeof data.parameter_schema === 'object' && !Array.isArray(data.parameter_schema)
         ? data.parameter_schema
         : null;
     if (!parameterSchema)
@@ -110,9 +141,23 @@ export function parseToolDefinition(item) {
     else {
         return null;
     }
+    let description = typeof data.description === 'string' ? data.description : (item.title ?? toolName);
+    if (isChainRunBinding(binding))
+        description = `${description} ${CHAIN_RETRY_HELP}`;
+    // Advertise the create endpoint's scope alias for older published schemas.
+    // Both hosted and packaged clients use this parser before strict validation.
+    if ((binding.kind === 'api_method' && binding.method === 'createAction')
+        || (binding.kind === 'http_api' && /^\/(?:api\/v1\/)?wire\/actions?\/create$/.test(binding.path ?? ''))) {
+        const scopeHelp = 'scope: fleet limits the chain to agents of your operator; unscoped is public. The endpoint maps top-level scope to action_definition.scope (stored in definition.scope and structured_data.definition.scope). Both fields must agree when supplied.';
+        parameterSchema = { ...parameterSchema, properties: {
+                scope: { type: 'string', enum: ['fleet', 'unscoped'], description: scopeHelp },
+                ...(parameterSchema.properties ?? {}),
+            } };
+        description = `${description} ${scopeHelp}`;
+    }
     return {
         toolName,
-        description: typeof data.description === 'string' ? data.description : (item.title ?? toolName),
+        description,
         parameterSchema,
         binding,
         gate: data.gate === 'identity' ? 'identity' : 'confirmed',
@@ -157,7 +202,8 @@ export async function invokeToolDefinition(def, api, params) {
         if (typeof method !== 'function') {
             throw new Error(`tool_definition ${def.configHandle ?? def.toolName} binds to unknown adapter method '${def.binding.method}'`);
         }
-        return method.call(api, params);
+        const result = await method.call(api, params);
+        return isChainRunBinding(def.binding) || /chain|action_invoke/.test(def.toolName) ? compactChainReply(result) : result;
     }
     const httpMethod = def.binding.http_method ?? 'POST';
     const path = ('/' + (def.binding.path ?? '/').trim().replace(/^\/+/, '')).replace(/^\/api\/v1(?=\/|$)/, '') || '/';
@@ -167,20 +213,25 @@ export async function invokeToolDefinition(def, api, params) {
             if (value !== undefined)
                 query.set(key, String(value));
         }
-        return api.request(httpMethod, `${path}${query.size ? `${path.includes('?') ? '&' : '?'}${query}` : ''}`);
+        const result = await api.request(httpMethod, `${path}${query.size ? `${path.includes('?') ? '&' : '?'}${query}` : ''}`);
+        return /chain|action_invoke/.test(def.toolName) ? compactChainReply(result) : result;
     }
-    return api.request(httpMethod, path, params);
+    const result = await api.request(httpMethod, path, params);
+    return isChainRunBinding(def.binding) ? compactChainReply(result) : result;
 }
-/** Discover graph definitions through the free catalog, without buying/searching. */
-export async function fetchCatalogDefinitionItems(api, kind) {
+/** Discover through the free catalog. Only explicit user refreshes force cursor zero. */
+export async function fetchCatalogDefinitionItems(api, kind, forceRefresh = false) {
     const items = [];
     let cursor = 0;
     while (cursor !== null) {
-        const page = await api.request('GET', `/wire/catalog?action=list&kinds=${kind}&limit=200&cursor=${cursor}&refresh=${cursor === 0}`);
+        const page = await api.request('GET', `/wire/catalog?action=list&kinds=${kind}&limit=200&cursor=${cursor}&refresh=${forceRefresh && cursor === 0}`);
         const handles = page.entries.map(e => e.handle ?? e.name);
         if (handles.length) {
             const inspected = await api.request('GET', `/wire/catalog?action=inspect&names=${encodeURIComponent(handles.join(','))}`);
             const results = inspected.results ?? (inspected.entry && inspected.definition ? [{ entry: inspected.entry, definition: inspected.definition }] : []);
+            if (results.length !== handles.length) {
+                throw new Error('Catalog inspection was incomplete; retaining the previous tool set');
+            }
             for (const result of results) {
                 items.push({ type: kind === 'surface' ? 'surface_config' : kind, handle_path: result.entry.handle, structured_data: result.definition });
             }
@@ -192,4 +243,489 @@ export async function fetchCatalogDefinitionItems(api, kind) {
     }
     return items;
 }
+/** Reporting only: execution inputs and stored invocation results are untouched. */
+export const MAX_CHAIN_REPORT_BYTES = 64 * 1024;
+export const MAX_CHAIN_REPORT_ARRAY_ITEMS = 50;
+const STRING_BYTES = 2048;
+const OPAQUE_FIELDS = new Set(['token', 'quote_id', 'idempotency_key', 'signature', 'cursor', 'next_cursor']);
+const PRIMARY_LOCATOR_KEYS = ['handle_path', 'contribution_handle', 'head_handle'];
+const isReportLocator = (key, value) => /^(?:handle(?:_path|Path)?|.+(?:_handle(?:_path)?|Handle(?:Path)?))$/.test(key)
+    && typeof value === 'string' && value.length <= 256 && /^[a-z0-9_-]+\/\d+\/\d+$/i.test(value);
+const encoder = new TextEncoder();
+const bytes = (value) => encoder.encode(JSON.stringify(value) ?? 'null').length;
+const renderedReportBytes = (value, trace = false) => encoder.encode(JSON.stringify(value, null, trace ? undefined : 2) ?? 'null').length;
+const isOmissionCounts = (value) => Boolean(value && typeof value === 'object'
+    && !Array.isArray(value) && Object.keys(value).length
+    && Object.entries(value).every(([path, count]) => typeof count === 'number'
+        ? Number.isSafeInteger(count) && count >= 0
+        : ['', '/step_results', '/stepResults'].includes(path) && typeof count === 'string' && count.length <= 64 && /^(?:0|[1-9]\d*)$/.test(count)));
+// Large aggregate and direct step totals use decimal text without rounding.
+const encodeCount = (count) => count <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(count) : count.toString();
+// The empty JSON pointer summarizes descendant rows, not direct step rows.
+// Keep direct step counts separate so replay never counts descendants as steps.
+function summarizeOmissions(counts) {
+    const summary = {};
+    let descendants = BigInt(0);
+    for (const [path, count] of Object.entries(counts)) {
+        if (path === '/step_results' || path === '/stepResults')
+            summary[path] = count;
+        else
+            descendants += BigInt(count);
+    }
+    summary[''] = encodeCount(descendants);
+    return summary;
+}
+function normalizeOmissions(value, trace = false) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const row = value;
+    if (!isOmissionCounts(row._omitted))
+        return value;
+    const required = { _omitted: row._omitted };
+    for (const key of PRIMARY_LOCATOR_KEYS)
+        if (isReportLocator(key, row[key]))
+            required[key] = row[key];
+    return renderedReportBytes(required, trace) > MAX_CHAIN_REPORT_BYTES - 512
+        ? { ...row, _omitted: summarizeOmissions(row._omitted), report_truncated: true } : value;
+}
+// Reporting must not turn a completed invocation into a tool failure. This
+// bounded fallback preserves recovery locators and counts all removed steps.
+function minimalChainReply(value, trace = false) {
+    const row = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    const reply = {};
+    for (const key of PRIMARY_LOCATOR_KEYS)
+        if (isReportLocator(key, row[key]))
+            reply[key] = row[key];
+    for (const key of ['status', 'run_id'])
+        if (typeof row[key] === 'string' && bytes(row[key]) <= 256)
+            reply[key] = row[key];
+    const omissions = isOmissionCounts(row._omitted) ? { ...row._omitted } : {};
+    for (const key of ['step_results', 'stepResults'])
+        if (Array.isArray(row[key]) && row[key].length) {
+            omissions[`/${key}`] = encodeCount(BigInt(omissions[`/${key}`] ?? 0) + BigInt(row[key].length));
+        }
+    if (Object.keys(omissions).length)
+        reply._omitted = omissions;
+    reply.report_truncated = true;
+    if (renderedReportBytes(reply, trace) > MAX_CHAIN_REPORT_BYTES)
+        reply._omitted = summarizeOmissions(omissions);
+    return reply;
+}
+const hint = (handle) => handle
+    ? `read the full item with wire_read(${handle})`
+    : "inspect the run's authenticated invocation receipt";
+const marker = (handle) => ` [truncated; ${hint(handle)}]`;
+// With no locator in scope, report the cut without inventing a retrieval hint.
+const displayHint = (message) => message.replace(/; inspect the run's authenticated invocation receipt/g, '');
+function prefix(value, limit) {
+    const encoded = encoder.encode(value);
+    if (encoded.length <= limit)
+        return value;
+    let end = Math.max(0, limit);
+    while (end > 0 && (encoded[end] & 0xc0) === 0x80)
+        end--;
+    return new TextDecoder().decode(encoded.subarray(0, end));
+}
+function bounded(value, limit, handle, trace = false, reservedResult = 0, resultFits = false, keepResultWhole = resultFits) {
+    const budget = { left: limit, truncated: false, savings: 0 };
+    const take = (n) => { if (budget.left < n)
+        return false; budget.left -= n; return true; };
+    // Locator preference changes presentation, never the established row shares.
+    // Charge the original hint and account for any shorter rendered text when
+    // checking the pretty budget, so rounding cannot discard another locator.
+    const present = (original, preferred) => {
+        const cost = bytes(original);
+        const output = displayHint(bytes(preferred) <= cost ? preferred : original);
+        budget.savings += cost - bytes(output);
+        return output;
+    };
+    const note = (message, preferred = message) => {
+        budget.truncated = true;
+        const fallback = '[truncated; reply size limit]';
+        return take(bytes(message)) ? present(message, preferred) : take(bytes(fallback)) ? fallback : take(4) ? null : null;
+    };
+    const share = (allowance, work) => {
+        const remaining = budget.left;
+        budget.left = Math.max(0, allowance);
+        const result = work();
+        budget.left = remaining - (Math.max(0, allowance) - budget.left);
+        return result;
+    };
+    const addOmission = (context, path, count) => {
+        const exists = Object.hasOwn(context.values, path);
+        const previous = exists ? context.values[path] : 0;
+        if (!Number.isSafeInteger(count) || count < 0) {
+            context.collision = true;
+            budget.truncated = true;
+            return;
+        }
+        const exact = BigInt(previous) + BigInt(count);
+        if (exact > BigInt(Number.MAX_SAFE_INTEGER) && !['', '/step_results', '/stepResults'].includes(path)) {
+            // Preserve the existing safe per-array count and summarize the new rows
+            // in its containing object instead of rounding or losing them.
+            context.collision = true;
+            budget.truncated = true;
+            addOmission(context, '', count);
+            return;
+        }
+        const next = encodeCount(exact);
+        const overhead = context.reserved ? (Object.keys(context.values).length ? 1 : 0) : bytes('_omitted') + 4;
+        const cost = exists ? bytes(next) - bytes(context.values[path]) : overhead + bytes(path) + bytes(next) + 1;
+        if (cost <= 0 || take(cost)) {
+            context.values[path] = next;
+            context.reserved = true;
+        }
+        else
+            budget.truncated = true;
+    };
+    const omit = (context, path, count) => {
+        budget.truncated = true;
+        if (!context)
+            return;
+        if (!context.enabled) {
+            context.collision = true;
+            return;
+        }
+        addOmission(context, path, count);
+    };
+    const walk = (item, inherited, depth = 0, opaque = false, isTrace = trace, stepList = false, omissions, path = '', preferred = inherited) => {
+        if (isTrace && depth > 20)
+            return note(`[truncated; nesting limit; ${hint(inherited)}]`, `[truncated; nesting limit; ${hint(preferred)}]`);
+        if (typeof item === 'string') {
+            // Signed quotes and continuation tokens must remain executable, not become
+            // seemingly valid tokens with a reporting suffix. The total budget still applies.
+            if (opaque) {
+                if (take(bytes(item)))
+                    return item;
+                budget.truncated = true;
+                return undefined;
+            }
+            const suffix = marker(inherited);
+            const preferredSuffix = displayHint(marker(preferred));
+            const stringLimit = isTrace ? STRING_BYTES : Infinity;
+            const existingSuffix = [suffix, preferredSuffix].find(s => item.endsWith(s)
+                && encoder.encode(item.slice(0, -s.length)).length <= stringLimit);
+            const already = existingSuffix !== undefined;
+            const render = (original, source) => {
+                if (suffix === preferredSuffix)
+                    return original;
+                const cost = bytes(original);
+                const clean = item.endsWith(preferredSuffix) ? item.slice(0, -preferredSuffix.length) : source;
+                let low = 0, high = Math.min(encoder.encode(source).length, encoder.encode(clean).length);
+                while (low < high) {
+                    const mid = Math.ceil((low + high) / 2);
+                    if (bytes(prefix(clean, mid) + preferredSuffix) <= cost)
+                        low = mid;
+                    else
+                        high = mid - 1;
+                }
+                return present(original, prefix(clean, low) + preferredSuffix);
+            };
+            const plainFits = encoder.encode(item).length <= stringLimit;
+            if (!plainFits && existingSuffix === preferredSuffix && suffix !== preferredSuffix && bytes(item) <= budget.left) {
+                // A REST pass may already have rendered the preferred suffix. Keep it
+                // byte-exact without marking a new cut, but charge the inherited-hint
+                // allowance that established the surrounding rows' shares. Otherwise
+                // recognizing the suffix can silently displace a later array on retry.
+                let low = 0, high = Math.min(stringLimit, encoder.encode(item).length);
+                while (low < high) {
+                    const mid = Math.ceil((low + high) / 2);
+                    if (bytes(prefix(item, mid) + suffix) <= budget.left)
+                        low = mid;
+                    else
+                        high = mid - 1;
+                }
+                const cost = Math.max(bytes(item), bytes(prefix(item, low) + suffix));
+                take(cost);
+                budget.savings += cost - bytes(item);
+                return item;
+            }
+            if ((plainFits || already) && take(bytes(item))) {
+                return !plainFits && already && existingSuffix !== preferredSuffix
+                    ? render(item, item.slice(0, -existingSuffix.length)) : item;
+            }
+            budget.truncated = true;
+            const source = already ? item.slice(0, -existingSuffix.length) : item;
+            // Search the serialized size, including real JSON escaping and UTF-8.
+            let low = 0, high = Math.min(stringLimit, encoder.encode(source).length);
+            while (low < high) {
+                const mid = Math.ceil((low + high) / 2);
+                if (bytes(prefix(source, mid) + suffix) <= budget.left)
+                    low = mid;
+                else
+                    high = mid - 1;
+            }
+            const clipped = prefix(source, low) + suffix;
+            return take(bytes(clipped)) ? render(clipped, prefix(source, low)) : note('[truncated; reply size limit]');
+        }
+        if (!item || typeof item !== 'object') {
+            if (take(bytes(item)))
+                return item;
+            budget.truncated = true;
+            return undefined;
+        }
+        if (item instanceof Date)
+            return walk(item.toJSON(), inherited, depth + 1, false, isTrace, false, undefined, '', preferred);
+        if (Array.isArray(item)) {
+            if (!take(2))
+                return null;
+            const output = [];
+            const count = isTrace && !stepList ? Math.min(item.length, MAX_CHAIN_REPORT_ARRAY_ITEMS) : item.length;
+            for (let i = 0; i < count; i++) {
+                if (budget.left < 256)
+                    break;
+                const available = budget.left - 128 - (output.length ? 1 : 0);
+                const slots = isTrace ? Math.min(count - i, Math.floor(available / 256)) : 1;
+                const allowance = slots > 0 ? Math.floor(available / slots) : 0;
+                // A tiny share cannot hold a useful item. Count the remaining items
+                // instead of emitting empty objects or null locators for each of them.
+                if (allowance < 256)
+                    break;
+                const remaining = budget.left;
+                const savings = budget.savings;
+                take(output.length ? 1 : 0);
+                const child = share(allowance, () => walk(item[i], inherited, depth + 1, false, isTrace, false, omissions, `${path}/${i}`, preferred));
+                const source = item[i];
+                if (source && typeof source === 'object' && !Array.isArray(source) && child && typeof child === 'object') {
+                    const row = source;
+                    const kept = child;
+                    const lostLocator = PRIMARY_LOCATOR_KEYS.some(key => typeof row[key] === 'string' && row[key].length <= 256 && /^[a-z0-9_-]+\/\d+\/\d+$/i.test(row[key]) && kept[key] !== row[key]);
+                    if (lostLocator || (Object.values(row).some(v => v !== undefined) && Object.values(kept).every(v => v === undefined))) {
+                        budget.left = remaining;
+                        budget.savings = savings;
+                        break;
+                    }
+                }
+                output.push(child);
+            }
+            if (output.length < item.length)
+                omit(omissions, path, item.length - output.length);
+            return output;
+        }
+        if (!take(2))
+            return null;
+        const row = item;
+        const locatorKey = (key) => isReportLocator(key, row[key]);
+        // Prefer the row's primary locator, then current aliases, then relational
+        // aliases (prior/root/parent/source/target). Insertion order only breaks ties.
+        const aliasRank = (key) => /^(?:prior|previous|root|parent|source|target|chain)(?:_|[A-Z])/.test(key) ? 1 : 0;
+        const originalAliases = depth > 0 ? Object.keys(row) : [];
+        const aliases = [...originalAliases].sort((a, b) => aliasRank(a) - aliasRank(b));
+        const ownHandleKey = [...PRIMARY_LOCATOR_KEYS, ...aliases].find(locatorKey);
+        const allowanceHandleKey = [...PRIMARY_LOCATOR_KEYS, ...originalAliases].find(locatorKey);
+        const currentHandle = allowanceHandleKey ? row[allowanceHandleKey] : inherited;
+        const preferredHandle = ownHandleKey ? row[ownHandleKey] : preferred;
+        const output = {};
+        // Recovery locators are paid before the answer, inherited omission maps,
+        // or any share reservation can spend their bytes.
+        const prepaidLocators = new Set();
+        if (depth === 0)
+            for (const [key, child] of Object.entries(row)) {
+                if (!PRIMARY_LOCATOR_KEYS.includes(key) || !locatorKey(key))
+                    continue;
+                if (!take(bytes(key) + bytes(child) + 1 + (prepaidLocators.size ? 1 : 0))) {
+                    budget.truncated = true;
+                    return minimalChainReply(row, isTrace);
+                }
+                output[key] = child;
+                prepaidLocators.add(key);
+            }
+        // Pay the fitting answer before metadata. Keep its former reserve in the
+        // allocation calculation below so existing trace shares remain stable.
+        const wantsWholeResult = depth === 0 && !isTrace && keepResultWhole && Object.hasOwn(row, 'result');
+        const wholeResult = wantsWholeResult && take(bytes(row.result));
+        const prepaidResult = wholeResult ? bytes(row.result) : 0;
+        if (wantsWholeResult && !wholeResult)
+            budget.truncated = true;
+        const existingOmissions = row._omitted;
+        const numericOmissions = isOmissionCounts(existingOmissions);
+        const localOmissions = { values: {}, enabled: !Object.hasOwn(row, '_omitted') || Boolean(numericOmissions), collision: false, reserved: false };
+        if (numericOmissions) {
+            const counts = existingOmissions;
+            // Mechanical counts from a REST trace survive the MCP pass as numbers.
+            // Pay for them before any payload, then accumulate further cuts below.
+            if (take(bytes('_omitted') + bytes(counts) + 2)) {
+                localOmissions.values = { ...counts };
+                localOmissions.reserved = true;
+            }
+            else {
+                budget.truncated = true;
+                for (const [path, count] of Object.entries(counts)) {
+                    if (typeof count === 'number')
+                        addOmission(localOmissions, path, count);
+                    else
+                        localOmissions.collision = true;
+                }
+            }
+        }
+        let resultReserve = depth === 0 && Object.hasOwn(row, 'result')
+            ? Math.max(0, Math.min(reservedResult, Math.max(wholeResult && resultFits ? bytes(row.result) + 128 : 0, limit - 4096)) - prepaidResult) : 0;
+        // Primary locators survive even when aliases and payload fill the remaining share.
+        const priority = (key) => locatorKey(key) ? (PRIMARY_LOCATOR_KEYS.includes(key) ? -2 : -1) : depth === 0 && ['receipt', 'cascade', 'child_invocation_receipts'].includes(key) ? 4
+            : /^(stepName|status|.*handle.*|id|.*_id|cost|total_cost)$/.test(key) ? 0
+                : depth === 0 && key === 'result' && resultFits ? 1.5
+                    : ['step_results', 'stepResults'].includes(key) ? 2 : ['output', 'result'].includes(key) ? 3 : 1;
+        const entries = Object.entries(row).filter(([key]) => !prepaidLocators.has(key)
+            && !(numericOmissions && key === '_omitted')).sort(([a], [b]) => priority(a) - priority(b));
+        const followers = depth === 0 && entries.some(([key]) => priority(key) === 4);
+        let processed = 0;
+        for (const [key, child] of entries) {
+            const overhead = bytes(key) + 1 + (Object.keys(output).length ? 1 : 0);
+            // Reserve the omission marker before consuming payload bytes.
+            const minimum = priority(key) <= 0 && (child === null || typeof child !== 'object') ? Math.min(bytes(child), 512) : 128;
+            if (budget.left < overhead + 128 + minimum && !(wholeResult && key === 'result'))
+                break;
+            const remaining = budget.left;
+            const savings = budget.savings;
+            take(overhead);
+            const steps = depth === 0 && (key === 'step_results' || key === 'stepResults');
+            const receipt = depth === 0 && ['receipt', 'cascade', 'child_invocation_receipts'].includes(key);
+            const available = Math.max(0, budget.left - (depth === 0 && key !== 'result' ? Math.max(128, resultReserve) : 128));
+            const stepShare = !Object.hasOwn(row, 'result') ? available : resultFits || wholeResult
+                ? available - (followers ? Math.min(1024, Math.floor(available / 2)) : 0)
+                : Math.floor(available / 2);
+            const childPath = `/${key.replace(/~/g, '~0').replace(/\//g, '~1')}`;
+            const reported = wholeResult && key === 'result' ? child : steps
+                ? share(stepShare, () => walk(child, currentHandle, depth + 1, false, true, true, localOmissions, childPath, preferredHandle))
+                : share(receipt && resultReserve ? Math.min(available, Math.floor(budget.left / 2)) : available, () => walk(child, currentHandle, depth + 1, OPAQUE_FIELDS.has(key), isTrace || receipt, false, localOmissions, childPath, preferredHandle));
+            const emptyObject = reported && typeof reported === 'object' && !Array.isArray(reported)
+                && Object.values(reported).every(v => v === undefined) && child && typeof child === 'object' && Object.values(child).some(v => v !== undefined);
+            if ((reported === null && child !== null) || emptyObject) {
+                budget.left = remaining;
+                budget.savings = savings;
+                break;
+            }
+            output[key] = reported;
+            if (depth === 0 && key === 'result')
+                resultReserve = 0;
+            processed++;
+        }
+        // An earlier metadata field may stop the walk. Its reservation still
+        // belongs to the fitting answer, which must not disappear with the trace.
+        if (wholeResult && !Object.hasOwn(output, 'result')) {
+            take(bytes('result') + 1 + (Object.keys(output).length ? 1 : 0));
+            output.result = row.result;
+        }
+        // Keep the array's existing charge when its count fits in the child share.
+        // If that share ran out, the parent's reserved 128 bytes pay the missing
+        // count, even when the entire step field was omitted.
+        if (depth === 0) {
+            for (const key of ['step_results', 'stepResults']) {
+                if (!Array.isArray(row[key]))
+                    continue;
+                const kept = Array.isArray(output[key]) ? output[key].length : 0;
+                const dropped = row[key].length - kept;
+                if (dropped) {
+                    // The count also describes an absent field: zero rows were kept.
+                    // Do not synthesize an empty array, including when an authored
+                    // non-numeric _omitted field prevents mechanical counting.
+                    const path = `/${key}`;
+                    const previous = numericOmissions ? BigInt(existingOmissions[path] ?? 0) : BigInt(0);
+                    const counted = BigInt(localOmissions.values[path] ?? 0) - previous;
+                    const missing = BigInt(dropped) - counted;
+                    if (missing > BigInt(0))
+                        omit(localOmissions, path, Number(missing));
+                }
+            }
+        }
+        if (localOmissions.reserved)
+            output._omitted = localOmissions.values;
+        if (localOmissions.collision)
+            output.report_truncated = true;
+        if (processed < entries.length) {
+            const message = `[truncated; additional fields omitted; ${hint(currentHandle)}]`;
+            const extra = bytes('_truncated') + 2 + bytes(message);
+            budget.truncated = true;
+            if (take(extra))
+                output._truncated = present(message, `[truncated; additional fields omitted; ${hint(preferredHandle)}]`);
+        }
+        return output;
+    };
+    return { value: walk(value, handle, 0, false, trace, trace && Array.isArray(value)), truncated: budget.truncated, savings: budget.savings };
+}
+function report(value, handle, trace = false) {
+    value = normalizeOmissions(value, trace);
+    let limit = 60 * 1024; // Leave room for the REST run/poll envelope additions.
+    const hasResult = value && typeof value === 'object' && !Array.isArray(value) && Object.hasOwn(value, 'result');
+    const answer = hasResult ? value.result : undefined;
+    const resultBytes = hasResult ? bytes(answer) + 1024 : 0;
+    // Keep a fitting answer whole; oversized answers still share room with steps.
+    // MCP must fit pretty JSON too: promoting a compact-only fit costs trace
+    // handles even though the result still cannot be shown whole.
+    const prettyFits = trace || !hasResult || (resultBytes <= MAX_CHAIN_REPORT_BYTES
+        && encoder.encode(JSON.stringify({ result: answer }, null, 2)).length <= MAX_CHAIN_REPORT_BYTES - 1024);
+    const resultFits = resultBytes <= 60 * 1024 - 4096 && prettyFits;
+    const keepResultWhole = !trace && Boolean(hasResult) && prettyFits;
+    const reservedResult = resultFits ? resultBytes : Math.floor(limit / 2);
+    const primaryBytes = value && typeof value === 'object' && !Array.isArray(value) ? Object.entries(value)
+        .filter(([key, value]) => PRIMARY_LOCATOR_KEYS.includes(key) && isReportLocator(key, value))
+        .reduce((sum, [key, value]) => sum + bytes(key) + bytes(value) + 2, 0) : 0;
+    const priorOmissions = value && typeof value === 'object' && !Array.isArray(value)
+        ? value._omitted : undefined;
+    const omissionBytes = isOmissionCounts(priorOmissions)
+        ? bytes('_omitted') + bytes(priorOmissions) + 2 : 0;
+    const protectedBytes = primaryBytes + omissionBytes;
+    const fixedBytes = keepResultWhole ? bytes('result') + bytes(answer) + 1 + protectedBytes : 0;
+    const minimum = fixedBytes ? fixedBytes + 128 : 512 + protectedBytes;
+    // Large whole MCP answers can use the transport's remaining headroom;
+    // the compact REST envelope reserve does not belong to their trace.
+    if (keepResultWhole && !resultFits)
+        limit = MAX_CHAIN_REPORT_BYTES - 512;
+    limit = Math.max(limit, minimum);
+    let result = bounded(value, limit, handle, trace, reservedResult, resultFits, keepResultWhole);
+    // Only MCP renders pretty JSON; REST traces use the compact JSON budget.
+    let prettyLen = trace ? 0 : encoder.encode(JSON.stringify(result.value, null, 2) ?? 'null').length + result.savings;
+    while (!trace && prettyLen > MAX_CHAIN_REPORT_BYTES - 512 && limit > minimum) {
+        // Preserve the existing retry sequence for locator retention, while a
+        // whole result and the parent's omission reserve remain fixed costs.
+        const next = Math.max(minimum, Math.min(limit - 1024, Math.floor(limit * (MAX_CHAIN_REPORT_BYTES - 512) / prettyLen)));
+        if (next >= limit)
+            break;
+        const floor = resultFits && limit <= reservedResult + 4096 ? reservedResult : reservedResult + 4096;
+        limit = limit > floor && next < floor ? floor : next;
+        result = bounded(value, limit, handle, trace, reservedResult, resultFits, keepResultWhole);
+        prettyLen = encoder.encode(JSON.stringify(result.value, null, 2) ?? 'null').length + result.savings;
+    }
+    if (result.truncated && result.value && typeof result.value === 'object' && !Array.isArray(result.value)) {
+        result.value.report_truncated = true;
+    }
+    // The actual rendered reply, including its flag, is the final authority.
+    // Metadata can make an otherwise fitting answer impossible alongside the
+    // primary locator and omission counts. Cut the answer in that case.
+    const renderedBytes = (reply) => renderedReportBytes(reply, trace);
+    while (renderedBytes(result.value) > MAX_CHAIN_REPORT_BYTES) {
+        const next = Math.max(512 + protectedBytes, Math.min(limit - 1024, Math.floor(limit * (MAX_CHAIN_REPORT_BYTES - 512) / renderedBytes(result.value))));
+        if (next >= limit)
+            return minimalChainReply(value, trace);
+        limit = next;
+        result = bounded(value, limit, handle, trace, reservedResult, resultFits, false);
+        if (result.value && typeof result.value === 'object' && !Array.isArray(result.value)) {
+            result.value.report_truncated = true;
+        }
+    }
+    return result.value;
+}
+/** Bounded list for local use; transport replies use compactStepTraceReport. */
+export function compactStepTrace(value, inheritedHandle) {
+    try {
+        return report(value, inheritedHandle, true);
+    }
+    catch {
+        return Array.isArray(value) ? [] : minimalChainReply(value, true);
+    }
+}
+/** Portable REST envelope: JSON arrays cannot carry their own omission count. */
+export function compactStepTraceReport(value, inheritedHandle) {
+    const step_results = compactStepTrace(value, inheritedHandle);
+    const dropped = Array.isArray(value) ? value.length - (Array.isArray(step_results) ? step_results.length : 0) : 0;
+    return { step_results, ...(dropped ? { _omitted: { '/step_results': dropped }, report_truncated: true } : {}) };
+}
+export function compactChainReply(value) {
+    try {
+        return report(value);
+    }
+    catch {
+        return minimalChainReply(value);
+    }
+}
 //# sourceMappingURL=tool-projection.js.map