@myagentroam/node 0.11.39 → 0.11.41

package/dist/runner/mar-agent/conversation-normalizer.js

@@ -7,6 +7,7 @@ export function normalizeMarAgentUsage(usage) {
 import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../normalization.js';
 import { runnerErrorProjection } from '../runner-error.js';
 import { toolPresentationSchema } from '@myagentroam/protocol';
+import { boundExecutionPresentation, publicOutputSnapshot } from '../execution-presentation.js';
 export class MarAgentConversationNormalizer {
     input(entry) {
         return {
@@ -25,12 +26,10 @@ export class MarAgentConversationNormalizer {
     }
     #tools = new Map();
     #commands = new Map();
-    #processOrigins = new Map();
     #subagentTitles = new Map();
     #subagentDetails = new Map();
     #codeModeObservationIds = new Set();
     #codeModeSourceCallIds = new Set();
-    #toolOutputSnapshots = new Map();
     #codeModeOutputCalls = new Map();
     #codeModeOutputSnapshots = new Map();
     #runningCodeModeCells = new Map();
@@ -69,7 +68,8 @@ export class MarAgentConversationNormalizer {
             const payload = {
                 text: event.type === 'message.completed' ? event.text : '',
                 format: 'markdown',
-                model: typeof modelName === 'string' ? modelName : null
+                model: typeof modelName === 'string' ? modelName : null,
+                phase: event.phase
             };
             return [
                 {
@@ -168,7 +168,6 @@ export class MarAgentConversationNormalizer {
     #toolStarted(event) {
         const ownItemId = itemId('tool', event.callId);
         this.#clearRetainedCodeModeCellsForOtherExecutions(event.executionId);
-        this.#toolOutputSnapshots.delete(event.callId);
         this.#codeModeOutputCalls.delete(event.callId);
         this.#clearCodeModeOutputSnapshots(event.callId);
         if (event.toolName === 'exec' || event.toolName === 'exec_wait') {
@@ -182,13 +181,17 @@ export class MarAgentConversationNormalizer {
             if (action === 'start' && typeof input.command === 'string') {
                 const command = {
                     itemId: ownItemId,
-                    turnKey: event.turnId ?? event.executionId,
                     command: compactRunnerText(input.command, 10_000),
                     cwd: typeof input.cwd === 'string' ? compactRunnerText(input.cwd, 4_096) : null,
                     status: 'IN_PROGRESS',
                     outputPreview: '',
                     exitCode: null,
-                    truncated: false
+                    truncated: event.truncated === true ||
+                        input.command.length > 10_000 ||
+                        (typeof input.cwd === 'string' && input.cwd.length > 4096),
+                    inputTruncated: event.truncated === true ||
+                        input.command.length > 10_000 ||
+                        (typeof input.cwd === 'string' && input.cwd.length > 4096)
                 };
                 this.#commands.set(event.callId, command);
                 this.#tools.set(event.callId, {
@@ -203,49 +206,6 @@ export class MarAgentConversationNormalizer {
                 });
                 return [commandItem(command, 'IN_PROGRESS')];
             }
-            if ((action === 'poll' || action === 'write' || action === 'cancel') &&
-                typeof input.processId === 'string') {
-                const origin = this.#processOrigins.get(input.processId);
-                if (origin !== undefined) {
-                    const previous = this.#commands.get(origin);
-                    const sameTurn = previous?.turnKey === (event.turnId ?? event.executionId);
-                    if (previous !== undefined && !sameTurn) {
-                        const command = {
-                            itemId: ownItemId,
-                            turnKey: event.turnId ?? event.executionId,
-                            command: previous.command,
-                            cwd: previous.cwd,
-                            status: 'IN_PROGRESS',
-                            outputPreview: '',
-                            exitCode: null,
-                            truncated: false
-                        };
-                        this.#commands.set(event.callId, command);
-                        this.#tools.set(event.callId, {
-                            toolName: event.toolName,
-                            input: event.input,
-                            itemId: ownItemId,
-                            structured: true,
-                            executionId: event.executionId,
-                            ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
-                            active: true,
-                            commandOrigin: event.callId
-                        });
-                        return [];
-                    }
-                    this.#tools.set(event.callId, {
-                        toolName: event.toolName,
-                        input: event.input,
-                        itemId: ownItemId,
-                        structured: true,
-                        executionId: event.executionId,
-                        ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
-                        active: true,
-                        commandOrigin: origin
-                    });
-                    return [];
-                }
-            }
         }
         const agentId = isMarAgentControlTool(event.toolName)
             ? marAgentAgentId(event.input)
@@ -275,9 +235,20 @@ export class MarAgentConversationNormalizer {
     #toolOutput(event) {
         const { callId, toolName, executionId, turnId, parentCallId, output } = event;
         const inputOutput = [output.stdout, output.stderr].filter(Boolean).join('\n');
+        const displayOutput = execDisplayOutput(output.displayOutput) ?? {
+            stdout: output.stdout,
+            stderr: output.stderr,
+            stdoutDroppedBytes: 0,
+            stderrDroppedBytes: 0
+        };
+        const displayed = [displayOutput.stdout, displayOutput.stderr].filter(Boolean).join('\n');
+        const bounded = publicOutputSnapshot(displayed, output.truncated ||
+            displayOutput.stdoutDroppedBytes > 0 ||
+            displayOutput.stderrDroppedBytes > 0);
         const snapshot = {
-            outputPreview: compactRunnerText(inputOutput, 10_000),
-            truncated: output.truncated || inputOutput.length > 10_000
+            outputPreview: bounded.text,
+            truncated: bounded.truncated || inputOutput.length > 10_000,
+            displayOutput
         };
         if (parentCallId !== undefined)
             return this.#codeModeToolOutput(callId, parentCallId, toolName, executionId, turnId, output.processId, snapshot);
@@ -295,19 +266,18 @@ export class MarAgentConversationNormalizer {
             if (toolName !== 'exec_wait')
                 return [];
             return [
-                genericToolItem(state.itemId, toolName, 'IN_PROGRESS', state.input, snapshot.outputPreview, null, snapshot.truncated)
+                genericToolItem(state.itemId, toolName, 'IN_PROGRESS', state.input, snapshot.outputPreview, null, snapshot.truncated, { processId: output.processId, displayOutput: snapshot.displayOutput })
             ];
         }
         const command = this.#commands.get(state.commandOrigin);
         if (command === undefined || command.status !== 'IN_PROGRESS')
             return [];
-        this.#toolOutputSnapshots.set(callId, {
-            commandOrigin: state.commandOrigin,
-            ...snapshot
-        });
-        return [
-            commandItem(commandWithOutputSnapshots(command, [...this.#toolOutputSnapshots.values()].filter((entry) => entry.commandOrigin === state.commandOrigin)), 'IN_PROGRESS')
-        ];
+        const display = snapshot.displayOutput;
+        if (display !== undefined)
+            command.displayOutput = display;
+        command.outputPreview = snapshot.outputPreview;
+        command.truncated = snapshot.truncated;
+        return [commandItem(command, 'IN_PROGRESS')];
     }
     #codeModeToolOutput(callId, parentCallId, toolName, executionId, turnId, processId, snapshot) {
         const parent = this.#tools.get(parentCallId);
@@ -339,9 +309,9 @@ export class MarAgentConversationNormalizer {
             .map((entry) => entry.outputPreview)
             .filter(Boolean)
             .join('\n');
-        const truncated = [...snapshots.values()].some((entry) => entry.truncated) || combined.length > 10_000;
+        const bounded = publicOutputSnapshot(combined, [...snapshots.values()].some((entry) => entry.truncated));
         return [
-            genericToolItem(target.itemId, target.toolName, 'IN_PROGRESS', target.input, compactRunnerText(combined, 10_000), null, truncated)
+            genericToolItem(target.itemId, target.toolName, 'IN_PROGRESS', target.input, bounded.text, null, bounded.truncated)
         ];
     }
     #trackCodeModeOutputCall(event) {
@@ -409,7 +379,6 @@ export class MarAgentConversationNormalizer {
         const state = this.#tools.get(event.callId);
         if (state !== undefined)
             state.active = false;
-        this.#toolOutputSnapshots.delete(event.callId);
         const data = record(event.data);
         const cellId = typeof data?.cellId === 'string' ? data.cellId : undefined;
         const status = data?.status;
@@ -468,7 +437,6 @@ export class MarAgentConversationNormalizer {
         for (const [callId, state] of this.#tools)
             if (state.executionId !== executionId) {
                 state.active = false;
-                this.#toolOutputSnapshots.delete(callId);
             }
         for (const [callId, state] of this.#codeModeOutputCalls)
             if (state.executionId !== executionId)
@@ -499,21 +467,19 @@ export class MarAgentConversationNormalizer {
     }
     #toolCompleted(event) {
         const state = this.#tools.get(event.callId);
-        if ((event.toolName === 'exec' || event.toolName === 'exec_wait') &&
-            state?.commandOrigin !== undefined) {
+        if (event.toolName === 'exec' && state?.commandOrigin !== undefined) {
             const command = this.#commands.get(state.commandOrigin);
             const result = execResult(event.data, event.summary, event.truncated === true);
             if (command !== undefined && result !== undefined) {
-                if (result.processId !== undefined)
-                    this.#processOrigins.set(result.processId, state.commandOrigin);
                 applyCommandResult(command, result);
-                const status = result.status === 'running'
-                    ? 'IN_PROGRESS'
-                    : result.status === 'completed' && result.exitCode === 0
-                        ? 'COMPLETED'
-                        : 'FAILED';
-                command.status = status;
-                return [commandItem(command, status)];
+                const data = record(event.data);
+                const display = execDisplayOutput(data?.displayOutput);
+                if (display !== undefined)
+                    command.displayOutput = display;
+                else
+                    delete command.displayOutput;
+                command.status = 'COMPLETED';
+                return [commandItem(command, 'COMPLETED')];
             }
         }
         if (event.toolName === 'apply_patch' &&
@@ -559,16 +525,17 @@ export class MarAgentConversationNormalizer {
     }
     #toolFailed(event) {
         const state = this.#tools.get(event.callId);
-        if ((event.toolName === 'exec' || event.toolName === 'exec_wait') &&
-            state?.commandOrigin !== undefined) {
+        if (event.toolName === 'exec' && state?.commandOrigin !== undefined) {
             const command = this.#commands.get(state.commandOrigin);
-            const input = record(state.input);
-            if (command !== undefined &&
-                command.status === 'IN_PROGRESS' &&
-                (state.itemId !== command.itemId ||
-                    input?.action === 'start' ||
-                    (input?.action == null && typeof input?.command === 'string'))) {
+            if (command !== undefined) {
+                const error = {
+                    code: compactRunnerText(event.code, 80) || 'UNKNOWN',
+                    message: compactRunnerText(event.message ?? event.code, 1000)
+                };
                 command.status = 'FAILED';
+                command.error = error;
+                delete command.displayOutput;
+                command.outputPreview = '';
                 return [commandItem(command, 'FAILED')];
             }
         }
@@ -854,24 +821,89 @@ function normalizeContextCompaction(event, anchorItemId) {
 function validCompactAnchor(value) {
     return value !== undefined && value.length > 0 && value.length <= 128 ? value : undefined;
 }
+function codeObservationOutput(data, summary) {
+    if (Array.isArray(data?.observations)) {
+        return data.observations
+            .flatMap((entry) => {
+            const observation = record(entry);
+            if (observation?.type === 'value' && typeof observation.value === 'string')
+                return [observation.value];
+            const result = record(observation?.result);
+            const source = record(observation?.source);
+            if (observation?.type === 'tool_result' &&
+                (source?.toolName === 'exec' || source?.toolName === 'exec_wait')) {
+                const resultData = record(result?.data);
+                const display = record(resultData?.displayOutput) ?? resultData;
+                if (typeof display?.stdout === 'string' || typeof display?.stderr === 'string')
+                    return [display?.stdout, display?.stderr].filter((value) => typeof value === 'string' && value.length > 0);
+            }
+            return observation?.type === 'tool_result' && typeof result?.content === 'string'
+                ? [result.content]
+                : [];
+        })
+            .join('\n');
+    }
+    return summary ?? undefined;
+}
+function codeExecutionError(data) {
+    const error = record(data?.error);
+    if (typeof error?.code !== 'string' || !error.code || typeof error.message !== 'string')
+        return undefined;
+    return {
+        code: compactRunnerText(error.code, 80),
+        message: compactRunnerText(error.message, 1000)
+    };
+}
 function genericToolItem(id, toolName, status, input, outputSummary = null, errorCode = null, truncated = false, output, subagentTitle, knownSubagentDetails, sleepStartedAt) {
     if (toolName === 'code_exec') {
         const code = typeof input === 'string' ? input : record(input)?.code;
         const source = typeof code === 'string' ? code : compactRunnerValue(input, 10_000).text || toolName;
-        const output = errorCode === null
+        const resultData = record(output);
+        const codeOutput = codeObservationOutput(resultData, outputSummary);
+        const resultError = codeExecutionError(resultData);
+        const preview = errorCode === null
             ? (outputSummary ?? '')
             : [errorCode, outputSummary].filter(Boolean).join(': ');
         return commandItem({
             itemId: id,
             command: compactRunnerText(source, 10_000),
             cwd: null,
-            outputPreview: compactRunnerText(output, 10_000),
+            outputPreview: compactRunnerText(preview, 10_000),
             exitCode: null,
-            truncated: truncated || source.length > 10_000 || output.length > 10_000
-        }, status, 'Code execution');
+            truncated: truncated ||
+                resultData?.truncated === true ||
+                source.length > 10_000 ||
+                preview.length > 10_000
+        }, status, 'Code execution', {
+            kind: 'CODE',
+            ...(source.length > 10_000 ? { truncation: { input: true } } : {}),
+            ...(errorCode === null
+                ? resultError === undefined
+                    ? {}
+                    : { error: resultError }
+                : {
+                    error: {
+                        code: compactRunnerText(errorCode, 80),
+                        message: compactRunnerText(outputSummary ?? '', 1000)
+                    }
+                }),
+            ...(codeOutput === undefined ? {} : { output: [{ channel: 'TEXT', text: codeOutput }] })
+        });
     }
     if (toolName === 'code_exec_wait' || toolName === 'exec_wait') {
         const inputRecord = record(input);
+        const resultData = record(output);
+        const display = execDisplayOutput(resultData?.displayOutput);
+        const legacyBlocks = [
+            ...(typeof resultData?.stdout === 'string'
+                ? [{ channel: 'STDOUT', text: resultData.stdout }]
+                : []),
+            ...(typeof resultData?.stderr === 'string'
+                ? [{ channel: 'STDERR', text: resultData.stderr }]
+                : [])
+        ];
+        const codeOutput = toolName === 'code_exec_wait' ? codeObservationOutput(resultData, outputSummary) : undefined;
+        const resultError = toolName === 'code_exec_wait' ? codeExecutionError(resultData) : undefined;
         const action = typeof inputRecord?.action === 'string' ? inputRecord.action : 'poll';
         const inputSummary = compactRunnerValue(input, 10_000);
         const result = output === undefined ? null : compactRunnerValue(output, 10_000);
@@ -890,13 +922,62 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
             itemId: id,
             command: toolName,
             cwd: null,
-            outputPreview: details,
-            exitCode: null,
+            outputPreview: status === 'IN_PROGRESS' && outputSummary !== null
+                ? outputSummary
+                : legacyBlocks.length > 0
+                    ? legacyBlocks
+                        .map((block) => block.text)
+                        .filter(Boolean)
+                        .join('\n')
+                    : details,
+            exitCode: typeof resultData?.exitCode === 'number' ? resultData.exitCode : null,
             truncated: truncated ||
+                resultData?.truncated === true ||
                 inputSummary.truncated ||
                 result?.truncated === true ||
                 resultSummary.length > 10_000
-        }, status, toolName === 'code_exec_wait' ? 'Code execution wait' : 'Command wait');
+        }, status, toolName === 'code_exec_wait' ? 'Code execution wait' : 'Command wait', {
+            kind: 'CONTROL',
+            ...(display === undefined
+                ? {}
+                : {
+                    output: [
+                        { channel: 'STDOUT', text: display.stdout },
+                        { channel: 'STDERR', text: display.stderr }
+                    ]
+                }),
+            ...(display === undefined && legacyBlocks.length > 0 ? { output: legacyBlocks } : {}),
+            ...(codeOutput === undefined
+                ? {}
+                : { output: [{ channel: 'TEXT', text: codeOutput }] }),
+            ...((typeof inputRecord?.data === 'string' && inputRecord.data.length > 10_000) ||
+                (display !== undefined && (display.stdoutDroppedBytes || display.stderrDroppedBytes)) ||
+                (display === undefined && legacyBlocks.length > 0 && truncated)
+                ? {
+                    truncation: {
+                        ...(typeof inputRecord?.data === 'string' && inputRecord.data.length > 10_000
+                            ? { input: true }
+                            : {}),
+                        ...(display !== undefined &&
+                            (display.stdoutDroppedBytes || display.stderrDroppedBytes)
+                            ? { output: 'HEAD' }
+                            : display === undefined && legacyBlocks.length > 0 && truncated
+                                ? { output: 'SOURCE' }
+                                : {})
+                    }
+                }
+                : {}),
+            ...(errorCode === null
+                ? resultError === undefined
+                    ? {}
+                    : { error: resultError }
+                : {
+                    error: {
+                        code: compactRunnerText(errorCode, 80),
+                        message: compactRunnerText(outputSummary ?? '', 1000)
+                    }
+                })
+        });
     }
     const subagent = marAgentSubagentProjection(toolName, input, output, subagentTitle, knownSubagentDetails);
     const toolCategory = isImageGenerationTool(toolName) ? 'IMAGE_GENERATION' : undefined;
@@ -965,7 +1046,50 @@ function projectToolPresentation(toolName, input, output, startedAt) {
     const parsed = toolPresentationSchema.safeParse(candidate);
     return parsed.success ? parsed.data : { kind };
 }
-function commandItem(command, status, title) {
+function execDisplayOutput(value) {
+    const data = record(value);
+    if (typeof data?.stdout !== 'string' ||
+        typeof data.stderr !== 'string' ||
+        typeof data.stdoutDroppedBytes !== 'number' ||
+        !Number.isSafeInteger(data.stdoutDroppedBytes) ||
+        data.stdoutDroppedBytes < 0 ||
+        typeof data.stderrDroppedBytes !== 'number' ||
+        !Number.isSafeInteger(data.stderrDroppedBytes) ||
+        data.stderrDroppedBytes < 0)
+        return undefined;
+    return {
+        stdout: data.stdout,
+        stderr: data.stderr,
+        stdoutDroppedBytes: data.stdoutDroppedBytes,
+        stderrDroppedBytes: data.stderrDroppedBytes
+    };
+}
+function commandItem(command, status, title, execution) {
+    const display = command.displayOutput;
+    const detail = execution ?? {
+        kind: 'SHELL',
+        ...(command.error === undefined ? {} : { error: command.error }),
+        ...(!command.inputTruncated &&
+            !(display && (display.stdoutDroppedBytes > 0 || display.stderrDroppedBytes > 0))
+            ? {}
+            : {
+                truncation: {
+                    ...(command.inputTruncated ? { input: true } : {}),
+                    ...(display && (display.stdoutDroppedBytes > 0 || display.stderrDroppedBytes > 0)
+                        ? { output: 'HEAD' }
+                        : {})
+                }
+            }),
+        ...(display === undefined
+            ? {}
+            : {
+                output: [
+                    { channel: 'STDOUT', text: display.stdout },
+                    { channel: 'STDERR', text: display.stderr }
+                ]
+            })
+    };
+    const bounded = boundExecutionPresentation(detail);
     return {
         itemId: command.itemId,
         kind: 'command_execution',
@@ -978,37 +1102,21 @@ function commandItem(command, status, title) {
             outputRef: null,
             exitCode: command.exitCode,
             durationMs: null,
-            truncated: command.truncated
+            truncated: command.truncated ||
+                command.inputTruncated === true ||
+                bounded.truncated ||
+                (display !== undefined &&
+                    (display.stdoutDroppedBytes > 0 || display.stderrDroppedBytes > 0)),
+            toolPresentation: bounded.presentation
         },
         merge: true
     };
 }
-function commandWithOutputSnapshots(command, snapshots) {
-    const outputPreview = [
-        command.outputPreview,
-        ...snapshots.map((snapshot) => snapshot.outputPreview)
-    ]
-        .filter(Boolean)
-        .join('\n');
-    return {
-        ...command,
-        outputPreview: compactRunnerText(outputPreview, 10_000),
-        truncated: command.truncated ||
-            snapshots.some((snapshot) => snapshot.truncated) ||
-            outputPreview.length > 10_000
-    };
-}
 function applyCommandResult(command, result) {
     const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
-    if (output.length > 0) {
-        const combined = result.cached
-            ? output
-            : [command.outputPreview, output].filter(Boolean).join('\n');
-        command.truncated ||= combined.length > 10_000;
-        command.outputPreview = compactRunnerText(combined, 10_000);
-    }
-    command.exitCode = result.exitCode ?? command.exitCode;
-    command.truncated ||= result.truncated;
+    command.outputPreview = compactRunnerText(output, 10_000);
+    command.truncated = result.truncated || output.length > 10_000;
+    command.exitCode = result.exitCode ?? null;
 }
 function fileChangeItem(id, status, changes) {
     return { itemId: id, kind: 'file_change', status, payload: { changes }, merge: true };
@@ -1126,11 +1234,17 @@ function marAgentSubagentProjection(toolName, input, output, knownTitle, knownDe
             ? outputData.description
             : operation === 'START' && typeof inputData?.description === 'string'
                 ? inputData.description
-                : ''), 500);
+                : operation === 'START' && typeof inputData?.title === 'string'
+                    ? inputData.title
+                    : ''), 500);
     return {
         subagentOperation: operation,
         ...(operation === 'STATUS' ? { subagentWait: inputData?.waitMs !== 0 } : {}),
         subagentId: marAgentAgentId(input) ?? marAgentAgentId(controlOutput) ?? null,
+        ...(typeof outputData?.productSessionId === 'string' &&
+            outputData.productSessionId === marAgentAgentId(controlOutput)
+            ? { subagentSessionId: outputData.productSessionId }
+            : {}),
         ...(title.length === 0 ? {} : { title }),
         ...subagentPayload(details),
         ...(typeof details.latestMessage?.text === 'string'
@@ -1171,9 +1285,9 @@ function marAgentSubagentOperation(toolName) {
         return 'START';
     if (toolName === 'agent_wait')
         return 'STATUS';
-    if (toolName === 'agent_message')
+    if (toolName === 'agent_send' || toolName === 'agent_message')
         return 'MESSAGE';
-    if (toolName === 'agent_cancel')
+    if (toolName === 'agent_stop' || toolName === 'agent_cancel')
         return 'CANCEL';
     return undefined;
 }

package/dist/runner/mar-agent/managed-run-controller.js

@@ -51,6 +51,11 @@ export class MarAgentManagedRunController {
                     }
                 }),
             customTitle: (sessionId) => this.host.customTitle?.(sessionId) ?? undefined,
+            ...(options.attachNetworkContext === undefined
+                ? {}
+                : {
+                    attachNetworkContext: options.attachNetworkContext
+                }),
             modelUsage: (runId, usage) => this.host.emit(runId, 'run.usage', normalizeMarAgentUsage(usage)),
             publishModelResource: options.publishModelResource,
             question: (runId, request, signal) => this.requestQuestion(runId, request, signal),

package/dist/runner/mar-agent/marctl-skill.js

@@ -1,4 +1,4 @@
-import { hasMarctlContext, marctlDescription, marctlInstructions } from '../../marctl-guidance.js';
+import { hasMarctlContext, marctlManagementDescription, marctlManagementInstructions } from '../../marctl-guidance.js';
 export function marctlExecutionEnvironment(environment = {}) {
     return Object.fromEntries(Object.entries(environment).filter(([key]) => key.startsWith('MAR_CTL_')));
 }
@@ -7,8 +7,8 @@ export function marctlHostSkill(environment = {}) {
         return undefined;
     return {
         name: 'marctl',
-        description: marctlDescription,
+        description: marctlManagementDescription,
         requiredTools: ['exec'],
-        load: async () => marctlInstructions
+        load: async () => marctlManagementInstructions
     };
 }

package/dist/runner/mar-agent/runtime-model-factory.js

@@ -63,6 +63,7 @@ export class MarAgentRuntimeModelFactory {
                     reasoningEfforts: configuration.reasoningEfforts,
                     defaultReasoningEffort: resolveMarAgentDefaultReasoningEffort(configuration.defaultReasoningEffort, configuration.reasoningEfforts),
                     conversationModel: configuration.conversationModel ?? true,
+                    subagentModel: configuration.subagentModel ?? false,
                     titleGeneration: configuration.titleGeneration,
                     codeMode: configuration.codeMode,
                     ...(configuration.serviceTier === undefined

package/dist/runner/mar-agent/session-runtime.js

@@ -2,6 +2,8 @@ import { createHash, randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { access, constants } from 'node:fs/promises';
 import { LocalAgentHost } from '@myagentroam/agent/host';
+import { SESSION_CONTEXT_PROVIDER } from '@myagentroam/agent/extensions';
+import { agentNetworkExtension } from './agent-network-extension.js';
 import { marAgentRuntimeCompactConfigurationSchema } from '@myagentroam/protocol';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { nodeLog } from '../../operational.js';
@@ -26,8 +28,10 @@ export async function createSessionRuntime(input, sessionKey, fingerprint, hostC
     let agent;
     let models = [];
     let releaseEnvironment;
+    let networkContext;
     try {
         releaseEnvironment = dependencies.retainEnvironment?.(input.secretEnvironment ?? {});
+        networkContext = dependencies.attachNetworkContext?.(input.sessionId);
         const mcp = mcpLease.pool;
         const localHost = new LocalAgentHost({
             publishModelResource: dependencies.publishModelResource === undefined
@@ -68,12 +72,36 @@ export async function createSessionRuntime(input, sessionKey, fingerprint, hostC
         });
         const compactState = { revision: 0 };
         updateMarAgentCompactState(compactState, input.compact, models, input.models.map((model) => model.id));
+        const compactSource = marAgentCompactExtensionSource(compactState);
+        const networkProvider = networkContext;
         agent = await dependencies.createAgent({
             mode: 'node',
             host: localHost,
             models: sdkModelConfigurations(models.filter((model) => input.models.some((candidate) => candidate.id === model.id))),
             defaultModelId: input.model.id,
-            extensions: marAgentCompactExtensionSource(compactState),
+            extensions: networkProvider === undefined
+                ? compactSource
+                : {
+                    async resolve(request) {
+                        const snapshot = await compactSource.resolve(request);
+                        return {
+                            ...snapshot,
+                            extensions: [
+                                ...snapshot.extensions,
+                                {
+                                    id: 'mar.node.agent-network-context',
+                                    apiVersion: '1.0',
+                                    attachSession(context) {
+                                        context.services.provide(SESSION_CONTEXT_PROVIDER, networkProvider);
+                                    }
+                                },
+                                ...(networkProvider.invoke === undefined
+                                    ? []
+                                    : [agentNetworkExtension(networkProvider.invoke, currentRunId)])
+                            ]
+                        };
+                    }
+                },
             ...(input.personalInstructions ? { systemInstruction: input.personalInstructions } : {})
         });
         const customTitle = dependencies.customTitle(input.sessionId) ?? undefined;
@@ -92,6 +120,9 @@ export async function createSessionRuntime(input, sessionKey, fingerprint, hostC
             normalizer: new MarAgentConversationNormalizer(),
             mcpLease,
             releaseEnvironment,
+            ...(networkContext === undefined
+                ? {}
+                : { releaseNetworkContext: () => networkContext?.close() }),
             automaticTitleEnabled: input.externalSessionId === undefined,
             models,
             compactState,
@@ -103,6 +134,7 @@ export async function createSessionRuntime(input, sessionKey, fingerprint, hostC
     catch (error) {
         for (const cleanup of [
             () => agent?.dispose(),
+            () => networkContext?.close(),
             () => closeModelCredentialProviders(models),
             () => mcpLease.release(),
             () => releaseEnvironment?.()
@@ -155,6 +187,7 @@ export async function releaseSessionRuntime(runtime) {
     const failures = [];
     for (const cleanup of [
         () => runtime.agent.dispose(),
+        () => runtime.releaseNetworkContext?.(),
         () => runtime.mcpLease.release(),
         () => runtime.releaseEnvironment?.()
     ]) {