@myagentroam/agent 0.9.158 → 0.9.160

package/dist/agent-core/tools/mcp/catalog.js

@@ -136,10 +136,10 @@ function assertSchema(schema) {
     }
 }
 /** Shared Host and Node publication boundary, not a provider-specific conversion. */
-export function assertMcpToolDefinition(value) {
+export function assertMcpToolDefinition(value, options = {}) {
     if (!record(value) ||
         !text(value.name, 256) ||
-        !/^mcp__[A-Za-z0-9_-]+__[A-Za-z0-9_-]+$/u.test(value.name) ||
+        (!options.nativeToolNames && !/^mcp__[A-Za-z0-9_-]+__[A-Za-z0-9_-]+$/u.test(value.name)) ||
         typeof value.description !== 'string' ||
         value.description.length > 65536 ||
         (value.parallelSafety !== undefined &&
@@ -159,7 +159,7 @@ export function assertMcpToolDefinition(value) {
     if (Buffer.byteLength(JSON.stringify(value)) > MCP_DEFINITION_LIMITS.definitionBytes)
         invalid();
 }
-export function assertMcpToolCatalog(value) {
+export function assertMcpToolCatalog(value, options = {}) {
     if (!record(value) ||
         typeof value.revision !== 'string' ||
         value.revision.length > 512 ||
@@ -204,7 +204,7 @@ export function assertMcpToolCatalog(value) {
             !['session', 'execution'].includes(String(tool.lifetime)) ||
             !['direct', 'deferred'].includes(String(tool.exposure)))
             invalid();
-        assertMcpToolDefinition(tool.definition);
+        assertMcpToolDefinition(tool.definition, options);
         if (tool.annotations !== undefined) {
             if (!record(tool.annotations))
                 invalid();

package/dist/agent-core/tools/mcp/history.js

@@ -4,8 +4,8 @@ export function discoveredMcpToolNames(messages) {
     const names = new Set();
     for (const message of messages)
         for (const tool of calls.has(message.callId ?? '') ? (message.toolSearchTools ?? []) : [])
-            if (tool.name.startsWith('mcp__'))
-                names.add(tool.name);
+            // Paired discovery receipts provide candidates; the current captured MCP catalog is authority.
+            names.add(tool.name);
     return [...names];
 }
 export function rebindMcpToolSearchOutputs(messages, registry) {

package/dist/agent-core/tools/mcp/tool-search.d.ts

@@ -20,7 +20,9 @@ export declare class DeferredMcpRegistry {
     #private;
     constructor(discoveredNames: readonly string[]);
     restore(discoveredNames: readonly string[]): void;
-    update(catalog: McpToolCatalog, eligible: (tool: McpCatalogTool) => boolean): void;
+    update(catalog: McpToolCatalog, eligible: (tool: McpCatalogTool) => boolean, options?: {
+        nativeToolNames?: boolean;
+    }): void;
     get hasDeferred(): boolean;
     snapshot(): readonly string[];
     expectedTool(name: string): {

package/dist/agent-core/tools/mcp/tool-search.js

@@ -63,8 +63,8 @@ export class DeferredMcpRegistry {
         // GC may remove evidence, but cannot grant a capability from another Execution.
         this.#executionSelected = new Set([...this.#executionSelected].filter((name) => surviving.has(name)));
     }
-    update(catalog, eligible) {
-        assertMcpToolCatalog(catalog);
+    update(catalog, eligible, options = {}) {
+        assertMcpToolCatalog(catalog, options);
         this.#catalog = { ...catalog, tools: catalog.tools.filter(eligible) };
         const validSession = new Set(this.#catalog.tools
             .filter((tool) => tool.lifetime === 'session' && tool.exposure === 'deferred')

package/dist/agent-core/tools/output-projection.d.ts

@@ -1,5 +1,5 @@
 import type { SubagentTaskSnapshot } from '../subagent/contracts.js';
-import type { ApplyPatchResult, CodeCellEventData, ExecResult, MarAgentToolArtifact, ReadEventData, ViewImageResult } from './contracts.js';
+import type { ApplyPatchResult, CodeCellEventData, ExecResult, MarAgentToolArtifact, ToolExecutionResult, ReadEventData, ViewImageResult } from './contracts.js';
 import type { ToolRuntimeImage } from './runtime-context.js';
 export declare function currentExecutionImages(modelInputImages: readonly {
     readonly mimeType: string;
@@ -12,3 +12,5 @@ export declare function boundedModelToolOutput(toolName: string, value: string,
 /** Project only known, validated tool result shapes into public structured events. */
 export declare function structuredToolEventData(toolName: string, value: unknown): CodeCellEventData | ExecResult | ApplyPatchResult | ReadEventData | ViewImageResult | SubagentTaskSnapshot | undefined;
 export declare function structuredToolArtifacts(value: readonly MarAgentToolArtifact[] | undefined): readonly MarAgentToolArtifact[] | undefined;
+/** Shared result contract for model, programmatic, and native API callers. */
+export declare function validateToolResult(value: ToolExecutionResult): ToolExecutionResult;

package/dist/agent-core/tools/output-projection.js

@@ -149,8 +149,10 @@ export function structuredToolEventData(toolName, value) {
 export function structuredToolArtifacts(value) {
     if (value === undefined)
         return undefined;
-    if (value.length !== 1 ||
-        value.some((artifact) => artifact.kind !== 'image' ||
+    if (!Array.isArray(value) ||
+        value.length !== 1 ||
+        value.some((artifact) => !artifact ||
+            artifact.kind !== 'image' ||
             artifact.mimeType !== 'image/png' ||
             typeof artifact.name !== 'string' ||
             artifact.name.length === 0 ||
@@ -162,6 +164,13 @@ export function structuredToolArtifacts(value) {
         throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_INVALID', 'Tool image artifact is invalid.');
     return value.map((artifact) => ({ ...artifact }));
 }
+/** Shared result contract for model, programmatic, and native API callers. */
+export function validateToolResult(value) {
+    if (!value || typeof value.content !== 'string')
+        throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_INVALID', 'Tool result must contain string content.');
+    const artifacts = structuredToolArtifacts(value.artifacts);
+    return artifacts === undefined ? value : { ...value, artifacts };
+}
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/agent-core/tools/runtime-context.d.ts

@@ -51,5 +51,6 @@ export interface ToolRuntimeContext {
     recentImages?: readonly ToolRuntimeImage[];
     searchMcpTools?: (input: unknown, signal: AbortSignal) => Promise<import('./contracts.js').ToolExecutionResult>;
     expectedMcpTool?: import('./contracts.js').McpToolCallContext['expectedTool'];
+    invokeTool?: (call: import('./contracts.js').ToolCall, context: ToolRuntimeContext, caller: import('./contracts.js').ToolCaller) => Promise<import('./contracts.js').ToolExecutionResult>;
     emit(event: ToolRuntimeEvent): Promise<void>;
 }

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

@@ -1,2 +1,4 @@
 import type { ToolRuntimeContext } from './runtime-context.js';
-export declare function executeRegisteredTool(name: string, arguments_: unknown, callId: string, context: ToolRuntimeContext): Promise<import("./contracts.js").ToolExecutionResult>;
+export declare function executeRegisteredTool(name: string, arguments_: unknown, callId: string, context: ToolRuntimeContext, caller?: import('./contracts.js').ToolCaller): Promise<import("./contracts.js").ToolExecutionResult>;
+/** Invoke an already captured source; names never reselect a different backend. */
+export declare function executeCapturedTool(kind: 'builtin' | 'host' | 'mcp', call: import('./contracts.js').ToolCall, context: ToolRuntimeContext): Promise<import('./contracts.js').ToolExecutionResult>;

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

@@ -1,11 +1,26 @@
 import { MarAgentError } from '../error.js';
-import { AGENT_TOOL_HANDLERS } from './registry.js';
-export async function executeRegisteredTool(name, arguments_, callId, context) {
-    const handler = AGENT_TOOL_HANDLERS.get(name);
-    if (handler)
-        return handler(arguments_, context, callId);
-    const call = { name, arguments: arguments_, callId };
-    if (name.startsWith('mcp__')) {
+import { randomUUID } from 'node:crypto';
+import { AGENT_TOOL_HANDLERS, BUILTIN_TOOL_DEFINITIONS } from './registry.js';
+import { normalizeToolInput } from './input.js';
+import { validateToolResult } from './output-projection.js';
+export async function executeRegisteredTool(name, arguments_, callId, context, caller = 'direct') {
+    if (context.invokeTool)
+        return validateToolResult(await context.invokeTool({ name, arguments: arguments_, callId }, context, caller));
+    return validateToolResult(await executeCapturedTool(AGENT_TOOL_HANDLERS.has(name) ? 'builtin' : name.startsWith('mcp__') ? 'mcp' : 'host', { name, arguments: arguments_, callId }, context));
+}
+/** Invoke an already captured source; names never reselect a different backend. */
+export async function executeCapturedTool(kind, call, context) {
+    const definition = kind === 'builtin'
+        ? BUILTIN_TOOL_DEFINITIONS.find((tool) => tool.name === call.name)
+        : undefined;
+    if (definition)
+        call = { ...call, arguments: normalizeToolInput(call.arguments, definition.inputSchema) };
+    if (kind === 'builtin') {
+        const handler = AGENT_TOOL_HANDLERS.get(call.name);
+        if (handler)
+            return handler(call.arguments, context, call.callId ?? randomUUID());
+    }
+    if (kind === 'mcp') {
         if (!context.host.callMcpTool)
             throw new MarAgentError('MAR_AGENT_MCP_FAILED', 'MCP execution is unavailable.');
         return context.host.callMcpTool(call, context.signal, {

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

@@ -1,4 +1,6 @@
 import type { ClientToolDefinition } from '../model/contracts.js';
+/** A managed independent callback must not borrow its still-active creator's tool barrier. */
+export declare function withIndependentSessionTools<Value>(run: () => Value): Value;
 /** One barrier domain for foreground tools and all retained cells in a Session. */
 export declare function createSessionToolScheduler(): <T>(definition: ClientToolDefinition | undefined, run: () => Promise<T>) => Promise<T>;
 /** Schedules an incremental stream while preserving the same safe/serial barriers as batches. */

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

@@ -1,13 +1,50 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const sessionToolIngress = new AsyncLocalStorage();
+/** A managed independent callback must not borrow its still-active creator's tool barrier. */
+export function withIndependentSessionTools(run) {
+    return sessionToolIngress.run(Symbol(), run);
+}
 /** One barrier domain for foreground tools and all retained cells in a Session. */
 export function createSessionToolScheduler() {
-    const schedule = createToolCallScheduler([
+    const leases = new AsyncLocalStorage();
+    const definitions = [
         { name: 'safe', parallelSafety: 'safe' },
         { name: 'serial', parallelSafety: 'serial' }
-    ], (job) => job.run());
-    return (definition, run) => schedule({
-        name: definition?.parallelSafety === 'safe' ? 'safe' : 'serial',
-        run
-    });
+    ];
+    const execute = async (job) => {
+        const lease = {
+            active: true,
+            ingress: sessionToolIngress.getStore(),
+            schedule: createToolCallScheduler(definitions, execute),
+            children: new Set()
+        };
+        return leases.run(lease, async () => {
+            try {
+                return await job.run();
+            }
+            finally {
+                // The parent keeps its barrier until every accepted descendant has settled.
+                while (lease.children.size)
+                    await Promise.all([...lease.children]);
+                lease.active = false;
+            }
+        });
+    };
+    const root = createToolCallScheduler(definitions, execute);
+    return (definition, run) => {
+        const inherited = leases.getStore();
+        const parent = inherited?.ingress === sessionToolIngress.getStore() ? inherited : undefined;
+        const result = (parent?.active ? parent.schedule : root)({
+            name: definition?.parallelSafety === 'safe' ? 'safe' : 'serial',
+            run
+        });
+        if (parent?.active) {
+            const settled = result.then(() => undefined, () => undefined);
+            parent.children.add(settled);
+            void settled.then(() => parent.children.delete(settled));
+        }
+        return result;
+    };
 }
 /** Schedules an incremental stream while preserving the same safe/serial barriers as batches. */
 export function createToolCallScheduler(definitions, execute) {

package/dist/index.d.ts

@@ -8,7 +8,28 @@ export { testMarAgentModelTransport } from './agent-core/model/transport-test.js
 export type { AccessMode, ExecutionMode, ExecutionResult, MarAgentImageMetadata, RolloutBudgetOptions, RunInput, RunInputImage } from './agent-core/runtime/contracts.js';
 export type { MarAgentEvent } from './agent-core/runtime/events.js';
 export { createMarAgent } from './agent-core/sdk/agent.js';
+export type { CoreAgentExtensionContext, CoreSessionExtensionContext, CoreRuntimeExtension, CoreExtensionSnapshot, CoreExtensionSource, CoreExtensionDiagnostic, CoreDomainOperations, CoreDomainFacts, CoreHookRegistrar, CoreCapabilitySnapshot, CoreCommandSpec, CorePromptSection, CoreServiceDeclaration, CoreServiceDependency } from './agent-core/extensions/contracts.js';
+export type { CoreDisposer, CoreResourceRegistration, CoreResourceScope } from './agent-core/extensions/resources.js';
+export type { CoreHookOptions, CoreInterceptor } from './agent-core/extensions/hooks.js';
+export type { CoreOperationContext } from './agent-core/extensions/operation.js';
+export type { CoreServiceKey, CoreServiceRegistry } from './agent-core/extensions/services.js';
+export type { CoreToolSpec, CoreToolRef, CoreToolInvocation, CoreToolCheck, CoreToolAttempt, CoreToolCompletion, CoreToolFailure } from './agent-core/extensions/tools.js';
+export type { CoreModelMessage, CoreModelRequest, CoreRequestSnapshot } from './agent-core/extensions/model-request.js';
+export type { CoreModelEvent } from './agent-core/extensions/model-stream.js';
+export type { CorePromptPart, CorePromptFacts, CorePromptComposition, CorePromptSectionInput } from './agent-core/extensions/prompt-composition.js';
+export type { CoreFilesApi, CoreFilesBackend, CoreFilePath, CoreFileWrite, CoreFileRemove, CoreFileTransfer, CoreFileType, CoreFileInfo, CoreFileEntry, CoreFileCompletion } from './agent-core/extensions/files.js';
+export type { CoreHostExtensionPorts, CoreHostToolSource, CoreHostToolsBackend } from './agent-core/host/contracts.js';
+export type { CoreEnvironmentApi, CoreEnvironmentBackend, CoreEnvironmentKey, CoreEnvironmentSet, CoreEnvironmentChange, CoreEnvironmentCompletion } from './agent-core/extensions/environment.js';
+export type { CoreMcpApi, CoreMcpBackend, CoreMcpConnectionBackend, CoreMcpToolCall, CoreMcpServerDefinition, CoreMcpServerRef, CoreMcpServerRegistration, CoreMcpConnectionRef, CoreMcpConnectInput, CoreMcpConnectionInput, CoreMcpCallInput, CoreMcpCatalog, CoreMcpCompletion } from './agent-core/extensions/mcp.js';
+export type { CoreAgentsApi, CoreAgentsBackend, CoreAgentSpawnInput, CoreAgentTarget, CoreAgentWaitInput, CoreAgentMessageInput, CoreAgentSnapshot, CoreAgentHandledResult, CoreAgentSpawnResult, CoreAgentCompletion } from './agent-core/extensions/agents.js';
+export type { CoreSettingsApi, CoreSettingsBackend, CoreSettingsReadInput, CoreSettingsUpdate, CoreSettingsDescription, CoreSettingDefinition, CoreSettingsSnapshot, CoreSettingsResult, CoreSettingsCompletion } from './agent-core/extensions/settings.js';
+export type { CoreNetworkApi, CoreNetworkBackend, CoreHttpRequest, CoreHttpResponse, CoreHttpCompletion } from './agent-core/extensions/network.js';
+export type { CoreSessionApi, CoreSessionReceipt, CoreSessionInspection, CoreSessionDescription, CoreSessionMessages, CoreSessionMessagesInput, CoreSessionMessage, CoreSessionOperationStatus, CoreAppendInput, CoreSubmitInput, CoreInputSource, CoreCompactInput, CoreSessionActionResult } from './agent-core/extensions/session-input.js';
+export type { CorePromptInput, CorePromptResult } from './agent-core/extensions/prompt-input.js';
+export type { CoreModelsApi, CoreModelDescription, CoreModelTextBlock, CoreGenerateInput, CoreGenerateResult } from './agent-core/extensions/models.js';
+export type { CoreDataApi, CoreJsonValue, CoreCheckpoint, CoreCheckpointApi, CoreStateApi, CoreStateChange, CoreStoreApi, CoreStoreCommit } from './agent-core/extensions/data.js';
 export { generateSessionTitle, type GenerateSessionTitleInput } from './shared/auto-title.js';
+export type { CoreProcessesApi, CoreProcessesBackend, CoreProcessInput, CoreProcessRunInput, CoreProcessHandle, CoreProcessExit, CoreProcessResult, CoreProcessCompletion } from './agent-core/extensions/processes.js';
 export type { CreateMarAgentOptions, CreateSessionInput, ExecutionHandle, MarAgent, MarAgentSession, SessionTitleUpdateInput } from './agent-core/sdk/types.js';
 export { openMarAgentSessionCatalog, type MarAgentContextUsage, type MarAgentHistoryEntry, type MarAgentHistoryPage, type MarAgentSessionCatalog, type MarAgentSessionDeleteResult, type MarAgentSessionImage, type MarAgentSessionPage, type MarAgentSessionSummary } from './agent-core/session/catalog.js';
 export type { SessionListInput, SessionSource } from './agent-core/session/types.js';

package/dist/sandbox/linux/bubblewrap-sandbox-executor.js

@@ -98,6 +98,7 @@ export class BubblewrapSandboxExecutor {
                 return child;
             }
             catch (error) {
+                request.signal?.throwIfAborted();
                 throw unavailable(error);
             }
         }
@@ -202,9 +203,11 @@ export class BubblewrapSandboxExecutor {
             args.push(mount.access === 'READ_WRITE' ? '--bind' : '--ro-bind', mount.source, mount.destination);
         if (request.owner !== undefined) {
             if (!CURSOR_SAFE_ID.test(request.owner.sessionId) ||
-                !CURSOR_SAFE_ID.test(request.owner.executionId))
+                (request.owner.executionId !== undefined && !CURSOR_SAFE_ID.test(request.owner.executionId)))
                 throw policyInvalid();
-            args.push('--setenv', 'MAR_AGENT_SESSION_ID', request.owner.sessionId, '--setenv', 'MAR_AGENT_EXECUTION_ID', request.owner.executionId);
+            args.push('--setenv', 'MAR_AGENT_SESSION_ID', request.owner.sessionId);
+            if (request.owner.executionId !== undefined)
+                args.push('--setenv', 'MAR_AGENT_EXECUTION_ID', request.owner.executionId);
         }
         for (const [name, value] of explicitEnvironment(request))
             args.push('--setenv', name, value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.9.158",
+  "version": "0.9.160",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",