@myagentroam/node 0.11.43 → 0.11.45

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

@@ -1,4 +1,5 @@
 import { agentNetworkWaitModelOutput } from './agent-network-wait-output.js';
+import { agentOperationEvent } from './agent-operation-presentation.js';
 const text = { type: 'string', minLength: 1 };
 const attachmentIds = {
     type: 'array',
@@ -52,7 +53,7 @@ const tools = [
     },
     {
         action: 'send',
-        description: 'Send input, decide a child approval or update a Goal; goal:null leaves it unchanged, goal:{clear:true} clears it. Prefer REPLACE_CURRENT for timely communication or course correction. QUEUE is consumed only after current work and earlier queued inputs finish; an active Goal must exit first. Sending to a non-child does not subscribe to its updates.',
+        description: 'Send input, decide an approval or update a Goal; goal:null leaves it unchanged, goal:{clear:true} clears it. Prefer REPLACE_CURRENT for timely communication or course correction. QUEUE is consumed only after current work and earlier queued inputs finish; an active Goal must exit first. Sending to a non-child does not subscribe to its updates.',
         properties: {
             agentId: text,
             content: { type: 'string' },
@@ -112,11 +113,50 @@ const tools = [
         required: ['agentId']
     }
 ];
+const delegationPrompt = [
+    '# Delegation and coordination',
+    'Delegate bounded, self-contained tasks when independent progress or context savings materially helps. Keep simple or tightly coupled work local.',
+    'Give each child an objective, necessary context, expected output, and a read-only boundary or non-overlapping write scope.',
+    'While children run, continue meaningful non-overlapping work. Do not redo delegated work. Wait only when the next step needs the result.',
+    'Verify consequential findings and changes. Join or stop task-required child work before final delivery, and retain responsibility for the final result.'
+].join('\n\n');
+const collaborationPrompt = [
+    '# Workspace collaboration',
+    "Use native agent_* tools to collaborate within the Agent Network when another Session's context or ongoing work materially helps. Keep requests focused and avoid unnecessary cross-Session coordination. Peer Sessions retain their own work and lifecycle; do not treat them as task-owned children or stop them merely for task cleanup. Sending to a non-child does not subscribe to its updates; explicitly wait when you need its progress or completion."
+].join('\n\n');
+const managementPrompt = [
+    '# Workspace management',
+    "Load marctl when needed to manage existing Session settings, titles, persistent prompts or schedules, or to discover authorized Nodes, execute remote commands or transfer files. Ordinary Agent collaboration and selecting a child's model or effort at creation use native agent_* tools. Do not switch to marctl when a native operation fails."
+].join('\n\n');
 export function agentNetworkExtension(invoke, currentExecution) {
     return {
         id: 'mar.node.agent-network',
         apiVersion: '1.0',
         attachSession(context) {
+            context.hooks.intercept('prompt.sections', (input, _call, next) => {
+                const available = new Set(input.facts?.tools);
+                const enabled = input.facts?.mode !== 'compact';
+                return next({
+                    ...input,
+                    sections: [
+                        ...input.sections,
+                        {
+                            id: 'mar.node.agent-network:delegation',
+                            text: enabled && available.has('agent_start') ? delegationPrompt : null
+                        },
+                        {
+                            id: 'mar.node.agent-network:collaboration',
+                            text: enabled && available.has('agent_send') ? collaborationPrompt : null
+                        },
+                        {
+                            id: 'mar.node.agent-network:management',
+                            text: enabled && tools.some((tool) => available.has(`agent_${tool.action}`))
+                                ? managementPrompt
+                                : null
+                        }
+                    ]
+                });
+            });
             for (const tool of tools)
                 context.tools.register({
                     name: `agent_${tool.action}`,
@@ -124,6 +164,7 @@ export function agentNetworkExtension(invoke, currentExecution) {
                     allowedCallers: ['direct', 'programmatic'],
                     eventInputFields: [
                         'agentId',
+                        'agentIds',
                         'title',
                         'executionId',
                         'runner',
@@ -144,22 +185,11 @@ export function agentNetworkExtension(invoke, 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 ?? {}
+                            ...agentOperationEvent(tool.action, input, result)
                         };
                     }
                 });

package/dist/runner/mar-agent/agent-operation-presentation.js

@@ -0,0 +1,167 @@
+import { agentOperationPresentationSchema } from '@myagentroam/protocol';
+import { isPlainRecord } from '../../util/records.js';
+const actions = {
+    agent_start: 'START',
+    agent_send: 'SEND',
+    agent_wait: 'WAIT',
+    agent_stop: 'STOP',
+    agent_list: 'LIST',
+    agent_view: 'VIEW'
+};
+export function agentOperationAction(toolName) {
+    return Object.hasOwn(actions, toolName) ? actions[toolName] : undefined;
+}
+function text(value, max = 128) {
+    return typeof value === 'string' && value.trim()
+        ? value.slice(0, max).replace(/[\uD800-\uDBFF]$/u, '')
+        : undefined;
+}
+function latestWaitMessage(updates) {
+    if (!Array.isArray(updates))
+        return undefined;
+    const message = updates.findLast((entry) => isPlainRecord(entry) && entry.kind === 'message' && typeof entry.value === 'string');
+    if (!isPlainRecord(message))
+        return undefined;
+    const value = text(message.value, 800);
+    if (!value)
+        return undefined;
+    return {
+        value,
+        ...(message.final === true ? { final: true } : {}),
+        ...(message.truncated === true || message.value.length > 800
+            ? { truncated: true }
+            : {})
+    };
+}
+/** Input identities are display-only; only successful Node results establish navigation. */
+export function agentOperationPresentation(toolName, input, data) {
+    const action = agentOperationAction(toolName);
+    if (!action)
+        return undefined;
+    const parsed = agentOperationPresentationSchema.safeParse(isPlainRecord(data) ? data.agentOperation : undefined);
+    if (parsed.success && parsed.data.action === action)
+        return parsed.data;
+    const value = isPlainRecord(input) ? input : {};
+    const ids = typeof value.agentId === 'string'
+        ? [value.agentId]
+        : Array.isArray(value.agentIds)
+            ? value.agentIds
+            : [];
+    return {
+        action,
+        targets: ids
+            .filter((id) => typeof id === 'string' && id.length > 0 && id.length <= 128)
+            .slice(0, 8)
+            .map((agentId) => ({ agentId })),
+        ...(text(value.scope, 32) ? { scope: text(value.scope, 32) } : {})
+    };
+}
+/** Whitelist public receipts; never serialize configuration, credentials or full history. */
+export function agentOperationEvent(action, input, result) {
+    const operation = agentOperationPresentation(`agent_${action}`, input);
+    const value = isPlainRecord(result) ? result : {};
+    const args = isPlainRecord(input) ? input : {};
+    const rows = action === 'list' ? value.sessions : action === 'wait' ? value.agents : undefined;
+    const records = Array.isArray(rows)
+        ? rows
+        : action === 'list'
+            ? []
+            : action === 'view'
+                ? isPlainRecord(value.session)
+                    ? [value.session]
+                    : []
+                : typeof value.agentId === 'string'
+                    ? [value]
+                    : [];
+    const returnedTargets = records
+        .flatMap((entry) => {
+        if (!isPlainRecord(entry))
+            return [];
+        const rawId = entry.agentId ?? entry.id;
+        const agentId = typeof rawId === 'string' && rawId.length <= 128 ? text(rawId) : undefined;
+        if (!agentId)
+            return [];
+        const title = text(entry.title ?? (action === 'start' ? args.title : undefined), 500);
+        return [{ agentId, sessionId: agentId, ...(title ? { title } : {}) }];
+    })
+        .slice(0, 100);
+    // An any-wait may return one result for several requested targets; keep the call multi-target.
+    const targets = action === 'wait' && operation.targets.length > 0
+        ? operation.targets.map((target) => returnedTargets.find((result) => result.agentId === target.agentId) ?? target)
+        : returnedTargets;
+    const presentation = { ...operation, targets };
+    if (records.length > returnedTargets.length)
+        presentation.targetsTruncated = true;
+    // Core accepts at most 8 KiB of explicit extension event data.
+    while (Buffer.byteLength(JSON.stringify({ agentOperation: presentation }), 'utf8') > 7000) {
+        targets.pop();
+        presentation.targetsTruncated = true;
+    }
+    const receipt = {};
+    if (action === 'list' && Array.isArray(value.models)) {
+        receipt.runner = text(value.runner);
+        receipt.modelCount = value.models.length;
+    }
+    if (action === 'view' && isPlainRecord(value.session)) {
+        for (const key of ['status', 'model', 'effort']) {
+            const field = text(value.session[key]);
+            if (field)
+                receipt[key] = field;
+        }
+        const message = isPlainRecord(value.session.latestMessage)
+            ? value.session.latestMessage
+            : undefined;
+        const messageText = text(message?.text, 800);
+        if (messageText)
+            receipt.latestMessage = {
+                text: messageText,
+                truncated: message?.truncated === true || messageText !== message?.text
+            };
+    }
+    for (const key of ['status', 'waitOutcome', 'waitFor', 'mode', 'reason', 'executionId']) {
+        const field = text(value[key]);
+        if (field)
+            receipt[key] = field;
+    }
+    for (const key of ['message', 'cancel', 'goal', 'approval', 'observation']) {
+        const item = value[key];
+        if (!isPlainRecord(item))
+            continue;
+        receipt[key] = {
+            ...(text(item.status) ? { status: text(item.status) } : {}),
+            ...(text(item.code) ? { code: text(item.code) } : {}),
+            ...(isPlainRecord(item.result) && text(item.result.delivery)
+                ? { delivery: text(item.result.delivery) }
+                : {})
+        };
+    }
+    if (Array.isArray(rows))
+        receipt.count = rows.length;
+    if (action === 'wait' && Array.isArray(rows))
+        receipt.agents = rows.slice(0, 8).map((entry) => {
+            const agent = isPlainRecord(entry) ? entry : {};
+            return {
+                agentId: text(agent.agentId),
+                status: text(agent.status),
+                waitOutcome: text(agent.waitOutcome),
+                summary: text(agent.summary, 800),
+                latestMessage: latestWaitMessage(agent.updates),
+                ...(agent.summaryTruncated === true ||
+                    (typeof agent.summary === 'string' && agent.summary.length > 800)
+                    ? { summaryTruncated: true }
+                    : {})
+            };
+        });
+    if (action === 'wait' && !Array.isArray(rows))
+        receipt.latestMessage = latestWaitMessage(value.updates);
+    const summary = text(value.summary, 4000);
+    if (summary)
+        receipt.summary = summary;
+    if (value.summaryTruncated === true ||
+        (typeof value.summary === 'string' && value.summary.length > 4000))
+        receipt.summaryTruncated = true;
+    return {
+        eventData: { agentOperation: presentation },
+        eventSummary: JSON.stringify(receipt)
+    };
+}