@myagentroam/agent 0.11.39 → 0.11.40

package/dist/sdk/execution-round-preparation.js

@@ -1,18 +1,18 @@
 /** Owns round retries when late input or resource collection invalidates a candidate. */
 export function createExecutionRoundPreparer(ports) {
     return async (continuation) => {
-        let includeSubagentUpdates = true;
+        let includeSessionContext = true;
         for (;;) {
-            await ports.prepareInputs(includeSubagentUpdates);
+            await ports.prepareInputs(includeSessionContext);
             const candidate = await ports.buildCandidate(continuation);
             if (await ports.adoptLateInput()) {
-                includeSubagentUpdates = false;
+                includeSessionContext = false;
                 continue;
             }
             const prepared = await ports.prepareResources(candidate);
             if ('round' in prepared)
                 return prepared.round;
-            includeSubagentUpdates = false;
+            includeSessionContext = false;
         }
     };
 }

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

@@ -5,7 +5,6 @@ import { assertMcpToolCatalog } from '../tools/mcp/catalog.js';
 import { DeferredMcpRegistry } from '../tools/mcp/tool-search.js';
 import { discoveredMcpToolNames, rebindMcpToolSearchOutputs } from '../tools/mcp/history.js';
 import { BUILTIN_TOOL_DEFINITIONS } from '../tools/registry.js';
-import { agentStartToolDefinitionWithModels } from '../tools/agent/agent-start.js';
 import { toolCallers } from '../tools/callers.js';
 import { ExecutionToolSources } from './extension-tools.js';
 /** Initializes one Execution's catalog before Extension attachment owns its bindings. */
@@ -36,11 +35,7 @@ export async function initializeExecutionToolCatalog(input) {
     const extensions = (await host.listExecutionExtensions?.(context)) ?? {};
     if (extensions.tools?.some((tool) => tool.name.startsWith('mcp__')))
         throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Host tools cannot use the MCP namespace.');
-    const builtins = BUILTIN_TOOL_DEFINITIONS.map((tool) => tool.name === 'agent_start'
-        ? agentStartToolDefinitionWithModels([...input.models.values()]
-            .filter((configuration) => configuration.conversationModel !== false)
-            .map(({ id, name, reasoningEfforts }) => ({ id, name, reasoningEfforts })))
-        : tool);
+    const builtins = BUILTIN_TOOL_DEFINITIONS;
     const tools = [
         ...builtins,
         ...(extensions.tools ?? []),
@@ -62,10 +57,7 @@ export class ExecutionToolCatalog {
     }
     eligible(tool) {
         toolCallers(tool);
-        if (this.input.child &&
-            (tool.agentScope === 'ROOT_ONLY' ||
-                tool.name.startsWith('agent_') ||
-                tool.name === 'question'))
+        if (this.input.child && (tool.agentScope === 'ROOT_ONLY' || tool.name === 'question'))
             return false;
         if (tool.name === 'tool_search')
             return this.input.registry.hasDeferred;

package/dist/sdk/execution-tool-scope.d.ts

@@ -11,7 +11,6 @@ import type { ExtensionSession } from '../extensions/session.js';
 import type { ExtensionOperations, ExtensionOperationContext } from '../extensions/operation.js';
 import type { ExtensionPromptComposition } from '../extensions/prompt-composition.js';
 import type { DeferredMcpRegistry } from '../tools/mcp/tool-search.js';
-import type { SubagentSessionController } from '../subagent/session-controller.js';
 import type { ResolvedModelConfiguration } from './model-runtime.js';
 import type { ExecutionMode } from './types.js';
 import type { CompactFlight } from '../runtime/compaction/coordinator.js';
@@ -31,8 +30,7 @@ export declare function createExecutionToolScope(input: {
     readonly todo: ToolRuntimeContext['todo'];
     readonly waitInterrupt: ToolRuntimeContext['waitInterrupt'];
     readonly skills: ToolRuntimeContext['skills'];
-    readonly subagents: Pick<SubagentSessionController, 'captureParentFrame' | 'captureExecution' | 'modelMessages'> | undefined;
-    readonly coreExtensions: Pick<ExtensionSession, 'epoch' | 'agentAction' | 'withTools' | 'invoke' | 'assertLive' | 'pin' | 'diagnose' | 'composeModelSystem'>;
+    readonly coreExtensions: Pick<ExtensionSession, 'epoch' | 'withTools' | 'invoke' | 'assertLive' | 'pin' | 'diagnose' | 'composeModelSystem' | 'services'>;
     readonly operations: Pick<ExtensionOperations, 'enter'>;
     readonly scheduleTool: SessionRuntime['scheduleTool'];
     readonly sources: Pick<ExecutionToolSources, 'withFrame' | 'assertActive'>;

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

@@ -1,12 +1,12 @@
-import { bindAgentController } from './extension-agent-controller.js';
 import { createExecutionCodeModeContext } from './execution-code-mode.js';
 import { currentExecutionImages } 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';
+import { SESSION_CONTEXT_PROVIDER } from '../extensions/session-context.js';
 /** Capture immutable round tool identities, parent scope and resource capabilities. */
 export function createExecutionToolScope(input) {
-    const { store, host, sessionId, executionId, turnId, mode, controller, sessionWriterOwner, selectedModel, permissionPolicy, todo, waitInterrupt, skills, subagents, coreExtensions, operations, scheduleTool, sources, mcpRegistry, autoPermissionPrompt, currentExecutionToolImages, inputImageBytes, snapshotTools, baseTools, captureTools, promptComposition, smartInput, modelInputImages, startCompact, preparedPrompt, clearPreparedPrompt, operation, emit } = input;
+    const { store, host, sessionId, executionId, turnId, mode, controller, sessionWriterOwner, selectedModel, permissionPolicy, todo, waitInterrupt, skills, coreExtensions, operations, scheduleTool, sources, mcpRegistry, autoPermissionPrompt, currentExecutionToolImages, inputImageBytes, snapshotTools, baseTools, captureTools, promptComposition, smartInput, modelInputImages, startCompact, preparedPrompt, clearPreparedPrompt, operation, emit } = input;
     const captureRoundToolScope = () => {
         const roundTools = snapshotTools();
         const availableBindings = captureTools();
@@ -22,10 +22,10 @@ export function createExecutionToolScope(input) {
         const roundMcpExpectations = new Map(roundTools
             .filter((tool) => roundBindings.get(tool.name)?.mcp !== undefined)
             .map((tool) => [tool.name, mcpRegistry.expectedTool(tool.name)]));
-        const parentFrame = subagents === undefined || mode === 'compact'
-            ? undefined
-            : subagents.captureParentFrame(executionId);
         const roundSmartInput = smartInput();
+        const modelMessages = mode === 'compact'
+            ? undefined
+            : coreExtensions.services.resolve(SESSION_CONTEXT_PROVIDER)?.wake;
         const toolContext = {
             imageStore: store,
             host: host,
@@ -47,12 +47,7 @@ export function createExecutionToolScope(input) {
             permissionPolicy,
             writeToolResultResource: (text) => store.writeToolResultResource(sessionId, text),
             todo,
-            ...(subagents === undefined || mode === 'compact'
-                ? {}
-                : {
-                    subagents: bindAgentController(subagents.captureExecution(executionId), coreExtensions.agentAction),
-                    subagentMessages: subagents.modelMessages
-                }),
+            ...(modelMessages === undefined ? {} : { contextUpdates: modelMessages }),
             mode,
             sessionId,
             executionId,
@@ -72,9 +67,12 @@ export function createExecutionToolScope(input) {
                     ...(context.parentCallId === undefined
                         ? {}
                         : { parentToolCallId: context.parentCallId }),
+                    ...(context.waitInterrupt === undefined
+                        ? {}
+                        : { waitInterrupt: context.waitInterrupt }),
                     signal: context.signal
                 }, (operation) => coreExtensions.invoke(call, operation, roundBindings))));
-                return sources.withFrame(context, () => parentFrame === undefined ? invoke() : parentFrame(invoke));
+                return sources.withFrame(context, invoke);
             }
         };
         const recentImages = async () => {

package/dist/sdk/extension-models.js

@@ -16,6 +16,9 @@ export function createExtensionModels(state, createAdapter, activeAdapters, reso
                 maxOutputTokens: model.maxOutputTokens,
                 inputCapabilities: Object.freeze([...model.inputCapabilities]),
                 reasoningEfforts: Object.freeze([...model.reasoningEfforts]),
+                defaultReasoningEffort: model.defaultReasoningEffort,
+                conversationModel: model.conversationModel !== false,
+                subagentModel: model.subagentModel === true,
                 isDefault: model.id === defaultModelId
             })));
         },

package/dist/sdk/extension-session-launch.d.ts

@@ -3,7 +3,7 @@ import type { ExtensionOperationContext } from '../extensions/operation.js';
 import type { ExecutionMode, RunInput } from './types.js';
 import type { InternalExecutionHandle, InternalExecutionOptions } from './session-execution.js';
 /** Adapts committed Extension input to an independently owned Execution. */
-export declare function createExtensionSessionLaunch(sourceType: 'user' | 'subagent', start: (mode: ExecutionMode, input: RunInput, options: InternalExecutionOptions) => InternalExecutionHandle): (entry: SessionInputEntry, request: Exclude<ExtensionSessionRequest, {
+export declare function createExtensionSessionLaunch(start: (mode: ExecutionMode, input: RunInput, options: InternalExecutionOptions) => InternalExecutionHandle): (entry: SessionInputEntry, request: Exclude<ExtensionSessionRequest, {
     kind: "append";
 }>, call: ExtensionOperationContext) => Promise<InternalExecutionHandle & {
     inputCommitted: Promise<ExtensionSessionActionResult>;
@@ -14,5 +14,6 @@ export declare function extensionInputSource(call: ExtensionOperationContext, pr
     ownerInstanceId?: string;
     extensionId?: string;
     operationId: string;
-    actor: "model" | "sdk" | "extension" | "code-mode";
+    sessionId: string;
+    actor: "model" | "extension" | "sdk" | "code-mode";
 };

package/dist/sdk/extension-session-launch.js

@@ -2,10 +2,8 @@ import { AgentError } from '../error.js';
 import { DEFAULT_COMPACTION_FOCUS } from '../runtime/compaction/history.js';
 import { recordSessionInputCommit } from '../extensions/session-input.js';
 /** Adapts committed Extension input to an independently owned Execution. */
-export function createExtensionSessionLaunch(sourceType, start) {
+export function createExtensionSessionLaunch(start) {
     return async (entry, request, call) => {
-        if (sourceType !== 'user')
-            throw new AgentError('MAR_AGENT_SESSION_INPUT_UNAVAILABLE', 'Idle subagent input must use its task controller.');
         let resolveInput;
         let rejectInput;
         const inputCommitted = new Promise((resolve, reject) => {
@@ -64,6 +62,7 @@ export function createExtensionSessionLaunch(sourceType, start) {
 export function extensionInputSource(call, provenance, modelAttribution) {
     return {
         operationId: call.operationId,
+        sessionId: call.sessionId,
         actor: call.actor,
         ...(call.extensionId ? { extensionId: call.extensionId } : {}),
         ...(call.ownerInstanceId ? { ownerInstanceId: call.ownerInstanceId } : {}),

package/dist/sdk/extension-tools.js

@@ -38,8 +38,6 @@ export class ExecutionToolSources {
                             return false;
                         if (definition.name === 'skill')
                             return context.skills.size > 0;
-                        if (['agent_start', 'agent_wait', 'agent_message', 'agent_cancel'].includes(definition.name))
-                            return context.subagents !== undefined;
                         if (definition.name === 'tool_search')
                             return (this.#currentFrame()?.searchMcpTools !== undefined || this.#scope !== undefined);
                         return true;

package/dist/sdk/native-steer.d.ts

@@ -11,10 +11,10 @@ export declare function createNativeSteer(input: {
     isOpen(): boolean;
     operation<T>(action: (call: ExtensionOperationContext) => T): T;
     admit(content: ExtensionPromptInput, call: ExtensionOperationContext, write: (content: ExtensionPromptInput, call: ExtensionOperationContext) => Promise<ExtensionPromptResult>): Promise<unknown>;
-    receive(content: ExtensionPromptInput, clientMessageId: string, call: ExtensionOperationContext): Promise<SessionRecord>;
+    receive(content: ExtensionPromptInput, clientMessageId: string, call: ExtensionOperationContext, source?: import('../extensions/session-input.js').ExtensionInputSource): Promise<SessionRecord>;
     notify(entry: Extract<SteerResult, {
         status: 'accepted';
     }>['entry']): Promise<unknown>;
     diagnose(): void;
     wake(): void;
-}): (request: SteerInput) => Promise<SteerResult>;
+}): (request: SteerInput, source?: import('../extensions/session-input.js').ExtensionInputSource) => Promise<SteerResult>;

package/dist/sdk/native-steer.js

@@ -5,7 +5,7 @@ import { imageMetadata } from '../session/catalog.js';
 export function createNativeSteer(input) {
     const retries = new Map();
     let admissionTail = Promise.resolve();
-    return async (request) => {
+    return async (request, source) => {
         if (request.expectedExecutionId !== input.executionId)
             return Promise.resolve({ status: 'notAccepted' });
         const previous = retries.get(request.clientMessageId);
@@ -39,7 +39,7 @@ export function createNativeSteer(input) {
                 result.resolve({ status: 'notAccepted' });
                 return {};
             }
-            const record = await input.receive(actual, request.clientMessageId, effective);
+            const record = await input.receive(actual, request.clientMessageId, effective, source);
             committed = true;
             entry.nativeSteer.recordId = record.recordId;
             const payload = record.payload;

package/dist/sdk/session-composition.d.ts

@@ -1,28 +1,12 @@
 import type { AgentHost, HostDescription } from '../host/contracts.js';
 import type { ExtensionManager } from '../extensions/manager.js';
-import type { ExtensionOperationContext } from '../extensions/operation.js';
-import type { AgentReasoningEffort } from '../model/configuration.js';
 import type { ModelAdapter } from '../model/contracts.js';
 import type { SessionStore } from '../session/store/contracts.js';
-import type { SubagentMailboxMessage, SubagentMessageDelivery, SubagentTurnHandle } from '../subagent/session-controller.js';
 import type { ResolvedModelConfiguration } from './model-runtime.js';
 import type { SessionRegistry } from './session-registry.js';
 import type { SessionRuntime } from './session-runtime.js';
 import type { AgentSession, CreateAgentOptions } from './types.js';
-export interface InternalAgentSession extends AgentSession {
-    startSubagentTurn(input: {
-        readonly permissionMode?: import('../tools/permissions.js').PermissionMode;
-        readonly prompt: string;
-        readonly modelId: string;
-        readonly reasoningEffort: AgentReasoningEffort;
-        readonly role: 'general-purpose' | 'explore';
-        readonly initialMailbox: readonly SubagentMailboxMessage[];
-        readonly turnId: string;
-        readonly delivery?: SubagentMessageDelivery;
-        readonly mcpExecutionScopeId?: string;
-        readonly origin?: ExtensionOperationContext;
-    }): SubagentTurnHandle;
-}
+export type InternalAgentSession = AgentSession;
 /** Agent-owned resources and identities shared with Session orchestration. */
 export interface AgentSessionComposition {
     readonly activeExecutionAdapters: {
@@ -31,6 +15,7 @@ export interface AgentSessionComposition {
     };
     readonly sessionRuntimes: SessionRegistry<SessionRuntime>;
     readonly sessionWriterOwner: object;
+    readonly onExecutionRegistered: (runtime: SessionRuntime) => void;
 }
 export interface SessionServices {
     readonly host: AgentHost;

package/dist/sdk/session-execution-factory.d.ts

@@ -11,7 +11,7 @@ import type { ToolHost } from '../tools/runtime-context.js';
 import { type InternalExecutionHandle, type InternalExecutionOptions } from './session-execution.js';
 import { SessionRuntime } from './session-runtime.js';
 import type { CreateAgentOptions, ExecutionMode, RunInput } from './types.js';
-import type { AgentSessionComposition, InternalAgentSession, SessionServices } from './session-composition.js';
+import type { AgentSessionComposition, SessionServices } from './session-composition.js';
 /** Composes the execution-owned workflow from Session capabilities. */
 export declare function createSessionExecutionFactory(ports: {
     assertCanStart: SessionServices['assertCanStart'];
@@ -26,7 +26,7 @@ export declare function createSessionExecutionFactory(ports: {
     sessionWriterOwner: object;
     activeExecutionAdapters: AgentSessionComposition['activeExecutionAdapters'];
     sessionId: string;
-    sessionRuntime: Pick<SessionRuntime, 'assertCanExecute' | 'bindExecutionContext' | 'deactivateExecution' | 'joinRecordProjection' | 'registerExecution' | 'restoreExecutionState' | 'scheduleTool' | 'sessionBackend' | 'subagents' | 'unbindExecutionContext' | 'unregisterExecution' | 'updateContextualWorldState' | 'recordRequest' | 'completeRequest'>;
+    sessionRuntime: Pick<SessionRuntime, 'assertCanExecute' | 'bindExecutionContext' | 'deactivateExecution' | 'joinRecordProjection' | 'registerExecution' | 'publishEvent' | 'restoreExecutionState' | 'scheduleTool' | 'sessionBackend' | 'unbindExecutionContext' | 'unregisterExecution' | 'updateContextualWorldState' | 'recordRequest' | 'completeRequest'>;
     sessionSource: Awaited<ReturnType<SessionStore['getSession']>>['source'];
     logicalWorkspace: string;
     instructionWorkspace: string;
@@ -39,5 +39,4 @@ export declare function createSessionExecutionFactory(ports: {
     appendExtensionMessage(entry: SessionInputEntry, request: Extract<ExtensionSessionRequest, {
         kind: 'append';
     }>, call: ExtensionOperationContext): Promise<ExtensionSessionActionResult>;
-    startSubagentTurn(id: string, input: Parameters<InternalAgentSession['startSubagentTurn']>[0]): Promise<ReturnType<InternalAgentSession['startSubagentTurn']>>;
 }): (mode: ExecutionMode, input: RunInput, internal?: InternalExecutionOptions) => InternalExecutionHandle;

package/dist/sdk/session-execution-factory.js

@@ -1,6 +1,7 @@
 import { restoreMessages } from '../runtime/context/restore.js';
 import { latestModelUsage, reasoningEffortBaseline } from '../runtime/context/usage.js';
 import { publicModelUsage } from '../runtime/event-projection.js';
+import { truncateModelText } from '../runtime/token-budget.js';
 import { executeRoundTools } from '../tools/execution.js';
 import { rebindMcpToolSearchOutputs } from '../tools/mcp/history.js';
 import { ExecutionToolPermissions, projectPermissionTool, resolvePermissionMode, withToolPermissions } from '../tools/permissions.js';
@@ -24,6 +25,7 @@ import { ResourceInputProjection } from './resource-input.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { AgentError, describeAgentError } from '../error.js';
 import { transformCoreModelStream } from '../extensions/model-stream.js';
+import { SESSION_CONTEXT_PROVIDER } from '../extensions/session-context.js';
 import { invokeCorePromptSubmission } from '../extensions/prompt-input.js';
 import { prepareModelConfiguration } from '../model/request-configuration.js';
 import { MAR_AGENT_PROMPT_VERSION } from '../prompts/index.js';
@@ -38,12 +40,9 @@ import { loadAgentInstructions, renderAgentInstructions } from '../runtime/conte
 import { normalizeMessagesForModel } from '../runtime/context/normalize.js';
 import { compactSummaryFromCheckpoint } from '../session/record-projection.js';
 import { SessionExecution } from './session-execution.js';
-function restoreSubagentOrigin(origin) {
-    return { ...origin.correlation, signal: origin.signal };
-}
 /** Composes the execution-owned workflow from Session capabilities. */
 export function createSessionExecutionFactory(ports) {
-    const { assertCanStart, extensions: extensionManager, baseTools: extensionBaseTools, hasCustomAdapters, modelState, host, store, description, settings, sessionWriterOwner, activeExecutionAdapters, sessionId, sessionRuntime, sessionSource, logicalWorkspace, instructionWorkspace, currentEnvironment, buildSessionPromptSections, sessionAdapter, refreshSessionAdapters, sessionInputs, withRecordProjection, appendExtensionMessage, startSubagentTurn } = ports;
+    const { assertCanStart, extensions: extensionManager, baseTools: extensionBaseTools, hasCustomAdapters, modelState, host, store, description, settings, sessionWriterOwner, activeExecutionAdapters, sessionId, sessionRuntime, sessionSource, logicalWorkspace, instructionWorkspace, currentEnvironment, buildSessionPromptSections, sessionAdapter, refreshSessionAdapters, sessionInputs, withRecordProjection, appendExtensionMessage } = ports;
     const execution = (mode, input, internal = {}) => {
         assertCanStart(sessionId);
         sessionRuntime.assertCanExecute();
@@ -83,49 +82,6 @@ export function createSessionExecutionFactory(ports) {
         const manualCompactionId = mode === 'compact' ? randomUUID() : undefined;
         sessionRuntime.registerExecution(executionOwner);
         const inputs = sessionInputs();
-        const acceptParent = (message) => {
-            const origin = message.delivery?.origin === undefined
-                ? undefined
-                : restoreSubagentOrigin(message.delivery.origin);
-            const signal = AbortSignal.any([
-                controller.signal,
-                ...(message.delivery?.signal === undefined ? [] : [message.delivery.signal])
-            ]);
-            if (signal.aborted) {
-                message.delivery?.settled?.('cancelled');
-                return;
-            }
-            const accept = (call) => {
-                const entry = inputs.accept({ kind: 'submit', input: { text: message.text } }, call, (request, call, leaf) => leaf(request, call), 'accepted', message);
-                void entry.terminal.then(() => {
-                    if (entry.receipt.status === 'cancelled' || entry.receipt.status === 'failed')
-                        message.delivery?.settled?.(entry.receipt.status);
-                });
-            };
-            if (origin) {
-                accept(Object.freeze({
-                    ...origin,
-                    sessionId,
-                    sessionEpoch: extensionManager.session(sessionId)?.epoch ?? 0,
-                    signal,
-                    executionId,
-                    turnId
-                }));
-                return;
-            }
-            extensionManager.operations.enter({
-                sessionId,
-                sessionEpoch: extensionManager.session(sessionId)?.epoch ?? 0,
-                actor: 'sdk',
-                entry: 'native-api',
-                signal,
-                executionId,
-                turnId
-            }, accept);
-        };
-        for (const message of internal.initialMailbox ?? [])
-            acceptParent(message);
-        let acceptsMailbox = sessionSource.type === 'subagent' && mode !== 'compact';
         let acceptsSteer = false;
         let exhaustedModelAttempt;
         const eventPorts = {
@@ -143,6 +99,7 @@ export function createSessionExecutionFactory(ports) {
                         messageSources.set(message, stored);
                 }
             },
+            observe: (event) => sessionRuntime.publishEvent(event),
             ...(internal.publishHostEvents === false
                 ? {}
                 : { publish: (full) => host.emit(full) })
@@ -187,7 +144,6 @@ export function createSessionExecutionFactory(ports) {
         let releaseImageBytes;
         const contextGc = new ContextGcRuntime();
         let selectedAdapter;
-        const subagents = sessionSource.type === 'user' ? sessionRuntime.subagents : undefined;
         executionOwner.start({
             scope: (run) => withToolPermissions(permissionPolicy, run),
             prepareProgram: async () => {
@@ -255,14 +211,13 @@ export function createSessionExecutionFactory(ports) {
                 let smartInput;
                 let compactContext;
                 let startCompact;
-                const { startInitialInput, receiveSteer, appendSubagentUpdates, appendMailboxMessages } = createExecutionInput({
+                const { startInitialInput, receiveSteer, appendExtensionContext, appendMailboxMessages } = createExecutionInput({
                     host,
                     store,
                     sessionId,
                     executionId,
                     turnId,
                     mode,
-                    source: sessionSource.type,
                     controller,
                     inputs,
                     messages,
@@ -320,49 +275,6 @@ export function createSessionExecutionFactory(ports) {
                 const initialSmartTokens = latestSmartContextTokens(contextRecords, selectedModel.id, selectedModel.contextWindowTokens);
                 const compactUserTokenLimit = Math.min(20_000, Math.floor(selectedModel.contextWindowTokens / 8));
                 const reasoningEffort = input.reasoningEffort ?? selectedModel.defaultReasoningEffort;
-                if (mode !== 'compact' && subagents)
-                    await subagents.beginParentExecution({
-                        executionId,
-                        modelId: selectedModel.id,
-                        reasoningEffort,
-                        models: executionModels,
-                        emitTerminal: async (task) => emit({
-                            type: 'subagent.completed',
-                            agentId: task.agentId,
-                            description: task.description,
-                            status: task.status,
-                            ...(task.permissionStop === undefined
-                                ? {}
-                                : { permissionStop: task.permissionStop }),
-                            ...(task.modelId === undefined ? {} : { modelId: task.modelId }),
-                            ...(task.modelName === undefined ? {} : { modelName: task.modelName }),
-                            ...(task.reasoningEffort === undefined
-                                ? {}
-                                : { reasoningEffort: task.reasoningEffort }),
-                            ...(task.latestMessage === undefined ? {} : { latestMessage: task.latestMessage }),
-                            ...(task.latestActivity === undefined
-                                ? {}
-                                : { latestActivity: task.latestActivity }),
-                            ...(task.errorCode === undefined ? {} : { errorCode: task.errorCode }),
-                            ...(task.errorMessage === undefined ? {} : { errorMessage: task.errorMessage })
-                        }),
-                        startTurn: async (turn) => {
-                            return startSubagentTurn(turn.sessionId, {
-                                permissionMode: permissionPolicy.mode,
-                                prompt: turn.prompt,
-                                modelId: turn.modelId,
-                                reasoningEffort: turn.reasoningEffort,
-                                role: turn.role,
-                                initialMailbox: turn.initialMailbox,
-                                turnId: turn.turnId,
-                                ...(turn.origin === undefined
-                                    ? {}
-                                    : { origin: restoreSubagentOrigin(turn.origin) }),
-                                mcpExecutionScopeId: executionId,
-                                ...(turn.delivery ? { delivery: turn.delivery } : {})
-                            });
-                        }
-                    });
                 const catalogContext = {
                     sessionId,
                     executionId,
@@ -472,17 +384,21 @@ export function createSessionExecutionFactory(ports) {
                 toolCatalog.refresh();
                 const restoreMcpDiscovery = () => toolCatalog.restore();
                 const loadRetainedSessionResources = async () => {
-                    await subagents?.prepareSessionResources(controller.signal);
                     const hostResources = (await host.listSessionResources?.(sessionId)) ?? {
                         processes: []
                     };
+                    const provider = coreExtensions.services.resolve(SESSION_CONTEXT_PROVIDER);
+                    const extensions = (await provider?.resources?.(controller.signal)) ?? [];
+                    controller.signal.throwIfAborted();
                     return {
                         ...(hostResources.idleTtlMs === undefined
                             ? {}
                             : { idleTtlMs: hostResources.idleTtlMs }),
                         processes: hostResources.processes,
                         ...(hostResources.codeCells ? { codeCells: hostResources.codeCells } : {}),
-                        subagents: subagents?.listSessionResources() ?? []
+                        extensions: extensions
+                            .slice(0, 8)
+                            .map((value) => truncateModelText(value, 32768, 'extension resource').content)
                     };
                 };
                 await modelContext.initializeWorldState();
@@ -520,7 +436,6 @@ export function createSessionExecutionFactory(ports) {
                     todo,
                     waitInterrupt,
                     skills: instructionContext?.skills ?? new Map(),
-                    subagents,
                     coreExtensions,
                     operations: extensionManager.operations,
                     scheduleTool: sessionRuntime.scheduleTool,
@@ -665,7 +580,6 @@ export function createSessionExecutionFactory(ports) {
                             workspace: logicalWorkspace,
                             platform: description.platform
                         },
-                        child: sessionSource.type === 'subagent',
                         start: (value) => startCompact(value),
                         wait: (value) => compactContext(value),
                         activeProcesses: async () => {
@@ -760,10 +674,12 @@ export function createSessionExecutionFactory(ports) {
                         return;
                     }
                     const prepareRound = createExecutionRoundPreparer({
-                        prepareInputs: (includeSubagentUpdates) => contextCoordinator.prepareInputs({
-                            includeSubagentUpdates,
+                        prepareInputs: (includeSessionContext) => contextCoordinator.prepareInputs({
+                            includeSessionContext,
                             appendMailbox: appendMailboxMessages,
-                            appendSubagentUpdates: () => appendSubagentUpdates(subagents),
+                            appendSessionContext: async () => {
+                                await appendExtensionContext(coreExtensions.services.resolve(SESSION_CONTEXT_PROVIDER));
+                            },
                             refreshTools: () => {
                                 updateMcpRegistry();
                                 toolCatalog.refresh();
@@ -807,9 +723,7 @@ export function createSessionExecutionFactory(ports) {
                         },
                         prepareResources: async ({ candidateRequest, request, toolScope }) => {
                             resourceInput.observe(candidateRequest.messages);
-                            const media = sessionSource.type === 'subagent'
-                                ? undefined
-                                : await resourceInput.gcCandidate(request, candidateRequest.images);
+                            const media = await resourceInput.gcCandidate(request, candidateRequest.images);
                             if (media?.reason === 'HARD_LIMIT') {
                                 const committed = await contextCoordinator.gc({ request, toolScope }, modelLifecycle.usage, media);
                                 if (committed)
@@ -854,7 +768,6 @@ export function createSessionExecutionFactory(ports) {
                             hasPending: () => inputs.hasBoundaryPending && !inputs.executing,
                             append: appendMailboxMessages,
                             close: () => {
-                                acceptsMailbox = false;
                                 acceptsSteer = false;
                             }
                         }
@@ -881,7 +794,6 @@ export function createSessionExecutionFactory(ports) {
                 };
             },
             beforeFailure: async (error) => {
-                acceptsMailbox = false;
                 acceptsSteer = false;
                 executionOwner.stopSteer();
                 await sessionRuntime.joinRecordProjection();
@@ -890,21 +802,20 @@ export function createSessionExecutionFactory(ports) {
             },
             diagnostic: (error) => modelAttemptFailureDiagnostic(describeAgentError(error, 'MAR_AGENT_EXECUTION_FAILED'), exhaustedModelAttempt),
             emit,
-            endParent: () => subagents?.endParentExecution(executionId),
+            endParent: () => { },
             finalize: (failed) => executionOwner.finish({
                 failed,
                 reason: controller.signal.reason ?? new AgentError('MAR_AGENT_CANCELLED', 'Execution ended.'),
                 releaseImageBytes: () => releaseImageBytes?.(),
                 revokeBindings: () => {
                     executionOwner.revokeViews(new AgentError('MAR_AGENT_CANCELLED', 'Execution ended.'));
-                    acceptsMailbox = false;
                 },
                 closeToolSources: () => {
                     executionToolSources?.close();
                     executionOwner.detachToolSources();
                 },
                 detachAbort: () => internal.signal?.removeEventListener('abort', abortSource),
-                endParent: () => subagents?.endParentExecution(executionId),
+                endParent: () => { },
                 deactivate: () => {
                     sessionRuntime.unbindExecutionContext(executionContext);
                     sessionRuntime.deactivateExecution(executionOwner);
@@ -916,12 +827,7 @@ export function createSessionExecutionFactory(ports) {
                 sessionRuntime.unregisterExecution(executionOwner);
             }
         });
-        return executionOwner.handle((message, delivery) => {
-            if (!acceptsMailbox || controller.signal.aborted)
-                return false;
-            acceptParent({ text: message, ...(delivery ? { delivery } : {}) });
-            return true;
-        });
+        return executionOwner.handle();
     };
     return execution;
 }

package/dist/sdk/session-execution.d.ts

@@ -1,5 +1,4 @@
 import type { ExtensionInputSource } from '../extensions/session-input.js';
-import type { SubagentMailboxMessage } from '../subagent/session-controller.js';
 import { AsyncQueue } from '../runtime/async-queue.js';
 import { ExecutionLoop } from '../runtime/execution.js';
 import type { RoundToolScope } from '../tools/execution.js';
@@ -7,7 +6,6 @@ import { CompactCoordinator } from '../runtime/compaction/coordinator.js';
 import { CompactRequests } from '../runtime/compaction/requests.js';
 import type { ExecutionMode, ExecutionResult, AgentEvent } from './types.js';
 import type { ModelAdapter, ModelTurnSession } from '../model/contracts.js';
-import type { SubagentMessageDelivery } from '../subagent/session-controller.js';
 import type { SessionModelMessage } from '../session/model-request.js';
 import type { ExecutionToolSources } from './extension-tools.js';
 import type { ExecutionHandle } from './types.js';
@@ -23,15 +21,12 @@ export interface InternalExecutionOptions {
     readonly modelText?: string;
     readonly inputContext?: readonly string[];
     readonly modelContext?: readonly string[];
-    readonly initialMailbox?: readonly SubagentMailboxMessage[];
     readonly turnId?: string;
-    readonly delivery?: SubagentMessageDelivery;
     readonly mcpExecutionScopeId?: string;
 }
 export interface InternalExecutionHandle extends ExecutionHandle {
     readonly persistedEvents: boolean;
     readonly turnId: string;
-    enqueueMessage(message: string, delivery?: SubagentMessageDelivery): boolean;
 }
 export interface SessionExecutionContext {
     readonly executionId: string;
@@ -39,7 +34,7 @@ export interface SessionExecutionContext {
     readonly mode: ExecutionMode;
     readonly models: ReadonlyMap<string, ResolvedModelConfiguration>;
     readonly instruction: string | undefined;
-    readonly steer?: ((input: import('./types.js').SteerInput) => Promise<import('./types.js').SteerResult>) | undefined;
+    readonly steer?: ((input: import('./types.js').SteerInput, source?: import('../extensions/session-input.js').ExtensionInputSource) => Promise<import('./types.js').SteerResult>) | undefined;
     readonly compactRequests?: CompactRequests | undefined;
     readonly requestMessages?: {
         read(): readonly SessionModelMessage[];
@@ -52,6 +47,7 @@ export interface SessionExecutionContext {
 export type ExecutionEventPayload<T = AgentEvent> = T extends AgentEvent ? Omit<T, 'eventId' | 'sequence' | 'timestamp' | 'sessionId' | 'executionId' | 'turnId'> : never;
 export interface ExecutionEventPorts {
     persist(event: AgentEvent, payload: AgentEvent): Promise<void>;
+    observe?(event: AgentEvent): void;
     publish?(event: AgentEvent): void | Promise<void>;
     hasRetainedLease?(): boolean;
 }
@@ -80,6 +76,16 @@ export declare class SessionExecution {
         readonly generation: number;
         readonly instruction: string | undefined;
     };
+    get observedTerminal(): (import("./types.js").AgentEventBase & {
+        type: "execution.completed";
+        permissionStop?: import("../host.js").PermissionStop;
+    }) | (import("./types.js").AgentEventBase & {
+        type: "execution.failed";
+        code: string;
+        message?: string;
+    }) | (import("./types.js").AgentEventBase & {
+        type: "execution.cancelled";
+    }) | undefined;
     bindViews(views: Partial<Pick<SessionExecutionContext, 'requestMessages' | 'appendedMessages' | 'toolSources'>>): void;
     acceptSteer(steer: NonNullable<SessionExecutionContext['steer']>): void;
     stopSteer(): void;
@@ -157,7 +163,7 @@ export declare class SessionExecution {
         readonly settle: (status: ExecutionResult['status']) => void;
     }): void;
     join(): Promise<ExecutionResult> | undefined;
-    handle(enqueueMessage: (message: string, delivery?: SubagentMessageDelivery) => boolean): InternalExecutionHandle;
+    handle(): InternalExecutionHandle;
     cancel(reason?: unknown): void;
 }
 export {};