@myagentroam/agent 0.9.151 → 0.9.153

package/dist/agent-core/host/contracts.d.ts

@@ -1,7 +1,7 @@
 import type { MarAgentEvent } from '../runtime/events.js';
 import type { ClientToolDefinition, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolExecutionContext, ToolExecutionResult } from '../tools/contracts.js';
 export declare const MAR_AGENT_HOST_API_VERSION = "1.0";
-export type MarAgentHostCapability = 'workspace.read' | 'workspace.patch' | 'process.manage' | 'code.execute' | 'user-input.request' | 'event.publish' | 'session.store' | 'mcp.tools' | 'image.read' | 'web.search' | 'web.fetch';
+export type MarAgentHostCapability = 'workspace.read' | 'workspace.patch' | 'process.manage' | 'code.execute' | 'user-input.request' | 'event.publish' | 'session.store' | 'mcp.tools' | 'image.read';
 export interface HostDescription {
     apiVersion: string;
     mode: 'normal' | 'node';

package/dist/agent-core/host/local-agent-host.d.ts

@@ -16,6 +16,7 @@ export interface LocalAgentExecutionMcpBinding extends LocalAgentMcpBinding {
 export interface LocalAgentExecutionExtensions extends HostExecutionExtensions {
     /** Host-private process environment, snapshotted when bound to an execution. */
     readonly environment?: Readonly<Record<string, string>>;
+    isToolAvailable?(name: string, context: Pick<ToolExecutionContext, 'sessionId' | 'executionId' | 'modelId'>): boolean;
     executeTool?(call: ToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
 }
 export declare class LocalAgentHost implements MarAgentHost {
@@ -36,12 +37,6 @@ export declare class LocalAgentHost implements MarAgentHost {
         extensions?: LocalAgentExecutionExtensions;
         environment?: NodeJS.ProcessEnv;
         guaranteedCommands?: Readonly<Record<string, string>>;
-        webSearch?: (input: {
-            query: string;
-            maxResults: number;
-        }, signal: AbortSignal) => Promise<ToolExecutionResult>;
-        webFetch?: boolean;
-        allowUntrustedTls?: boolean;
         resourceIdleTtlMs?: number;
         processExecutor?: LocalProcessExecutor;
         codeModeEngineFactory?: CodeModeEngineFactory;

package/dist/agent-core/host/local-agent-host.js

@@ -25,8 +25,6 @@ export class LocalAgentHost {
     #environment;
     #guaranteedCommands;
     #shell;
-    #hasWebSearch;
-    #hasWebFetch;
     #resourceIdleTtlMs;
     constructor(input) {
         this.#home = resolve(input.homeDirectory);
@@ -34,15 +32,9 @@ export class LocalAgentHost {
         this.#environment = input.environment ?? process.env;
         this.#guaranteedCommands = input.guaranteedCommands ?? {};
         this.#shell = selectExecutionShell(this.#environment);
-        this.#hasWebSearch = input.webSearch !== undefined;
-        this.#hasWebFetch = input.webFetch !== false;
         this.#resourceIdleTtlMs = input.resourceIdleTtlMs;
         const processExecutor = input.processExecutor ?? directLocalProcessExecutor;
         this.#tools = new LocalToolRegistry(this.#workspace, this.#environment, this.#shell.path, {
-            ...(input.webSearch ? { webSearch: input.webSearch } : {}),
-            webFetch: this.#hasWebFetch,
-            allowUntrustedTls: input.allowUntrustedTls ??
-                this.#environment['MAR_AGENT_WEB_FETCH_ALLOW_UNTRUSTED_TLS'] === '1',
             ...(input.codeModeEngineFactory === undefined
                 ? {}
                 : { codeModeEngineFactory: input.codeModeEngineFactory }),
@@ -97,9 +89,7 @@ export class LocalAgentHost {
                 'code.execute',
                 'user-input.request',
                 'event.publish',
-                'session.store',
-                ...(this.#hasWebFetch ? ['web.fetch'] : []),
-                ...(this.#hasWebSearch ? ['web.search'] : [])
+                'session.store'
             ],
             limits: {
                 maxProcesses: TOOL_EXECUTION_LIMITS.maxProcesses,
@@ -113,7 +103,9 @@ export class LocalAgentHost {
         const binding = this.#executionMcp.get(context.executionId);
         const extensions = binding?.extensions ?? this.#extensions;
         if (extensions?.tools?.some((tool) => tool.name === call.name)) {
-            if (binding?.active === false || !extensions.executeTool)
+            if (binding?.active === false ||
+                !extensions.executeTool ||
+                extensions.isToolAvailable?.(call.name, context) === false)
                 throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Host tool execution is unavailable.');
             context.signal.throwIfAborted();
             return extensions.executeTool(call, context);
@@ -141,8 +133,15 @@ export class LocalAgentHost {
     }
     async listExecutionExtensions(context) {
         const binding = this.#executionBinding(context);
-        const { environment: _environment, ...extensions } = binding?.extensions ?? this.#extensions ?? {};
-        return extensions;
+        const { environment: _environment, isToolAvailable, ...extensions } = binding?.extensions ?? this.#extensions ?? {};
+        return {
+            ...extensions,
+            ...(extensions.tools === undefined
+                ? {}
+                : {
+                    tools: extensions.tools.filter((tool) => isToolAvailable?.(tool.name, context) !== false)
+                })
+        };
     }
     emit(event) {
         this.events.push(event);

package/dist/agent-core/prompts/execution-budget.d.ts

@@ -1,3 +1,3 @@
 import type { RolloutBudgetStage } from '../runtime/rollout-budget.js';
-export type ExecutionBudgetEnvironmentStage = Exclude<RolloutBudgetStage, 'normal'> | 'inactive';
+export type ExecutionBudgetEnvironmentStage = Exclude<RolloutBudgetStage, 'normal' | 'exhausted'> | 'inactive';
 export declare function executionBudgetEnvironmentEntry(stage: ExecutionBudgetEnvironmentStage): string;

package/dist/agent-core/prompts/execution-budget.js

@@ -2,10 +2,8 @@ export function executionBudgetEnvironmentEntry(stage) {
     if (stage === 'inactive')
         return '<execution_guidance status="inactive" />';
     const privateInstruction = 'This is internal runtime guidance. Never mention the budget, thresholds, remaining amount, or budget stage in user-visible progress or the final answer.';
-    const guidance = stage === 'exhausted'
-        ? 'The shared rollout budget is exhausted. Do not start or continue investigation, optional work, new tool exploration, or new subagents. Return a concise final answer now using the current verified staged result. Clearly distinguish completed work from anything still incomplete, without mentioning this budget.'
-        : stage === 'finalize'
-            ? 'Enter finalization now. Do not start new investigation or new subagents. Complete only the current atomic change, the minimum necessary verification, and the final answer as soon as possible.'
-            : 'Stop expanding scope and stop optional work. Prefer completing the current objective with the evidence already gathered, and avoid new investigation unless it is strictly required for correctness.';
+    const guidance = stage === 'finalize'
+        ? 'Enter finalization now. Do not start new investigation or new subagents. Complete only the current atomic change, the minimum necessary verification, and the final answer as soon as possible.'
+        : 'Stop expanding scope and stop optional work. Prefer completing the current objective with the evidence already gathered, and avoid new investigation unless it is strictly required for correctness.';
     return `<execution_guidance stage="${stage}">\n${privateInstruction}\n\n${guidance}\n</execution_guidance>`;
 }

package/dist/agent-core/runtime/execution.js

@@ -34,6 +34,7 @@ export class ExecutionLoop {
             const pendingTools = [];
             let incompleteToolCall = false;
             const round = await input.prepareRound(pendingOutputContinuation);
+            input.rolloutBudget?.assertAvailable();
             let sawModelSemanticEvent = false;
             let requestStartedAt;
             let firstModelResponseAt;
@@ -293,11 +294,6 @@ export class ExecutionLoop {
             }
             recoveringFromContextOverflow = false;
             input.observeUsage(roundServerUsage);
-            if (pendingTools.length === 0 && input.mailbox.hasPending()) {
-                await input.mailbox.append();
-                this.finalAnswer = '';
-                continue;
-            }
             const toolResults = await executeRoundTools(pendingTools, round.toolScope);
             for (const result of toolResults) {
                 if ('images' in result && result.images?.length)
@@ -335,11 +331,12 @@ export class ExecutionLoop {
                     this.finalAnswer = '';
             }
             input.rolloutBudget?.recordUsage(latestUsage);
+            if (!input.signal.aborted)
+                input.rolloutBudget?.assertAvailable();
             if (mode !== 'compact' && stop === 'max_output') {
                 const needsContinuation = !sawTool || incompleteToolCall;
                 if (needsContinuation) {
-                    if (maxOutputContinuationUsed ||
-                        (input.rolloutBudget?.active && input.rolloutBudget.stage === 'exhausted'))
+                    if (maxOutputContinuationUsed)
                         throw new MarAgentError('MAR_AGENT_MODEL_OUTPUT_INCOMPLETE', 'Model output reached its limit before completing.');
                     maxOutputContinuationUsed = true;
                     pendingOutputContinuation = {
@@ -358,6 +355,7 @@ export class ExecutionLoop {
                 const aborted = toolResults.find((result) => result.failed)?.error;
                 throw aborted ?? new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.');
             }
+            input.rolloutBudget?.assertAvailable();
             if (input.mailbox.hasPending()) {
                 await input.mailbox.append();
                 this.finalAnswer = '';

package/dist/agent-core/runtime/rollout-budget.d.ts

@@ -19,6 +19,7 @@ export declare class RolloutBudget {
     get stage(): RolloutBudgetStage;
     recordUsage(usage: ModelUsage | undefined): number;
     discard(): void;
+    assertAvailable(): void;
 }
 export declare function resolveRolloutBudgetOptions(options: false | RolloutBudgetOptions | undefined): ResolvedRolloutBudgetOptions | undefined;
 export declare function createRolloutBudget(options: false | RolloutBudgetOptions | undefined): RolloutBudget | undefined;

package/dist/agent-core/runtime/rollout-budget.js

@@ -48,6 +48,10 @@ export class RolloutBudget {
     discard() {
         this.#active = false;
     }
+    assertAvailable() {
+        if (this.stage === 'exhausted')
+            throw new MarAgentError('MAR_AGENT_ROLLOUT_BUDGET_EXCEEDED', 'The shared execution token budget has been exhausted.');
+    }
 }
 export function resolveRolloutBudgetOptions(options) {
     if (options === false)

package/dist/agent-core/sdk/session.js

@@ -234,7 +234,10 @@ export function createSessionOpener(services) {
                     let recordedEnvironment = restored.environmentState;
                     let projectedExecutionBudgetStage;
                     const appendExecutionBudgetEnvironment = () => {
+                        rolloutBudget?.assertAvailable();
                         const currentStage = rolloutBudget?.active ? rolloutBudget.stage : 'inactive';
+                        if (currentStage === 'exhausted')
+                            return;
                         if (currentStage === projectedExecutionBudgetStage)
                             return;
                         const previousStage = projectedExecutionBudgetStage;
@@ -420,6 +423,7 @@ export function createSessionOpener(services) {
                     const catalogContext = {
                         sessionId,
                         executionId,
+                        modelId: selectedModel.id,
                         ...(sessionSource.type === 'subagent'
                             ? internal.mcpExecutionScopeId === undefined
                                 ? {}
@@ -479,12 +483,8 @@ export function createSessionOpener(services) {
                             ? selectedModelForTools.codeMode && description.capabilities.includes('code.execute')
                             : tool.name === 'question'
                                 ? mode === 'plan'
-                                : tool.name === 'web_search'
-                                    ? !selectedModelForTools.hostedWebSearch &&
-                                        description.capabilities.includes('web.search')
-                                    : tool.name === 'view_image'
-                                        ? selectedModelForTools.inputCapabilities.includes('IMAGE')
-                                        : tool.name !== 'web_fetch' || description.capabilities.includes('web.fetch');
+                                : tool.name !== 'view_image' ||
+                                    selectedModelForTools.inputCapabilities.includes('IMAGE');
                     };
                     mcpRegistry.update(mcpCatalog, (tool) => toolEligible(tool.definition));
                     rebindMcpToolSearchOutputs(messages, mcpRegistry);
@@ -806,9 +806,7 @@ export function createSessionOpener(services) {
                                 executionEnvironment = { ...currentEnvironment, ...currentLocalTimeContext() };
                                 await recordEnvironment();
                             }
-                            const toolsAllowed = mode !== 'compact' &&
-                                (!rolloutBudget?.active || rolloutBudget.stage !== 'exhausted');
-                            const roundTools = mode === 'compact' ? executionTools : toolsAllowed ? executionTools : [];
+                            const roundTools = executionTools;
                             const codeModeEnabled = roundTools.some((tool) => tool.name === 'code_exec');
                             const residentTools = mcpRegistry.projectDirect(baseTools());
                             const requestTools = (() => {
@@ -839,6 +837,7 @@ export function createSessionOpener(services) {
                                 mode,
                                 sessionId,
                                 executionId,
+                                modelId: selectedModel.id,
                                 signal: controller.signal,
                                 emit,
                                 skills: instructionContext?.skills ?? new Map()
@@ -891,11 +890,7 @@ export function createSessionOpener(services) {
                                     system: systemPrompt,
                                     messages: modelMessages.map((message) => projectCodeModeSearchResult(message, codeModeEnabled)),
                                     tools: requestTools,
-                                    ...(mode === 'compact'
-                                        ? { toolChoice: 'none' }
-                                        : toolsAllowed
-                                            ? {}
-                                            : { allowTools: false }),
+                                    ...(mode === 'compact' ? { toolChoice: 'none' } : {}),
                                     promptCacheKey: sessionId,
                                     reasoningEffort,
                                     ...(requestReasoningEffort === undefined ? {} : { requestReasoningEffort }),

package/dist/agent-core/session/jsonl-store.js

@@ -11,6 +11,8 @@ import { contextGcBaseFromRecords, contextGcBaseSequence, contextGcMinimumUsageG
 import { beginSessionStorageTransaction, isUnjournaledTransactionFile, recoverSessionStorageTransaction } from './transaction-recovery.js';
 const MAX_SEGMENT_BYTES = 16 * 1024 * 1024;
 const REVERSE_READ_CHUNK_BYTES = 64 * 1024;
+const MAX_HISTORY_PAGE_FILES = 32;
+const MAX_HISTORY_PAGE_OFFSETS = 128;
 const MAX_INPUT_IMAGES = 5;
 const MAX_INPUT_IMAGE_BYTES = 5 * 1024 * 1024;
 const MAX_INPUT_IMAGES_BYTES = 10 * 1024 * 1024;
@@ -161,7 +163,8 @@ export class JsonlSessionStore {
             recordWrites: new Map(),
             writerLeases: new Map(),
             segments: new Map(),
-            executionModelReads: new Map()
+            executionModelReads: new Map(),
+            historyPagePositions: new Map()
         };
     }
     /** Merge dirty metadata with disk membership; only createdIds publish locally new entries. */
@@ -1171,7 +1174,7 @@ export class JsonlSessionStore {
             if (segment !== undefined && segment.firstSequence >= before)
                 continue;
             const needed = limit - page.length;
-            const window = await readRecordPageFromTail(path, before, needed);
+            const window = await readRecordPageFromTail(path, before, needed, this.#shared.historyPagePositions);
             page.unshift(...window.records);
             if (window.hasEarlier) {
                 hasEarlier = true;
@@ -2338,9 +2341,9 @@ async function repairSegmentTail(path) {
         await handle.close();
     }
 }
-async function readRecordPageFromTail(path, beforeSequence, limit) {
+async function readRecordPageFromTail(path, beforeSequence, limit, positions) {
     const newestFirst = [];
-    for await (const record of readRecordsFromTail(path)) {
+    for await (const record of readRecordsFromTail(path, { beforeSequence, limit, positions })) {
         if (!(record.sequence < beforeSequence))
             continue;
         newestFirst.push(record);
@@ -2353,14 +2356,42 @@ async function readRecordPageFromTail(path, beforeSequence, limit) {
     };
 }
 /** Decode complete records newest-first, releasing the file as soon as a reader stops. */
-async function* readRecordsFromTail(path) {
+async function* readRecordsFromTail(path, page) {
     const handle = await open(path, 'r');
     try {
-        const size = (await handle.stat()).size;
+        const metadata = await handle.stat({ bigint: true });
+        const size = Number(metadata.size);
         let position = size;
+        let cached;
+        if (page !== undefined) {
+            const signature = `${metadata.dev}:${metadata.ino}:${metadata.size}:${metadata.mtimeNs}:${metadata.ctimeNs}`;
+            const previous = page.positions.get(path);
+            cached = previous?.signature === signature ? previous : { signature, offsets: new Map() };
+            page.positions.delete(path);
+            page.positions.set(path, cached);
+            if (page.positions.size > MAX_HISTORY_PAGE_FILES)
+                page.positions.delete(page.positions.keys().next().value);
+            let nearestSequence = Number.POSITIVE_INFINITY;
+            for (const [sequence, offset] of cached.offsets) {
+                if (sequence >= page.beforeSequence && sequence < nearestSequence) {
+                    nearestSequence = sequence;
+                    position = offset;
+                }
+            }
+        }
+        let accepted = 0;
+        const remember = (record, offset) => {
+            if (page === undefined || cached === undefined || record.sequence >= page.beforeSequence)
+                return;
+            if (++accepted !== page.limit)
+                return;
+            cached.offsets.set(record.sequence, offset);
+            if (cached.offsets.size > MAX_HISTORY_PAGE_OFFSETS)
+                cached.offsets.delete(cached.offsets.keys().next().value);
+        };
         let pendingLineParts = [];
         let invalidFinalLineMayBeIgnored = false;
-        let inspectedFileEnd = false;
+        let inspectedFileEnd = position !== size;
         const decode = (line, allowInvalidFinalLine) => {
             if (line.length === 0)
                 return undefined;
@@ -2402,8 +2433,10 @@ async function* readRecordsFromTail(path) {
                 invalidFinalLineMayBeIgnored = false;
                 pendingLineParts = [];
                 lineEnd = index;
-                if (record !== undefined)
+                if (record !== undefined) {
+                    remember(record, start + index + 1);
                     yield record;
+                }
             }
             if (lineEnd > 0)
                 pendingLineParts.unshift(Buffer.from(value.subarray(0, lineEnd)));
@@ -2411,8 +2444,10 @@ async function* readRecordsFromTail(path) {
         }
         if (pendingLineParts.length > 0) {
             const record = decode(Buffer.concat(pendingLineParts), invalidFinalLineMayBeIgnored);
-            if (record !== undefined)
+            if (record !== undefined) {
+                remember(record, 0);
                 yield record;
+            }
         }
     }
     finally {

package/dist/agent-core/tools/contracts.d.ts

@@ -25,6 +25,8 @@ export interface ToolExecutionContext {
     signal: AbortSignal;
     sessionId: string;
     executionId: string;
+    /** Current model identity for neutral Host-owned tool policies. */
+    modelId?: string;
     recentImages?: readonly {
         readonly mimeType: string;
         readonly data: Buffer;
@@ -39,7 +41,7 @@ export interface ToolExecutionContext {
         invoke(call: ToolCall, signal: AbortSignal): Promise<ToolExecutionResult>;
     };
 }
-export interface McpToolCatalogContext extends Pick<ToolExecutionContext, 'sessionId' | 'executionId'> {
+export interface McpToolCatalogContext extends Pick<ToolExecutionContext, 'sessionId' | 'executionId' | 'modelId'> {
     executionScopeId?: string;
     claimExecutionScope?: boolean;
 }

package/dist/agent-core/tools/local/registry.d.ts

@@ -4,13 +4,7 @@ import type { ToolCall, ToolExecutionContext, ToolExecutionResult } from '../con
 import { type WorkspacePathMount } from '../shared/path-resolver.js';
 export declare class LocalToolRegistry {
     #private;
-    constructor(workspace: string, environment?: NodeJS.ProcessEnv, shell?: string, web?: {
-        webSearch?: (input: {
-            query: string;
-            maxResults: number;
-        }, signal: AbortSignal) => Promise<ToolExecutionResult>;
-        webFetch?: boolean;
-        allowUntrustedTls?: boolean;
+    constructor(workspace: string, environment?: NodeJS.ProcessEnv, shell?: string, options?: {
         processExecutor?: LocalProcessExecutor;
         codeModeEngineFactory?: CodeModeEngineFactory;
         restrictPaths?: boolean;

package/dist/agent-core/tools/local/registry.js

@@ -3,25 +3,25 @@ import { ApplyPatchTool, applyPatchToolInput } from './apply-patch.js';
 import { CodeModeTool } from '../code-mode/index.js';
 import { ExecTool, execToolInput } from './exec.js';
 import { ReadTool, formatBatchReadOutput } from './read.js';
-import { executeWebFetch } from './web-fetch.js';
-import { executeWebSearch } from './web-search.js';
 import { WorkspacePathResolver } from '../shared/path-resolver.js';
 import { ViewImageTool } from './view-image.js';
 export class LocalToolRegistry {
     #exec;
     #code;
     #handlers;
-    constructor(workspace, environment = process.env, shell, web = {}) {
+    constructor(workspace, environment = process.env, shell, options = {}) {
         const paths = new WorkspacePathResolver(workspace, {
-            ...(web.restrictPaths === undefined ? {} : { restrictPaths: web.restrictPaths }),
-            ...(web.workspaceWritable === undefined ? {} : { rootWritable: web.workspaceWritable }),
-            ...(web.pathMounts === undefined ? {} : { mounts: web.pathMounts })
+            ...(options.restrictPaths === undefined ? {} : { restrictPaths: options.restrictPaths }),
+            ...(options.workspaceWritable === undefined
+                ? {}
+                : { rootWritable: options.workspaceWritable }),
+            ...(options.pathMounts === undefined ? {} : { mounts: options.pathMounts })
         });
         const read = new ReadTool(paths);
         const viewImage = new ViewImageTool(paths);
         const patch = new ApplyPatchTool(paths);
-        this.#exec = new ExecTool(paths, undefined, undefined, environment, shell, web.processExecutor);
-        this.#code = new CodeModeTool(paths, environment, web.processExecutor, web.codeModeEngineFactory);
+        this.#exec = new ExecTool(paths, undefined, undefined, environment, shell, options.processExecutor);
+        this.#code = new CodeModeTool(paths, environment, options.processExecutor, options.codeModeEngineFactory);
         this.#handlers = new Map([
             ['code_exec', (arguments_, context) => this.#code.start(arguments_, context)],
             ['code_exec_wait', (arguments_, context) => this.#code.wait(arguments_, context)],
@@ -57,27 +57,7 @@ export class LocalToolRegistry {
                     });
                     return { content: JSON.stringify(result), data: result, truncated: result.truncated };
                 }
-            ]),
-            ...(web.webSearch
-                ? [
-                    [
-                        'web_search',
-                        async (arguments_, context) => {
-                            return executeWebSearch(arguments_, context.signal, (input, signal) => web.webSearch(input, signal));
-                        }
-                    ]
-                ]
-                : []),
-            ...(web.webFetch === false
-                ? []
-                : [
-                    [
-                        'web_fetch',
-                        async (arguments_, context) => {
-                            return executeWebFetch(arguments_, context.signal, web.allowUntrustedTls === true);
-                        }
-                    ]
-                ])
+            ])
         ]);
     }
     execute(call, context) {

package/dist/agent-core/tools/registry.js

@@ -12,8 +12,6 @@ import { executeTodoRead, todoReadToolDefinition } from './agent/todo-read.js';
 import { executeTodoWrite, todoWriteToolDefinition } from './agent/todo-write.js';
 import { executeToolSearch, toolSearchToolDefinition } from './mcp/tool-search.js';
 import { viewImageToolDefinition } from './local/view-image.js';
-import { webFetchToolDefinition } from './local/web-fetch.js';
-import { webSearchToolDefinition } from './local/web-search.js';
 export const BUILTIN_TOOL_DEFINITIONS = [
     skillToolDefinition,
     toolSearchToolDefinition,
@@ -30,9 +28,7 @@ export const BUILTIN_TOOL_DEFINITIONS = [
     agentStartToolDefinition,
     agentWaitToolDefinition,
     agentMessageToolDefinition,
-    agentCancelToolDefinition,
-    webSearchToolDefinition,
-    webFetchToolDefinition
+    agentCancelToolDefinition
 ];
 export const AGENT_TOOL_HANDLERS = new Map([
     ['skill', executeSkill],

package/dist/agent-core/tools/runtime-context.d.ts

@@ -44,6 +44,7 @@ export interface ToolRuntimeContext {
     mode: ExecutionMode;
     sessionId: string;
     executionId: string;
+    modelId?: string;
     signal: AbortSignal;
     codeMode?: import('./contracts.js').ToolExecutionContext['codeMode'];
     skills: ReadonlyMap<string, AgentSkill>;

package/dist/agent-core/tools/runtime.js

@@ -20,6 +20,7 @@ export async function executeRegisteredTool(name, arguments_, callId, context) {
         signal: context.signal,
         sessionId: context.sessionId,
         executionId: context.executionId,
+        ...(context.modelId === undefined ? {} : { modelId: context.modelId }),
         ...(context.recentImages === undefined ? {} : { recentImages: context.recentImages }),
         ...(context.codeMode === undefined ? {} : { codeMode: context.codeMode })
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.9.151",
+  "version": "0.9.153",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",

package/dist/agent-core/tools/local/web-fetch.d.ts

@@ -1,4 +0,0 @@
-import type { ToolExecutionResult } from '../contracts.js';
-import type { ClientToolDefinition } from '../../model/contracts.js';
-export declare const webFetchToolDefinition: ClientToolDefinition;
-export declare function executeWebFetch(input: unknown, signal: AbortSignal, allowUntrustedTls?: boolean): Promise<ToolExecutionResult>;

package/dist/agent-core/tools/local/web-fetch.js

@@ -1,85 +0,0 @@
-import { request as httpRequest } from 'node:http';
-import { request as httpsRequest } from 'node:https';
-import { MarAgentError } from '../../error.js';
-export const webFetchToolDefinition = {
-    name: 'web_fetch',
-    allowedCallers: ['direct', 'programmatic'],
-    parallelSafety: 'safe',
-    description: 'Fetch a specific HTTP or HTTPS URL, including explicitly permitted intranet URLs.',
-    inputSchema: {
-        type: 'object',
-        properties: { url: { type: 'string' } },
-        required: ['url'],
-        additionalProperties: false
-    }
-};
-export async function executeWebFetch(input, signal, allowUntrustedTls = false) {
-    const value = input;
-    if (typeof value?.url !== 'string')
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'URL is required.');
-    let url;
-    try {
-        url = new URL(value.url);
-    }
-    catch {
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'URL is invalid.');
-    }
-    if (url.protocol !== 'http:' && url.protocol !== 'https:')
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Only HTTP and HTTPS URLs are supported.');
-    return fetchWebUrl(url, signal, allowUntrustedTls);
-}
-async function fetchWebUrl(url, signal, allowUntrustedTls, redirects = 0) {
-    if (redirects > 5)
-        throw new MarAgentError('MAR_AGENT_WEB_FETCH_FAILED', 'Too many redirects.');
-    return new Promise((resolve, reject) => {
-        const request = (url.protocol === 'https:' ? httpsRequest : httpRequest)(url, {
-            signal,
-            headers: {
-                accept: 'text/html,application/json,text/plain;q=0.9,*/*;q=0.1',
-                'accept-encoding': 'identity',
-                'user-agent': 'MyAgentRoam/0.9'
-            },
-            ...(url.protocol === 'https:' ? { rejectUnauthorized: !allowUntrustedTls } : {})
-        }, (response) => {
-            const status = response.statusCode ?? 0;
-            if (status >= 300 && status < 400 && response.headers.location) {
-                response.resume();
-                void fetchWebUrl(new URL(response.headers.location, url), signal, allowUntrustedTls, redirects + 1).then(resolve, reject);
-                return;
-            }
-            if (status < 200 || status >= 300) {
-                response.resume();
-                reject(new MarAgentError('MAR_AGENT_WEB_FETCH_FAILED', `HTTP ${status}.`));
-                return;
-            }
-            const contentType = String(response.headers['content-type'] ?? 'text/plain').toLowerCase();
-            if (!/^(text\/|application\/(json|xml|xhtml\+xml))/u.test(contentType)) {
-                response.resume();
-                reject(new MarAgentError('MAR_AGENT_WEB_FETCH_UNSUPPORTED_CONTENT', 'Response is not readable text.'));
-                return;
-            }
-            const chunks = [];
-            let bytes = 0;
-            let truncated = false;
-            response.on('data', (chunk) => {
-                if (bytes >= 1_000_000) {
-                    truncated = true;
-                    return;
-                }
-                const remaining = 1_000_000 - bytes;
-                chunks.push(chunk.subarray(0, remaining));
-                bytes += Math.min(chunk.length, remaining);
-                if (chunk.length > remaining)
-                    truncated = true;
-            });
-            response.on('end', () => resolve({
-                content: Buffer.concat(chunks).toString('utf8'),
-                data: { url: url.href, status },
-                truncated
-            }));
-            response.on('error', reject);
-        });
-        request.on('error', reject);
-        request.end();
-    });
-}

package/dist/agent-core/tools/local/web-search.d.ts

@@ -1,7 +0,0 @@
-import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { ToolExecutionResult } from '../contracts.js';
-export declare const webSearchToolDefinition: ClientToolDefinition;
-export declare function executeWebSearch(input: unknown, signal: AbortSignal, search: (input: {
-    query: string;
-    maxResults: number;
-}, signal: AbortSignal) => Promise<ToolExecutionResult>): Promise<ToolExecutionResult>;

package/dist/agent-core/tools/local/web-search.js

@@ -1,34 +0,0 @@
-import { MarAgentError } from '../../error.js';
-export const webSearchToolDefinition = {
-    name: 'web_search',
-    allowedCallers: ['direct', 'programmatic'],
-    parallelSafety: 'safe',
-    description: 'Search the web for current information. Use web_fetch to open a specific result.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            query: { type: 'string', description: 'Search query.' },
-            maxResults: { type: 'integer', minimum: 1, maximum: 10, default: 8 }
-        },
-        required: ['query'],
-        additionalProperties: false
-    }
-};
-export async function executeWebSearch(input, signal, search) {
-    const value = input;
-    if (typeof value?.query !== 'string' || value.query.trim().length === 0)
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Search query is required.');
-    try {
-        return await search({
-            query: value.query.trim(),
-            maxResults: typeof value.maxResults === 'number'
-                ? Math.min(10, Math.max(1, Math.trunc(value.maxResults)))
-                : 8
-        }, signal);
-    }
-    catch (error) {
-        if (error instanceof MarAgentError)
-            throw error;
-        throw new MarAgentError('MAR_AGENT_WEB_SEARCH_FAILED', 'Web search failed.', { cause: error });
-    }
-}