@myagentroam/agent 0.10.18 → 0.10.20

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

@@ -27,10 +27,11 @@ export const codeModeToolDefinition = {
 - 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.
 - 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:
-- tools.NAME(input) returns a Promise. Use the existing tool input schema; freeform tools such as apply_patch accept a raw string, not a JSON wrapper.
+- tools.NAME(input) returns a Promise. Use the existing tool input schema; freeform tools such as apply_patch accept a raw string, not a JSON wrapper. For parameterless tools prefer tools.NAME({}); tools.NAME() is accepted only for explicitly closed empty-object schemas.
 - Results use the MAR envelope: { content?: string, data?: unknown, images?: Array<{mimeType:string,dataBase64:string}>, truncated?: boolean }. Redundant JSON content is omitted when it exactly renders data; independent text remains in content. Prefer data for programmatic results: result.data.results[0].text for read source text and result.data.exitCode/result.data.stdout for exec. content, when present, is rendered text, not raw file bytes. Use only fields documented by that tool; do not invent success or ok flags.
 - Tool errors reject with code/message and may be caught. A failed cell preserves already emitted output alongside its status and error; completed tool effects are not rolled back. Inspect it before retrying completed work. Await every call; unawaited calls fail the cell. Use Promise.all for independent calls and sequential await for dependencies. Runtime preserves safe/serial barriers and Host checks.
 - 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.

package/dist/agent-core/tools/code-mode/quickjs-engine.js

@@ -224,10 +224,13 @@ export async function createCodeModeEngine(options) {
                     return guestError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Code Mode state is too large.');
             };
             const tools = vm.newObject();
+            const parameterlessTools = new Set(input.catalog.filter(isParameterlessTool).map((tool) => tool.name));
             let toolCallSequence = 0;
             for (const name of input.tools) {
                 method(tools, name, (args = vm.undefined) => {
-                    const parsed = jsonValue(args, true);
+                    const parsed = vm.typeof(args) === 'undefined' && parameterlessTools.has(name)
+                        ? { value: {} }
+                        : jsonValue(args, true);
                     if (parsed.error)
                         return parsed;
                     const operationId = ++toolCallSequence;
@@ -704,19 +707,64 @@ function compilerSourceLocation(error, source) {
     const lines = source.split('\n');
     const line = error.lineNumber - 1;
     if (line > lines.length)
-        return ` (code-mode.js:${source.split(/\r\n|[\r\n\u2028\u2029]/u).length}, end of input)`;
+        return compilerCaret(source, source, true);
     const column = Number(typeof error.stack === 'string'
         ? error.stack.match(/^\s*at code-mode\.js:\d+:(\d+)(?:\n|$)/u)?.[1]
         : undefined);
-    if (!Number.isSafeInteger(column) || column < 1)
-        return '';
+    if (!Number.isSafeInteger(column) ||
+        column < 1 ||
+        column > Array.from(lines[line - 1]).length + 1) {
+        // Without a valid column, intra-LF-line separators make the original source line ambiguous.
+        if (/[\r\u2028\u2029]/u.test(lines[line - 1].replace(/\r$/u, '')))
+            return '';
+        const preceding = line > 1 ? lines.slice(0, line - 1).join('\n') + '\n' : '';
+        return ` (code-mode.js:${preceding.split(/\r\n|[\r\n\u2028\u2029]/u).length})`;
+    }
     const prefix = [
         ...lines.slice(0, line - 1),
         Array.from(lines[line - 1])
             .slice(0, column - 1)
             .join('')
     ].join('\n');
-    return ` (code-mode.js:${prefix.split(/\r\n|[\r\n\u2028\u2029]/u).length})`;
+    return compilerCaret(source, prefix);
+}
+function compilerCaret(source, prefix, endOfInput = false) {
+    const segments = prefix.split(/\r\n|[\r\n\u2028\u2029]/u);
+    const line = segments.length;
+    const column = Array.from(segments.at(-1)).length + 1;
+    const character = source.slice(prefix.length)[Symbol.iterator]().next().value;
+    // Source may contain credentials, commands or private code. Show only a punctuation token.
+    const token = endOfInput
+        ? '<end of input>'
+        : character === undefined || /[\r\n\u2028\u2029]/u.test(character)
+            ? '<end of line>'
+            : /^[{}[\]():;,.=+*/?!<>|&%\-]$/u.test(character)
+                ? character
+                : '<character omitted>';
+    const preview = '<source omitted>';
+    return ` (code-mode.js:${line}${endOfInput ? ', end of input' : ''})\nSyntax location: line ${line}, column ${column}\n${line} | ${preview}${token}\n${' '.repeat(String(line).length)} | ${' '.repeat(preview.length)}^`;
+}
+function isParameterlessTool(tool) {
+    const schema = tool.inputSchema;
+    return (tool.inputMode === 'json' &&
+        schema?.type === 'object' &&
+        schema.additionalProperties === false &&
+        schema.properties !== null &&
+        typeof schema.properties === 'object' &&
+        !Array.isArray(schema.properties) &&
+        Object.keys(schema.properties).length === 0 &&
+        (schema.required === undefined ||
+            (Array.isArray(schema.required) && schema.required.length === 0)) &&
+        Object.keys(schema).every((key) => [
+            'type',
+            'properties',
+            'additionalProperties',
+            'required',
+            'title',
+            'description',
+            '$schema',
+            '$comment'
+        ].includes(key)));
 }
 function diagnostic(code, message) {
     return Object.assign(new Error(message), { code });

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

@@ -91,7 +91,7 @@ class FreeformPatchParser {
                 throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Patch exceeds the file limit.');
         }
         if (!changes.some((change) => change.kind !== 'update' || change.targetPath || change.hunks.some((hunk) => !hunk.anchor)))
-            this.#fail('Patch must change or move at least one file.', 1);
+            this.#fail('Patch must change or move at least one file. No additions, deletions, or moves were supplied; context-only hunks only validate existing lines. Use read to inspect a file, or supply -old/+new lines to edit it.', 1);
         return changes;
     }
     #marker(index, marker, position) {

package/package.json

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