@myagentroam/agent 0.9.140 → 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.
@@ -30,7 +29,7 @@ Tool calls:
 - skill, tool_search, question, code_exec, code_exec_wait and direct-only tools cannot be called here. Load Skills directly and read their instructions before the next tool call. Use direct tool_search before a later code cell for deferred tools; the current cell's tools do not change.
 
 Built-in namespaces:
-- out.text(value): void emits text. Strings and scalar values are stringified; JSON-compatible objects/arrays are serialized as compact JSON. Excess ordinary text is truncated with omission metadata, without stopping later code or tools. Cyclic or unsupported object values fail. Only explicitly emitted output reaches the model.
+- out.text(value): void emits text. Strings and scalar values are stringified; JSON-compatible objects/arrays are serialized as compact JSON. Structured image objects (image/* mimeType and string dataBase64, or native MCP type:image with string data) are recursively summarized without their Base64 payload; originals remain unchanged. Ordinary strings remain unchanged. This does not emit pixels: use out.image(result.images[0]) for images. Prefer result.data or result.content over the whole image result. Excess ordinary text is truncated with omission metadata, without stopping later code or tools. Cyclic or unsupported object values fail. Only explicitly emitted output reaches the model.
 - out.image(value: {mimeType:string,dataBase64:string}): void emits one returned image; for example out.image(result.images[0]) when that image exists and the model supports images. It does not accept a path, URL, or result.content.
 - state.get(key), state.has(key), state.set(key, value), state.delete(key) access bounded session JSON state. Mutations commit atomically only when the cell succeeds; failed or cancelled cells discard them.
 - catalog.tools() returns a read-only snapshot of the tools callable in this cell, including name, description, inputSchema and inputMode. It does not discover or authorize additional tools.
@@ -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/quickjs-engine.js

@@ -527,13 +527,23 @@ function streamText(value, emit) {
         else {
             emit('{');
             let first = true;
-            for (const name of Object.keys(item)) {
+            const names = Object.keys(item);
+            // Special-case view_image and native MCP image objects: text omits Base64; out.image keeps pixels.
+            const imagePayload = names.includes('mimeType') &&
+                typeof item.mimeType === 'string' &&
+                item.mimeType.startsWith('image/');
+            for (const name of names) {
                 if (!first)
                     emit(',');
                 first = false;
                 chunks(name, true);
                 emit(':');
-                write(item[name], name);
+                const field = item[name];
+                write(imagePayload &&
+                    (name === 'dataBase64' || (name === 'data' && item.type === 'image')) &&
+                    typeof field === 'string'
+                    ? '[image payload omitted; use out.image]'
+                    : field, name);
             }
             emit('}');
         }

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;
+};