@myagentroam/node 0.11.38 → 0.11.40

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?.()
     ]) {

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

@@ -122,6 +122,7 @@ export class MarAgentRunner extends AbstractRunner {
                 id: model.id,
                 label: model.name,
                 supportedEfforts: [...model.reasoningEfforts],
+                subagentModel: model.subagentModel === true,
                 defaultEffort: resolveMarAgentDefaultReasoningEffort(model.defaultReasoningEffort, model.reasoningEfforts),
                 ...(index === 0 ? { isDefault: true } : {})
             })),
@@ -195,6 +196,16 @@ export class MarAgentRunner extends AbstractRunner {
             ]
         };
     }
+    childModels() {
+        const eligible = new Set(this.#models
+            .filter((model) => model.enabled && model.conversationModel !== false && model.subagentModel === true)
+            .map((model) => model.id));
+        return this.profileForValidation().models.filter((model) => eligible.has(model.id));
+    }
+    assertChildModel(modelId) {
+        if (!this.childModels().some((model) => model.id === modelId))
+            throw new Error('MAR_AGENT_SUBAGENT_MODEL_UNAVAILABLE');
+    }
     supportsConfiguration(configuration) {
         if (configuration.runner !== this.name)
             return false;
@@ -289,6 +300,9 @@ export class MarAgentRunner extends AbstractRunner {
                                 runner: this.name,
                                 externalSessionId: session.id,
                                 cwd: session.workspace,
+                                ...(session.source?.parentSessionId === undefined
+                                    ? {}
+                                    : { parentSessionId: session.source.parentSessionId }),
                                 lastActivityAt: Date.parse(session.lastActivityAt)
                             })
                         ]
@@ -311,6 +325,9 @@ export class MarAgentRunner extends AbstractRunner {
                             runner: this.name,
                             externalSessionId: session.id,
                             cwd: session.workspace,
+                            ...(session.source?.parentSessionId === undefined
+                                ? {}
+                                : { parentSessionId: session.source.parentSessionId }),
                             ...title,
                             lastActivityAt: Date.parse(session.lastActivityAt)
                         }),
@@ -406,6 +423,25 @@ export class MarAgentRunner extends AbstractRunner {
             await catalog.close().catch(() => undefined);
         }
     }
+    supportsNativeBatchRemoval() {
+        return true;
+    }
+    async removeNativeMembers(sessions) {
+        const ids = sessions.map((session) => {
+            if (session.runner !== this.name || session.externalSessionId === null)
+                throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+            return session.externalSessionId;
+        });
+        for (const id of ids)
+            await this.#releaseSessionResources?.(id);
+        const catalog = await openAgentSessionCatalog({ homeDirectory: this.homeDirectory });
+        try {
+            await catalog.deleteMembers(ids);
+        }
+        finally {
+            await catalog.close().catch(() => undefined);
+        }
+    }
     async readManagedRunnerTitle(session, nativeSessionId) {
         if (session.runner !== this.name || session.externalSessionId !== nativeSessionId)
             return undefined;

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

@@ -1,4 +1,5 @@
 import { compactRunnerText, compactRunnerValue } from '../normalization.js';
+import { publicOutputSnapshot, shellExecution } from '../execution-presentation.js';
 export function normalizeOpenCodeTool(toolName, state) {
     const status = state?.status === 'completed'
         ? 'COMPLETED'
@@ -23,7 +24,11 @@ export function normalizeOpenCodeTool(toolName, state) {
                 outputRef: null,
                 exitCode: typeof state?.exitCode === 'number' ? state.exitCode : null,
                 durationMs: null,
-                truncated: false
+                truncated: typeof state?.output === 'string' && state.output.length > 10_000,
+                ...(typeof state?.output === 'string'
+                    ? { output: publicOutputSnapshot(state.output) }
+                    : {}),
+                toolPresentation: shellExecution(typeof state?.output === 'string' ? state.output : undefined)
             }
         };
     return {

package/dist/runtime-state.js

@@ -872,6 +872,63 @@ export class NodeRuntimeState {
                 return executionId;
         return undefined;
     }
+    /** Read the identity and status of one Execution without following a later turn. */
+    executionSnapshot(executionId) {
+        const execution = this.executions.get(executionId);
+        if (execution !== undefined) {
+            const run = this.getRun(execution.runId);
+            return run === undefined
+                ? undefined
+                : {
+                    executionId,
+                    runId: run.id,
+                    sessionId: run.sessionId,
+                    status: execution.status
+                };
+        }
+        const retained = this.retainedExecutionTurns.get(executionId);
+        if (retained === undefined)
+            return undefined;
+        const turn = this.turns.get(retained.sessionId)?.find((value) => value.id === retained.turnId);
+        return turn?.runId == null
+            ? undefined
+            : {
+                executionId,
+                runId: turn.runId,
+                sessionId: retained.sessionId,
+                status: turn.status
+            };
+    }
+    latestRunExecution(runId) {
+        const turn = this.conversationTurnForRun(runId);
+        if (turn === undefined)
+            return undefined;
+        for (const execution of this.executions.values())
+            if (execution.runId === runId && execution.turnId === turn.id)
+                return this.executionSnapshot(execution.id);
+        for (const [executionId, retained] of this.retainedExecutionTurns)
+            if (retained.sessionId === turn.sessionId && retained.turnId === turn.id)
+                return this.executionSnapshot(executionId);
+        return undefined;
+    }
+    /** Resolve the current or most recent retained Execution of a Session. */
+    latestSessionExecution(sessionId) {
+        const active = this.activeSessionRun(sessionId);
+        if (active !== undefined)
+            return this.latestRunExecution(active.id);
+        const turns = this.turns.get(sessionId) ?? [];
+        for (let index = turns.length - 1; index >= 0; index -= 1) {
+            const turn = turns[index];
+            const live = [...this.executions.values()].find((value) => value.turnId === turn.id);
+            if (live !== undefined)
+                return this.executionSnapshot(live.id);
+            for (const [executionId, retained] of this.retainedExecutionTurns) {
+                if (retained.sessionId === sessionId && retained.turnId === turn.id)
+                    return this.executionSnapshot(executionId);
+            }
+        }
+        return undefined;
+    }
     createExecution(runId) {
         const canonicalRunId = this.canonicalRunId(runId);
         const turn = this.currentTurnForRun(canonicalRunId);