@myagentroam/agent 0.9.134 → 0.9.136

package/dist/runtime/context-gc.js

@@ -1,5 +1,5 @@
 import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcLogicalPathKey, contextGcMinimumUsageGrowth, contextGcRecordSourceHash, contextGcTargetKey, normalizeContextGcReplacements } from '../session/context-gc-checkpoint.js';
-import { contextGcApplyPatchInputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcExecResult } from '../session/context-gc-replacements.js';
+import { contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from '../session/context-gc-replacements.js';
 import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentPriorFinalIsRetained, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, contextGcSubagentSnapshotTurnId, normalizeContextGcSubagentSnapshot } from '../session/context-gc-subagent.js';
 import { parseReadContextOutput } from '../tools/read-context.js';
 import { CONTEXT_GC_TOKEN_ESTIMATOR, contextGcCacheImpact, contextGcMessageTokens, contextGcPrefixTokens, contextGcReclaimedTokens } from './context-gc-tokens.js';
@@ -167,8 +167,12 @@ export function inspectContextGc(input) {
     });
     if (stageAPlan?.economics.passes) {
         const exec = collectExecCandidates(input, groups, existingTargets, usageRatio);
+        const codeMode = collectCodeModeCandidates(input, groups, existingTargets, usageRatio);
         const web = collectWebCandidates(input, groups, existingTargets, usageRatio);
-        const protectedCandidateTokens = deterministicProtectedTokens + exec.protectedTokens + web.protectedTokens;
+        const protectedCandidateTokens = deterministicProtectedTokens +
+            exec.protectedTokens +
+            codeMode.protectedTokens +
+            web.protectedTokens;
         const stageAPlanWithProtectedCandidates = evaluateCandidateSet(input, existing, deterministicCandidates, {
             stage: 'STAGE_A',
             contextUsageTokens,
@@ -177,7 +181,7 @@ export function inspectContextGc(input) {
             normalRolloutOrdinal,
             protectedCandidateTokens
         }) ?? stageAPlan;
-        const marginal = mergeMarginalLargeOutputCandidates(input, existing, deterministicCandidates, [...exec.eligible, ...web.eligible], stageAPlanWithProtectedCandidates, {
+        const marginal = mergeMarginalLargeOutputCandidates(input, existing, deterministicCandidates, [...exec.eligible, ...codeMode.eligible, ...web.eligible], stageAPlanWithProtectedCandidates, {
             contextUsageTokens,
             usageRatio,
             usageRecord,
@@ -185,7 +189,7 @@ export function inspectContextGc(input) {
             protectedCandidateTokens
         });
         const plan = finalizePlan(input, marginal ?? stageAPlanWithProtectedCandidates);
-        const retryAfterRollouts = Math.min(exec.retryAfterRollouts, web.retryAfterRollouts);
+        const retryAfterRollouts = Math.min(exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts);
         return plan
             ? {
                 plan,
@@ -196,26 +200,99 @@ export function inspectContextGc(input) {
             : {};
     }
     const exec = collectExecCandidates(input, groups, existingTargets, usageRatio);
+    const codeMode = collectCodeModeCandidates(input, groups, existingTargets, usageRatio);
     const web = collectWebCandidates(input, groups, existingTargets, usageRatio);
-    const combined = evaluateCandidateSet(input, existing, [...deterministicCandidates, ...exec.eligible, ...web.eligible], {
+    const combined = evaluateCandidateSet(input, existing, [...deterministicCandidates, ...exec.eligible, ...codeMode.eligible, ...web.eligible], {
         stage: 'STAGE_A_AND_EXEC',
         contextUsageTokens,
         usageRatio,
         usageRecord,
         normalRolloutOrdinal,
-        protectedCandidateTokens: deterministicProtectedTokens + exec.protectedTokens + web.protectedTokens
+        protectedCandidateTokens: deterministicProtectedTokens +
+            exec.protectedTokens +
+            codeMode.protectedTokens +
+            web.protectedTokens
     });
     if (combined?.economics.passes) {
         const plan = finalizePlan(input, combined);
         return plan ? { plan } : {};
     }
-    const retryAfterRollouts = Math.min(stageA.retryAfterRollouts, subagent.retryAfterRollouts, exec.retryAfterRollouts, web.retryAfterRollouts);
-    return deterministicProtectedTokens + exec.protectedTokens + web.protectedTokens >=
+    const retryAfterRollouts = Math.min(stageA.retryAfterRollouts, subagent.retryAfterRollouts, exec.retryAfterRollouts, codeMode.retryAfterRollouts, web.retryAfterRollouts);
+    return deterministicProtectedTokens +
+        exec.protectedTokens +
+        codeMode.protectedTokens +
+        web.protectedTokens >=
         contextGcMinimumReclaimedTokens(contextUsageTokens, input.contextWindowTokens) &&
         Number.isFinite(retryAfterRollouts)
         ? { retryAfterRollouts }
         : {};
 }
+function collectCodeModeCandidates(input, groups, existingTargets, usageRatio) {
+    const eligible = [];
+    let protectedTokens = 0;
+    let retryAfterRollouts = Infinity;
+    for (const group of [...groups.values()].filter((item) => item.toolName === 'code_mode')) {
+        if (!group.call ||
+            !group.result ||
+            group.failed ||
+            !group.completed ||
+            group.call.message.role !== 'tool_call' ||
+            group.result.message.role !== 'tool' ||
+            typeof group.result.message.content !== 'string')
+            continue;
+        const code = normalizeContextGcCodeModeInput(group.call.message.arguments);
+        const completedPayload = group.completed.payload;
+        if (!code || !isRecord(completedPayload) || typeof completedPayload.truncated !== 'boolean')
+            continue;
+        const visibleTokens = contextGcMessageTokens(input, [
+            group.call.message,
+            group.result.message,
+            ...group.aliases.map((alias) => alias.message)
+        ]);
+        const minimumVisibleTokens = usageRatio >= COMPACT_CREDIT_ACTIVATION_RATIO
+            ? HIGH_WATER_LARGE_TERMINAL_OUTPUT_TOKENS
+            : LARGE_TERMINAL_OUTPUT_TOKENS;
+        if (visibleTokens < minimumVisibleTokens)
+            continue;
+        const callTarget = targetFor(group.call.record, group.call.message);
+        const resultTarget = targetFor(group.result.record, group.result.message);
+        if (!callTarget || !resultTarget)
+            continue;
+        const evidenceSequence = group.result.record.sequence;
+        const replacements = [];
+        if (!existingTargets.has(contextGcTargetKey(callTarget)))
+            replacements.push({
+                kind: 'TOOL_CALL_INPUT',
+                toolName: 'code_mode',
+                callId: group.callId,
+                target: callTarget,
+                replacementArguments: contextGcCodeModeInputReplacement(code),
+                providerAliasTargets: group.aliases
+                    .map(({ record, message }) => targetFor(record, message))
+                    .filter((target) => target !== undefined),
+                evidenceSequence
+            });
+        if (!existingTargets.has(contextGcTargetKey(resultTarget)))
+            replacements.push({
+                kind: 'CODE_MODE_OUTPUT',
+                callId: group.callId,
+                target: resultTarget,
+                replacementContent: contextGcCodeModeOutputReplacement(group.result.message.content, completedPayload.truncated),
+                evidenceSequence
+            });
+        if (replacements.length === 0)
+            continue;
+        const observedRollouts = successfulRolloutsAfter(input.records, evidenceSequence, input.modelId, input.contextWindowTokens);
+        const candidate = { replacements, observedRollouts, evidenceSequence };
+        if (observedRollouts >= CONTEXT_GC_POLICY.largeExecProtectionRollouts)
+            eligible.push(candidate);
+        else {
+            protectedTokens += candidateTokens(input, candidate);
+            retryAfterRollouts = Math.min(retryAfterRollouts, CONTEXT_GC_POLICY.largeExecProtectionRollouts - observedRollouts);
+        }
+    }
+    return { eligible, protectedTokens, retryAfterRollouts };
+}
 function mergeMarginalLargeOutputCandidates(input, existing, deterministicCandidates, execCandidates, stageAPlan, state) {
     let selected = [...deterministicCandidates];
     let current = stageAPlan;

package/dist/runtime/context-projection.js

@@ -61,6 +61,7 @@ export function applyContextGcReplacementsToMessages(messages, messageSources, r
             else if (replacement.kind === 'TOOL_CALL_INPUT' && next.role === 'tool_call')
                 next = { ...next, arguments: structuredClone(replacement.replacementArguments) };
             else if ((replacement.kind === 'EXEC_OUTPUT' ||
+                replacement.kind === 'CODE_MODE_OUTPUT' ||
                 replacement.kind === 'SUBAGENT_OUTPUT' ||
                 replacement.kind === 'WEB_OUTPUT') &&
                 next.role === 'tool')
@@ -117,7 +118,19 @@ export function restoreModelContext(payload, providerModelId) {
     if (payload.role === 'tool' &&
         typeof payload.content === 'string' &&
         typeof payload.callId === 'string')
-        return { role: 'tool', content: payload.content, callId: payload.callId };
+        return {
+            role: 'tool',
+            content: payload.content,
+            callId: payload.callId,
+            ...(Array.isArray(payload.toolSearchTools)
+                ? {
+                    toolSearchTools: payload.toolSearchTools.filter((tool) => isRecord(tool) &&
+                        typeof tool.name === 'string' &&
+                        typeof tool.description === 'string' &&
+                        isRecord(tool.inputSchema))
+                }
+                : {})
+        };
     if (payload.role === 'tool_call' &&
         typeof payload.callId === 'string' &&
         typeof payload.name === 'string')
@@ -164,13 +177,17 @@ export function restoreModelContext(payload, providerModelId) {
 export function providerToolCallId(message) {
     if (message.role !== 'provider' || message.provider !== 'OPENAI_RESPONSES' || !message.item)
         return undefined;
-    if (message.item.type !== 'function_call' && message.item.type !== 'custom_tool_call')
+    if (message.item.type !== 'function_call' &&
+        message.item.type !== 'custom_tool_call' &&
+        message.item.type !== 'tool_search_call')
         return undefined;
     return typeof message.item.call_id === 'string' ? message.item.call_id : undefined;
 }
 export function providerToolName(message) {
     if (message.role !== 'provider' || !message.item)
         return undefined;
+    if (message.item.type === 'tool_search_call')
+        return 'tool_search';
     return typeof message.item.name === 'string' ? message.item.name : undefined;
 }
 function targetFromMessage(record, message) {

package/dist/sandbox/linux/bubblewrap-sandbox-executor.js

@@ -61,13 +61,14 @@ export class BubblewrapSandboxExecutor {
         validateProfile(this.options.profile);
         await validateBackend(this.#bubblewrapPath);
         const mounts = await this.#mounts();
+        const runtimeMounts = await trustedRuntimeMounts(request.runtimeDirectories ?? [], mounts);
         const cwd = await workingDirectory(request, mounts, this.options.profile.workingDirectory);
         const command = sandboxCommand(request, mounts);
         const launchDirectory = await mkdtemp(join(tmpdir(), 'mar-agent-bwrap-launch-'));
         const argumentPath = join(launchDirectory, 'arguments');
         const seccompPath = join(launchDirectory, 'seccomp.bpf');
         try {
-            const arguments_ = this.#arguments(mounts, cwd, request);
+            const arguments_ = this.#arguments(mounts, cwd, request, runtimeMounts);
             await Promise.all([
                 writeFile(argumentPath, `${arguments_.join('\0')}\0`, { mode: 0o600, flag: 'wx' }),
                 writeFile(seccompPath, seccompFilter(process.arch), { mode: 0o600, flag: 'wx' })
@@ -150,7 +151,7 @@ export class BubblewrapSandboxExecutor {
         await prepareNestedMountDestinations(ordered);
         return ordered;
     }
-    #arguments(mounts, cwd, request) {
+    #arguments(mounts, cwd, request, runtimeMounts) {
         const networkMode = this.options.profile.networkMode ?? 'NONE';
         const temporaryDirectory = this.options.profile.temporaryDirectory ?? { kind: 'EPHEMERAL' };
         const args = [
@@ -186,6 +187,8 @@ export class BubblewrapSandboxExecutor {
             '--tmpfs',
             '/',
             ...runtimeMountArguments(),
+            ...sandboxDirectoryArguments(runtimeMounts),
+            ...runtimeMounts.flatMap((mount) => ['--ro-bind', mount.source, mount.destination]),
             ...sandboxDirectoryArguments(mounts),
             ...(temporaryDirectory.kind === 'EPHEMERAL' ? ['--tmpfs', '/tmp'] : []),
             '--proc',
@@ -512,6 +515,30 @@ function sandboxDirectoryArguments(mounts) {
     })
         .flatMap((directory) => ['--dir', directory]);
 }
+/** Host assets retain absolute module URLs, but cannot overlay or widen profile mounts. */
+async function trustedRuntimeMounts(directories, mounts) {
+    if (!Array.isArray(directories) || directories.length > 16)
+        throw policyInvalid();
+    const result = [];
+    for (const path of directories) {
+        if (typeof path !== 'string' || path.length > 4096)
+            throw policyInvalid();
+        const source = await secureDirectory(path);
+        if (source.split('/').filter(Boolean).length < 3)
+            throw policyInvalid();
+        const overlaps = (left, right) => left === right || within(left, right) || within(right, left);
+        if (mounts.some((mount) => overlaps(source, mount.source) || overlaps(source, mount.destination)) ||
+            ['/home/mar', '/runtime', '/etc', '/proc', '/dev', '/run', '/tmp'].some((root) => overlaps(source, root)))
+            throw policyInvalid();
+        // These trees are already exposed read-only by the fixed runtime policy.
+        if (['/usr', '/bin', '/sbin', '/lib', '/lib64'].some((root) => within(root, source)))
+            continue;
+        if (result.some((mount) => overlaps(source, mount.source)))
+            throw policyInvalid();
+        result.push({ source, destination: source, access: 'READ_ONLY' });
+    }
+    return result;
+}
 function runtimeMountArguments() {
     const args = [];
     const nodeRuntimeDirectory = resolve(process.execPath, '..', '..');