@myagentroam/node 0.11.39 → 0.11.40

package/dist/migrations/v022.js

@@ -0,0 +1,58 @@
+import { DatabaseSync } from 'node:sqlite';
+import { NODE_SCHEMA_V13 } from './v013.js';
+import { NODE_SCHEMA_MIGRATION_V14 } from './v014.js';
+import { NODE_SCHEMA_MIGRATION_V15 } from './v015.js';
+import { NODE_SCHEMA_MIGRATION_V16 } from './v016.js';
+import { NODE_SCHEMA_MIGRATION_V17 } from './v017.js';
+import { NODE_SCHEMA_MIGRATION_V18 } from './v018.js';
+import { NODE_SCHEMA_MIGRATION_V19 } from './v019.js';
+import { NODE_SCHEMA_MIGRATION_V20 } from './v020.js';
+import { NODE_SCHEMA_MIGRATION_V21 } from './v021.js';
+const sql = `ALTER TABLE agent_sessions ADD COLUMN parent_session_id TEXT;
+UPDATE agent_sessions SET parent_session_id = CASE
+  WHEN json_type(metadata, '$.parentSessionId') = 'text'
+  THEN json_extract(metadata, '$.parentSessionId') ELSE NULL END;
+UPDATE agent_sessions SET metadata = json_remove(metadata, '$.parentSessionId');
+CREATE INDEX agent_sessions_workspace_parent ON agent_sessions(workspace_id, parent_session_id);`;
+export const NODE_SCHEMA_MIGRATION_V22 = {
+    version: 22,
+    sql,
+    preflight: (database) => NODE_SCHEMA_MIGRATION_V21.assert(database),
+    assert(database) {
+        const reference = new DatabaseSync(':memory:');
+        try {
+            reference.exec(NODE_SCHEMA_V13);
+            for (const migration of [
+                NODE_SCHEMA_MIGRATION_V14,
+                NODE_SCHEMA_MIGRATION_V15,
+                NODE_SCHEMA_MIGRATION_V16,
+                NODE_SCHEMA_MIGRATION_V17,
+                NODE_SCHEMA_MIGRATION_V18,
+                NODE_SCHEMA_MIGRATION_V19,
+                NODE_SCHEMA_MIGRATION_V20,
+                NODE_SCHEMA_MIGRATION_V21
+            ])
+                reference.exec(migration.sql);
+            reference.exec(sql);
+            const schema = (db) => db
+                .prepare("SELECT type,name,sql FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%' ORDER BY type,name")
+                .all()
+                .map((row) => [
+                row.type,
+                row.name,
+                row.name === 'node_schema_migrations'
+                    ? String(row.sql).replace(/\s+/g, '')
+                    : String(row.sql).replace(/\s+/g, ' ').trim()
+            ]);
+            const actual = schema(database);
+            const expected = schema(reference);
+            const mismatch = expected.find((row) => !actual.some((value) => JSON.stringify(value) === JSON.stringify(row))) ??
+                actual.find((row) => !expected.some((value) => JSON.stringify(value) === JSON.stringify(row)));
+            if (mismatch !== undefined)
+                throw new Error(`NODE_DATABASE_SCHEMA_INVALID:${String(mismatch[1])}`);
+        }
+        finally {
+            reference.close();
+        }
+    }
+};

package/dist/runner/abstract-runner.js

@@ -36,6 +36,13 @@ export class AbstractRunner {
             model.supportedEfforts.includes(configuration.effort) &&
             profile.accessOptions.some((candidate) => candidate.id === configuration.access));
     }
+    /** Models eligible for a child session, based on this runner's current profile. */
+    childModels() {
+        return this.profileForValidation().models;
+    }
+    assertChildModel(modelId) {
+        void modelId;
+    }
     presentSession(session, capabilities, context) {
         void [session, capabilities, context];
         throw new RunnerCapabilityError(this.name, 'session.presentation');
@@ -72,6 +79,13 @@ export class AbstractRunner {
         void [session, nativeSessionId];
         return false;
     }
+    supportsNativeBatchRemoval() {
+        return false;
+    }
+    async removeNativeMembers(sessions) {
+        void sessions;
+        throw new Error('NATIVE_BATCH_REMOVE_UNAVAILABLE');
+    }
     async forkNative(session, boundary, title) {
         void [session, boundary, title];
         throw new RunnerCapabilityError(this.name, 'session.rewind');

package/dist/runner/claude/tool-normalizer.js

@@ -1,5 +1,6 @@
 import { claudeContentBlocks } from './message-parsers.js';
 import { compactRunnerText, compactRunnerValue } from '../normalization.js';
+import { publicOutputSnapshot, shellExecution } from '../execution-presentation.js';
 import { RunnerUsageTracker, usageToken, usageTokenSum } from '../../service/runner-usage-tracker.js';
 export class ClaudeUsageNormalizer {
     tracker;
@@ -105,7 +106,11 @@ export function normalizeClaudeTool(toolName, input, output, failed, truncated,
                 outputRef: null,
                 exitCode: null,
                 durationMs: null,
-                truncated: outputTruncated
+                truncated: outputTruncated,
+                ...(output === null || output === undefined
+                    ? {}
+                    : { output: publicOutputSnapshot(output, truncated) }),
+                toolPresentation: shellExecution(output ?? undefined, truncated)
             }
         };
     if (isFileTool(toolName)) {

package/dist/runner/codex/conversation-parser.js

@@ -131,6 +131,7 @@ import { runnerErrorProjection } from '../runner-error.js';
 import { conversationImageAttachmentSchema } from '@myagentroam/protocol';
 import { parseCodexComposerImageMarkers } from './composer-image-markers.js';
 import { normalizeCodexTool } from './tool-normalizer.js';
+import { publicOutputSnapshot, shellExecution } from '../execution-presentation.js';
 import { publicGoalHistoryText } from '../../service/goal-runtime.js';
 const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
@@ -716,7 +717,7 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
                     ? compactRunnerText(value.command, 10_000)
                     : '(No command provided)',
                 cwd: typeof value.cwd === 'string' ? compactRunnerText(value.cwd, 4_096) : null,
-                outputPreview: compactRunnerText(output, 10_000),
+                outputPreview: publicOutputSnapshot(output).text,
                 outputRef: null,
                 exitCode: typeof value.exitCode === 'number' && Number.isInteger(value.exitCode)
                     ? value.exitCode
@@ -726,7 +727,17 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
                     value.durationMs >= 0
                     ? value.durationMs
                     : null,
-                truncated: output.length > 10_000
+                truncated: output.length > 10_000,
+                ...(base.status !== 'IN_PROGRESS'
+                    ? {
+                        output: typeof value.aggregatedOutput === 'string'
+                            ? publicOutputSnapshot(output)
+                            : undefined
+                    }
+                    : {}),
+                toolPresentation: shellExecution(base.status === 'IN_PROGRESS' || typeof value.aggregatedOutput !== 'string'
+                    ? undefined
+                    : output)
             }
         };
     }
@@ -888,7 +899,7 @@ export function codexLiveConversationItem(value, completed, imageAttachments = [
                     ? compactRunnerText(value.command, 10_000)
                     : '(No command provided)',
                 cwd: typeof value.cwd === 'string' ? compactRunnerText(value.cwd, 4_096) : null,
-                outputPreview: compactRunnerText(output, 10_000),
+                outputPreview: publicOutputSnapshot(output).text,
                 outputRef: null,
                 exitCode: typeof value.exitCode === 'number' && Number.isInteger(value.exitCode)
                     ? value.exitCode
@@ -898,7 +909,15 @@ export function codexLiveConversationItem(value, completed, imageAttachments = [
                     value.durationMs >= 0
                     ? value.durationMs
                     : null,
-                truncated: output.length > 10_000
+                truncated: output.length > 10_000,
+                ...(completed
+                    ? {
+                        output: typeof value.aggregatedOutput === 'string'
+                            ? publicOutputSnapshot(output)
+                            : undefined
+                    }
+                    : {}),
+                toolPresentation: shellExecution(!completed || typeof value.aggregatedOutput !== 'string' ? undefined : output)
             }
         };
     }

package/dist/runner/codex/managed-run-controller.js

@@ -1,6 +1,7 @@
 import { NODE_MCP } from '../../mcp/naming.js';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { extractId } from './conversation-parser.js';
+import { publicOutputSnapshot } from '../execution-presentation.js';
 import { normalizeCodexApproval } from './tool-normalizer.js';
 import { parseSecretEnvironment } from '../../mcp/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
@@ -279,13 +280,14 @@ export class CodexManagedRunController {
         if (notification.method === 'item/commandExecution/outputDelta' &&
             typeof params.itemId === 'string' &&
             typeof params.delta === 'string') {
+            const output = publicOutputSnapshot(params.delta);
             this.emitItem(runId, {
                 itemId: boundedConversationItemId('codex', params.itemId),
                 kind: 'command_execution',
                 status: 'IN_PROGRESS',
-                payload: { outputPreview: compactRunnerText(params.delta, 10_000) },
+                payload: { outputPreview: output.text, output },
                 merge: true,
-                append: 'outputPreview'
+                append: 'output'
             });
             return;
         }

package/dist/runner/codex/tool-normalizer.js

@@ -1,4 +1,5 @@
 import { compactRunnerText } from '../normalization.js';
+import { publicOutputSnapshot, shellExecution } from '../execution-presentation.js';
 export function normalizeCodexApproval(method) {
     return method === 'item/commandExecution/requestApproval'
         ? { toolName: 'command_execution', reason: 'Command execution requires approval.' }
@@ -17,6 +18,10 @@ export function normalizeCodexTool(input) {
                 payload: {
                     outputPreview,
                     truncated: input.truncated === true || (input.outputSummary?.length ?? 0) > 10_000,
+                    ...(input.outputSummary == null
+                        ? {}
+                        : { output: publicOutputSnapshot(input.outputSummary, input.truncated === true) }),
+                    toolPresentation: shellExecution(input.outputSummary ?? undefined, input.truncated === true),
                     ...(attachments.length === 0 ? {} : { attachments })
                 }
             };
@@ -37,6 +42,10 @@ export function normalizeCodexTool(input) {
                 outputRef: null,
                 exitCode: null,
                 durationMs: null,
+                toolPresentation: shellExecution(input.outputSummary ?? undefined, input.truncated === true),
+                ...(input.outputSummary == null
+                    ? {}
+                    : { output: publicOutputSnapshot(input.outputSummary, input.truncated === true) }),
                 truncated: input.truncated === true ||
                     command.length > 10_000 ||
                     (input.outputSummary?.length ?? 0) > 10_000,

package/dist/runner/execution-presentation.js

@@ -0,0 +1,56 @@
+const MAX_BYTES = 128 * 1024;
+function tail(text, limit) {
+    if (limit === 0)
+        return '';
+    const result = text.slice(-limit);
+    const first = result.charCodeAt(0);
+    return first >= 0xdc00 && first <= 0xdfff ? result.slice(1) : result;
+}
+export function publicOutputSnapshot(text, truncated = false) {
+    return { text: tail(text, 10_000), truncated: truncated || text.length > 10_000 };
+}
+/** Keep public execution output bounded without copying an unbounded source. */
+export function boundExecutionPresentation(execution) {
+    let truncated = (execution.output?.length ?? 0) > 4;
+    const output = execution.output?.slice(0, 4).map((block) => {
+        if (block.text.length > 10_000)
+            truncated = true;
+        return { ...block, text: tail(block.text, 10_000) };
+    });
+    const detail = {
+        ...execution,
+        ...(output === undefined ? {} : { output }),
+        ...(execution.truncation === undefined ? {} : { truncation: { ...execution.truncation } })
+    };
+    if (truncated)
+        detail.truncation = { ...detail.truncation, output: detail.truncation?.output ?? 'HEAD' };
+    const presentation = { kind: 'EXECUTION', execution: detail };
+    const size = () => Buffer.byteLength(JSON.stringify(presentation));
+    for (const block of [...(detail.output ?? [])].reverse()) {
+        if (size() <= MAX_BYTES)
+            break;
+        const source = block.text;
+        detail.truncation = { ...detail.truncation, output: detail.truncation?.output ?? 'HEAD' };
+        truncated = true;
+        let low = 0;
+        let high = source.length;
+        while (low < high) {
+            const middle = Math.ceil((low + high) / 2);
+            block.text = tail(source, middle);
+            if (size() <= MAX_BYTES)
+                low = middle;
+            else
+                high = middle - 1;
+        }
+        block.text = tail(source, low);
+    }
+    return { presentation, truncated };
+}
+/** Project only the stream facts actually supplied by the runner. */
+export function shellExecution(output, sourceTruncated = false) {
+    return boundExecutionPresentation({
+        kind: 'SHELL',
+        ...(output === undefined ? {} : { output: [{ channel: 'COMBINED', text: output }] }),
+        ...(sourceTruncated ? { truncation: { output: 'SOURCE' } } : {})
+    }).presentation;
+}

package/dist/runner/mar-agent/agent-network-extension.js

@@ -0,0 +1,168 @@
+import { agentNetworkWaitModelOutput } from './agent-network-wait-output.js';
+const text = { type: 'string', minLength: 1 };
+const attachmentIds = {
+    type: 'array',
+    items: text,
+    maxItems: 32,
+    description: 'Existing composer attachment IDs.'
+};
+const attachments = {
+    type: 'array',
+    maxItems: 5,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['name', 'mime', 'dataBase64'],
+        properties: { name: text, mime: text, dataBase64: text }
+    }
+};
+const goal = {
+    anyOf: [
+        { type: 'null' },
+        {
+            type: 'object',
+            properties: { objective: text },
+            required: ['objective'],
+            additionalProperties: false
+        },
+        {
+            type: 'object',
+            properties: { clear: { type: 'boolean', const: true } },
+            required: ['clear'],
+            additionalProperties: false
+        }
+    ]
+};
+const tools = [
+    {
+        action: 'start',
+        description: 'Start a child Agent with a message or image and optional Goal; returns without waiting.',
+        properties: {
+            content: { type: 'string' },
+            attachments,
+            attachmentIds,
+            runner: text,
+            model: text,
+            effort: text,
+            title: text,
+            goal,
+            clientMessageId: text
+        },
+        required: ['title']
+    },
+    {
+        action: 'send',
+        description: 'Send input, decide a child approval or update a Goal; goal:null leaves it unchanged, goal:{clear:true} clears it.',
+        properties: {
+            agentId: text,
+            content: { type: 'string' },
+            attachments,
+            attachmentIds,
+            goal,
+            approval: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['approvalId', 'decision'],
+                properties: { approvalId: text, decision: { type: 'string', enum: ['approve', 'reject'] } }
+            },
+            deliveryIntent: { type: 'string', enum: ['SEND', 'QUEUE', 'REPLACE_CURRENT'] },
+            clientMessageId: text
+        },
+        required: ['agentId']
+    },
+    {
+        action: 'wait',
+        description: 'Wait for completion or messages; defaults to direct children, completion and 30 seconds. Use waitMs 0 for a snapshot.',
+        properties: {
+            agentId: text,
+            agentIds: { type: 'array', items: text, minItems: 1, maxItems: 8 },
+            mode: { type: 'string', enum: ['any', 'all'] },
+            waitFor: { type: 'string', enum: ['message', 'completion'] },
+            waitMs: { type: 'integer', minimum: 0, maximum: 300000 }
+        }
+    },
+    {
+        action: 'stop',
+        description: 'Stop the specified Agent Execution and clear its Goal.',
+        properties: { agentId: text, executionId: text },
+        required: ['agentId', 'executionId']
+    },
+    {
+        action: 'list',
+        description: 'List Sessions, descendants or a Runner profile.',
+        properties: {
+            scope: { type: 'string', enum: ['workspace', 'children', 'descendants', 'profile'] },
+            agentId: text,
+            parent: text,
+            runner: text,
+            query: { type: 'string' },
+            limit: { type: 'integer', minimum: 1, maximum: 100 },
+            cursor: text
+        }
+    },
+    {
+        action: 'view',
+        description: 'View an Agent session, Goal and recent history.',
+        properties: {
+            agentId: text,
+            includeHistory: { type: 'boolean' },
+            limit: { type: 'integer', minimum: 1, maximum: 100 },
+            cursor: text
+        },
+        required: ['agentId']
+    }
+];
+export function agentNetworkExtension(invoke, currentExecution) {
+    return {
+        id: 'mar.node.agent-network',
+        apiVersion: '1.0',
+        attachSession(context) {
+            for (const tool of tools)
+                context.tools.register({
+                    name: `agent_${tool.action}`,
+                    description: tool.description,
+                    allowedCallers: ['direct', 'programmatic'],
+                    eventInputFields: [
+                        'agentId',
+                        'title',
+                        'executionId',
+                        'runner',
+                        'model',
+                        'effort',
+                        'waitFor',
+                        'waitMs',
+                        'scope'
+                    ],
+                    inputSchema: {
+                        type: 'object',
+                        properties: tool.properties,
+                        ...(tool.required ? { required: [...tool.required] } : {}),
+                        additionalProperties: false
+                    },
+                    async execute(input, call) {
+                        const executionId = currentExecution();
+                        if (!executionId)
+                            throw new Error('AGENT_ACTOR_NOT_ACTIVE');
+                        const result = await invoke(executionId, tool.action, input, call);
+                        const value = result !== null && typeof result === 'object' && !Array.isArray(result)
+                            ? result
+                            : undefined;
+                        const id = value?.agentId;
+                        const eventData = ['start', 'send', 'stop', 'wait'].includes(tool.action) &&
+                            typeof id === 'string' &&
+                            id.length > 0 &&
+                            id.length <= 128
+                            ? { agentId: id, productSessionId: id }
+                            : undefined;
+                        const modelResult = tool.action === 'wait' ? agentNetworkWaitModelOutput(result) : result;
+                        return {
+                            data: result,
+                            content: JSON.stringify(modelResult),
+                            eventSummary: JSON.stringify(eventData ?? {}),
+                            eventData: eventData ?? {}
+                        };
+                    }
+                });
+        }
+    };
+}

package/dist/runner/mar-agent/agent-network-wait-output.js

@@ -0,0 +1,72 @@
+import { isPlainRecord } from '../../util/records.js';
+function prefix(value, bytes) {
+    const input = Buffer.from(value, 'utf8');
+    let end = Math.min(bytes, input.length);
+    while (end > 0 && end < input.length && (input[end] & 0xc0) === 0x80)
+        end--;
+    return input.subarray(0, end).toString('utf8');
+}
+function projectAgent(input, maximumBytes) {
+    const result = {
+        ...input,
+        ...(Array.isArray(input.changedFiles) ? { changedFiles: [...input.changedFiles] } : {}),
+        ...(Array.isArray(input.updates)
+            ? { updates: input.updates.map((item) => (isPlainRecord(item) ? { ...item } : item)) }
+            : {})
+    };
+    const size = () => Buffer.byteLength(JSON.stringify(result), 'utf8');
+    while (size() > maximumBytes &&
+        Array.isArray(result.changedFiles) &&
+        result.changedFiles.length) {
+        result.changedFiles.pop();
+        result.changedFilesTruncated = true;
+    }
+    const shorten = (target, field, flag) => {
+        if (size() <= maximumBytes || typeof target[field] !== 'string')
+            return;
+        const value = target[field];
+        let low = 0;
+        let high = Buffer.byteLength(value, 'utf8');
+        target[flag] = true;
+        while (low < high) {
+            const middle = Math.ceil((low + high) / 2);
+            target[field] = prefix(value, middle);
+            if (size() <= maximumBytes)
+                low = middle;
+            else
+                high = middle - 1;
+        }
+        target[field] = prefix(value, low);
+    };
+    shorten(result, 'summary', 'summaryTruncated');
+    if (Array.isArray(result.updates))
+        for (const update of result.updates)
+            if (isPlainRecord(update))
+                shorten(update, 'value', 'truncated');
+    if (size() <= maximumBytes)
+        return result;
+    return {
+        agentId: input.agentId,
+        runId: input.runId,
+        executionId: input.executionId,
+        status: input.status,
+        waitOutcome: input.waitOutcome,
+        detailsTruncated: true
+    };
+}
+/** Limit only the model-facing view; the Node use-case result remains unchanged. */
+export function agentNetworkWaitModelOutput(input) {
+    if (!isPlainRecord(input))
+        return input;
+    if (!Array.isArray(input.agents))
+        return {
+            ...projectAgent(input, 34_000),
+            ...(typeof input.waitFor === 'string' ? { waitFor: input.waitFor } : {}),
+            ...(typeof input.reason === 'string' ? { reason: input.reason } : {})
+        };
+    const budget = Math.floor(34_000 / Math.max(1, input.agents.length));
+    return {
+        ...input,
+        agents: input.agents.map((item) => (isPlainRecord(item) ? projectAgent(item, budget) : item))
+    };
+}