@myagentroam/agent 0.9.141 → 0.9.142

package/dist/{tools/code-mode.js → agent-core/tools/code-mode/index.js}

@@ -1,19 +1,18 @@
 import { randomUUID } from 'node:crypto';
-import { createRequire } from 'node:module';
-import { pathToFileURL } from 'node:url';
 import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
 import { dirname, sep } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { StringDecoder } from 'node:string_decoder';
-import { MarAgentError, describeMarAgentError } from '../error.js';
-import { directLocalProcessExecutor, signalProcessTree } from '../host/local-process-executor.js';
-import { TOOL_EXECUTION_LIMITS as limits } from './execution-limits.js';
-import { createToolCallScheduler } from './scheduler.js';
-import { detectImageMime } from './view-image.js';
-import { allowsDirectTool, allowsToolCaller } from './callers.js';
-import { CodeCells } from './code-mode/cells.js';
-import { BoundedTextOutput, renderCapturedText } from './code-mode/text-output.js';
-import { parseCodeModeStateMutations } from './code-mode/state.js';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { MarAgentError, describeMarAgentError } from '../../error.js';
+import { directLocalProcessExecutor, signalProcessTree } from '../../host/local-process-executor.js';
+import { allowsDirectTool, allowsToolCaller } from '../callers.js';
+import { CodeCells } from './cells.js';
+import { parseCodeModeStateMutations } from './state.js';
+import { BoundedTextOutput, renderCapturedText } from './text-output.js';
+import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
+import { createToolCallScheduler } from '../scheduler.js';
+import { detectImageMime } from '../local/view-image.js';
 export const codeModeToolDefinition = {
     name: 'code_exec',
     description: `Run JavaScript to orchestrate or compose tool calls.
@@ -154,10 +153,10 @@ function defaultEngineFactory() {
         return root.includes(`${sep}.pnpm${sep}`) ? dirname(dirname(root)) : root;
     };
     return {
-        moduleUrl: new URL('./code-mode/quickjs-engine.js', import.meta.url).href,
+        moduleUrl: new URL('./quickjs-engine.js', import.meta.url).href,
         runtimeDirectories: [
             ...new Set([
-                fileURLToPath(new URL('./code-mode/', import.meta.url)),
+                fileURLToPath(new URL('.', import.meta.url)),
                 dependencyRoot(core),
                 dependencyRoot(variant),
                 dependencyRoot(ffi)
@@ -255,7 +254,7 @@ export class CodeModeTool {
                 `--max-old-space-size=${limits.codeHeapMegabytes}`,
                 '--input-type=module',
                 '--eval',
-                await readFile(new URL('./code-mode/worker.js', import.meta.url), 'utf8')
+                await readFile(new URL('./worker.js', import.meta.url), 'utf8')
             ],
             cwd,
             shell: false,

package/dist/{tools → agent-core/tools}/code-mode/state.d.ts

@@ -1,15 +1,5 @@
-export interface CodeModeStateEntry {
-    readonly key: string;
-    readonly value: unknown;
-}
-export type CodeModeStateMutation = {
-    readonly operation: 'set';
-    readonly key: string;
-    readonly value: unknown;
-} | {
-    readonly operation: 'delete';
-    readonly key: string;
-};
+import type { CodeModeStateEntry, CodeModeStateMutation } from '../contracts.js';
+export type { CodeModeStateEntry, CodeModeStateMutation } from '../contracts.js';
 type StateRecord = {
     readonly type: string;
     readonly payload: unknown;
@@ -17,4 +7,3 @@ type StateRecord = {
 export declare function parseCodeModeStateMutations(value: unknown): CodeModeStateMutation[];
 export declare function restoreCodeModeState(records: readonly StateRecord[]): CodeModeStateEntry[];
 export declare function applyCodeModeStateMutations(entries: readonly CodeModeStateEntry[], mutations: readonly CodeModeStateMutation[]): CodeModeStateEntry[];
-export {};

package/dist/agent-core/tools/code-mode/worker.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,168 @@
+import type { ExecutionMode } from '../runtime/contracts.js';
+export type ToolCaller = 'direct' | 'programmatic';
+export interface ClientToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    /** Runtime-only provider lowering hint; unsupported adapters fall back to a normal function tool. */
+    nativeType?: 'tool_search';
+    /** Runtime-only result contract; never forwarded as an upstream tool field. */
+    outputSchema?: Record<string, unknown>;
+    /** Runtime-only policy. MCP defaults to both callers; other tools default to direct only. */
+    allowedCallers?: readonly ToolCaller[];
+    inputMode?: 'json' | 'freeform';
+    parallelSafety?: 'safe' | 'serial';
+    /** Runtime-only Agent catalog scope; never forwarded as an upstream tool field. */
+    agentScope?: 'ROOT_AND_SUBAGENTS' | 'ROOT_ONLY';
+}
+export interface ToolCall {
+    name: string;
+    arguments: unknown;
+    callId?: string;
+}
+export interface ToolExecutionContext {
+    mode: ExecutionMode;
+    signal: AbortSignal;
+    sessionId: string;
+    executionId: string;
+    recentImages?: readonly {
+        readonly mimeType: string;
+        readonly data: Buffer;
+    }[];
+    codeMode?: {
+        retainSession?(): Promise<() => Promise<void>>;
+        onSettled?(result: CodeCellEventData): Promise<void>;
+        supportsImages?: boolean;
+        tools: readonly ClientToolDefinition[];
+        state?: readonly CodeModeStateEntry[];
+        commitState?(mutations: readonly CodeModeStateMutation[]): Promise<readonly CodeModeStateEntry[]>;
+        invoke(call: ToolCall, signal: AbortSignal): Promise<ToolExecutionResult>;
+    };
+}
+export interface McpToolCatalogContext extends Pick<ToolExecutionContext, 'sessionId' | 'executionId'> {
+    executionScopeId?: string;
+    claimExecutionScope?: boolean;
+}
+export interface McpToolCatalog {
+    readonly revision: string;
+    readonly servers: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly description?: string;
+        readonly instructions?: string;
+    }[];
+    readonly tools: readonly McpCatalogTool[];
+}
+export interface McpCatalogTool {
+    readonly definition: ClientToolDefinition;
+    readonly serverId: string;
+    readonly rawName: string;
+    readonly sourceIdentity: string;
+    readonly definitionRevision: string;
+    readonly lifetime: 'session' | 'execution';
+    readonly exposure: 'direct' | 'deferred';
+    /** Untrusted MCP hints; never an authorization or parallel-safety decision. */
+    readonly annotations?: Readonly<Record<string, unknown>>;
+}
+export interface McpToolCallContext extends Pick<ToolExecutionContext, 'sessionId' | 'executionId'> {
+    readonly mode?: ExecutionMode;
+    readonly expectedTool?: {
+        readonly sourceIdentity: string;
+        readonly definitionRevision: string;
+    };
+}
+export interface MarAgentToolImageArtifact {
+    kind: 'image';
+    name: string;
+    mimeType: 'image/png';
+    byteSize: number;
+    sha256: string;
+    fileName: string;
+}
+export type MarAgentToolArtifact = MarAgentToolImageArtifact;
+export interface ToolExecutionResult {
+    content: string;
+    data?: unknown;
+    /** Runtime-only definitions used to encode a Tool Search output. */
+    toolSearchTools?: readonly ClientToolDefinition[];
+    truncated?: boolean;
+    images?: readonly {
+        mimeType: string;
+        dataBase64: string;
+    }[];
+    artifacts?: readonly MarAgentToolArtifact[];
+}
+export interface CodeCellEventData {
+    cellId: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    cached?: boolean;
+}
+export interface ExecResult {
+    status: 'running' | 'completed' | 'cancelled';
+    processId?: string;
+    stdout: string;
+    stderr: string;
+    exitCode?: number | null;
+    truncated: boolean;
+    stdoutBytes: number;
+    stderrBytes: number;
+    stdoutDroppedBytes: number;
+    stderrDroppedBytes: number;
+    /** A terminal snapshot replay rather than new process output. */
+    cached?: boolean;
+}
+export interface ApplyPatchFileResult {
+    path: string;
+    targetPath?: string;
+    operation: 'added' | 'modified' | 'deleted' | 'moved';
+    addedLines: number;
+    deletedLines: number;
+}
+export interface ApplyPatchResult {
+    files: ApplyPatchFileResult[];
+    totals: {
+        files: number;
+        addedLines: number;
+        deletedLines: number;
+    };
+}
+export interface ReadEventData {
+    mode: 'batch';
+    results: Array<{
+        path: string;
+        startLine?: number;
+        endLine?: number;
+        error?: {
+            code: string;
+            message: string;
+        };
+    }>;
+    truncated: boolean;
+}
+export interface ViewImageResult {
+    path: string;
+    mimeType: 'image/png' | 'image/jpeg' | 'image/webp';
+    bytes: number;
+    sha256: string;
+}
+export interface TodoItem {
+    id: string;
+    step: string;
+    status: 'pending' | 'in_progress' | 'completed';
+}
+export interface TodoSnapshot {
+    revision: number;
+    items: TodoItem[];
+}
+export interface CodeModeStateEntry {
+    readonly key: string;
+    readonly value: unknown;
+}
+export type CodeModeStateMutation = {
+    readonly operation: 'set';
+    readonly key: string;
+    readonly value: unknown;
+} | {
+    readonly operation: 'delete';
+    readonly key: string;
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,34 @@
+import type { ModelEvent } from '../model/contracts.js';
+import type { EventPayload } from '../runtime/events.js';
+import type { ClientToolDefinition, McpToolCallContext, ToolExecutionContext, ToolExecutionResult } from './contracts.js';
+import type { ToolRuntimeContext, ToolRuntimeImage } from './runtime-context.js';
+import { type createSessionToolScheduler } from './scheduler.js';
+export type ClientToolCall = Extract<ModelEvent, {
+    type: 'client_tool.call';
+}>;
+export type ExecutedToolCall = {
+    call: ClientToolCall;
+    content: string;
+    images?: ToolExecutionResult['images'];
+} & ({
+    failed: false;
+    output: ToolExecutionResult;
+} | {
+    failed: true;
+    error: unknown;
+});
+/** One immutable model round's catalog; execution resources remain owned by the SDK/Host. */
+export interface RoundToolScope {
+    readonly context: Omit<ToolRuntimeContext, 'codeMode' | 'expectedMcpTool' | 'searchMcpTools' | 'recentImages'>;
+    readonly tools: readonly ClientToolDefinition[];
+    readonly expectations: ReadonlyMap<string, McpToolCallContext['expectedTool']>;
+    readonly extensionToolNames: ReadonlySet<string>;
+    readonly schedule: ReturnType<typeof createSessionToolScheduler>;
+    readonly emit: (event: EventPayload) => Promise<void>;
+    readonly searchMcpTools: NonNullable<ToolRuntimeContext['searchMcpTools']>;
+    readonly recentImages: () => ToolRuntimeImage[];
+    readonly captureCodeContext: () => Omit<ToolRuntimeContext, 'signal' | 'codeMode' | 'expectedMcpTool' | 'searchMcpTools'>;
+    readonly codeModeContext: (call: ClientToolCall) => Promise<Omit<NonNullable<ToolExecutionContext['codeMode']>, 'invoke'>>;
+}
+/** Complete every call in model order even if individual execution fails. */
+export declare function executeRoundTools(calls: readonly ClientToolCall[], scope: RoundToolScope): Promise<ExecutedToolCall[]>;

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

@@ -0,0 +1,102 @@
+import { MarAgentError, describeMarAgentError } from '../error.js';
+import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
+import { allowsToolCaller } from './callers.js';
+import { CodeCellExecutionError } from './code-mode/cells.js';
+import { createCodeToolDispatch } from './code-mode/dispatch.js';
+import { boundedModelToolOutput, structuredToolArtifacts, structuredToolEventData } from './output-projection.js';
+import { executeRegisteredTool } from './runtime.js';
+import { scheduleToolCallBatch } from './scheduler.js';
+/** Complete every call in model order even if individual execution fails. */
+export async function executeRoundTools(calls, scope) {
+    const executeCall = async (call, signal = scope.context.signal, caller = 'direct', parentCallId) => {
+        await scope.emit({
+            type: 'tool.started',
+            toolName: call.name,
+            callId: call.callId,
+            ...(parentCallId === undefined ? {} : { parentCallId }),
+            input: call.arguments
+        });
+        try {
+            if (call.argumentError)
+                throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', call.argumentError);
+            if (!scope.tools.some((tool) => tool.name === call.name && allowsToolCaller(tool, caller)))
+                throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable in this execution.');
+            const codeMode = await scope.codeModeContext(call);
+            const runTool = () => {
+                signal.throwIfAborted();
+                return executeRegisteredTool(call.name, call.arguments, call.callId, {
+                    ...scope.context,
+                    ...(scope.expectations.get(call.name)
+                        ? { expectedMcpTool: scope.expectations.get(call.name) }
+                        : {}),
+                    searchMcpTools: scope.searchMcpTools,
+                    signal,
+                    codeMode: {
+                        ...codeMode,
+                        invoke: createCodeToolDispatch({
+                            context: scope.captureCodeContext(),
+                            tools: scope.tools,
+                            expectations: scope.expectations,
+                            parentCallId: call.callId,
+                            schedule: scope.schedule,
+                            emit: scope.emit
+                        })
+                    },
+                    ...(scope.extensionToolNames.has(call.name) ? { recentImages: scope.recentImages() } : {})
+                });
+            };
+            const output = call.name === 'code_exec' || call.name === 'code_exec_wait'
+                ? await runTool()
+                : await scope.schedule(scope.tools.find((tool) => tool.name === call.name), runTool);
+            const modelOutput = boundedModelToolOutput(call.name, output.content, output.data);
+            const eventSummary = output.content.slice(0, AGENT_EXECUTION_POLICY.toolEventSummaryCharacters);
+            const structuredData = structuredToolEventData(call.name, output.data);
+            const artifacts = structuredToolArtifacts(output.artifacts);
+            await scope.emit({
+                type: 'tool.completed',
+                toolName: call.name,
+                callId: call.callId,
+                ...(parentCallId === undefined ? {} : { parentCallId }),
+                summary: eventSummary,
+                truncated: output.truncated === true ||
+                    modelOutput.truncated ||
+                    eventSummary.length < output.content.length,
+                ...(artifacts === undefined ? {} : { artifacts }),
+                ...(structuredData === undefined ? {} : { data: structuredData })
+            });
+            return {
+                call,
+                output,
+                content: modelOutput.content,
+                ...(output.images?.length ? { images: output.images } : {}),
+                failed: false
+            };
+        }
+        catch (error) {
+            const diagnostic = describeMarAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');
+            const partial = error instanceof CodeCellExecutionError ? error.result : undefined;
+            await scope.emit({
+                type: 'tool.failed',
+                toolName: call.name,
+                callId: call.callId,
+                ...(parentCallId === undefined ? {} : { parentCallId }),
+                code: diagnostic.code,
+                message: diagnostic.message
+            });
+            return {
+                call,
+                content: partial === undefined
+                    ? JSON.stringify({
+                        error: diagnostic.code,
+                        message: diagnostic.message,
+                        ...(error instanceof MarAgentError && error.retryable ? { retryable: true } : {})
+                    })
+                    : boundedModelToolOutput(call.name, partial.content, partial.data).content,
+                ...(partial?.images?.length ? { images: partial.images } : {}),
+                failed: true,
+                error
+            };
+        }
+    };
+    return scheduleToolCallBatch(calls, scope.tools, executeCall);
+}

package/dist/agent-core/tools/local/apply-patch.d.ts

@@ -0,0 +1,19 @@
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ApplyPatchResult } from '../contracts.js';
+import { WorkspacePathResolver } from '../shared/path-resolver.js';
+export type { ApplyPatchFileResult, ApplyPatchResult } from '../contracts.js';
+export declare const applyPatchToolDefinition: ClientToolDefinition;
+export declare function applyPatchToolInput(input: unknown): string;
+interface PatchFileOperations {
+    rename(source: string, target: string): Promise<void>;
+    rm(path: string, options?: {
+        force?: boolean;
+        recursive?: boolean;
+    }): Promise<void>;
+}
+export declare class ApplyPatchTool {
+    #private;
+    private readonly paths;
+    constructor(paths: WorkspacePathResolver, operations?: Partial<PatchFileOperations>);
+    execute(patch: string): Promise<ApplyPatchResult>;
+}

package/dist/{tools → agent-core/tools/local}/apply-patch.js

@@ -2,8 +2,8 @@ import { randomUUID } from 'node:crypto';
 import { chmod, lstat, mkdir, readFile, rename, rm, rmdir, writeFile } from 'node:fs/promises';
 import { dirname, isAbsolute, parse, resolve } from 'node:path';
 import { TextDecoder } from 'node:util';
-import { MarAgentError } from '../error.js';
-import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
+import { MarAgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const applyPatchToolDefinition = {
     name: 'apply_patch',
     allowedCallers: ['direct', 'programmatic'],
@@ -53,6 +53,12 @@ export const applyPatchToolDefinition = {
         additionalProperties: false
     }
 };
+export function applyPatchToolInput(input) {
+    const patch = typeof input === 'string' ? input : input?.patch;
+    if (typeof patch !== 'string')
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Patch is required.');
+    return patch;
+}
 const defaultFileOperations = { rename, rm };
 const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
 export class ApplyPatchTool {

package/dist/{tools → agent-core/tools/local}/exec.d.ts

@@ -1,6 +1,8 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import { type LocalProcessExecutor } from '../host/local-process-executor.js';
-import { WorkspacePathResolver } from './shared/path-resolver.js';
+import { type LocalProcessExecutor } from '../../host/local-process-executor.js';
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import type { ExecResult } from '../contracts.js';
+import { WorkspacePathResolver } from '../shared/path-resolver.js';
+export type { ExecResult } from '../contracts.js';
 export type ExecInput = {
     action?: 'start';
     command: string;
@@ -19,20 +21,6 @@ export type ExecInput = {
     action: 'cancel';
     processId: string;
 };
-export interface ExecResult {
-    status: 'running' | 'completed' | 'cancelled';
-    processId?: string;
-    stdout: string;
-    stderr: string;
-    exitCode?: number | null;
-    truncated: boolean;
-    stdoutBytes: number;
-    stderrBytes: number;
-    stdoutDroppedBytes: number;
-    stderrDroppedBytes: number;
-    /** A terminal snapshot replay rather than new process output. */
-    cached?: boolean;
-}
 export declare const execToolDefinition: ClientToolDefinition;
 export declare const execWaitToolDefinition: ClientToolDefinition;
 /** Validate the public entry points before delegating to the single process manager. */

package/dist/{tools → agent-core/tools/local}/exec.js

@@ -1,13 +1,13 @@
-import { directLocalProcessExecutor, signalProcessTree } from '../host/local-process-executor.js';
 import { randomUUID } from 'node:crypto';
 import { StringDecoder } from 'node:string_decoder';
-import { MarAgentError } from '../error.js';
-import { TOOL_EXECUTION_LIMITS } from './execution-limits.js';
+import { MarAgentError } from '../../error.js';
+import { directLocalProcessExecutor, signalProcessTree } from '../../host/local-process-executor.js';
+import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
 export const execToolDefinition = {
     name: 'exec',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'safe',
-    description: 'Start a platform-native command, script, or program in workspace/default cwd. Returns a stable processId, status, bounded stdout/stderr, cumulative byte counts, dropped-byte counts, exitCode and truncated. A completed status does not imply exitCode 0; inspect stderr/exitCode. For subsequent waiting, stdin writes or cancellation, use exec_wait with processId, not exec. Truncation does not stop the process. Cancelling the initial wait does not terminate the process.',
+    description: 'Start a platform-native command, script, or program in workspace/default cwd. Returns a stable processId, status, bounded stdout/stderr, cumulative byte counts, dropped-byte counts, exitCode and truncated. A completed status does not imply exitCode 0; inspect stderr/exitCode. For subsequent waiting, stdin writes or cancellation, call exec_wait directly with processId, not exec. Truncation does not stop the process. Cancelling the initial wait does not terminate the process.',
     outputSchema: {
         type: 'object',
         required: ['content', 'data'],

package/dist/{tools → agent-core/tools/local}/read.d.ts

@@ -1,5 +1,6 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-import { WorkspacePathResolver } from './shared/path-resolver.js';
+import type { ClientToolDefinition } from '../../model/contracts.js';
+import { WorkspacePathResolver } from '../shared/path-resolver.js';
+export type { ReadEventData } from '../contracts.js';
 export declare const readToolDefinition: ClientToolDefinition;
 export interface ReadRequest {
     path: string;
@@ -30,22 +31,13 @@ export interface BatchReadResult {
     results: Array<ReadResult | ReadErrorResult>;
     truncated: boolean;
 }
-export interface ReadEventData {
-    mode: 'batch';
-    results: Array<{
-        path: string;
-        startLine?: number;
-        endLine?: number;
-        error?: {
-            code: string;
-            message: string;
-        };
-    }>;
-    truncated: boolean;
-}
 export declare class ReadTool {
     #private;
     private readonly paths;
     constructor(paths: WorkspacePathResolver);
     execute(arguments_: unknown, signal?: AbortSignal): Promise<BatchReadResult>;
 }
+export declare function formatBatchReadOutput(results: Array<ReadResult | ReadErrorResult>): {
+    content: string;
+    truncated: boolean;
+};