@myagentroam/agent 0.11.6 → 0.11.8

package/dist/agent-core/model/anthropic-messages.js

@@ -317,7 +317,12 @@ export class AnthropicMessagesAdapter {
                             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Anthropic returned an invalid or oversized native thinking block.');
                         thinkingBytes += Buffer.byteLength(JSON.stringify(item));
                         assertAnthropicThinkingBudget(thinkingBytes);
-                        yield observeModelStreamEvent({ type: 'response.item', provider: 'ANTHROPIC_MESSAGES', item }, modelStreamEventObservedAt(raw));
+                        yield observeModelStreamEvent({
+                            type: 'response.item',
+                            provider: 'ANTHROPIC_MESSAGES',
+                            contextKind: 'private',
+                            item
+                        }, modelStreamEventObservedAt(raw));
                     }
                     if (block.type === 'thinking' && block.text.trim())
                         yield observeModelStreamEvent({

package/dist/agent-core/model/contracts.d.ts

@@ -149,6 +149,7 @@ export type ModelEvent = {
 } | {
     type: 'response.item';
     provider: 'OPENAI_RESPONSES' | 'ANTHROPIC_MESSAGES';
+    contextKind?: ModelMessage['contextKind'];
     item: Record<string, unknown>;
 } | {
     type: 'text.delta';

package/dist/agent-core/model/native-context.d.ts

@@ -0,0 +1,3 @@
+import type { ModelMessage } from './contracts.js';
+/** Interpret only the existing native context record shapes and their model ownership. */
+export declare function restoreNativeModelContext(payload: Record<string, unknown>, activeModelId?: string): ModelMessage | undefined;

package/dist/agent-core/model/native-context.js

@@ -0,0 +1,44 @@
+import { anthropicThinkingBlock } from './anthropic-thinking.js';
+/** Interpret only the existing native context record shapes and their model ownership. */
+export function restoreNativeModelContext(payload, activeModelId) {
+    const modelId = typeof payload.providerModelId === 'string' && payload.providerModelId.length > 0
+        ? payload.providerModelId
+        : undefined;
+    const contextKind = nativeContextKind(payload.contextKind);
+    if (payload.provider === 'ANTHROPIC_MESSAGES') {
+        const item = anthropicThinkingBlock(payload.item);
+        return item && modelId
+            ? {
+                role: 'provider',
+                content: '',
+                provider: 'ANTHROPIC_MESSAGES',
+                providerModelId: modelId,
+                contextKind: contextKind ?? 'private',
+                item
+            }
+            : undefined;
+    }
+    if (payload.provider !== 'OPENAI_RESPONSES' ||
+        !payload.item ||
+        typeof payload.item !== 'object' ||
+        Array.isArray(payload.item))
+        return undefined;
+    const restoredModelId = modelId ?? activeModelId;
+    return {
+        role: 'provider',
+        content: '',
+        provider: 'OPENAI_RESPONSES',
+        ...(restoredModelId === undefined ? {} : { providerModelId: restoredModelId }),
+        ...(contextKind === undefined ? {} : { contextKind }),
+        item: payload.item
+    };
+}
+function nativeContextKind(value) {
+    return value === 'environment' ||
+        value === 'private' ||
+        value === 'contextual' ||
+        value === 'summary' ||
+        value === 'compact_control'
+        ? value
+        : undefined;
+}

package/dist/agent-core/model/request-configuration.d.ts

@@ -0,0 +1,17 @@
+import { type MarAgentModelConfiguration, type MarAgentReasoningEffort } from './configuration.js';
+import type { ModelMessage } from './contracts.js';
+/** Resolve request effort and native updates without owning their persistence or timing. */
+export declare function prepareModelConfiguration(model: Pick<MarAgentModelConfiguration, 'id' | 'protocol' | 'responsesConfigurationUpdates' | 'codexCredential'>, effort: MarAgentReasoningEffort, context: {
+    readonly baselineEffort: MarAgentReasoningEffort | undefined;
+    readonly messages: readonly ModelMessage[];
+    readonly checkpointAdopted?: false;
+} | {
+    readonly checkpointAdopted: true;
+}): {
+    readonly requestReasoningEffort?: MarAgentReasoningEffort;
+    readonly updates: readonly ModelMessage[];
+    readonly contextProjection: {
+        readonly modelProtocol: MarAgentModelConfiguration['protocol'];
+        readonly responsesConfigurationUpdates: boolean;
+    };
+};

package/dist/agent-core/model/request-configuration.js

@@ -0,0 +1,47 @@
+import { marAgentReasoningEffortSchema, usesResponsesConfigurationUpdates } from './configuration.js';
+/** Resolve request effort and native updates without owning their persistence or timing. */
+export function prepareModelConfiguration(model, effort, context) {
+    const useUpdates = usesResponsesConfigurationUpdates(model);
+    const contextProjection = {
+        modelProtocol: model.protocol,
+        responsesConfigurationUpdates: useUpdates
+    };
+    if (context.checkpointAdopted)
+        return { requestReasoningEffort: effort, updates: [], contextProjection };
+    if (!useUpdates)
+        return { updates: [], contextProjection };
+    const requestReasoningEffort = context.baselineEffort ?? effort;
+    const effectiveEffort = context.baselineEffort === undefined
+        ? requestReasoningEffort
+        : (lastConfigurationEffort(context.messages, model.id) ?? requestReasoningEffort);
+    return {
+        requestReasoningEffort,
+        contextProjection,
+        updates: effectiveEffort === effort
+            ? []
+            : [
+                {
+                    role: 'provider',
+                    content: '',
+                    provider: 'OPENAI_RESPONSES',
+                    providerModelId: model.id,
+                    item: { type: 'configuration_update', reasoning: { effort } }
+                }
+            ]
+    };
+}
+function lastConfigurationEffort(messages, modelId) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role !== 'provider' ||
+            message.provider !== 'OPENAI_RESPONSES' ||
+            message.providerModelId !== modelId ||
+            message.item?.type !== 'configuration_update')
+            continue;
+        const reasoning = message.item.reasoning;
+        const effort = marAgentReasoningEffortSchema.safeParse(reasoning?.effort);
+        if (effort.success)
+            return effort.data;
+    }
+    return undefined;
+}

package/dist/agent-core/model/tool-declarations.d.ts

@@ -0,0 +1,4 @@
+import type { MarAgentModelConfiguration } from './configuration.js';
+import type { ClientToolDefinition } from './contracts.js';
+/** Native Responses discovery carries deferred definitions in history, not the top-level catalog. */
+export declare function projectModelRequestTools(model: Pick<MarAgentModelConfiguration, 'protocol'>, tools: readonly ClientToolDefinition[], residentNames: ReadonlySet<string>): readonly ClientToolDefinition[];

package/dist/agent-core/model/tool-declarations.js

@@ -0,0 +1,6 @@
+/** Native Responses discovery carries deferred definitions in history, not the top-level catalog. */
+export function projectModelRequestTools(model, tools, residentNames) {
+    return model.protocol === 'OPENAI_RESPONSES'
+        ? tools.filter((tool) => residentNames.has(tool.name))
+        : tools;
+}

package/dist/agent-core/runtime/context/projection.js

@@ -1,4 +1,4 @@
-import { anthropicThinkingBlock } from '../../model/anthropic-thinking.js';
+import { restoreNativeModelContext } from '../../model/native-context.js';
 import { appliedInputRecord } from '../../session/deferred-input.js';
 import { inputMetadataFromRecord } from '../../session/store/index.js';
 import { contextGcTargetKey, latestValidContextGcCheckpoint } from '../../session/context-gc-checkpoint.js';
@@ -227,34 +227,8 @@ export function restoreModelContext(payload, providerModelId) {
                 ? { inputMode: payload.inputMode }
                 : {})
         };
-    if (payload.role === 'provider' && payload.provider === 'ANTHROPIC_MESSAGES') {
-        const item = anthropicThinkingBlock(payload.item);
-        const modelId = modelIdFromPayload(payload, 'providerModelId');
-        return item && modelId
-            ? {
-                role: 'provider',
-                provider: 'ANTHROPIC_MESSAGES',
-                providerModelId: modelId,
-                contextKind: 'private',
-                content: '',
-                item
-            }
-            : undefined;
-    }
-    if (payload.role === 'provider' &&
-        payload.provider === 'OPENAI_RESPONSES' &&
-        isRecord(payload.item)) {
-        const restoredProviderModelId = modelIdFromPayload(payload, 'providerModelId') ?? providerModelId;
-        return {
-            role: 'provider',
-            content: '',
-            provider: 'OPENAI_RESPONSES',
-            ...(restoredProviderModelId === undefined
-                ? {}
-                : { providerModelId: restoredProviderModelId }),
-            item: payload.item
-        };
-    }
+    if (payload.role === 'provider')
+        return restoreNativeModelContext(payload, providerModelId);
     return undefined;
 }
 export function providerToolCallId(message) {

package/dist/agent-core/runtime/context/usage.d.ts

@@ -8,7 +8,6 @@ export interface AuthoritativeModelUsage {
 }
 export declare function latestModelUsage(records: readonly import('../../session/store/index.js').SessionRecord[], selectedModelId: string): AuthoritativeModelUsage | undefined;
 export declare function reasoningEffortBaseline(records: readonly import('../../session/store/index.js').SessionRecord[], modelId: string): MarAgentReasoningEffort | undefined;
-export declare function lastConfigurationEffort(messages: readonly ModelMessage[], modelId: string): MarAgentReasoningEffort | undefined;
 export declare function shouldUseNativeCompaction(input: {
     readonly estimatedRequestTokens: number;
     readonly contextWindowTokens: number;

package/dist/agent-core/runtime/context/usage.js

@@ -82,21 +82,6 @@ export function reasoningEffortBaseline(records, modelId) {
     }
     return baseline;
 }
-export function lastConfigurationEffort(messages, modelId) {
-    for (let index = messages.length - 1; index >= 0; index--) {
-        const message = messages[index];
-        if (message.role !== 'provider' ||
-            message.provider !== 'OPENAI_RESPONSES' ||
-            message.providerModelId !== modelId ||
-            message.item?.type !== 'configuration_update')
-            continue;
-        const reasoning = message.item.reasoning;
-        const effort = marAgentReasoningEffortSchema.safeParse(reasoning?.effort);
-        if (effort.success)
-            return effort.data;
-    }
-    return undefined;
-}
 export function shouldUseNativeCompaction(input) {
     if (input.estimatedRequestTokens <= input.contextWindowTokens)
         return true;

package/dist/agent-core/runtime/execution.js

@@ -132,9 +132,7 @@ export class ExecutionLoop {
                             content: '',
                             provider: event.provider,
                             providerModelId: input.model.id,
-                            ...(event.provider === 'ANTHROPIC_MESSAGES'
-                                ? { contextKind: 'private' }
-                                : {}),
+                            ...(event.contextKind === undefined ? {} : { contextKind: event.contextKind }),
                             item: event.item
                         };
                         messages.push(message);

package/dist/agent-core/sdk/model-runtime.d.ts

@@ -9,5 +9,10 @@ export declare function resolveAgentModels(configurations: readonly MarAgentMode
     readonly credentialProviders: Set<ModelCredentialProvider>;
 };
 export declare function createModelTurnSession(adapter: ModelAdapter): ModelTurnSession;
+/** Owns only one Execution's model turn and explicitly transferred adapters. */
+export declare function createExecutionModelResources(activeAdapters: Set<ModelAdapter>): {
+    openTurn(adapter: ModelAdapter, ownsAdapter: boolean): ModelTurnSession;
+    close(): Promise<void>;
+};
 export declare function closeModelAdapters(adapters: Iterable<ModelAdapter>): Promise<void>;
 export declare function addModelCredentialProviders(target: Set<ModelCredentialProvider>, configuration: MarAgentModelConfiguration): void;

package/dist/agent-core/sdk/model-runtime.js

@@ -51,6 +51,34 @@ export function createModelTurnSession(adapter) {
         close: () => turn.close()
     };
 }
+/** Owns only one Execution's model turn and explicitly transferred adapters. */
+export function createExecutionModelResources(activeAdapters) {
+    let turn;
+    const ownedAdapters = new Set();
+    return {
+        openTurn(adapter, ownsAdapter) {
+            if (ownsAdapter) {
+                ownedAdapters.add(adapter);
+                activeAdapters.add(adapter);
+            }
+            turn = createModelTurnSession(adapter);
+            return turn;
+        },
+        async close() {
+            await turn?.close().catch(() => undefined);
+            try {
+                await closeModelAdapters(ownedAdapters);
+            }
+            catch {
+                // Model cleanup must not replace the Execution result.
+            }
+            finally {
+                for (const adapter of ownedAdapters)
+                    activeAdapters.delete(adapter);
+            }
+        }
+    };
+}
 export async function closeModelAdapters(adapters) {
     const results = await Promise.allSettled([...new Set(adapters)].flatMap((adapter) => adapter.close === undefined ? [] : [adapter.close()]));
     const failure = results.find((result) => result.status === 'rejected');

package/dist/agent-core/sdk/request-preparation.d.ts

@@ -0,0 +1,7 @@
+import type { MarAgentModelConfiguration } from '../model/configuration.js';
+import type { ClientToolDefinition, ModelMessage, ModelRequest } from '../model/contracts.js';
+import { type ContextualWorldState } from '../runtime/context/world-state.js';
+/** Assemble captured round values only. Admission, Hooks and publication belong to Session. */
+export declare function prepareSessionModelRequest(candidate: ModelRequest, model: Pick<MarAgentModelConfiguration, 'protocol' | 'inputCapabilities'>, entries: ContextualWorldState['entries'], residentTools: readonly ClientToolDefinition[], autoPermission: boolean): ModelRequest;
+/** The actual candidate and current Session view share the same side-effect-free projection. */
+export declare function projectSessionRequestMessages(messages: readonly ModelMessage[], entries: ContextualWorldState['entries'], supportsImages: boolean, codeMode: boolean, autoPermission?: boolean): ModelMessage[];

package/dist/agent-core/sdk/request-preparation.js

@@ -0,0 +1,23 @@
+import { projectModelRequestTools } from '../model/tool-declarations.js';
+import { projectSmartCompactionMessage } from '../runtime/compaction/smart.js';
+import { normalizeMessagesForModel } from '../runtime/context/normalize.js';
+import { insertContextualWorldState } from '../runtime/context/world-state.js';
+import { projectCodeModeSearchResult, projectCodeModeTools } from '../tools/code-mode/index.js';
+import { projectPermissionTool } from '../tools/permissions.js';
+/** Assemble captured round values only. Admission, Hooks and publication belong to Session. */
+export function prepareSessionModelRequest(candidate, model, entries, residentTools, autoPermission) {
+    const codeMode = candidate.tools.some((tool) => tool.name === 'code_exec');
+    return {
+        ...candidate,
+        messages: projectSessionRequestMessages(candidate.messages, entries, model.inputCapabilities.includes('IMAGE'), codeMode, autoPermission),
+        tools: projectModelRequestTools(model, projectCodeModeTools(candidate.tools, residentTools), new Set(residentTools.map((tool) => tool.name)))
+    };
+}
+/** The actual candidate and current Session view share the same side-effect-free projection. */
+export function projectSessionRequestMessages(messages, entries, supportsImages, codeMode, autoPermission = false) {
+    return normalizeMessagesForModel(insertContextualWorldState(messages, entries), {
+        supportsImages
+    }).map((message) => projectCodeModeSearchResult(autoPermission && message.toolSearchTools
+        ? { ...message, toolSearchTools: message.toolSearchTools.map(projectPermissionTool) }
+        : projectSmartCompactionMessage(message), codeMode));
+}

package/dist/agent-core/sdk/session.d.ts

@@ -7,7 +7,7 @@ import { ExtensionRequestSnapshots } from '../extensions/model-request.js';
 import { SessionInputCoordinator, type CoreSessionBackend } from '../extensions/session-input.js';
 import type { CoreAgentsBackend } from '../extensions/agents.js';
 import type { HostDescription, MarAgentHost } from '../host/contracts.js';
-import { type MarAgentReasoningEffort } from '../model/configuration.js';
+import type { MarAgentReasoningEffort } from '../model/configuration.js';
 import type { ModelAdapter, ModelMessage } from '../model/contracts.js';
 import { CompactRequests } from '../runtime/compaction/requests.js';
 import { JsonlSessionStore } from '../session/store/index.js';

package/dist/agent-core/sdk/session.js

@@ -1,11 +1,12 @@
 import { restoreMessages } from '../runtime/context/restore.js';
 import { createNativeSteer } from './native-steer.js';
-import { lastConfigurationEffort, latestModelUsage, reasoningEffortBaseline } from '../runtime/context/usage.js';
+import { latestModelUsage, reasoningEffortBaseline } from '../runtime/context/usage.js';
 import { splitContextualPrompt } from '../runtime/context/contextual-blocks.js';
-import { contextualInstructionInsertIndex, insertContextualWorldState, latestContextualWorldStateGeneration, parsePersistedContextualWorldState, persistContextualWorldState, resetContextualWorldState, updateContextualWorldState, updatePromptWorldState } from '../runtime/context/world-state.js';
+import { contextualInstructionInsertIndex, latestContextualWorldStateGeneration, parsePersistedContextualWorldState, persistContextualWorldState, resetContextualWorldState, updateContextualWorldState, updatePromptWorldState } from '../runtime/context/world-state.js';
 import { eventForPersistence, publicModelUsage } from '../runtime/event-projection.js';
 import { ExecutionLoop } from '../runtime/execution.js';
-import { closeModelAdapters, createModelTurnSession } from './model-runtime.js';
+import { closeModelAdapters, createExecutionModelResources, createModelTurnSession } from './model-runtime.js';
+import { prepareSessionModelRequest, projectSessionRequestMessages } from './request-preparation.js';
 import { createSubagentBackend } from './subagent-backend.js';
 import { ExecutionToolPermissions, projectPermissionTool, resolvePermissionMode, withToolPermissions } from '../tools/permissions.js';
 import { createToolWaitInterrupt } from '../tools/wait.js';
@@ -24,7 +25,7 @@ import { createExtensionAgentsBackend } from './extension-agents.js';
 import { coreMcpCatalog } from '../extensions/mcp.js';
 import { isDeepStrictEqual } from 'node:util';
 import { MarAgentError, describeMarAgentError } from '../error.js';
-import { usesResponsesConfigurationUpdates } from '../model/configuration.js';
+import { prepareModelConfiguration } from '../model/request-configuration.js';
 import { autoPermissionPrompt } from '../prompts/permissions.js';
 import { MAR_AGENT_PROMPT_VERSION, buildSystemPromptSections } from '../prompts/index.js';
 import { renderPromptSections } from '../extensions/prompt-composition.js';
@@ -43,12 +44,11 @@ import { ContextGcRuntime } from '../runtime/context/gc-runtime.js';
 import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
 import { loadAgentInstructions, renderAgentInstructions } from '../runtime/context/instructions.js';
 import { normalizeMessagesForModel } from '../runtime/context/normalize.js';
-import { latestSmartContextTokens, projectSmartCompactionMessage, requestSmartCompaction } from '../runtime/compaction/smart.js';
+import { latestSmartContextTokens, requestSmartCompaction } from '../runtime/compaction/smart.js';
 import { compactSummaryFromCheckpoint, inputMetadataFromRecord } from '../session/store/index.js';
 import { SubagentSessionController } from '../subagent/session-controller.js';
 import { agentStartToolDefinitionWithModels } from '../tools/agent/agent-start.js';
 import { allowsDirectTool, allowsToolCaller, toolCallers } from '../tools/callers.js';
-import { projectCodeModeSearchResult, projectCodeModeTools } from '../tools/code-mode/index.js';
 import { assertMcpToolCatalog } from '../tools/mcp/catalog.js';
 import { BUILTIN_TOOL_DEFINITIONS } from '../tools/registry.js';
 import { createSessionToolScheduler } from '../tools/scheduler.js';
@@ -362,10 +362,9 @@ export function createSessionOpener(services) {
                 let finalAnswer = '';
                 let executionLoop;
                 let executionToolSources;
-                let selectedTurn;
                 const contextGc = new ContextGcRuntime();
                 let selectedAdapter;
-                const executionScopedAdapters = new Set();
+                const modelResources = createExecutionModelResources(activeExecutionAdapters);
                 const subagents = sessionSource.type === 'user' ? sessionRuntime.subagents : undefined;
                 try {
                     controller.signal.throwIfAborted();
@@ -767,28 +766,11 @@ export function createSessionOpener(services) {
                         });
                     selectedAdapter = sessionAdapter(input.modelId ?? executionDefaultModelId, executionModels);
                     const selectedModel = executionModels.get(input.modelId ?? executionDefaultModelId);
-                    if (services.hasCustomAdapters && selectedAdapter.createTurnSession === undefined) {
-                        executionScopedAdapters.add(selectedAdapter);
-                        activeExecutionAdapters.add(selectedAdapter);
-                    }
-                    const selected = createModelTurnSession(selectedAdapter);
-                    selectedTurn = selected;
+                    const selected = modelResources.openTurn(selectedAdapter, services.hasCustomAdapters && selectedAdapter.createTurnSession === undefined);
                     let lastServerUsage = latestModelUsage(contextRecords, selectedModel.id);
                     let smartContextTokens = latestSmartContextTokens(contextRecords, selectedModel.id, selectedModel.contextWindowTokens);
                     const compactUserTokenLimit = Math.min(20_000, Math.floor(selectedModel.contextWindowTokens / 8));
                     const reasoningEffort = input.reasoningEffort ?? selectedModel.defaultReasoningEffort;
-                    const useEffortUpdates = usesResponsesConfigurationUpdates(selectedModel);
-                    const previousReasoningEffort = useEffortUpdates
-                        ? reasoningEffortBaseline(contextRecords, selectedModel.id)
-                        : undefined;
-                    let requestReasoningEffort = useEffortUpdates
-                        ? (previousReasoningEffort ?? reasoningEffort)
-                        : undefined;
-                    let effectiveReasoningEffort = useEffortUpdates
-                        ? previousReasoningEffort === undefined
-                            ? requestReasoningEffort
-                            : (lastConfigurationEffort(messages, selectedModel.id) ?? requestReasoningEffort)
-                        : undefined;
                     if (mode !== 'compact' && subagents)
                         await subagents.beginParentExecution({
                             executionId,
@@ -1310,25 +1292,21 @@ export function createSessionOpener(services) {
                             diagnose: () => coreExtensions.diagnose({ code: 'MAR_AGENT_STEER_POST_COMMIT_FAILED', sessionId })
                         });
                     }
-                    if (mode !== 'compact' &&
-                        useEffortUpdates &&
-                        effectiveReasoningEffort !== reasoningEffort) {
-                        const update = {
-                            role: 'provider',
-                            content: '',
-                            provider: 'OPENAI_RESPONSES',
-                            providerModelId: selectedModel.id,
-                            item: { type: 'configuration_update', reasoning: { effort: reasoningEffort } }
-                        };
-                        messages.push(update);
-                        await store.append(sessionId, {
-                            type: 'model.context',
-                            payload: update,
-                            executionId,
-                            turnId
-                        });
-                        effectiveReasoningEffort = reasoningEffort;
-                    }
+                    const modelConfiguration = prepareModelConfiguration(selectedModel, reasoningEffort, {
+                        baselineEffort: reasoningEffortBaseline(contextRecords, selectedModel.id),
+                        messages
+                    });
+                    let requestReasoningEffort = modelConfiguration.requestReasoningEffort;
+                    if (mode !== 'compact')
+                        for (const update of modelConfiguration.updates) {
+                            messages.push(update);
+                            await store.append(sessionId, {
+                                type: 'model.context',
+                                payload: update,
+                                executionId,
+                                turnId
+                            });
+                        }
                     const runPreparedExecution = async (compactFocus = input.prompt, compactSignal = controller.signal) => {
                         const initialSystemPrompt = mode === 'compact'
                             ? buildExecutionSystemPrompt(executionTools, 'run')
@@ -1403,8 +1381,9 @@ export function createSessionOpener(services) {
                             lastServerContextTokens = undefined;
                             lastServerUsage = undefined;
                             smartContextTokens = undefined;
-                            requestReasoningEffort = reasoningEffort;
-                            effectiveReasoningEffort = reasoningEffort;
+                            requestReasoningEffort = prepareModelConfiguration(selectedModel, reasoningEffort, {
+                                checkpointAdopted: true
+                            }).requestReasoningEffort;
                         };
                         const compactLeaf = async (input, signal, prepare, compactionId) => {
                             if (messages.length < 2)
@@ -1688,37 +1667,27 @@ export function createSessionOpener(services) {
                                 executionEnvironment = { ...currentEnvironment, ...currentLocalTimeContext() };
                                 await modelContext.recordEnvironment();
                                 const { roundTools, roundBindings, toolScope, composeSystemPrompt } = captureRoundToolScope();
-                                const codeModeEnabled = roundTools.some((tool) => tool.name === 'code_exec');
                                 const residentTools = projectTools(mcpRegistry.projectDirect(baseTools()));
-                                const requestTools = (() => {
-                                    if (selectedModel.protocol !== 'OPENAI_RESPONSES')
-                                        return projectCodeModeTools(roundTools, residentTools);
-                                    const directNames = new Set(residentTools.map((tool) => tool.name));
-                                    // Discovery and caller policy are independent: keep nested declarations for active tools.
-                                    return projectCodeModeTools(roundTools, residentTools).filter((tool) => directNames.has(tool.name));
-                                })();
                                 const requestContextMessages = pendingOutputContinuation === undefined
                                     ? messages
                                     : [...messages, pendingOutputContinuation];
                                 sources.bind(toolScope);
                                 const composedSystem = splitContextualPrompt(await composeSystemPrompt());
                                 const candidateWorld = updatePromptWorldState(modelContext.worldState, messages.length, composedSystem.parts);
-                                const modelMessages = projectSessionRequestMessages(requestContextMessages, candidateWorld.entries, selectedModel.inputCapabilities.includes('IMAGE'), codeModeEnabled, permissionPolicy.mode === 'auto');
-                                const systemPrompt = composedSystem.system;
-                                const candidateRequest = {
-                                    system: systemPrompt,
+                                const candidateRequest = prepareSessionModelRequest({
+                                    system: composedSystem.system,
                                     ...(composedSystem.systemBlocks
                                         ? { systemBlocks: composedSystem.systemBlocks }
                                         : {}),
-                                    messages: modelMessages,
-                                    tools: requestTools,
+                                    messages: requestContextMessages,
+                                    tools: roundTools,
                                     promptCacheKey: sessionId,
                                     reasoningEffort,
                                     ...(requestReasoningEffort === undefined ? {} : { requestReasoningEffort }),
                                     ...(modelInputImages?.length ? { images: modelInputImages } : {}),
                                     onAttemptDiagnostic: recordModelAttempt('EXECUTION')
-                                };
-                                preparingRequestMessages = modelMessages;
+                                }, selectedModel, candidateWorld.entries, residentTools, permissionPolicy.mode === 'auto');
+                                preparingRequestMessages = candidateRequest.messages;
                                 preparingRequestBaseLength = messages.length;
                                 let request;
                                 try {
@@ -1803,8 +1772,7 @@ export function createSessionOpener(services) {
                                         modelId: selectedModel.id,
                                         contextWindowTokens: selectedModel.contextWindowTokens,
                                         usage: latestUsage,
-                                        modelProtocol: selectedModel.protocol,
-                                        responsesConfigurationUpdates: usesResponsesConfigurationUpdates(selectedModel),
+                                        ...modelConfiguration.contextProjection,
                                         workspace: logicalWorkspace,
                                         platform: description.platform,
                                         getActiveProcessIds: async () => {
@@ -1894,6 +1862,7 @@ export function createSessionOpener(services) {
                     };
                 }
                 finally {
+                    // Revoke this Execution's request and input bindings, not Session warm resources.
                     delete executionContext.requestMessages;
                     compactRequests.close(new MarAgentError('MAR_AGENT_CANCELLED', 'Execution ended.'));
                     if (executionContext.compactRequests === compactRequests)
@@ -1905,18 +1874,10 @@ export function createSessionOpener(services) {
                     if (executionContext.toolSources === executionToolSources)
                         delete executionContext.toolSources;
                     internal.signal?.removeEventListener('abort', abortSource);
+                    // Compact retains its existing owner, waiting and error propagation.
                     await compactCoordinator.close(controller.signal.reason ?? new MarAgentError('MAR_AGENT_CANCELLED', 'Execution ended.'));
-                    await selectedTurn?.close().catch(() => undefined);
-                    try {
-                        await closeModelAdapters(executionScopedAdapters);
-                    }
-                    catch {
-                        // Execution cleanup is best effort.
-                    }
-                    finally {
-                        for (const adapter of executionScopedAdapters)
-                            activeExecutionAdapters.delete(adapter);
-                    }
+                    await modelResources.close();
+                    // Ending the parent Execution does not destroy Session-owned child tasks.
                     subagents?.endParentExecution(executionId);
                     try {
                         await releaseSession?.();
@@ -1927,6 +1888,7 @@ export function createSessionOpener(services) {
                             throw error;
                     }
                     finally {
+                        // Writer release cannot skip owner-safe deactivation; the event stream closes last.
                         if (sessionRuntime.execution === executionContext)
                             delete sessionRuntime.execution;
                         active.delete(`${sessionId}:${executionId}`);
@@ -2262,14 +2224,6 @@ function modelAttemptFailureDiagnostic(diagnostic, summary) {
         message: `${prefix}${[...diagnostic.message].slice(0, availableCharacters).join('')}`
     };
 }
-/** Shared, side-effect-free projection for the real request and current Session request view. */
-function projectSessionRequestMessages(messages, entries, supportsImages, codeMode, autoPermission = false) {
-    return normalizeMessagesForModel(insertContextualWorldState(messages, entries), {
-        supportsImages
-    }).map((message) => projectCodeModeSearchResult(autoPermission && message.toolSearchTools
-        ? { ...message, toolSearchTools: message.toolSearchTools.map(projectPermissionTool) }
-        : projectSmartCompactionMessage(message), codeMode));
-}
 function projectAppendedModelMessage(input) {
     if (input.visibility === 'transcript')
         return undefined;

package/package.json

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