@myagentroam/agent 0.9.135 → 0.9.137

package/dist/sdk/agent.js

@@ -3,7 +3,7 @@ import { isDeepStrictEqual } from 'node:util';
 import { describeMarAgentError, MarAgentError } from '../error.js';
 import { negotiateHost } from '../host/contracts.js';
 import { AnthropicMessagesAdapter, isAnthropicRecoverableStreamError } from '../model/anthropic-messages.js';
-import { marAgentReasoningEffortSchema, resolveModelDefaultReasoningEffort } from '../model/configuration.js';
+import { marAgentReasoningEffortSchema, resolveModelDefaultReasoningEffort, usesResponsesConfigurationUpdates } from '../model/configuration.js';
 import { modelRetryMaxAttempts, isRetryableModelRequestError, waitForModelRetry } from '../model/http.js';
 import { OpenAiResponsesAdapter, isOpenAiResponsesRecoverableStreamError } from '../model/openai-responses.js';
 import { AsyncQueue } from '../runtime/async-queue.js';
@@ -11,9 +11,11 @@ import { PlanOutputPrefix, splitPlanOutput } from '../runtime/plan-output.js';
 import { AGENT_EXECUTION_POLICY } from '../runtime/execution-policy.js';
 import { RolloutBudget, resolveRolloutBudgetOptions } from '../runtime/rollout-budget.js';
 import { ContextGcRuntime } from '../runtime/context-gc-runtime.js';
-import { buildContextProjection } from '../runtime/context-projection.js';
+import { buildContextProjection, providerToolCallId, providerToolName } from '../runtime/context-projection.js';
 import { countModelTokens, countTextLines, truncateModelText } from '../runtime/token-budget.js';
 import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
+import { DeferredMcpRegistry } from '../tools/tool-search.js';
+import { assertMcpToolCatalog } from './mcp-catalog.js';
 import { DEFAULT_COMPACTION_FOCUS, CompactionOperation, buildCompactionInput, buildCompactionMessages, buildNativeCompactionMessages, buildCompactedHistory, compactedHistoryMessages, continuationMessage } from '../runtime/compact.js';
 import { buildSystemPrompt, MAR_AGENT_PROMPT_VERSION } from '../prompts/index.js';
 import { buildEnvironmentContext } from '../prompts/core.js';
@@ -31,8 +33,10 @@ import { BUILTIN_TOOL_DEFINITIONS } from '../tools/registry.js';
 import { agentStartToolDefinitionWithModels } from '../tools/agent-start.js';
 import { executeRegisteredTool } from '../tools/runtime.js';
 import { scheduleToolCallBatch } from '../tools/scheduler.js';
-import { withCodeModeResultTypes } from '../tools/code-mode.js';
+import { projectCodeModeSearchResult, projectCodeModeTools } from '../tools/code-mode.js';
+import { allowsDirectTool, allowsToolCaller, toolCallers } from '../tools/callers.js';
 import { SubagentSessionController } from '../subagent/session-controller.js';
+const MODEL_PERFORMANCE_MIN_INTERVAL_MS = 1_000;
 /** Retry only classified recoverable failures within the attempt budget; never retry cancellation. */
 async function recoverModelStream(error, retryState, signal) {
     if (signal.aborted ||
@@ -261,6 +265,7 @@ export async function createMarAgentWithAdapter(options) {
                     releaseSession = await store.acquireSessionLease(sessionId);
                     await refreshSessionAdapters(executionModelGeneration);
                     const sessionState = await store.readExecutionState(sessionId);
+                    let codeModeState = await store.readCodeModeState(sessionId);
                     const todo = TodoStore.restore(sessionState.todo);
                     const contextRecords = sessionState.contextRecords;
                     const contextualWorldStateGeneration = latestContextualWorldStateGeneration(contextRecords);
@@ -410,9 +415,7 @@ export async function createMarAgentWithAdapter(options) {
                     let lastServerUsage = latestModelUsage(contextRecords, selectedModel.id);
                     const compactUserTokenLimit = Math.min(20_000, Math.floor(selectedModel.contextWindowTokens / 8));
                     const reasoningEffort = input.reasoningEffort ?? selectedModel.defaultReasoningEffort;
-                    const useEffortUpdates = selectedModel.protocol === 'OPENAI_RESPONSES' &&
-                        selectedModel.responsesEncoding !== 'LITE' &&
-                        selectedModel.codexCredential === true;
+                    const useEffortUpdates = usesResponsesConfigurationUpdates(selectedModel);
                     const previousReasoningEffort = useEffortUpdates
                         ? reasoningEffortBaseline(contextRecords, selectedModel.id)
                         : undefined;
@@ -496,7 +499,32 @@ export async function createMarAgentWithAdapter(options) {
                                 : { executionScopeId: internal.mcpExecutionScopeId }
                             : { claimExecutionScope: true })
                     };
-                    const mcpTools = (await options.host.listMcpTools?.(catalogContext)) ?? [];
+                    const readMcpCatalog = async () => {
+                        if (options.host.listMcpToolCatalog) {
+                            const catalog = await options.host.listMcpToolCatalog(catalogContext);
+                            assertMcpToolCatalog(catalog);
+                            return catalog;
+                        }
+                        const definitions = (await options.host.listMcpTools?.(catalogContext)) ?? [];
+                        return {
+                            revision: createHash('sha256').update(JSON.stringify(definitions)).digest('hex'),
+                            servers: [{ id: 'legacy', name: 'External MCP' }],
+                            tools: definitions.map((definition) => ({
+                                definition,
+                                serverId: 'legacy',
+                                rawName: definition.name,
+                                sourceIdentity: `legacy:${executionId}`,
+                                definitionRevision: createHash('sha256')
+                                    .update(JSON.stringify(definition))
+                                    .digest('hex'),
+                                lifetime: 'execution',
+                                exposure: 'deferred'
+                            }))
+                        };
+                    };
+                    const mcpCatalog = await readMcpCatalog();
+                    const mcpRegistry = new DeferredMcpRegistry(discoveredMcpToolNames(messages));
+                    const mcpTools = mcpCatalog.tools.map((tool) => tool.definition);
                     const extensions = (await options.host.listExecutionExtensions?.(catalogContext)) ?? {};
                     if (extensions.tools?.some((tool) => tool.name.startsWith('mcp__')))
                         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Host tools cannot use the MCP namespace.');
@@ -511,12 +539,15 @@ export async function createMarAgentWithAdapter(options) {
                     const combinedTools = [...builtinTools, ...(extensions.tools ?? []), ...mcpTools];
                     if (new Set(combinedTools.map((tool) => tool.name)).size !== combinedTools.length)
                         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Tool names conflict.');
-                    const availableTools = combinedTools.filter((tool) => {
+                    const toolEligible = (tool) => {
+                        toolCallers(tool);
                         if (sessionSource.type === 'subagent' && tool.agentScope === 'ROOT_ONLY')
                             return false;
                         if (sessionSource.type === 'subagent' &&
                             (tool.name.startsWith('agent_') || tool.name === 'question'))
                             return false;
+                        if (tool.name === 'tool_search')
+                            return mcpRegistry.hasDeferred;
                         return tool.name === 'code_mode'
                             ? selectedModelForTools.codeMode && description.capabilities.includes('code.execute')
                             : tool.name === 'question'
@@ -527,7 +558,10 @@ export async function createMarAgentWithAdapter(options) {
                                     : tool.name === 'view_image'
                                         ? selectedModelForTools.inputCapabilities.includes('IMAGE')
                                         : tool.name !== 'web_fetch' || description.capabilities.includes('web.fetch');
-                    });
+                    };
+                    mcpRegistry.update(mcpCatalog, (tool) => toolEligible(tool.definition));
+                    rebindMcpToolSearchOutputs(messages, mcpRegistry);
+                    const availableTools = combinedTools.filter(toolEligible);
                     const instructionContext = await loadAgentInstructions({
                         home: description.homeDirectory,
                         workspace: instructionWorkspace,
@@ -546,8 +580,14 @@ export async function createMarAgentWithAdapter(options) {
                         agentInstructionInsertIndex &&
                         messages[agentInstructionInsertIndex - 1]?.contextKind === 'environment')
                         agentInstructionInsertIndex--;
-                    const tools = withCodeModeResultTypes(availableTools.filter((tool) => tool.name !== 'skill' || (instructionContext?.skills.size ?? 0) > 0));
-                    const executionTools = tools;
+                    const baseTools = () => [...builtinTools, ...(extensions.tools ?? [])].filter((tool) => toolEligible(tool) &&
+                        (tool.name !== 'skill' || (instructionContext?.skills.size ?? 0) > 0));
+                    let executionTools = mcpRegistry.project(baseTools());
+                    const restoreMcpDiscovery = () => {
+                        mcpRegistry.restore(discoveredMcpToolNames(messages));
+                        rebindMcpToolSearchOutputs(messages, mcpRegistry);
+                        executionTools = mcpRegistry.project(baseTools());
+                    };
                     const loadRetainedSessionResources = async () => {
                         const hostResources = (await options.host.listSessionResources?.(sessionId)) ?? {
                             processes: []
@@ -581,7 +621,13 @@ export async function createMarAgentWithAdapter(options) {
                             ? { guaranteedCommands: description.guaranteedCommands }
                             : {}),
                         workspace: logicalWorkspace,
-                        tools: availableTools.map((tool) => tool.name),
+                        tools: availableTools
+                            .filter((tool) => !tool.name.startsWith('mcp__'))
+                            .map((tool) => tool.name),
+                        directTools: availableTools
+                            .filter((tool) => !tool.name.startsWith('mcp__') &&
+                            allowsDirectTool(tool, availableTools.some((candidate) => candidate.name === 'code_mode')))
+                            .map((tool) => tool.name),
                         highDensityCompaction: selectedModel.highDensityCompaction,
                         extension: [
                             options.systemInstruction,
@@ -591,6 +637,27 @@ export async function createMarAgentWithAdapter(options) {
                             .filter(Boolean)
                             .join('\n\n')
                     });
+                    const syncMcpWorldState = async (index) => {
+                        const snapshot = mcpRegistry.navigation();
+                        if (contextualWorldState.mcpSnapshot === snapshot)
+                            return;
+                        contextualWorldState = {
+                            ...contextualWorldState,
+                            mcpSnapshot: snapshot,
+                            entries: [
+                                ...contextualWorldState.entries,
+                                {
+                                    index,
+                                    kind: 'mcp',
+                                    content: snapshot ?? '<mcp_catalog>No deferred MCP tools remain.</mcp_catalog>'
+                                }
+                            ]
+                        };
+                        sessionRuntime.contextualWorldState = contextualWorldState;
+                        await persistContextualWorldState(store, sessionId, contextualWorldState);
+                    };
+                    if (mode !== 'compact')
+                        await syncMcpWorldState(agentInstructionInsertIndex);
                     const initialSystemPrompt = mode === 'compact'
                         ? buildExecutionSystemPrompt(executionTools, 'run')
                         : buildExecutionSystemPrompt();
@@ -740,6 +807,7 @@ export async function createMarAgentWithAdapter(options) {
                         });
                         contextGc.reset();
                         messages.splice(0, messages.length, environmentContextUpdate(executionEnvironment), ...compactedHistoryMessages(replacementHistory));
+                        restoreMcpDiscovery();
                         projectedExecutionBudgetStage = undefined;
                         recordedEnvironment = executionEnvironment;
                         compactionUserMessages = replacementHistory
@@ -785,7 +853,12 @@ export async function createMarAgentWithAdapter(options) {
                         let roundServerUsage;
                         const pendingTools = [];
                         let incompleteToolCall = false;
+                        executionTools = mcpRegistry.project(baseTools());
+                        if (mode !== 'compact')
+                            await syncMcpWorldState(messages.length);
                         await ensureContextBudget();
+                        if (mode !== 'compact')
+                            await syncMcpWorldState(messages.length);
                         appendExecutionBudgetEnvironment();
                         if (mode !== 'compact') {
                             executionEnvironment = { ...currentEnvironment, ...currentLocalTimeContext() };
@@ -793,6 +866,16 @@ export async function createMarAgentWithAdapter(options) {
                         }
                         const toolsAllowed = mode !== 'compact' && (!rolloutBudget?.active || rolloutBudget.stage !== 'exhausted');
                         const roundTools = mode === 'compact' ? executionTools : toolsAllowed ? executionTools : [];
+                        const codeModeEnabled = roundTools.some((tool) => tool.name === 'code_mode');
+                        const residentTools = mcpRegistry.projectDirect(baseTools());
+                        const requestTools = (() => {
+                            if (selectedModel.protocol !== 'OPENAI_RESPONSES' ||
+                                selectedModel.responsesEncoding === 'LITE')
+                                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 systemPrompt = mode === 'compact'
                             ? buildExecutionSystemPrompt(roundTools, 'run')
                             : buildExecutionSystemPrompt(roundTools);
@@ -804,8 +887,47 @@ export async function createMarAgentWithAdapter(options) {
                             : normalizeMessagesForModel(insertContextualWorldState(requestContextMessages, contextualWorldState.entries), {
                                 supportsImages: selectedModel.inputCapabilities.includes('IMAGE')
                             });
+                        const roundMcpExpectations = new Map(roundTools
+                            .filter((tool) => tool.name.startsWith('mcp__'))
+                            .map((tool) => [tool.name, mcpRegistry.expectedTool(tool.name)]));
                         let sawModelSemanticEvent = false;
+                        let requestStartedAt;
+                        let firstModelResponseAt;
+                        let requestCompletedAt;
+                        let requestOutputTokens;
+                        let outputTokenRevision = 0;
+                        let lastPerformanceEmittedAt;
+                        let lastPublishedOutputTokenRevision = 0;
+                        let performanceEmitted = false;
                         const roundMessageCount = messages.length;
+                        const emitPerformance = async (sampledAt, force = false) => {
+                            if (mode === 'compact' || firstModelResponseAt === undefined)
+                                return;
+                            const outputDurationMs = Math.max(0, Math.round(sampledAt - firstModelResponseAt));
+                            const outputTokens = requestOutputTokens;
+                            const tokensPerSecond = outputTokens !== undefined && outputDurationMs > 0
+                                ? Number(((outputTokens * 1000) / outputDurationMs).toFixed(2))
+                                : undefined;
+                            if (performanceEmitted &&
+                                (tokensPerSecond === undefined ||
+                                    outputTokenRevision === lastPublishedOutputTokenRevision))
+                                return;
+                            if (!force &&
+                                lastPerformanceEmittedAt !== undefined &&
+                                sampledAt - lastPerformanceEmittedAt < MODEL_PERFORMANCE_MIN_INTERVAL_MS)
+                                return;
+                            await emit({
+                                type: 'model.performance',
+                                latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)),
+                                ...(outputTokens === undefined ? {} : { outputTokens }),
+                                outputDurationMs,
+                                ...(tokensPerSecond === undefined ? {} : { tokensPerSecond })
+                            });
+                            performanceEmitted = true;
+                            lastPerformanceEmittedAt = sampledAt;
+                            if (tokensPerSecond !== undefined)
+                                lastPublishedOutputTokenRevision = outputTokenRevision;
+                        };
                         const persistToolCalls = async (calls) => {
                             for (const call of calls) {
                                 const message = {
@@ -834,11 +956,12 @@ export async function createMarAgentWithAdapter(options) {
                             const startModel = manualCompaction
                                 ? (request) => manualCompaction.start(selected, request)
                                 : (request) => selected.start(request, controller.signal);
+                            requestStartedAt = performance.now();
                             for await (const event of startModel({
                                 retryState: modelRetryState,
                                 system: systemPrompt,
-                                messages: modelMessages,
-                                tools: roundTools,
+                                messages: modelMessages.map((message) => projectCodeModeSearchResult(message, codeModeEnabled)),
+                                tools: requestTools,
                                 ...(mode === 'compact'
                                     ? { toolChoice: 'none' }
                                     : toolsAllowed
@@ -850,8 +973,11 @@ export async function createMarAgentWithAdapter(options) {
                                 ...(modelInputImages?.length ? { images: modelInputImages } : {}),
                                 onAttemptDiagnostic: recordModelAttempt(mode === 'compact' ? 'COMPACTION' : 'EXECUTION')
                             })) {
-                                if (event.type !== 'response.started' && event.type !== 'usage')
+                                const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event) ? performance.now() : undefined;
+                                if (modelResponseAt !== undefined) {
                                     sawModelSemanticEvent = true;
+                                    firstModelResponseAt ??= modelResponseAt;
+                                }
                                 if (event.type === 'response.item') {
                                     // Compaction keeps only its successful checkpoint, never intermediate native output.
                                     if (mode === 'compact')
@@ -884,13 +1010,14 @@ export async function createMarAgentWithAdapter(options) {
                                         }
                                         delta = prefix.push(delta);
                                     }
-                                    if (mode !== 'compact' && delta)
+                                    if (mode !== 'compact' && delta) {
                                         await emit({
                                             type: 'message.delta',
                                             itemId: event.itemId,
                                             phase: event.phase,
                                             delta
                                         });
+                                    }
                                 }
                                 else if (event.type === 'text.completed') {
                                     const phase = event.phase ?? 'final_answer';
@@ -904,7 +1031,7 @@ export async function createMarAgentWithAdapter(options) {
                                                 const itemId = index === 0 ? event.itemId : `${event.itemId}:plan-part:${index}`;
                                                 if (part.kind === 'plan')
                                                     await emit({ type: 'plan.completed', itemId, text: part.text });
-                                                else
+                                                else {
                                                     await emit({
                                                         type: 'message.completed',
                                                         itemId,
@@ -913,9 +1040,10 @@ export async function createMarAgentWithAdapter(options) {
                                                         modelId: selectedModel.id,
                                                         modelName: selectedModel.name
                                                     });
+                                                }
                                             }
                                         }
-                                        else
+                                        else {
                                             await emit({
                                                 type: 'message.completed',
                                                 itemId: event.itemId,
@@ -924,11 +1052,21 @@ export async function createMarAgentWithAdapter(options) {
                                                 modelId: selectedModel.id,
                                                 modelName: selectedModel.name
                                             });
+                                        }
                                     }
                                     messages.push({ role: 'assistant', content: event.text });
                                 }
                                 else if (event.type === 'usage') {
                                     latestUsage = event.usage;
+                                    const outputTokens = typeof event.usage.outputTokens === 'number' &&
+                                        Number.isSafeInteger(event.usage.outputTokens) &&
+                                        event.usage.outputTokens >= 0
+                                        ? event.usage.outputTokens
+                                        : undefined;
+                                    if (outputTokens !== undefined) {
+                                        requestOutputTokens = outputTokens;
+                                        outputTokenRevision++;
+                                    }
                                     const reportedContext = event.usage.contextInputTokens ?? event.usage.inputTokens;
                                     if (reportedContext !== undefined &&
                                         Number.isSafeInteger(reportedContext) &&
@@ -974,8 +1112,16 @@ export async function createMarAgentWithAdapter(options) {
                                     sawTool = true;
                                     pendingTools.push(event);
                                 }
-                                else if (event.type === 'completed')
+                                else if (event.type === 'completed') {
                                     stop = event.reason;
+                                    requestCompletedAt = performance.now();
+                                }
+                                if (modelResponseAt !== undefined)
+                                    await emitPerformance(modelResponseAt);
+                            }
+                            if (mode !== 'compact' && firstModelResponseAt !== undefined) {
+                                const completedAt = requestCompletedAt ?? performance.now();
+                                await emitPerformance(completedAt, true);
                             }
                             pendingOutputContinuation = undefined;
                             incompleteToolCall = pendingTools.some((call) => call.argumentError !== undefined);
@@ -1031,21 +1177,31 @@ export async function createMarAgentWithAdapter(options) {
                             finalAnswer = '';
                             continue;
                         }
-                        const executeCall = async (call, signal = controller.signal) => {
+                        const executeCall = async (call, signal = controller.signal, caller = 'direct', parentCallId) => {
                             await emit({
                                 type: 'tool.started',
                                 toolName: call.name,
                                 callId: call.callId,
+                                ...(parentCallId === undefined ? {} : { parentCallId }),
                                 input: call.arguments
                             });
                             try {
                                 if (call.argumentError)
                                     throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', call.argumentError);
-                                if (!availableTools.some((tool) => tool.name === call.name))
+                                if (!roundTools.some((tool) => tool.name === call.name && allowsToolCaller(tool, caller)))
                                     throw new MarAgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable in this execution.');
                                 const output = await executeRegisteredTool(call.name, call.arguments, call.callId, {
                                     host: options.host,
                                     todo,
+                                    ...(roundMcpExpectations.get(call.name)
+                                        ? { expectedMcpTool: roundMcpExpectations.get(call.name) }
+                                        : {}),
+                                    searchMcpTools: (arguments_, searchSignal) => mcpRegistry.expose(arguments_, {
+                                        signal: searchSignal,
+                                        base: baseTools(),
+                                        window: selectedModel.contextWindowTokens,
+                                        system: systemPrompt
+                                    }),
                                     ...(subagents === undefined ? {} : { subagents }),
                                     mode,
                                     sessionId,
@@ -1053,14 +1209,22 @@ export async function createMarAgentWithAdapter(options) {
                                     signal,
                                     codeMode: {
                                         supportsImages: selectedModel.inputCapabilities.includes('IMAGE'),
-                                        tools: roundTools,
+                                        tools: roundTools.filter((tool) => allowsToolCaller(tool, 'programmatic')),
+                                        state: codeModeState,
+                                        commitState: async (mutations) => {
+                                            codeModeState = await store.commitCodeModeState(sessionId, mutations, {
+                                                executionId,
+                                                turnId
+                                            });
+                                            return codeModeState;
+                                        },
                                         invoke: async (nested, nestedSignal) => {
                                             const result = await executeCall({
                                                 type: 'client_tool.call',
                                                 name: nested.name,
                                                 arguments: nested.arguments,
                                                 callId: nested.callId ?? randomUUID()
-                                            }, nestedSignal);
+                                            }, nestedSignal, 'programmatic', call.callId);
                                             if (result.failed)
                                                 throw result.error;
                                             return { ...result.output, content: result.content };
@@ -1082,6 +1246,7 @@ export async function createMarAgentWithAdapter(options) {
                                     type: 'tool.completed',
                                     toolName: call.name,
                                     callId: call.callId,
+                                    ...(parentCallId === undefined ? {} : { parentCallId }),
                                     summary: eventSummary,
                                     truncated: output.truncated === true ||
                                         modelOutput.truncated ||
@@ -1103,6 +1268,7 @@ export async function createMarAgentWithAdapter(options) {
                                     type: 'tool.failed',
                                     toolName: call.name,
                                     callId: call.callId,
+                                    ...(parentCallId === undefined ? {} : { parentCallId }),
                                     code: diagnostic.code,
                                     message: diagnostic.message
                                 });
@@ -1127,10 +1293,14 @@ export async function createMarAgentWithAdapter(options) {
                                     mimeType: image.mimeType,
                                     data: Buffer.from(image.dataBase64, 'base64')
                                 })));
+                            const toolSearchTools = result.call.name === 'tool_search' && !result.failed
+                                ? result.output.toolSearchTools
+                                : undefined;
                             const message = {
                                 role: 'tool',
                                 callId: result.call.callId,
                                 content: result.content,
+                                ...(toolSearchTools === undefined ? {} : { toolSearchTools }),
                                 ...('images' in result && result.images?.length ? { images: result.images } : {})
                             };
                             messages.push(message);
@@ -1139,7 +1309,10 @@ export async function createMarAgentWithAdapter(options) {
                                 payload: {
                                     role: message.role,
                                     callId: message.callId,
-                                    content: message.content
+                                    content: message.content,
+                                    ...(message.toolSearchTools === undefined
+                                        ? {}
+                                        : { toolSearchTools: message.toolSearchTools })
                                 },
                                 executionId,
                                 turnId
@@ -1182,6 +1355,7 @@ export async function createMarAgentWithAdapter(options) {
                                 contextWindowTokens: selectedModel.contextWindowTokens,
                                 usage: latestUsage,
                                 modelProtocol: selectedModel.protocol,
+                                responsesConfigurationUpdates: usesResponsesConfigurationUpdates(selectedModel),
                                 workspace: logicalWorkspace,
                                 platform: description.platform,
                                 getActiveProcessIds: async () => {
@@ -1201,6 +1375,7 @@ export async function createMarAgentWithAdapter(options) {
                                     projection: committed.projection
                                 });
                                 messages.splice(0, messages.length, ...refreshed.messages);
+                                restoreMcpDiscovery();
                                 projectedExecutionBudgetStage = undefined;
                                 recordedEnvironment = refreshed.environmentState;
                                 compactionUserMessages = [...refreshed.userMessages];
@@ -1986,7 +2161,7 @@ function parsePersistedContextualWorldState(payload) {
         const entry = value;
         if (!Number.isSafeInteger(entry.index) ||
             entry.index < 0 ||
-            (entry.kind !== 'instructions' && entry.kind !== 'resources') ||
+            (entry.kind !== 'instructions' && entry.kind !== 'resources' && entry.kind !== 'mcp') ||
             typeof entry.content !== 'string' ||
             entry.content.length === 0)
             return undefined;
@@ -2004,6 +2179,7 @@ function parsePersistedContextualWorldState(payload) {
         initialized: true,
         instructionSnapshot,
         resourceSnapshot,
+        mcpSnapshot: typeof record.mcpSnapshot === 'string' ? record.mcpSnapshot : undefined,
         entries
     };
 }
@@ -2021,6 +2197,7 @@ async function persistContextualWorldState(store, sessionId, state) {
         generation: state.generation ?? null,
         instructionSnapshot: state.instructionSnapshot ?? null,
         resourceSnapshot: state.resourceSnapshot ?? null,
+        mcpSnapshot: state.mcpSnapshot ?? null,
         entries: state.entries
     });
 }
@@ -2038,6 +2215,7 @@ function updateContextualWorldState(state, index, current) {
         entries.push({ index, kind: 'resources', content: resourceContent });
     return {
         generation: state.generation,
+        mcpSnapshot: state.mcpSnapshot,
         initialized: true,
         instructionSnapshot: current.instructionSnapshot,
         resourceSnapshot: current.resourceSnapshot,
@@ -2100,6 +2278,38 @@ function stableJson(value) {
             .join(',')}}`;
     return JSON.stringify(value) ?? 'undefined';
 }
+function discoveredMcpToolNames(messages) {
+    const calls = toolSearchCallIds(messages);
+    const names = new Set();
+    for (const message of messages)
+        for (const tool of calls.has(message.callId ?? '') ? (message.toolSearchTools ?? []) : [])
+            if (tool.name.startsWith('mcp__'))
+                names.add(tool.name);
+    return [...names];
+}
+function rebindMcpToolSearchOutputs(messages, registry) {
+    const calls = toolSearchCallIds(messages);
+    for (const message of messages) {
+        if (!message.toolSearchTools)
+            continue;
+        if (!calls.has(message.callId ?? '')) {
+            delete message.toolSearchTools;
+            continue;
+        }
+        const definitions = registry.restoredDefinitions(message.toolSearchTools.map((tool) => tool.name));
+        message.toolSearchTools = definitions;
+    }
+}
+function toolSearchCallIds(messages) {
+    return new Set(messages
+        .filter((message) => (message.role === 'tool_call' &&
+        message.name === 'tool_search' &&
+        typeof message.callId === 'string') ||
+        (message.role === 'provider' &&
+            providerToolName(message) === 'tool_search' &&
+            providerToolCallId(message) !== undefined))
+        .map((message) => message.role === 'provider' ? providerToolCallId(message) : message.callId));
+}
 /** Project only known, validated tool result shapes into public structured events. */
 function structuredToolEventData(toolName, value) {
     if (!isRecord(value))
@@ -2196,13 +2406,26 @@ function structuredToolArtifacts(value) {
 }
 /** Keep streaming deltas live-only; exec output has one durable copy in model context records. */
 function eventForPersistence(event) {
-    if (event.type === 'message.delta' || event.type === 'context.compacting')
+    if (event.type === 'message.delta' ||
+        event.type === 'context.compacting' ||
+        event.type === 'model.performance' ||
+        event.type === 'message.performance')
         return undefined;
     if (event.type !== 'tool.completed' || event.toolName !== 'exec' || !event.data)
         return event;
     const metadata = Object.fromEntries(Object.entries(event.data).filter(([key]) => key !== 'stdout' && key !== 'stderr'));
     return { ...event, data: metadata };
 }
+function isModelResponseEvent(event) {
+    if (event.type === 'text.delta')
+        return event.delta.length > 0;
+    if (event.type === 'text.completed' || event.type === 'reasoning.summary')
+        return event.text.length > 0;
+    return (event.type === 'response.item' ||
+        event.type === 'client_tool.call' ||
+        event.type === 'hosted_tool' ||
+        event.type === 'citation');
+}
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/sdk/mcp-catalog.d.ts

@@ -0,0 +1,13 @@
+import type { ClientToolDefinition } from '../model/contracts.js';
+import type { McpToolCatalog } from './types.js';
+export declare const MCP_DEFINITION_LIMITS: Readonly<{
+    depth: 64;
+    nodes: 32768;
+    definitionBytes: number;
+    catalogBytes: number;
+    tools: 10000;
+    servers: 256;
+}>;
+/** Shared Host and Node publication boundary, not a provider-specific conversion. */
+export declare function assertMcpToolDefinition(value: unknown): asserts value is ClientToolDefinition;
+export declare function assertMcpToolCatalog(value: unknown): asserts value is McpToolCatalog;