@myagentroam/agent 0.9.152 → 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/sdk/session.js

@@ -423,6 +423,7 @@ export function createSessionOpener(services) {
                     const catalogContext = {
                         sessionId,
                         executionId,
+                        modelId: selectedModel.id,
                         ...(sessionSource.type === 'subagent'
                             ? internal.mcpExecutionScopeId === undefined
                                 ? {}
@@ -482,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);
@@ -840,6 +837,7 @@ export function createSessionOpener(services) {
                                 mode,
                                 sessionId,
                                 executionId,
+                                modelId: selectedModel.id,
                                 signal: controller.signal,
                                 emit,
                                 skills: instructionContext?.skills ?? new Map()

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.152",
+  "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 });
-    }
-}