@myagentroam/agent 0.11.32 → 0.11.34

package/dist/host/local-file-access.d.ts

@@ -0,0 +1,30 @@
+import type { ExtensionFilesBackend, ExtensionFilePath, ExtensionFileWrite, ExtensionFileRemove, ExtensionFileTransfer, ExtensionFileType } from '../extensions/files.js';
+import type { ExtensionOperationContext } from '../extensions/operation.js';
+import { WorkspacePathResolver } from '../tools/shared/path-resolver.js';
+/** Raw native access shares the exact resolver used by the Host's model-facing tools. */
+export declare class LocalFileAccess implements ExtensionFilesBackend {
+    #private;
+    readonly paths: WorkspacePathResolver;
+    constructor(paths: WorkspacePathResolver);
+    read(input: ExtensionFilePath, call: ExtensionOperationContext): Promise<Uint8Array<ArrayBuffer>>;
+    write(input: ExtensionFileWrite, call: ExtensionOperationContext): Promise<{
+        bytesWritten: number;
+    }>;
+    stat(input: ExtensionFilePath, call: ExtensionOperationContext): Promise<{
+        path: string;
+        type: ExtensionFileType;
+        size: number;
+        modifiedAtMs: number;
+        createdAtMs: number;
+    }>;
+    list(input: ExtensionFilePath, call: ExtensionOperationContext): Promise<{
+        name: string;
+        type: ExtensionFileType;
+    }[]>;
+    mkdir(input: ExtensionFilePath & {
+        readonly recursive?: boolean;
+    }, call: ExtensionOperationContext): Promise<void>;
+    remove(input: ExtensionFileRemove, call: ExtensionOperationContext): Promise<void>;
+    move(input: ExtensionFileTransfer, call: ExtensionOperationContext): Promise<void>;
+    copy(input: ExtensionFileTransfer, call: ExtensionOperationContext): Promise<void>;
+}

package/dist/host/local-file-access.js

@@ -0,0 +1,107 @@
+import { copyFile, lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { AgentError } from '../error.js';
+/** Raw native access shares the exact resolver used by the Host's model-facing tools. */
+export class LocalFileAccess {
+    paths;
+    constructor(paths) {
+        this.paths = paths;
+    }
+    read(input, call) {
+        return this.#execute('read', call, async () => new Uint8Array(await readFile(await this.#path(input.path), { signal: call.signal })));
+    }
+    write(input, call) {
+        return this.#execute('write', call, async () => {
+            if (!(input.bytes instanceof Uint8Array))
+                throw new AgentError('MAR_AGENT_FILE_INPUT_INVALID', 'File bytes must be a Uint8Array.');
+            const bytes = Buffer.from(input.bytes);
+            const path = await this.#path(input.path, true);
+            call.signal.throwIfAborted();
+            if (input.createParents)
+                await mkdir(dirname(path), { recursive: true });
+            await writeFile(path, bytes, { signal: call.signal });
+            return { bytesWritten: bytes.byteLength };
+        });
+    }
+    stat(input, call) {
+        return this.#execute('stat', call, async () => {
+            const path = await this.paths.resolveWithDisplay(this.#validatePath(input.path));
+            const info = await lstat(path.physicalPath);
+            return {
+                path: path.displayPath,
+                type: fileType(info),
+                size: info.size,
+                modifiedAtMs: info.mtimeMs,
+                createdAtMs: info.birthtimeMs
+            };
+        });
+    }
+    list(input, call) {
+        return this.#execute('list', call, async () => (await readdir(await this.#path(input.path), { withFileTypes: true })).map((entry) => ({
+            name: entry.name,
+            type: fileType(entry)
+        })));
+    }
+    mkdir(input, call) {
+        return this.#execute('mkdir', call, async () => {
+            const path = await this.#path(input.path, true);
+            call.signal.throwIfAborted();
+            await mkdir(path, { recursive: input.recursive ?? false });
+        });
+    }
+    remove(input, call) {
+        return this.#execute('remove', call, async () => {
+            const path = await this.#path(input.path, true);
+            call.signal.throwIfAborted();
+            await rm(path, { recursive: input.recursive ?? false, force: input.force ?? false });
+        });
+    }
+    move(input, call) {
+        return this.#execute('move', call, async () => {
+            const from = await this.#path(input.from, true);
+            const to = await this.#path(input.to, true);
+            call.signal.throwIfAborted();
+            await rename(from, to);
+        });
+    }
+    copy(input, call) {
+        return this.#execute('copy', call, async () => {
+            const from = await this.#path(input.from);
+            const to = await this.#path(input.to, true);
+            call.signal.throwIfAborted();
+            await copyFile(from, to);
+        });
+    }
+    #validatePath(path) {
+        if (typeof path !== 'string')
+            throw new AgentError('MAR_AGENT_FILE_INPUT_INVALID', 'File path must be a string.');
+        return path;
+    }
+    #path(path, write = false) {
+        return this.paths.resolve(this.#validatePath(path), write, write ? 'write' : 'read');
+    }
+    async #execute(operation, call, action) {
+        call.signal.throwIfAborted();
+        try {
+            return await action();
+        }
+        catch (cause) {
+            call.signal.throwIfAborted();
+            if (cause instanceof AgentError)
+                throw cause;
+            throw new AgentError('MAR_AGENT_FILE_OPERATION_FAILED', 'Native file operation failed.', {
+                details: { operation, reason: cause.code ?? 'UNKNOWN' },
+                cause
+            });
+        }
+    }
+}
+function fileType(info) {
+    return info.isSymbolicLink()
+        ? 'symlink'
+        : info.isFile()
+            ? 'file'
+            : info.isDirectory()
+                ? 'directory'
+                : 'other';
+}

package/dist/host/local-network-access.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionHttpRequest, ExtensionHttpResponse, ExtensionNetworkBackend } from '../extensions/network.js';
+import type { ExtensionOperationContext } from '../extensions/operation.js';
+/** Raw HTTP transport; presentation, retries, and browser fetch remain separate tools. */
+export declare class LocalNetworkAccess implements ExtensionNetworkBackend {
+    fetch(input: ExtensionHttpRequest, call: ExtensionOperationContext): Promise<ExtensionHttpResponse>;
+}

package/dist/host/local-network-access.js

@@ -0,0 +1,101 @@
+import { AgentError } from '../error.js';
+/** Raw HTTP transport; presentation, retries, and browser fetch remain separate tools. */
+export class LocalNetworkAccess {
+    async fetch(input, call) {
+        call.signal.throwIfAborted();
+        if (!input || typeof input.url !== 'string')
+            throw new AgentError('MAR_AGENT_NETWORK_REQUEST_INVALID', 'HTTP URL is required.');
+        let url;
+        try {
+            url = new URL(input.url);
+        }
+        catch {
+            throw new AgentError('MAR_AGENT_NETWORK_REQUEST_INVALID', 'HTTP URL is invalid.');
+        }
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new AgentError('MAR_AGENT_NETWORK_REQUEST_INVALID', 'An HTTP or HTTPS URL is required.');
+        const controller = new AbortController();
+        const signal = AbortSignal.any([
+            call.signal,
+            controller.signal,
+            ...(input.signal ? [input.signal] : [])
+        ]);
+        let response;
+        try {
+            response = await globalThis.fetch(url, {
+                ...(input.method === undefined ? {} : { method: input.method }),
+                ...(input.headers === undefined
+                    ? {}
+                    : {
+                        headers: input.headers.map(([name, value]) => [name, value])
+                    }),
+                ...(input.body === undefined
+                    ? {}
+                    : { body: typeof input.body === 'string' ? input.body : Buffer.from(input.body) }),
+                ...(input.redirect === undefined ? {} : { redirect: input.redirect }),
+                signal
+            });
+        }
+        catch (error) {
+            signal.throwIfAborted();
+            const cause = error && typeof error === 'object'
+                ? error.cause
+                : undefined;
+            throw new AgentError('MAR_AGENT_NETWORK_FAILED', 'HTTP request failed.', {
+                ...(typeof cause?.code === 'string' ? { details: { reasonCode: cause.code } } : {})
+            });
+        }
+        const reader = response.body?.getReader();
+        let closing;
+        const close = () => {
+            closing ??= (async () => {
+                signal.removeEventListener('abort', onAbort);
+                controller.abort();
+                try {
+                    await reader?.cancel();
+                }
+                catch (error) {
+                    // An already-aborted Fetch reader rejects cancel with that same cancellation reason.
+                    if (!signal.aborted || error !== signal.reason)
+                        throw error;
+                }
+                finally {
+                    reader?.releaseLock();
+                }
+            })();
+            return closing;
+        };
+        const onAbort = () => {
+            void close().catch(() => undefined);
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted) {
+            await close();
+            signal.throwIfAborted();
+        }
+        const body = async function* () {
+            try {
+                while (reader) {
+                    signal.throwIfAborted();
+                    const next = await reader.read();
+                    signal.throwIfAborted();
+                    if (next.done)
+                        return;
+                    yield next.value;
+                }
+            }
+            finally {
+                await close();
+            }
+        };
+        return {
+            url: response.url,
+            status: response.status,
+            statusText: response.statusText,
+            redirected: response.redirected,
+            headers: [...response.headers.entries()],
+            body: body(),
+            close
+        };
+    }
+}

package/dist/host/local-process-executor.d.ts

@@ -0,0 +1,5 @@
+import type { LocalProcessExecutor } from '../process/contracts.js';
+export type { LocalProcessExecutor, LocalProcessSpawnRequest } from '../process/contracts.js';
+/** Preserves the direct local execution behavior used by the CLI and normal Node Workbench. */
+export declare const directLocalProcessExecutor: LocalProcessExecutor;
+export { signalProcessTree } from './process-control.js';

package/dist/host/local-process-executor.js

@@ -0,0 +1,17 @@
+import { spawn } from 'node:child_process';
+import { prepareLocalShellProcess } from './local-shell.js';
+/** Preserves the direct local execution behavior used by the CLI and normal Node Workbench. */
+export const directLocalProcessExecutor = {
+    async spawn(request) {
+        request = prepareLocalShellProcess(request);
+        return spawn(request.command, [...(request.args ?? [])], {
+            cwd: request.cwd,
+            shell: request.shell ?? false,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+            detached: request.detached,
+            env: request.environment
+        });
+    }
+};
+export { signalProcessTree } from './process-control.js';

package/dist/host/local-session-environment.d.ts

@@ -0,0 +1,18 @@
+import type { ExtensionEnvironmentBackend, ExtensionEnvironmentKey, ExtensionEnvironmentSet } from '../extensions/environment.js';
+import type { ExtensionOperationContext } from '../extensions/operation.js';
+import type { LocalProcessSpawnRequest } from '../process/contracts.js';
+/** Session-owned overlay, shared by native and model/programmatic process starts. */
+export declare class LocalSessionEnvironment implements ExtensionEnvironmentBackend {
+    #private;
+    private readonly base;
+    private readonly executionEnvironment;
+    private readonly platform;
+    constructor(base: NodeJS.ProcessEnv, executionEnvironment: (executionId?: string) => Readonly<Record<string, string>> | undefined, platform?: NodeJS.Platform);
+    get(input: ExtensionEnvironmentKey, call: ExtensionOperationContext): Promise<string | undefined>;
+    set(input: ExtensionEnvironmentSet, call: ExtensionOperationContext): Promise<{
+        changed: boolean;
+    }>;
+    forProcess(request: LocalProcessSpawnRequest): LocalProcessSpawnRequest;
+    clearSession(sessionId: string): void;
+    clear(): void;
+}

package/dist/host/local-shell.d.ts

@@ -0,0 +1,3 @@
+import type { LocalProcessSpawnRequest } from '../process/contracts.js';
+/** Resolve Shell startup in the executor, after its environment policy has been applied. */
+export declare function prepareLocalShellProcess(request: LocalProcessSpawnRequest, platform?: NodeJS.Platform): LocalProcessSpawnRequest;

package/dist/host/local-tool-registry.d.ts

@@ -0,0 +1,34 @@
+import { LocalFileAccess } from './local-file-access.js';
+import { type LocalProcessExecutor } from './local-process-executor.js';
+import type { CodeModeEngineFactory } from '../tools/code-mode/engine.js';
+import type { ToolCall, ToolExecutionContext, ToolExecutionResult } from '../tools/contracts.js';
+import { type WorkspacePathMount } from '../tools/shared/path-resolver.js';
+import type { ExtensionOperationContext } from '../extensions/operation.js';
+export declare class LocalToolRegistry {
+    #private;
+    readonly processes: import('../extensions/processes.js').ExtensionProcessesBackend;
+    readonly files: LocalFileAccess;
+    constructor(workspace: string, environment?: NodeJS.ProcessEnv, shell?: string, options?: {
+        processExecutor?: LocalProcessExecutor;
+        codeModeEngineFactory?: CodeModeEngineFactory;
+        restrictPaths?: boolean;
+        workspaceWritable?: boolean;
+        pathMounts?: readonly WorkspacePathMount[];
+    });
+    execute(call: ToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
+    names(): readonly string[];
+    executeOperation(call: ToolCall, operation: ExtensionOperationContext): Promise<ToolExecutionResult>;
+    listSessionResources(sessionId: string): {
+        processId: string;
+        status: "completed" | "cancelled" | "running";
+        command: string;
+        cwd: string;
+    }[];
+    listCodeCells(sessionId: string): {
+        cellId: string;
+        status: "completed" | "failed" | "cancelled" | "running";
+        executionId: string;
+    }[];
+    disposeSessionResources(sessionId: string): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/host/local-tool-registry.js

@@ -0,0 +1,134 @@
+import { AgentError } from '../error.js';
+import { LocalFileAccess } from './local-file-access.js';
+import { directLocalProcessExecutor, signalProcessTree } from './local-process-executor.js';
+import { ApplyPatchTool, applyPatchToolInput, applyPatchToolDefinition } from '../tools/local/apply-patch.js';
+import { CodeModeTool, codeModeToolDefinition, codeExecWaitToolDefinition } from '../tools/code-mode/index.js';
+import { normalizeToolInput } from '../tools/input.js';
+import { execToolInput, execToolDefinition, execWaitToolDefinition, formatExecResult } from '../tools/local/exec.js';
+import { ExecTool } from './local-exec-tool.js';
+import { ReadTool, formatBatchReadOutput, readToolDefinition } from '../tools/local/read.js';
+import { WorkspacePathResolver } from '../tools/shared/path-resolver.js';
+import { ViewImageTool, viewImageToolDefinition } from '../tools/local/view-image.js';
+const definitions = [
+    readToolDefinition,
+    viewImageToolDefinition,
+    applyPatchToolDefinition,
+    execToolDefinition,
+    execWaitToolDefinition,
+    codeModeToolDefinition,
+    codeExecWaitToolDefinition
+];
+function executionContext(context) {
+    if (!context.executionId)
+        throw new AgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool requires a real Execution.');
+    return { ...context, executionId: context.executionId };
+}
+export class LocalToolRegistry {
+    processes;
+    files;
+    #exec;
+    #code;
+    #handlers;
+    constructor(workspace, environment = process.env, shell, options = {}) {
+        const paths = new WorkspacePathResolver(workspace, {
+            ...(options.restrictPaths === undefined ? {} : { restrictPaths: options.restrictPaths }),
+            ...(options.workspaceWritable === undefined
+                ? {}
+                : { rootWritable: options.workspaceWritable }),
+            ...(options.pathMounts === undefined ? {} : { mounts: options.pathMounts })
+        });
+        this.files = new LocalFileAccess(paths);
+        const read = new ReadTool(paths);
+        const viewImage = new ViewImageTool(paths);
+        const patch = new ApplyPatchTool(paths);
+        this.#exec = new ExecTool(paths, undefined, undefined, environment, shell, options.processExecutor);
+        this.processes = { spawn: (input, call) => this.#exec.spawn(input, call) };
+        this.#code = new CodeModeTool(paths, environment, options.processExecutor ?? directLocalProcessExecutor, signalProcessTree, options.codeModeEngineFactory);
+        this.#handlers = new Map([
+            [
+                'code_exec',
+                (arguments_, context) => this.#code.start(arguments_, executionContext(context))
+            ],
+            [
+                'code_exec_wait',
+                (arguments_, context) => this.#code.wait(arguments_, executionContext(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 result = await patch.execute(applyPatchToolInput(arguments_));
+                    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,
+                        ...(context.executionId === undefined
+                            ? {}
+                            : { executionId: context.executionId }),
+                        ...(context.operation === undefined
+                            ? {}
+                            : {
+                                operationId: context.operation.operationId,
+                                ...(context.operation.ownerInstanceId === undefined
+                                    ? {}
+                                    : { ownerInstanceId: context.operation.ownerInstanceId })
+                            })
+                    }, context.waitInterrupt, context.onOutput);
+                    return formatExecResult(result);
+                }
+            ])
+        ]);
+    }
+    execute(call, context) {
+        const handler = this.#handlers.get(call.name);
+        if (!handler)
+            throw new AgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable.');
+        return handler(normalizeToolInput(call.arguments, definitions.find((tool) => tool.name === call.name).inputSchema), context);
+    }
+    names() {
+        return [...this.#handlers.keys()];
+    }
+    executeOperation(call, operation) {
+        const handler = this.#handlers.get(call.name);
+        if (!handler)
+            throw new AgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable.');
+        return handler(normalizeToolInput(call.arguments, definitions.find((tool) => tool.name === call.name).inputSchema), {
+            mode: 'run',
+            signal: operation.signal,
+            sessionId: operation.sessionId,
+            ...(operation.executionId === undefined ? {} : { executionId: operation.executionId }),
+            operation
+        });
+    }
+    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()]);
+    }
+}

package/dist/host/network.d.ts

@@ -0,0 +1,5 @@
+import { type HttpRequestInit } from '../network/http.js';
+export type { HttpAttempt, HttpRequestInit } from '../network/http.js';
+/** A single non-replayed request using the Host's selected HTTP version and proxy. */
+export declare function requestHttp(url: string, init: HttpRequestInit, signal: AbortSignal, responseTimeoutMs: number): Promise<Response>;
+export { acquireModelCredential as acquireCredential, appendModelCredentialHeaders as appendCredentialHeaders } from '../network/credential-runtime.js';

package/dist/host/network.js

@@ -0,0 +1,42 @@
+import { fetchWithConnectionTimeout, hasErrorCode, isModelHttpAttempt } from '../network/http.js';
+import { isRetryableTransportError, TransportFault } from '../network/transport-error.js';
+import { AgentError } from '../error.js';
+/** A single non-replayed request using the Host's selected HTTP version and proxy. */
+export async function requestHttp(url, init, signal, responseTimeoutMs) {
+    try {
+        const resolved = typeof init === 'function' ? await init() : init;
+        const attempt = isModelHttpAttempt(resolved)
+            ? resolved
+            : { request: resolved, httpVersion: '1.1' };
+        return await fetchWithConnectionTimeout(url, attempt, signal, responseTimeoutMs);
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw signal.reason ?? error;
+        if (error instanceof Error &&
+            error.cause instanceof TransportFault &&
+            error.cause.kind === 'invalid-proxy') {
+            const fault = error.cause;
+            error.cause = new AgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'SOCKS5 proxy URL is invalid.', fault.cause === undefined ? undefined : { cause: fault.cause });
+            throw error;
+        }
+        if (error instanceof TransportFault) {
+            if (error.kind === 'connection-timeout')
+                throw new AgentError('MAR_AGENT_MODEL_TIMEOUT', 'Model connection timed out.', {
+                    details: { reason: 'MODEL_CONNECTION_TIMEOUT' },
+                    retryable: true
+                });
+            if (error.kind === 'http2-negotiation')
+                throw new AgentError('MAR_AGENT_MODEL_CONNECTION_FAILED', 'Model endpoint did not negotiate HTTP/2.', { cause: error.cause });
+            throw new AgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'SOCKS5 proxy URL is invalid.', error.cause === undefined ? undefined : { cause: error.cause });
+        }
+        if (!isRetryableTransportError(error))
+            throw error;
+        throw new AgentError(hasErrorCode(error, 'ETIMEDOUT') ||
+            hasErrorCode(error, 'UND_ERR_CONNECT_TIMEOUT') ||
+            hasErrorCode(error, 'UND_ERR_HEADERS_TIMEOUT')
+            ? 'MAR_AGENT_MODEL_TIMEOUT'
+            : 'MAR_AGENT_MODEL_CONNECTION_FAILED', 'Model transport request failed.', { retryable: true, details: { reason: 'MODEL_TRANSPORT_FAILURE' }, cause: error });
+    }
+}
+export { acquireModelCredential as acquireCredential, appendModelCredentialHeaders as appendCredentialHeaders } from '../network/credential-runtime.js';

package/dist/host/process-control.d.ts

@@ -0,0 +1,2 @@
+import { type ChildProcessWithoutNullStreams } from 'node:child_process';
+export declare function signalProcessTree(child: ChildProcessWithoutNullStreams, signal: NodeJS.Signals): Promise<void>;

package/dist/host/process-control.js

@@ -0,0 +1,26 @@
+import { spawn } from 'node:child_process';
+export async function signalProcessTree(child, signal) {
+    if (!child.pid)
+        return;
+    if (process.platform !== 'win32') {
+        try {
+            process.kill(-child.pid, signal);
+        }
+        catch (error) {
+            if (error.code !== 'ESRCH')
+                child.kill(signal);
+        }
+        return;
+    }
+    await new Promise((resolve) => {
+        const killer = spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], {
+            stdio: 'ignore',
+            windowsHide: true
+        });
+        killer.once('error', () => {
+            child.kill();
+            resolve();
+        });
+        killer.once('exit', () => resolve());
+    });
+}

package/dist/host/skill-contract.d.ts

@@ -0,0 +1,6 @@
+export interface HostSkill {
+    readonly name: string;
+    readonly description: string;
+    readonly requiredTools: readonly string[];
+    load(): Promise<string>;
+}

package/dist/host.d.ts

@@ -0,0 +1,17 @@
+export type { ExtensionEnvironmentBackend } from './extensions/environment.js';
+export type { ExtensionFilesBackend } from './extensions/files.js';
+export type { ExtensionMcpBackend, ExtensionMcpConnectionBackend } from './extensions/mcp.js';
+export type { ExtensionNetworkBackend } from './extensions/network.js';
+export type { ExtensionProcessesBackend } from './extensions/processes.js';
+export { AGENT_HOST_API_VERSION, negotiateHost } from './host/contracts.js';
+export type { AgentHost, AgentHostCapability, AgentHostExtensionPorts, AgentHostToolsBackend, AgentHostToolSource, HostDescription, HostExecutionExtensions, HostSessionResourceSnapshot, HostSkill } from './host/contracts.js';
+export type { LocalAgentExecutionExtensions, LocalAgentExecutionMcpBinding, LocalAgentMcpBinding } from './host/local-agent-host.js';
+export { LocalAgentHost, selectExecutionShell } from './host/local-agent-host.js';
+export type { LocalProcessExecutor, LocalProcessSpawnRequest } from './host/local-process-executor.js';
+export type { ModelRequestUsage, ModelUsageObservation, ModelUsageObserver } from './model/usage-observer.js';
+export type { SessionResource } from './session/store/contracts.js';
+export type { CodeModeEngine, CodeModeEngineFactory, CreateCodeModeEngine } from './tools/code-mode/engine.js';
+export type { ClientToolDefinition, McpCatalogTool, McpToolCallContext, McpToolCatalog, McpToolCatalogContext, ToolCall, ToolCaller, ToolExecutionContext, ToolExecutionResult } from './tools/contracts.js';
+export { assertMcpToolCatalog, assertMcpToolDefinition, MCP_DEFINITION_LIMITS } from './tools/mcp/catalog.js';
+export type { PermissionMode, PermissionStop, ToolApprovalDecision, ToolApprovalHandler, ToolApprovalRequest, ToolPermission } from './tools/permissions.js';
+export type { WorkspacePathMount } from './tools/shared/path-resolver.js';

package/dist/host.js

@@ -0,0 +1,3 @@
+export { AGENT_HOST_API_VERSION, negotiateHost } from './host/contracts.js';
+export { LocalAgentHost, selectExecutionShell } from './host/local-agent-host.js';
+export { assertMcpToolCatalog, assertMcpToolDefinition, MCP_DEFINITION_LIMITS } from './tools/mcp/catalog.js';