@myagentroam/agent 0.9.139 → 0.9.141

package/dist/host/local-agent-host.d.ts

@@ -1,6 +1,6 @@
 import type { CodeModeEngineFactory } from '../tools/code-mode/engine.js';
 import type { HostDescription } from './contracts.js';
-import type { LocalProcessExecutor } from './local-process-executor.js';
+import { type LocalProcessExecutor } from './local-process-executor.js';
 import type { WorkspacePathMount } from '../tools/shared/path-resolver.js';
 import type { MarAgentEvent, MarAgentHost, HostExecutionExtensions, McpToolCatalogContext, McpToolCatalog, McpToolCallContext, ToolCall, ToolExecutionContext, ToolExecutionResult } from '../sdk/types.js';
 export interface LocalAgentMcpBinding {
@@ -13,6 +13,8 @@ export interface LocalAgentExecutionMcpBinding extends LocalAgentMcpBinding {
     readonly extensions?: LocalAgentExecutionExtensions;
 }
 export interface LocalAgentExecutionExtensions extends HostExecutionExtensions {
+    /** Host-private process environment, snapshotted when bound to an execution. */
+    readonly environment?: Readonly<Record<string, string>>;
     executeTool?(call: ToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
 }
 export declare class LocalAgentHost implements MarAgentHost {

package/dist/host/local-agent-host.js

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
 import { basename, delimiter, isAbsolute, join, resolve, win32 } from 'node:path';
+import { directLocalProcessExecutor } from './local-process-executor.js';
 import { MAR_AGENT_HOST_API_VERSION } from './contracts.js';
 import { MarAgentError } from '../error.js';
 import { LocalToolRegistry } from '../tools/local-registry.js';
@@ -36,6 +37,7 @@ export class LocalAgentHost {
         this.#hasWebSearch = input.webSearch !== undefined;
         this.#hasWebFetch = input.webFetch !== false;
         this.#resourceIdleTtlMs = input.resourceIdleTtlMs;
+        const processExecutor = input.processExecutor ?? directLocalProcessExecutor;
         this.#tools = new LocalToolRegistry(this.#workspace, this.#environment, this.#shell.path, {
             ...(input.webSearch ? { webSearch: input.webSearch } : {}),
             webFetch: this.#hasWebFetch,
@@ -44,7 +46,25 @@ export class LocalAgentHost {
             ...(input.codeModeEngineFactory === undefined
                 ? {}
                 : { codeModeEngineFactory: input.codeModeEngineFactory }),
-            ...(input.processExecutor === undefined ? {} : { processExecutor: input.processExecutor }),
+            processExecutor: {
+                spawn: (request) => {
+                    const binding = request.owner && this.#executionMcp.get(request.owner.executionId);
+                    const environment = binding?.active ? binding.extensions?.environment : undefined;
+                    return processExecutor.spawn(environment === undefined
+                        ? request
+                        : {
+                            ...request,
+                            environment: { ...request.environment, ...environment },
+                            ...(request.environmentKeys === undefined
+                                ? {}
+                                : {
+                                    environmentKeys: [
+                                        ...new Set([...request.environmentKeys, ...Object.keys(environment)])
+                                    ]
+                                })
+                        });
+                }
+            },
             ...(input.restrictPaths === undefined ? {} : { restrictPaths: input.restrictPaths }),
             ...(input.workspaceWritable === undefined
                 ? {}
@@ -108,7 +128,12 @@ export class LocalAgentHost {
                 (async () => {
                     throw new MarAgentError('MAR_AGENT_MCP_FAILED', 'MCP execution is unavailable.');
                 }),
-            extensions,
+            extensions: {
+                ...extensions,
+                ...(extensions.environment === undefined
+                    ? {}
+                    : { environment: { ...extensions.environment } })
+            },
             active: true
         };
         this.#currentExecutionMcp = binding;
@@ -116,7 +141,8 @@ export class LocalAgentHost {
     }
     async listExecutionExtensions(context) {
         const binding = this.#executionBinding(context);
-        return binding?.extensions ?? this.#extensions ?? {};
+        const { environment: _environment, ...extensions } = binding?.extensions ?? this.#extensions ?? {};
+        return extensions;
     }
     emit(event) {
         this.events.push(event);

package/dist/model/anthropic-messages.js

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { MarAgentError } from '../error.js';
 import { resolveModelDefaultReasoningEffort } from './configuration.js';
-import { isRetryableUpstreamOverloadCode, number, parseSse, record, text } from './sse.js';
+import { isRetryableUpstreamOverloadCode, number, parseSse, record, text, observeModelStreamEvent, modelStreamEventObservedAt } from './sse.js';
 import { fetchModelResponse, modelRetryMaxAttempts, isRetryableModelRequestError, isRetryableModelTransportError, waitForModelRetry } from './http.js';
 import { anthropicThinkingBlock, assertAnthropicThinkingBudget } from './anthropic-thinking.js';
 export class AnthropicMessagesAdapter {
@@ -12,13 +12,22 @@ export class AnthropicMessagesAdapter {
     async *start(request, signal) {
         const retryState = request.retryState ?? { attempts: 0 };
         const maxAttempts = modelRetryMaxAttempts(retryState);
+        let resetOutputTiming = false;
         while (retryState.attempts < maxAttempts) {
+            if (resetOutputTiming)
+                yield { type: 'output.reset' };
+            resetOutputTiming = false;
             const attempt = retryState.attempts++;
             // Buffer non-semantic events until a semantic event makes this attempt non-retryable.
             const prelude = [];
             let sawSemanticEvent = false;
             try {
                 for await (const event of this.startAttempt(request, signal)) {
+                    if (event.type === 'output.delta') {
+                        resetOutputTiming = true;
+                        yield event;
+                        continue;
+                    }
                     if (!sawSemanticEvent && !isSemanticEvent(event)) {
                         prelude.push(event);
                         continue;
@@ -193,17 +202,25 @@ export class AnthropicMessagesAdapter {
                 if (deltaType === 'text_delta') {
                     const value = text(delta.text) ?? '';
                     block.text += value;
-                    yield { type: 'text.delta', itemId: block.id, phase: 'commentary', delta: value };
+                    yield observeModelStreamEvent({ type: 'text.delta', itemId: block.id, phase: 'commentary', delta: value }, modelStreamEventObservedAt(raw));
+                }
+                else if (deltaType === 'thinking_delta') {
+                    const value = text(delta.thinking) ?? '';
+                    block.text += value;
+                    if (value.length > 0)
+                        yield observeModelStreamEvent({ type: 'output.delta' }, modelStreamEventObservedAt(raw));
                 }
-                else if (deltaType === 'thinking_delta')
-                    block.text += text(delta.thinking) ?? '';
                 else if (deltaType === 'signature_delta') {
                     if (block.type !== 'thinking' || typeof delta.signature !== 'string')
                         throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Anthropic returned an invalid thinking signature delta.');
                     block.signature += delta.signature;
                 }
-                else if (deltaType === 'input_json_delta')
-                    block.json += text(delta.partial_json) ?? '';
+                else if (deltaType === 'input_json_delta') {
+                    const value = text(delta.partial_json) ?? '';
+                    block.json += value;
+                    if (value.length > 0)
+                        yield observeModelStreamEvent({ type: 'output.delta' }, modelStreamEventObservedAt(raw));
+                }
                 else if (deltaType === 'citations_delta') {
                     const citation = record(delta.citation);
                     const url = text(citation.url);
@@ -307,7 +324,7 @@ export class AnthropicMessagesAdapter {
                 };
             }
             else if (type === 'message_stop') {
-                yield { type: 'completed', reason: terminal ?? 'completed' };
+                yield observeModelStreamEvent({ type: 'completed', reason: terminal ?? 'completed' }, modelStreamEventObservedAt(raw));
             }
             else if (type === 'error') {
                 const upstream = record(event.error);

package/dist/model/contracts.d.ts

@@ -95,6 +95,10 @@ export type ModelStopReason = 'completed' | 'tool_use' | 'pause' | 'max_output'
 export type ModelEvent = {
     type: 'response.started';
     responseId: string;
+} | {
+    type: 'output.delta';
+} | {
+    type: 'output.reset';
 } | {
     type: 'response.item';
     provider: 'OPENAI_RESPONSES' | 'ANTHROPIC_MESSAGES';

package/dist/model/openai-responses.js

@@ -3,7 +3,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { describeMarAgentError, MarAgentError } from '../error.js';
 import { marAgentReasoningEffortSchema, resolveModelDefaultReasoningEffort, usesResponsesConfigurationUpdates } from './configuration.js';
 import WebSocket from 'ws';
-import { isRetryableUpstreamOverloadCode, number, parseSse, record, text } from './sse.js';
+import { isRetryableUpstreamOverloadCode, number, parseSse, record, text, observeModelStreamEvent, modelStreamEventObservedAt } from './sse.js';
 import { connectSocks5Target, fetchModelResponse, isRetryableModelHttpStatus, isRetryableModelTransportError, modelRetryMaxAttempts, isRetryableModelRequestError, modelRetryDelay, waitForModelRetry } from './http.js';
 import { acquireModelCredential, appendModelCredentialHeaders } from './runtime-credential.js';
 const WEBSOCKET_IDLE_TIMEOUT_MS = 300_000;
@@ -77,7 +77,11 @@ export class OpenAiResponsesAdapter {
         let invalidContinuationFallbackUsed = false;
         const retryState = request.retryState ?? { attempts: 0 };
         const maxAttempts = modelRetryMaxAttempts(retryState);
+        let resetOutputTiming = false;
         while (retryState.attempts < maxAttempts) {
+            if (resetOutputTiming)
+                yield { type: 'output.reset' };
+            resetOutputTiming = false;
             const attempt = retryState.attempts++;
             const attemptNumber = attempt + 1;
             const attemptStartedAt = Date.now();
@@ -99,6 +103,11 @@ export class OpenAiResponsesAdapter {
             });
             try {
                 for await (const event of this.startAttempt(request, signal, requestBody, useContinuation, credentialReason, turn)) {
+                    if (event.type === 'output.delta') {
+                        resetOutputTiming = true;
+                        yield event;
+                        continue;
+                    }
                     if (!sawSemanticEvent && !isSemanticEvent(event)) {
                         prelude.push(event);
                         continue;
@@ -341,8 +350,16 @@ export class OpenAiResponsesAdapter {
                 else if (type === 'response.custom_tool_call_input.delta') {
                     const itemId = text(event.item_id) ?? '';
                     const known = customCalls.get(itemId);
+                    const delta = text(event.delta) ?? '';
                     if (known)
-                        known.input += text(event.delta) ?? '';
+                        known.input += delta;
+                    if (delta.length > 0)
+                        yield observeModelStreamEvent({ type: 'output.delta' }, modelStreamEventObservedAt(raw));
+                }
+                else if (type === 'response.function_call_arguments.delta' ||
+                    type === 'response.reasoning_summary_text.delta') {
+                    if ((text(event.delta)?.length ?? 0) > 0)
+                        yield observeModelStreamEvent({ type: 'output.delta' }, modelStreamEventObservedAt(raw));
                 }
                 else if (type === 'response.created')
                     yield {
@@ -350,14 +367,14 @@ export class OpenAiResponsesAdapter {
                         responseId: responseEventId(event) ?? 'unknown'
                     };
                 else if (type === 'response.output_text.delta')
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'text.delta',
                         itemId: text(event.item_id) ?? 'text',
                         phase: messagePhase(event.phase) ??
                             textPhases.get(text(event.item_id) ?? '') ??
                             'commentary',
                         delta: text(event.delta) ?? ''
-                    };
+                    }, modelStreamEventObservedAt(raw));
                 else if (type === 'response.output_text.done') {
                     const itemId = text(event.item_id) ?? 'text';
                     const completedText = text(event.text) ?? '';
@@ -519,10 +536,10 @@ export class OpenAiResponsesAdapter {
                             ...(rolloutBudgetUnits === undefined ? {} : { rolloutBudgetUnits })
                         }
                     };
-                    yield {
+                    yield observeModelStreamEvent({
                         type: 'completed',
                         reason: type === 'response.incomplete' ? 'max_output' : 'completed'
-                    };
+                    }, modelStreamEventObservedAt(raw));
                     completed = true;
                 }
                 else if (type === 'error' || type === 'response.failed') {
@@ -634,6 +651,7 @@ class OpenAiResponsesTurnSession {
                     if (event.type === 'completed')
                         warmCompleted = event.reason === 'completed';
                     if (event.type === 'client_tool.call' ||
+                        event.type === 'output.delta' ||
                         event.type === 'text.delta' ||
                         event.type === 'text.completed' ||
                         event.type === 'response.item' ||
@@ -660,6 +678,7 @@ class OpenAiResponsesTurnSession {
                 else if (event.type === 'response.item')
                     outputItems.push(event.item);
                 else if (event.type === 'text.delta' ||
+                    event.type === 'output.delta' ||
                     event.type === 'text.completed' ||
                     event.type === 'reasoning.summary' ||
                     event.type === 'client_tool.call' ||
@@ -1179,7 +1198,8 @@ async function* webSocketMessages(socket, signal) {
     };
     const message = (value) => push({
         type: 'message',
-        value
+        value,
+        observedAt: performance.now()
     });
     const close = () => push({ type: 'closed' });
     const error = (cause) => push({
@@ -1228,7 +1248,7 @@ async function* webSocketMessages(socket, signal) {
                 const event = JSON.parse(text);
                 if (!isWebSocketNonProgressEvent(event))
                     idleDeadline = Date.now() + WEBSOCKET_IDLE_TIMEOUT_MS;
-                yield event;
+                yield observeModelStreamEvent(event, item.observedAt);
             }
             catch (cause) {
                 throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model WebSocket contained invalid JSON.', { cause });
@@ -1336,13 +1356,11 @@ const NON_SEMANTIC_OPENAI_RESPONSES_EVENTS = new Set([
     'codex.response.metadata',
     'response.content_part.added',
     'response.content_part.done',
-    'response.function_call_arguments.delta',
     'response.in_progress',
     'response.metadata',
     'response.queued',
     'response.reasoning_summary_part.added',
     'response.reasoning_summary_part.done',
-    'response.reasoning_summary_text.delta',
     'responsesapi.websocket_timing'
 ]);
 function isRetryableResponsesUpstreamError(code, message) {

package/dist/model/sse.d.ts

@@ -1,3 +1,5 @@
+export declare function observeModelStreamEvent<const T>(value: T, observedAt: number | undefined): T;
+export declare function modelStreamEventObservedAt(value: unknown): number | undefined;
 export declare function parseSse(response: Response, signal: AbortSignal, maxBytes?: number, idleTimeoutMs?: number): AsyncIterable<unknown>;
 export declare function isRetryableUpstreamOverloadCode(code: string | undefined): boolean;
 export declare function record(value: unknown): Record<string, unknown>;

package/dist/model/sse.js

@@ -1,6 +1,15 @@
 import { MarAgentError } from '../error.js';
 import { isRetryableModelHttpStatus } from './http.js';
 const DEFAULT_MODEL_STREAM_IDLE_TIMEOUT_MS = 300_000;
+const streamEventObservedAt = new WeakMap();
+export function observeModelStreamEvent(value, observedAt) {
+    if (typeof value === 'object' && value !== null && observedAt !== undefined)
+        streamEventObservedAt.set(value, observedAt);
+    return value;
+}
+export function modelStreamEventObservedAt(value) {
+    return typeof value === 'object' && value !== null ? streamEventObservedAt.get(value) : undefined;
+}
 export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, idleTimeoutMs = DEFAULT_MODEL_STREAM_IDLE_TIMEOUT_MS) {
     if (!response.ok) {
         const body = await readResponseText(response, signal, maxBytes, idleTimeoutMs);
@@ -34,6 +43,7 @@ export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, i
             if (signal.aborted)
                 throw signal.reason;
             const { value, done } = await readStreamChunk(reader, signal, idleTimeoutMs);
+            const observedAt = performance.now();
             if (done) {
                 streamCompleted = true;
                 break;
@@ -53,7 +63,7 @@ export async function* parseSse(response, signal, maxBytes = 16 * 1024 * 1024, i
                 if (data.length === 0 || data === '[DONE]')
                     continue;
                 try {
-                    yield JSON.parse(data);
+                    yield observeModelStreamEvent(JSON.parse(data), observedAt);
                 }
                 catch (cause) {
                     throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Model SSE contained invalid JSON.', { cause });

package/dist/prompts/resources.js

@@ -12,7 +12,9 @@ export function retainedSessionResourcesSnapshot(input) {
             ]
             : []),
         'These resources belong to this Session and survived the previous Execution. Reuse their stable IDs instead of starting duplicate processes or subagents.',
-        processes.length === 0 ? '' : 'Cancelling a managed process releases that process resource.',
+        processes.length === 0
+            ? ''
+            : 'Use exec_wait with processId to wait, write stdin or cancel; in Code Mode use tools.exec_wait. Cancelling a wait leaves the process running; explicit cancel releases the process resource.',
         subagents.length === 0
             ? ''
             : 'agent_cancel stops only the current child turn and retains its Session for later messages or explicit deletion.',
@@ -40,7 +42,7 @@ export function retainedSessionResourcesUpdate(snapshot, previousSnapshot, previ
         return undefined;
     if (!snapshot)
         return previousSnapshot || previousMayContainResources
-            ? 'The previously provided retained Session resources no longer apply. No retained processes, code cells or subagents remain.'
+            ? 'The previously provided retained Session resources no longer apply. No retained processes, code cells or subagents remain. Historical resource IDs are not live handles; do not poll or wait on them. Use already recorded results or saved artifacts to recover completed work before starting anything again.'
             : undefined;
     return previousSnapshot || previousMayContainResources
         ? `This replaces all previously provided retained Session resources.\n\n${snapshot}`

package/dist/prompts/workflow.js

@@ -16,6 +16,8 @@ export function toolUsagePrompt(tools, directTools = tools) {
         clauses.push('If the request names or clearly matches an available Skill description, call skill before generic tools and follow the loaded workflow; semantic matches do not require the user to know the Skill name. Do not load unrelated Skills or claim to use one without calling skill.');
     if (names.has('exec'))
         clauses.push('Use exec for platform-native commands, scripts, verification, and mechanical edits. Prefer rg or rg --files for search. Batch independent lookups and already-decided commands, preserving failure ordering. Use scripts for mechanical substitutions instead of reproducing long unchanged text in a patch; inspect actual effects afterward.');
+    if (names.has('exec_wait'))
+        clauses.push('Use exec_wait with processId for subsequent process waits, stdin writes or cancellation; in Code Mode use tools.exec_wait. exec only starts commands.');
     if (names.has('read'))
         clauses.push('Use read to batch known files and ranges. Batch only already-located, bounded ranges that are likely to fit together; for large files or documents, locate relevant sections before reading them. Read only what can affect the next decision, continue only relevant incomplete results using returned metadata, and avoid rereading unchanged content. Do not edit from an incomplete oversized-line preview. Obtain exact source with exec; if it still cannot fit, use a preconditioned deterministic replacement and verify the result.');
     if (names.has('apply_patch'))

package/dist/runtime/context-gc.js

@@ -690,7 +690,7 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
     let protectedTokens = 0;
     let retryAfterRollouts = Infinity;
     const execGroups = [...groups.values()]
-        .filter((group) => group.toolName === 'exec')
+        .filter((group) => group.toolName === 'exec' || group.toolName === 'exec_wait')
         .sort((left, right) => (left.call?.record.sequence ?? Number.MAX_SAFE_INTEGER) -
         (right.call?.record.sequence ?? Number.MAX_SAFE_INTEGER));
     const invocations = new Map();
@@ -713,15 +713,32 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
     }
     for (const startGroup of execGroups) {
         const start = invocations.get(startGroup.callId);
-        if (!start ||
-            (start.input.action !== 'start' &&
-                !(start.input.action == null && typeof start.input.command === 'string')))
+        if (!start)
             continue;
+        const isStart = start.group.toolName === 'exec' &&
+            (start.input.action === 'start' ||
+                (start.input.action == null && typeof start.input.command === 'string'));
+        const processId = typeof start.input.processId === 'string'
+            ? start.input.processId
+            : typeof start.result.processId === 'string'
+                ? start.result.processId
+                : undefined;
+        if (!isStart) {
+            if (start.group.toolName !== 'exec_wait' || !processId)
+                continue;
+            // A process may start inside a cell or before the visible history boundary.
+            // Begin with its first visible wait, but never split an unfinished lifecycle.
+            const previous = execGroups.findLast((group) => (group.call?.record.sequence ?? Infinity) < start.group.call.record.sequence &&
+                ((isRecord(group.call?.message.arguments) &&
+                    group.call.message.arguments.processId === processId) ||
+                    invocations.get(group.callId)?.result.processId === processId));
+            const previousStatus = previous && invocations.get(previous.callId)?.result.status;
+            if (previous && previousStatus !== 'completed' && previousStatus !== 'cancelled')
+                continue;
+        }
         const lifecycle = [start];
-        let processId;
         let terminal = start.result.status !== 'running';
         if (!terminal) {
-            processId = typeof start.result.processId === 'string' ? start.result.processId : undefined;
             if (!processId)
                 continue;
             const relatedGroups = execGroups.filter((group) => (group.call?.record.sequence ?? 0) > start.group.call.record.sequence &&
@@ -765,10 +782,10 @@ function collectExecCandidates(input, groups, existingTargets, usageRatio) {
             if (!existingTargets.has(contextGcTargetKey(callTarget)))
                 replacements.push({
                     kind: 'TOOL_CALL_INPUT',
-                    toolName: 'exec',
+                    toolName: invocation.group.toolName,
                     callId: invocation.group.callId,
                     target: callTarget,
-                    replacementArguments: contextGcExecInputReplacement(invocation.input),
+                    replacementArguments: contextGcExecInputReplacement(invocation.input, 3, invocation.group.toolName),
                     providerAliasTargets: invocation.group.aliases
                         .map(({ record, message }) => targetFor(record, message))
                         .filter((target) => target !== undefined),