@myagentroam/agent 0.11.45 → 0.11.47

package/dist/cli/subagent/index.js

@@ -11,6 +11,7 @@ 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.',
+    'Follow up through the direct delegate by default; inspect deeper Sessions only when a concrete issue needs independent verification.',
     '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');

package/dist/extensions/operation.d.ts

@@ -10,6 +10,8 @@ export interface ExtensionOperationContext {
     /** Correlation with the actual enclosing tool call; not an authority token. */
     readonly toolCallId?: string;
     readonly parentToolCallId?: string;
+    /** Publish bounded public metadata for this tool invocation, without changing its result. */
+    readonly publishEventData?: (data: Readonly<Record<string, unknown>>) => Promise<void>;
     /** Wakes a foreground tool wait when its Execution receives a steering input. */
     readonly waitInterrupt?: import('../runtime/wait.js').ToolWaitInterrupt;
     /** Present only for the exact tool invocation explicitly approved by the Host. */

package/dist/model/openai-responses.d.ts

@@ -35,6 +35,7 @@ declare class OpenAiResponsesTurnSession implements ModelTurnSession {
     private run;
     close(): Promise<void>;
     resetContinuation(): void;
+    restartProviderTurn(): void;
     continuationInputCount(): number;
     commitContinuationInput(messageCount: number): void;
     captureCompletedResponseId(responseId: string | undefined): void;

package/dist/model/openai-responses.js

@@ -14,7 +14,7 @@ import { acquireModelCredential, appendModelCredentialHeaders, modelCredentialSe
 import { reportModelAttempt } from './attempt-diagnostics.js';
 import { productUserAgent } from '../network/product-user-agent.js';
 import { ResponsesSessionCache, clearResponsesContinuation, invalidateResponsesWebSocket, terminateWebSocket } from './responses-session-cache.js';
-const WEBSOCKET_IDLE_TIMEOUT_MS = 300_000;
+const WEBSOCKET_IDLE_TIMEOUT_MS = 180_000;
 const WEBSOCKET_SEND_FRAME_BYTES = 1024 * 1024;
 export const OPENAI_RESPONSES_EARLY_EOF_REASON = 'OPENAI_RESPONSES_EARLY_EOF';
 export const OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT_REASON = 'OPENAI_RESPONSES_WEBSOCKET_CONNECTION_LIMIT';
@@ -61,6 +61,13 @@ export class OpenAiResponsesAdapter {
         const maxAttempts = modelRetryMaxAttempts(retryState);
         let resetOutputTiming = false;
         while (retryState.attempts < maxAttempts) {
+            signal.throwIfAborted();
+            if (retryState.attempts > 0) {
+                // Adapter retries and Runtime recovery share this counter, but not Provider Turn state.
+                turn.restartProviderTurn();
+                useContinuation = false;
+                requestBody = prepared.fullBody;
+            }
             if (resetOutputTiming)
                 yield { type: 'output.reset' };
             resetOutputTiming = false;
@@ -152,8 +159,7 @@ export class OpenAiResponsesAdapter {
                     invalidContinuationFallbackUsed = true;
                     useContinuation = false;
                     requestBody = prepared.fullBody;
-                    turn.resetContinuation();
-                    turn.invalidateWebSocket();
+                    turn.restartProviderTurn();
                     retryState.attempts = Math.max(0, retryState.attempts - 1);
                     credentialReason = 'RECONNECT';
                     await reportFailure(true, {
@@ -171,8 +177,7 @@ export class OpenAiResponsesAdapter {
                     invalidContinuationFallbackUsed = true;
                     useContinuation = false;
                     requestBody = prepared.fullBody;
-                    turn.resetContinuation();
-                    turn.invalidateWebSocket();
+                    turn.restartProviderTurn();
                     credentialReason = 'RECONNECT';
                     await reportFailure(true, {
                         retryDelayMs: 0,
@@ -697,7 +702,7 @@ class OpenAiResponsesTurnSession {
         }
         finally {
             if (!finished)
-                invalidateResponsesWebSocket(this.state, true);
+                this.restartProviderTurn();
             this.#completedResponseId = undefined;
             this.#active = undefined;
             this.#abort = undefined;
@@ -725,6 +730,11 @@ class OpenAiResponsesTurnSession {
     resetContinuation() {
         clearResponsesContinuation(this.state);
     }
+    restartProviderTurn() {
+        this.#turnState = undefined;
+        this.#completedResponseId = undefined;
+        invalidateResponsesWebSocket(this.state, true);
+    }
     continuationInputCount() {
         return this.state.lastMessageCount ?? 0;
     }

package/dist/model/sse.js

@@ -1,6 +1,6 @@
 import { AgentError } from '../error.js';
 import { isRetryableModelHttpStatus } from './http.js';
-const DEFAULT_MODEL_STREAM_IDLE_TIMEOUT_MS = 300_000;
+const DEFAULT_MODEL_STREAM_IDLE_TIMEOUT_MS = 180_000;
 const streamEventObservedAt = new WeakMap();
 export function observeModelStreamEvent(value, observedAt) {
     if (typeof value === 'object' && value !== null && observedAt !== undefined)

package/dist/runtime/events.d.ts

@@ -89,6 +89,12 @@ export type AgentEvent = AgentEventBase & ({
     input?: unknown;
     data?: import('./public-tool-metadata.js').PublicToolMetadata;
     truncated?: boolean;
+} | {
+    type: 'tool.updated';
+    toolName: string;
+    callId: string;
+    parentCallId?: string;
+    data: Readonly<Record<string, unknown>>;
 } | {
     type: 'tool.output';
     toolName: 'exec' | 'exec_wait' | 'code_exec_wait';

package/dist/runtime/model-progress.js

@@ -1,5 +1,5 @@
 import { AgentError } from '../error.js';
-const MODEL_PROGRESS_TIMEOUT_MS = 300_000;
+const MODEL_PROGRESS_TIMEOUT_MS = 180_000;
 /** Watch normalized generation progress, not transport traffic or consumer processing. */
 export async function* observeModelProgress(start, parent) {
     parent.throwIfAborted();
@@ -15,7 +15,7 @@ export async function* observeModelProgress(start, parent) {
             const startedAt = performance.now();
             let abort;
             const timer = setTimeout(() => {
-                controller.abort(new AgentError('MAR_AGENT_MODEL_TIMEOUT', 'Model request produced no generation progress for 300 seconds.', { details: { reason: 'MODEL_PROGRESS_TIMEOUT' }, retryable: true }));
+                controller.abort(new AgentError('MAR_AGENT_MODEL_TIMEOUT', 'Model request produced no generation progress for 180 seconds.', { details: { reason: 'MODEL_PROGRESS_TIMEOUT' }, retryable: true }));
             }, Math.ceil(remainingMs));
             timer.unref();
             let next;

package/dist/sdk/execution-tool-scope.js

@@ -1,5 +1,5 @@
 import { createExecutionCodeModeContext } from './execution-code-mode.js';
-import { currentExecutionImages } from '../tools/output-projection.js';
+import { currentExecutionImages, publicExtensionToolEventData } from '../tools/output-projection.js';
 import { requestSmartCompaction } from '../runtime/compaction/smart.js';
 import { renderPromptSections } from '../prompts/prompt-sections.js';
 import { withToolPermissions } from '../tools/permissions.js';
@@ -56,7 +56,8 @@ export function createExecutionToolScope(input) {
             waitInterrupt,
             emit,
             skills: skills,
-            invokeTool: (call, context, caller) => {
+            invokeTool: async (call, context, caller) => {
+                let active = true;
                 const invoke = () => coreExtensions.withTools(roundBindings, scheduleTool, () => withToolPermissions(permissionPolicy, () => operations.enter({
                     sessionId,
                     sessionEpoch: coreExtensions.epoch,
@@ -70,9 +71,35 @@ export function createExecutionToolScope(input) {
                     ...(context.waitInterrupt === undefined
                         ? {}
                         : { waitInterrupt: context.waitInterrupt }),
+                    ...(call.callId === undefined
+                        ? {}
+                        : {
+                            publishEventData: async (value) => {
+                                if (!active)
+                                    return;
+                                context.signal.throwIfAborted();
+                                const data = publicExtensionToolEventData(value);
+                                if (data === undefined)
+                                    return;
+                                await context.emit({
+                                    type: 'tool.updated',
+                                    toolName: call.name,
+                                    callId: call.callId,
+                                    ...(context.parentCallId === undefined
+                                        ? {}
+                                        : { parentCallId: context.parentCallId }),
+                                    data
+                                });
+                            }
+                        }),
                     signal: context.signal
                 }, (operation) => coreExtensions.invoke(call, operation, roundBindings))));
-                return sources.withFrame(context, invoke);
+                try {
+                    return await sources.withFrame(context, invoke);
+                }
+                finally {
+                    active = false;
+                }
             }
         };
         const recentImages = async () => {

package/dist/tools/code-mode/dispatch.d.ts

@@ -4,7 +4,7 @@ import type { McpToolCallContext, ToolCall, ToolExecutionResult } from '../contr
 import type { ToolRuntimeContext } from '../runtime-context.js';
 import type { createSessionToolScheduler } from '../scheduler.js';
 type ToolEvent = Extract<AgentEvent, {
-    type: 'tool.started' | 'tool.output' | 'tool.completed' | 'tool.failed';
+    type: 'tool.started' | 'tool.updated' | 'tool.output' | 'tool.completed' | 'tool.failed';
 }>;
 type Payload<T = ToolEvent> = T extends ToolEvent ? Omit<T, 'eventId' | 'sequence' | 'timestamp' | 'sessionId' | 'executionId' | 'turnId'> : never;
 /** Capture only the cell's immutable dispatch identity, never the model loop or its AbortSignal. */

package/dist/tools/code-mode/dispatch.js

@@ -32,7 +32,9 @@ export function createCodeToolDispatch(input) {
                 const expected = input.expectations.get(call.name);
                 const result = await executeRegisteredTool(call.name, call.arguments, callId, {
                     ...input.context,
-                    emit: (event) => event.type === 'tool.output' ? input.emit(event) : input.context.emit(event),
+                    emit: (event) => event.type === 'tool.output' || event.type === 'tool.updated'
+                        ? input.emit(event)
+                        : input.context.emit(event),
                     parentCallId: input.parentCallId,
                     signal,
                     ...(expected ? { expectedMcpTool: expected } : {})

package/dist/tools/runtime-context.d.ts

@@ -18,6 +18,12 @@ export interface ToolImageStore extends ResourceStore {
     } | undefined>;
 }
 export type ToolRuntimeEvent = {
+    type: 'tool.updated';
+    toolName: string;
+    callId: string;
+    parentCallId?: string;
+    data: Readonly<Record<string, unknown>>;
+} | {
     type: 'tool.output';
     toolName: 'exec' | 'exec_wait' | 'code_exec_wait';
     callId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.11.45",
+  "version": "0.11.47",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",