@myagentroam/agent 0.9.141 → 0.9.143

package/dist/tools/local-registry.js

@@ -1,373 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
-import { modelTokenBudgetBytes } from '../runtime/token-budget.js';
-import { ApplyPatchTool } from './apply-patch.js';
-import { ExecTool, execToolInput } from './exec.js';
-import { CodeModeTool } from './code-mode.js';
-import { ReadTool } from './read.js';
-import { WorkspacePathResolver } from './shared/path-resolver.js';
-import { ViewImageTool } from './view-image.js';
-import { request as httpRequest } from 'node:http';
-import { request as httpsRequest } from 'node:https';
-export class LocalToolRegistry {
-    #exec;
-    #code;
-    #handlers;
-    constructor(workspace, environment = process.env, shell, web = {}) {
-        const paths = new WorkspacePathResolver(workspace, {
-            ...(web.restrictPaths === undefined ? {} : { restrictPaths: web.restrictPaths }),
-            ...(web.workspaceWritable === undefined ? {} : { rootWritable: web.workspaceWritable }),
-            ...(web.pathMounts === undefined ? {} : { mounts: web.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.#handlers = new Map([
-            ['code_exec', (arguments_, context) => this.#code.start(arguments_, context)],
-            ['code_exec_wait', (arguments_, context) => this.#code.wait(arguments_, context)],
-            [
-                'read',
-                async (arguments_, context) => {
-                    const result = await read.execute(arguments_, context.signal);
-                    const formatted = formatBatchReadOutput(result.results);
-                    return {
-                        content: formatted.content,
-                        data: result,
-                        truncated: result.truncated || formatted.truncated
-                    };
-                }
-            ],
-            [
-                'view_image',
-                async (arguments_, context) => viewImage.execute(arguments_, context.signal)
-            ],
-            [
-                'apply_patch',
-                async (arguments_) => {
-                    const value = typeof arguments_ === 'string'
-                        ? arguments_
-                        : arguments_?.patch;
-                    if (typeof value !== 'string')
-                        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Patch is required.');
-                    const result = await patch.execute(value);
-                    return { content: JSON.stringify(result), data: result };
-                }
-            ],
-            ...['exec', 'exec_wait'].map((name) => [
-                name,
-                async (arguments_, context) => {
-                    const result = await this.#exec.execute(execToolInput(name, arguments_), context.signal, {
-                        sessionId: context.sessionId,
-                        executionId: context.executionId
-                    });
-                    return { content: JSON.stringify(result), data: result, truncated: result.truncated };
-                }
-            ]),
-            ...(web.webSearch
-                ? [
-                    [
-                        'web_search',
-                        async (arguments_, context) => {
-                            const value = arguments_;
-                            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 web.webSearch({
-                                    query: value.query.trim(),
-                                    maxResults: typeof value.maxResults === 'number'
-                                        ? Math.min(10, Math.max(1, Math.trunc(value.maxResults)))
-                                        : 8
-                                }, context.signal);
-                            }
-                            catch (error) {
-                                if (error instanceof MarAgentError)
-                                    throw error;
-                                throw new MarAgentError('MAR_AGENT_WEB_SEARCH_FAILED', 'Web search failed.', {
-                                    cause: error
-                                });
-                            }
-                        }
-                    ]
-                ]
-                : []),
-            ...(web.webFetch === false
-                ? []
-                : [
-                    [
-                        'web_fetch',
-                        async (arguments_, context) => {
-                            const value = arguments_;
-                            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, context.signal, web.allowUntrustedTls === true);
-                        }
-                    ]
-                ])
-        ]);
-    }
-    execute(call, context) {
-        const handler = this.#handlers.get(call.name);
-        if (!handler)
-            throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable.');
-        return handler(call.arguments, context);
-    }
-    listSessionResources(sessionId) {
-        return this.#exec.listSessionResources(sessionId);
-    }
-    listCodeCells(sessionId) {
-        return this.#code.listSessionResources(sessionId);
-    }
-    async disposeSessionResources(sessionId) {
-        await Promise.all([this.#exec.disposeSession(sessionId), this.#code.dispose(sessionId)]);
-    }
-    async dispose() {
-        await Promise.all([this.#exec.dispose(), this.#code.dispose()]);
-    }
-}
-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();
-    });
-}
-function escapeAttribute(value) {
-    return value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;');
-}
-function escapeText(value) {
-    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;');
-}
-function boundedUtf8Prefix(value, maximumBytes) {
-    if (Buffer.byteLength(value) <= maximumBytes)
-        return { value, truncated: false };
-    const marker = '…';
-    const contentBudget = Math.max(0, maximumBytes - Buffer.byteLength(marker));
-    let result = '';
-    let bytes = 0;
-    for (const character of value) {
-        const characterBytes = Buffer.byteLength(character);
-        if (bytes + characterBytes > contentBudget)
-            break;
-        result += character;
-        bytes += characterBytes;
-    }
-    return { value: `${result}${marker}`, truncated: true };
-}
-function oversizedLinePreview(value, retainedBytes, lineNumber) {
-    const bytes = Buffer.from(value, 'utf8');
-    if (retainedBytes >= bytes.length)
-        return { value, shownBytes: bytes.length, omittedBytes: 0 };
-    const headTarget = Math.floor(retainedBytes / 2);
-    const tailTarget = retainedBytes - headTarget;
-    let head = Math.min(headTarget, bytes.length);
-    while (head > 0 && isUtf8ContinuationByte(bytes[head]))
-        head--;
-    let tail = Math.max(head, bytes.length - tailTarget);
-    while (tail < bytes.length && isUtf8ContinuationByte(bytes[tail]))
-        tail++;
-    const shownBytes = head + bytes.length - tail;
-    const omittedBytes = bytes.length - shownBytes;
-    const marker = `...[${omittedBytes} bytes omitted from line ${lineNumber}]...`;
-    return {
-        value: `${bytes.toString('utf8', 0, head)}${marker}${bytes.toString('utf8', tail)}`,
-        shownBytes,
-        omittedBytes
-    };
-}
-function isUtf8ContinuationByte(value) {
-    return value !== undefined && (value & 0xc0) === 0x80;
-}
-function formatBatchReadResult(result, index, maximumBytes) {
-    const visiblePath = boundedUtf8Prefix(result.path, 128);
-    const path = escapeAttribute(visiblePath.value);
-    const pathTruncatedAttribute = visiblePath.truncated ? ' pathTruncated="true"' : '';
-    if ('error' in result) {
-        const message = boundedUtf8Prefix(result.error.message, 256);
-        const detailsTruncatedAttribute = message.truncated ? ' detailsTruncated="true"' : '';
-        const content = `<read_error index="${index}" path="${path}"${pathTruncatedAttribute} code="${escapeAttribute(result.error.code)}"${detailsTruncatedAttribute}>${escapeText(message.value)}</read_error>`;
-        if (Buffer.byteLength(content) <= maximumBytes)
-            return { content, previewComplete: true };
-        return {
-            content: `<read_error index="${index}" code="MAR_AGENT_TOOL_OUTPUT_LIMIT">Model-visible error metadata exceeds this item's output share.</read_error>`,
-            previewComplete: false
-        };
-    }
-    const lines = result.content ? result.content.split('\n') : [];
-    const render = (visibleLines) => {
-        const previewComplete = visibleLines === lines.length;
-        const endLine = visibleLines === 0 ? undefined : result.startLine + Math.max(0, visibleLines - 1);
-        const metadata = {
-            path: visiblePath.value,
-            ...(visiblePath.truncated ? { pathTruncated: true } : {}),
-            encoding: result.encoding,
-            newline: result.newline,
-            startLine: result.startLine,
-            ...(endLine === undefined ? {} : { endLine }),
-            eof: previewComplete ? result.eof : false,
-            truncated: previewComplete ? result.truncated : true,
-            ...(previewComplete
-                ? result.nextOffset === undefined
-                    ? {}
-                    : { nextOffset: result.nextOffset }
-                : { nextOffset: result.startLine + visibleLines }),
-            previewComplete
-        };
-        return [
-            `<read_result index="${index}" path="${path}"${pathTruncatedAttribute}>`,
-            lines.slice(0, visibleLines).join('\n'),
-            `<read_metadata>${JSON.stringify(metadata)}</read_metadata>`,
-            '</read_result>'
-        ]
-            .filter(Boolean)
-            .join('\n');
-    };
-    const full = render(lines.length);
-    if (Buffer.byteLength(full) <= maximumBytes)
-        return { content: full, previewComplete: true };
-    let low = 0;
-    let high = lines.length;
-    while (low < high) {
-        const middle = Math.ceil((low + high) / 2);
-        if (Buffer.byteLength(render(middle)) <= maximumBytes)
-            low = middle;
-        else
-            high = middle - 1;
-    }
-    const content = render(low);
-    if (low > 0 && Buffer.byteLength(content) <= maximumBytes)
-        return { content, previewComplete: low === lines.length };
-    if (lines.length > 0) {
-        const lineNumber = result.startLine;
-        const prefix = `${lineNumber}\t`;
-        const formattedLine = lines[0];
-        const sourceLine = formattedLine.startsWith(prefix)
-            ? formattedLine.slice(prefix.length)
-            : formattedLine;
-        const sourceLineBytes = Buffer.byteLength(sourceLine);
-        const renderOversizedLine = (retainedBytes) => {
-            const preview = oversizedLinePreview(sourceLine, retainedBytes, lineNumber);
-            const metadata = {
-                path: visiblePath.value,
-                ...(visiblePath.truncated ? { pathTruncated: true } : {}),
-                encoding: result.encoding,
-                newline: result.newline,
-                startLine: lineNumber,
-                endLine: lineNumber,
-                eof: false,
-                truncated: true,
-                previewComplete: false,
-                oversizedLine: {
-                    line: lineNumber,
-                    bytes: sourceLineBytes,
-                    shownBytes: preview.shownBytes,
-                    omittedBytes: preview.omittedBytes
-                }
-            };
-            return [
-                `<read_result index="${index}" path="${path}"${pathTruncatedAttribute}>`,
-                `${prefix}${preview.value}`,
-                `<read_metadata>${JSON.stringify(metadata)}</read_metadata>`,
-                '</read_result>'
-            ].join('\n');
-        };
-        let minimum = renderOversizedLine(0);
-        if (Buffer.byteLength(minimum) <= maximumBytes) {
-            let retainedLow = 0;
-            let retainedHigh = sourceLineBytes;
-            while (retainedLow < retainedHigh) {
-                const middle = Math.ceil((retainedLow + retainedHigh) / 2);
-                const candidate = renderOversizedLine(middle);
-                if (Buffer.byteLength(candidate) <= maximumBytes) {
-                    retainedLow = middle;
-                    minimum = candidate;
-                }
-                else
-                    retainedHigh = middle - 1;
-            }
-            return { content: minimum, previewComplete: false };
-        }
-    }
-    return {
-        content: `<read_error index="${index}" code="MAR_AGENT_TOOL_OUTPUT_LIMIT">Model-visible read metadata exceeds this item's output share.</read_error>`,
-        previewComplete: false
-    };
-}
-function formatBatchReadOutput(results) {
-    const blocks = [];
-    let bytes = 0;
-    let truncated = false;
-    const maximumBytes = modelTokenBudgetBytes(AGENT_EXECUTION_POLICY.modelToolOutputTokens);
-    for (const [index, result] of results.entries()) {
-        const separatorBytes = blocks.length === 0 ? 0 : 1;
-        const remainingItems = results.length - index;
-        const itemBudget = Math.floor((maximumBytes - bytes - separatorBytes) / remainingItems);
-        const block = formatBatchReadResult(result, index, itemBudget);
-        const blockBytes = Buffer.byteLength(block.content);
-        if (bytes + separatorBytes + blockBytes > maximumBytes)
-            break;
-        blocks.push(block.content);
-        bytes += separatorBytes + blockBytes;
-        if (!block.previewComplete)
-            truncated = true;
-    }
-    return { content: blocks.join('\n'), truncated };
-}

package/dist/tools/registry.js

@@ -1,47 +0,0 @@
-import { applyPatchToolDefinition } from './apply-patch.js';
-import { execToolDefinition, execWaitToolDefinition } from './exec.js';
-import { codeModeToolDefinition, codeExecWaitToolDefinition } from './code-mode.js';
-import { executeQuestion, questionToolDefinition } from './question.js';
-import { readToolDefinition } from './read.js';
-import { viewImageToolDefinition } from './view-image.js';
-import { executeAgentStart, agentStartToolDefinition } from './agent-start.js';
-import { executeAgentCancel, agentCancelToolDefinition } from './agent-cancel.js';
-import { executeAgentWait, agentWaitToolDefinition } from './agent-wait.js';
-import { executeAgentMessage, agentMessageToolDefinition } from './agent-message.js';
-import { executeTodoRead, todoReadToolDefinition } from './todo-read.js';
-import { executeTodoWrite, todoWriteToolDefinition } from './todo-write.js';
-import { webFetchToolDefinition } from './web-fetch.js';
-import { webSearchToolDefinition } from './web-search.js';
-import { executeSkill, skillToolDefinition } from './skill.js';
-import { executeToolSearch, toolSearchToolDefinition } from './tool-search.js';
-export const BUILTIN_TOOL_DEFINITIONS = [
-    skillToolDefinition,
-    toolSearchToolDefinition,
-    readToolDefinition,
-    viewImageToolDefinition,
-    execToolDefinition,
-    execWaitToolDefinition,
-    codeModeToolDefinition,
-    codeExecWaitToolDefinition,
-    applyPatchToolDefinition,
-    questionToolDefinition,
-    todoReadToolDefinition,
-    todoWriteToolDefinition,
-    agentStartToolDefinition,
-    agentWaitToolDefinition,
-    agentMessageToolDefinition,
-    agentCancelToolDefinition,
-    webSearchToolDefinition,
-    webFetchToolDefinition
-];
-export const AGENT_TOOL_HANDLERS = new Map([
-    ['skill', executeSkill],
-    ['tool_search', executeToolSearch],
-    ['question', executeQuestion],
-    ['todo_read', (_arguments, context) => executeTodoRead(context)],
-    ['todo_write', executeTodoWrite],
-    ['agent_start', executeAgentStart],
-    ['agent_wait', executeAgentWait],
-    ['agent_message', executeAgentMessage],
-    ['agent_cancel', executeAgentCancel]
-]);

package/dist/tools/web-fetch.d.ts

@@ -1,2 +0,0 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-export declare const webFetchToolDefinition: ClientToolDefinition;

package/dist/tools/web-fetch.js

@@ -1,12 +0,0 @@
-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
-    }
-};

package/dist/tools/web-search.d.ts

@@ -1,2 +0,0 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-export declare const webSearchToolDefinition: ClientToolDefinition;

package/dist/tools/web-search.js

@@ -1,15 +0,0 @@
-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
-    }
-};