@myagentroam/agent 0.10.68 → 0.11.1

package/dist/agent-core/session/store/jsonl-store.js

@@ -880,6 +880,9 @@ export class JsonlSessionStore {
     }
     async #appendRecord(sessionId, input) {
         this.#assertOpen();
+        const writer = this.#shared.writerLeases.get(sessionId);
+        if (writer?.appendFailure)
+            throw writer.appendFailure.error;
         const before = this.#shared.index.sessions.find((item) => item.id === sessionId) ??
             this.#shared.pendingSessions.get(sessionId);
         if (!before)
@@ -913,7 +916,10 @@ export class JsonlSessionStore {
             // The first append creates the first segment.
         }
         try {
-            await appendRecordBytes(path, serialized);
+            await appendRecordBytes(path, serialized, (error) => {
+                if (writer)
+                    writer.appendFailure = { error };
+            });
         }
         catch (error) {
             // A failed write/sync/close can leave a complete record on disk.
@@ -1232,6 +1238,8 @@ export class JsonlSessionStore {
             if (lease) {
                 if (lease.executing || owner === undefined || lease.owner !== owner)
                     throw new MarAgentError('MAR_AGENT_SESSION_LOCKED', 'Session already has a writer.');
+                if (lease.appendFailure)
+                    throw lease.appendFailure.error;
                 lease.executing = true;
             }
             else {
@@ -1261,6 +1269,8 @@ export class JsonlSessionStore {
             let lease = this.#shared.writerLeases.get(sessionId);
             if (lease && lease.owner !== owner)
                 throw new MarAgentError('MAR_AGENT_SESSION_LOCKED', 'Session already has a writer.');
+            if (lease?.appendFailure)
+                throw lease.appendFailure.error;
             if (!lease) {
                 const release = await this.#acquireSessionLease(sessionId);
                 lease = { owner, executing: false, retained: 0, release };

package/dist/agent-core/session/store/records.d.ts

@@ -20,4 +20,4 @@ export declare function readRecordsFromTail(path: string, page?: {
     readonly positions: Map<string, HistoryPagePositions>;
 }): AsyncGenerator<SessionRecord>;
 export declare function segmentNumberFromPath(path: string): number | undefined;
-export declare function appendRecordBytes(path: string, serialized: string): Promise<void>;
+export declare function appendRecordBytes(path: string, serialized: string, onWriteFailure: (error: unknown) => void): Promise<void>;

package/dist/agent-core/session/store/records.js

@@ -230,10 +230,11 @@ export function segmentNumberFromPath(path) {
     const match = /events-(\d{6})\.jsonl$/.exec(path);
     return match === null ? undefined : Number(match[1]);
 }
-export async function appendRecordBytes(path, serialized) {
+export async function appendRecordBytes(path, serialized, onWriteFailure) {
+    const bytes = Buffer.from(serialized);
     const handle = await open(path, 'a', 0o600);
+    let failure;
     try {
-        const bytes = Buffer.from(serialized);
         let offset = 0;
         while (offset < bytes.length) {
             const { bytesWritten } = await handle.write(bytes, offset, bytes.length - offset);
@@ -243,7 +244,18 @@ export async function appendRecordBytes(path, serialized) {
         }
         await handle.sync();
     }
-    finally {
+    catch (error) {
+        failure = { error };
+    }
+    try {
         await handle.close();
     }
+    catch (error) {
+        failure ??= { error };
+    }
+    if (failure) {
+        // Opening/encoding failures cannot have appended bytes; write/sync/close failures can.
+        onWriteFailure(failure.error);
+        throw failure.error;
+    }
 }

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

@@ -1,6 +1,8 @@
 import { MarAgentError } from '../error.js';
 /** Normalize trusted Host policy independently of discovery, Agent scope and parallel safety. */
 export function toolCallers(tool) {
+    if (tool.codeModeExposure !== undefined && tool.codeModeExposure !== 'both')
+        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Mode exposure is invalid.');
     const value = tool.allowedCallers;
     if (value === undefined)
         return tool.name.startsWith('mcp__') ? ['direct', 'programmatic'] : ['direct'];
@@ -31,5 +33,7 @@ export function allowsToolCaller(tool, caller) {
 /** Code Mode Only changes model exposure, never the Host's underlying caller permissions. */
 export function allowsDirectTool(tool, codeModeEnabled) {
     return (allowsToolCaller(tool, 'direct') &&
-        (!codeModeEnabled || !allowsToolCaller(tool, 'programmatic')));
+        (!codeModeEnabled ||
+            tool.codeModeExposure === 'both' ||
+            !allowsToolCaller(tool, 'programmatic')));
 }

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

@@ -21,14 +21,14 @@ import { failedToolResultExtensions } from '../result-extensions.js';
 export const codeModeToolDefinition = {
     name: 'code_exec',
     description: `Run JavaScript to orchestrate or compose tool calls.
-- Code Mode Only: call the programmatic tools listed below through tools.NAME inside this tool, including single-tool operations. They are omitted from the top-level tool list. Direct-only tools remain separate model tools and cannot be called here.
+- Code Mode Only by default: call the programmatic tools listed below through tools.NAME, including single-tool operations. Tools explicitly exposed in both places may also be called directly; follow each tool's calling guidance. Direct-only tools remain separate model tools and cannot be called here.
 - Run independent calls concurrently with Promise.all; await sequentially when data, side effects, or failure handling require ordering.
 - Complete known, bounded steps and deterministic result processing in code when this avoids a model round trip. Return to the model when interpretation or a new decision is needed; do not invent extra work to fill a cell.
 - Observe only evidence needed for the next decision or verification: use observe.result for original results, observe.text for derived values, and observe.image for image values. Preserve source and failure details needed for reasoning; keep other intermediate data in the cell.
 - Single-tool cells are valid. Keep loops and retries bounded, and do not blindly replay operations with side effects.
 - Evaluates source in a fresh restricted ECMAScript runtime with top-level await and Promise.all. It is not Node.js or a browser. JavaScript globals do not survive between cells; bounded JSON state is available through state.
 - Accepts JavaScript source text. When exposed as a freeform tool, send the source directly; when exposed with a JSON input schema, put the source in its code field. Do not add another JSON wrapper, quoted string, or markdown code fence inside the source.
-- Keep embedded commands, patches and source in JSON-escaped double-quoted strings when they contain backticks or literal \${...}; JavaScript template literals would interpolate them before the tool runs. Do not paste Python literals such as None into JavaScript expressions.
+- Keep embedded commands, patches and source in JSON-escaped double-quoted strings when they contain backticks or literal \${...}; escape newlines as \\n, never put literal line breaks inside single- or double-quoted JS strings. JavaScript template literals would interpolate their contents before the tool runs. Do not paste Python literals such as None into JavaScript expressions.
 - Use only standard ECMAScript built-ins and the explicitly documented tools, observe, state, catalog and cell namespaces. Do not use Node.js, browser or Web APIs. Module imports, filesystem and network APIs are unavailable. Obtain external capabilities only through available tools. Use tools.exec to start managed processes when permitted; use tools.exec_wait afterward to wait, write stdin or cancel.
 
 Tool calls:
@@ -41,7 +41,7 @@ Built-in namespaces:
 - observe.result(result): void registers an unmodified complete tools.NAME result or caught tool error as a trusted tool_result, using the original text and all images without repeating program data. Non-original, copied or modified values are rejected. This selects evidence for the next model response, not a log and not a new model call. Prefer observe.result for inspecting tool results.
 - observe.text(value): void registers text/JSON values. observe.image(value): void registers one image value when image input is supported. Both accept original tool results for compatibility and use the same complete tool_result observation path; they do not select part of an original result. Extracted single images, copies and computed summaries are value observations, never trusted tool results. Observations are returned in registration order. Only explicitly observed evidence reaches the model; registration does not prove inspection. Sources and types are runtime-assigned. No out or callable observe(value) alias exists.
 - 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 and inputSchema. It does not discover or authorize additional tools.
+- catalog.tools() returns a read-only array of the tools callable in this cell, including name, description and inputSchema. It does not discover or authorize additional tools.
 - await cell.sleep(ms) performs a cancellable delay up to ${limits.codeSleepMaxMs} ms.
 - await cell.yield_control() returns accumulated output to the model immediately while this cell continues running.
 - Optionally start source with // @options: {"yieldMs": ${limits.codeDefaultYieldMs}}. yieldMs defaults to ${limits.codeDefaultYieldMs} ms and controls this call's wait window (0..${limits.codeMaxYieldMs}), not nested tool timeouts or wait windows. A running result includes cellId; use direct code_exec_wait for new output, completion or termination.
@@ -106,7 +106,7 @@ export const codeExecWaitToolDefinition = {
 function projectProgrammaticTool(tool) {
     return {
         name: tool.name,
-        description: `Call only as tools.${tool.name} inside code_exec, never as a direct model tool.\nPass a JavaScript value matching inputSchema.\n${tool.description}`,
+        description: `${allowsDirectTool(tool, true) ? `Call directly or as tools.${tool.name} inside code_exec.` : `Call only as tools.${tool.name} inside code_exec, never as a direct model tool.`}\nInside code_exec, pass a JavaScript value matching inputSchema.\n${tool.description}`,
         inputSchema: stableToolSchema(tool.inputSchema)
     };
 }
@@ -121,14 +121,14 @@ export function projectCodeModeTools(tools, residentTools = tools) {
     const programmatic = orderToolDefinitions(residentTools.filter((tool) => allowsToolCaller(tool, 'programmatic')));
     const directory = JSON.stringify({
         callableNames: programmatic.map((tool) => tool.name),
-        programmaticOnly: programmatic.map(projectProgrammaticTool)
+        tools: programmatic.map(projectProgrammaticTool)
     });
     if (Buffer.byteLength(directory) > 32 * 1024)
         throw new MarAgentError('MAR_AGENT_TOOL_EXPOSURE_LIMIT', 'Programmatic tool directory is too large.');
     return direct.map((tool) => tool.name === 'code_exec'
         ? {
             ...tool,
-            description: `${codeModeToolDefinition.description}\nDeferred MCP definitions are returned by direct tool_search and become callable from the next model response, not later in the same response; they are not appended to this description.\nProgrammatic tools (call only inside code_exec): ${directory}`
+            description: `${codeModeToolDefinition.description}\nDeferred MCP definitions are returned by direct tool_search and become callable from the next model response, not later in the same response; they are not appended to this description.\nProgrammatic tools: ${directory}`
         }
         : tool);
 }
@@ -145,14 +145,23 @@ export function projectCodeModeSearchResult(message, codeModeEnabled) {
         };
     const tools = message.toolSearchTools.map((tool) => ({
         ...(allowsToolCaller(tool, 'programmatic')
-            ? projectProgrammaticTool(tool)
+            ? {
+                ...projectProgrammaticTool(tool),
+                ...(allowsDirectTool(tool, true)
+                    ? { inputMode: tool.inputMode ?? 'json' }
+                    : {})
+            }
             : {
                 name: tool.name,
                 description: tool.description,
                 inputSchema: stableToolSchema(tool.inputSchema),
                 inputMode: tool.inputMode ?? 'json'
             }),
-        caller: allowsToolCaller(tool, 'programmatic') ? 'programmatic' : 'direct'
+        caller: allowsToolCaller(tool, 'programmatic')
+            ? allowsDirectTool(tool, true)
+                ? 'both'
+                : 'programmatic'
+            : 'direct'
     }));
     return {
         ...message,

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

@@ -10,6 +10,8 @@ export interface ClientToolDefinition {
     outputSchema?: Record<string, unknown>;
     /** Runtime-only policy. MCP defaults to both callers; other tools default to direct only. */
     allowedCallers?: readonly ToolCaller[];
+    /** Runtime-only exposure override; retains both permitted entry points with Code Mode enabled. */
+    codeModeExposure?: 'both';
     inputMode?: 'json' | 'freeform';
     parallelSafety?: 'safe' | 'serial';
     /** Preserved business-schema eligibility after framework metadata projection. */

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

@@ -9,6 +9,7 @@ import { parsePatch } from './apply-patch-parser.js';
 export const applyPatchToolDefinition = {
     name: 'apply_patch',
     allowedCallers: ['direct', 'programmatic'],
+    codeModeExposure: 'both',
     parallelSafety: 'serial',
     description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch, each marker on its own line. Surrounding marker whitespace and an optional trailing *** are accepted; incomplete markers or extra text are rejected. Add File content lines, including blank lines, must start with +. Syntax errors include line/column and a bounded caret diagnostic with file content omitted. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>. Context-only hunks, including trailing hunks, and unchanged file sections are validated in order but are not written or reported as edits. The patch must include a change or move. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
     inputMode: 'freeform',

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

@@ -150,6 +150,7 @@ export function assertMcpToolDefinition(value, options = {}) {
             (!Array.isArray(value.allowedCallers) ||
                 !value.allowedCallers.length ||
                 value.allowedCallers.some((caller) => caller !== 'direct' && caller !== 'programmatic'))) ||
+        (value.codeModeExposure !== undefined && value.codeModeExposure !== 'both') ||
         (value.inputMode !== undefined && value.inputMode !== 'json'))
         invalid();
     assertJson(value);

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

@@ -14,7 +14,7 @@ export const TOOL_SEARCH_LIMITS = Object.freeze({
 });
 export const toolSearchToolDefinition = {
     name: 'tool_search',
-    description: 'Search deferred MCP metadata and return matching tool definitions for the next model call. Use the full callable name for exact selection, or keywords for BM25 search. Never executes the discovered tools. With Code Mode Only, programmatic tools must be called through code_exec, not directly. Already exposed tools need not be searched again. The selected definitions must fit the exposure budget or the search fails atomically.',
+    description: 'Search deferred MCP metadata and return matching tool definitions for the next model call. Use the full callable name for exact selection, or keywords for BM25 search. Never executes the discovered tools. With Code Mode Only, programmatic tools use code_exec unless explicitly exposed for both direct and programmatic calls. Already exposed tools need not be searched again. The selected definitions must fit the exposure budget or the search fails atomically.',
     inputSchema: {
         type: 'object',
         properties: {

package/package.json

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