@wix/pathgrade 1.0.13 → 1.0.15

package/dist/sdk/agent.js

@@ -17,6 +17,7 @@ import fs from 'fs-extra';
 import * as path from 'path';
 import { cleanDebugRuns, DEFAULT_DEBUG_RETAIN_RUNS, prepareManagedDebugRun, } from '../providers/debug-runs.js';
 import { collectOpenCodeMcpToolNames, validateOpenCodeDeclaration } from '../agents/opencode/contract.js';
+import { compileMcpMockApprovalSession, } from './mcp-mock-approvals.js';
 /**
  * Test-only injection point: override the sink used by the next emitter
  * built inside `createAgent`. Pass `null` to restore the default (stderr).
@@ -47,21 +48,23 @@ class AgentImpl {
     opencodeExecutable;
     opencodeMcpToolNames;
     activeChatSession;
-    constructor(ws, agentName, llm, timeoutSetting, conversationWindow, modelOpt, debugOpt, debugName, debugBaseDir, verbose, transport, mcpSafety, opencodeExecutable, opencodeMcpToolNames) {
-        this.ws = ws;
-        this.agentName = agentName;
-        this.llm = llm;
-        this.timeoutSetting = timeoutSetting;
-        this.modelOpt = modelOpt;
-        this.conversationWindowOpt = conversationWindow;
-        this.debugOpt = debugOpt;
-        this.debugName = debugName;
-        this.debugBaseDir = debugBaseDir;
-        this.verbose = verbose;
-        this.transport = transport;
-        this.mcpSafety = mcpSafety;
-        this.opencodeExecutable = opencodeExecutable;
-        this.opencodeMcpToolNames = opencodeMcpToolNames;
+    scriptedMcp;
+    constructor(opts) {
+        this.ws = opts.workspace;
+        this.agentName = opts.agentName;
+        this.llm = opts.llm;
+        this.timeoutSetting = opts.timeoutSetting;
+        this.modelOpt = opts.model;
+        this.conversationWindowOpt = opts.conversationWindow;
+        this.debugOpt = opts.debug;
+        this.debugName = opts.debugName;
+        this.debugBaseDir = opts.debugBaseDir;
+        this.verbose = opts.verbose;
+        this.transport = opts.transport;
+        this.mcpSafety = opts.mcpSafety;
+        this.opencodeExecutable = opts.opencodeExecutable;
+        this.opencodeMcpToolNames = opts.opencodeMcpToolNames;
+        this.scriptedMcp = opts.scriptedMcp;
     }
     get messages() {
         return this._messages;
@@ -106,6 +109,7 @@ class AgentImpl {
             ...(this.mcpSafety !== undefined ? { mcpSafety: this.mcpSafety } : {}),
             ...(this.opencodeExecutable !== undefined ? { opencodeExecutable: this.opencodeExecutable } : {}),
             ...(this.opencodeMcpToolNames !== undefined ? { opencodeMcpToolNames: this.opencodeMcpToolNames } : {}),
+            ...(this.scriptedMcp !== undefined ? { scriptedMcp: this.scriptedMcp } : {}),
         });
     }
     resolveTimeoutSec(mode, maxTurns) {
@@ -270,7 +274,12 @@ class AgentImpl {
         // scorer judge calls accumulate on the same tracker.
         const agent = this;
         const runStepScorers = async (scorers) => {
-            return evaluate(agent, scorers, { llm: this.llm });
+            const result = await evaluate(agent, scorers, { llm: this.llm });
+            const score = result.score;
+            if (score === undefined) {
+                throw new Error('Step scorer evaluation did not produce a score');
+            }
+            return { ...result, score };
         };
         try {
             const result = await runConversation(opts, {
@@ -391,14 +400,34 @@ export async function createAgent(opts) {
     const transport = agentName === 'codex'
         ? resolveCodexTransport(opts, process.env)
         : undefined;
+    let scriptedMcp;
+    if (opts.mcpMockApprovalRules !== undefined) {
+        if (opts.mcpMock === undefined)
+            throw new Error('mcpMockApprovalRules requires mcpMock');
+        if (opts.mcpConfigFile !== undefined)
+            throw new Error('mcpMockApprovalRules cannot be combined with mcpConfigFile');
+        if (opts.mcpSafety?.runMode !== undefined && opts.mcpSafety.runMode !== 'mock') {
+            throw new Error('mcpMockApprovalRules requires mcpSafety.runMode to be absent or mock');
+        }
+        if (agentName !== 'claude' && !(agentName === 'codex' && transport === 'app-server')) {
+            throw new Error('mcpMockApprovalRules supports Claude or Codex with transport app-server only');
+        }
+        scriptedMcp = compileMcpMockApprovalSession({
+            mcpMock: opts.mcpMock,
+            rules: opts.mcpMockApprovalRules,
+            provider: agentName,
+        });
+    }
     const timeoutSetting = opts.timeout ?? 300;
     // Capture runner context now; adapters own installation and restoration.
     const testCtx = opts.debug ? resolveCaseDebugContext() : { name: '', dir: '' };
-    const { timeout: _, mcpMock, mcpConfigFile, agent: __, debug: ___, transport: _____, mcpSafety: ______, opencodeExecutable, ...rest } = opts;
+    const { timeout: _, mcpMock, mcpConfigFile, mcpMockApprovalRules: ________, agent: __, debug: ___, transport: _____, mcpSafety: ______, opencodeExecutable, ...rest } = opts;
     const workspace = await prepareWorkspace({
         ...rest,
         agent: agentName,
-        mcp: mcpConfigFile ? { configFile: mcpConfigFile } : mcpMock ? { mock: mcpMock } : undefined,
+        mcp: scriptedMcp
+            ? undefined
+            : mcpConfigFile ? { configFile: mcpConfigFile } : mcpMock ? { mock: mcpMock } : undefined,
     });
     // Create agent LLM once, using the fully-resolved sandbox env (includes
     // keychain OAuth tokens, API keys, safe host vars).
@@ -412,7 +441,23 @@ export async function createAgent(opts) {
         sink: verboseSinkOverride ?? undefined,
         testName: testCtx.name || undefined,
     });
-    const agent = new AgentImpl(workspace, agentName, llm, timeoutSetting, opts.conversationWindow, opts.model, opts.debug, debugName, debugBaseDir, verbose, transport, opts.mcpSafety, opencodeExecutable, agentName === 'opencode' ? collectOpenCodeMcpToolNames(mcpMock) : undefined);
+    const agent = new AgentImpl({
+        workspace,
+        agentName,
+        llm,
+        timeoutSetting,
+        conversationWindow: opts.conversationWindow,
+        model: opts.model,
+        debug: opts.debug,
+        debugName,
+        debugBaseDir,
+        verbose,
+        transport,
+        mcpSafety: opts.mcpSafety,
+        opencodeExecutable,
+        opencodeMcpToolNames: agentName === 'opencode' ? collectOpenCodeMcpToolNames(mcpMock) : undefined,
+        scriptedMcp,
+    });
     lifecycleCore.registerAgent(agent);
     return agent;
 }

package/dist/sdk/diagnostics.d.ts

@@ -35,6 +35,7 @@ export interface BuildDiagnosticsReportInput {
     turnDetails?: TurnDetail[];
     reactionsFired?: ReactionFiredEntry[];
     scorers?: DiagnosticsScorer[];
+    warnings?: string[];
     log: LogEntry[];
 }
 export declare function buildDiagnosticsReport(input: BuildDiagnosticsReportInput): DiagnosticsReport;

package/dist/sdk/diagnostics.js

@@ -10,9 +10,12 @@ export function buildDiagnosticsReport(input) {
         ...detail,
         apiRetries: retriesByTurn.get(detail.turn) ?? 0,
     }));
-    const warnings = turnDetails
-        .filter((detail) => detail.outputLines > 500)
-        .map((detail) => `Turn ${detail.turn}: output exceeded 500 lines (${detail.outputLines} lines)`);
+    const warnings = [
+        ...(input.warnings ?? []),
+        ...turnDetails
+            .filter((detail) => detail.outputLines > 500)
+            .map((detail) => `Turn ${detail.turn}: output exceeded 500 lines (${detail.outputLines} lines)`),
+    ];
     return {
         turns: turnDetails.length,
         totalDurationMs: turnDetails.reduce((sum, detail) => sum + detail.durationMs, 0),

package/dist/sdk/index.d.ts

@@ -2,7 +2,8 @@ export { createAgent } from './agent.js';
 export { resolveAgentName, resolveCodexTransport, InvalidTransportEnvError, } from './agent-resolution.js';
 export { AgentCrashError } from './agent-crash.js';
 export { check, score, judge, toolUsage } from './scorers.js';
-export { getMcpToolCall, isMcpToolCall, findMcpToolCalls, getMcpStartupStatus, isMcpStartupStatus, } from './mcp-evidence.js';
+export { getMcpToolCall, isMcpToolCall, findMcpToolCalls, getMcpStartupStatus, isMcpStartupStatus, getMcpApproval, isMcpApproval, findMcpApprovals, getMcpInvocation, wasMcpToolInvoked, } from './mcp-evidence.js';
+export type { McpMockApprovalRule, McpMockJsonValue } from './mcp-mock-approvals.js';
 export { decideMcpToolCall, redactMcpSecrets, } from './mcp-safety.js';
 export { evaluate, EvalScorerError } from './evaluate.js';
 export { RUN_SNAPSHOT_VERSION, buildRunSnapshot, loadRunSnapshot, SnapshotParseError, SnapshotVersionError, WorkspaceMissingError, } from './snapshots.js';
@@ -29,9 +30,9 @@ export type { OnScorerErrorMode } from './evaluate.js';
 export type { EvalResultEvent, EvalResultObserver, ResultObserverHandle, ResultObserverOptions, ResultObserverOwner, } from './result-capture.js';
 export type { RunSnapshot } from './snapshots.js';
 export type { DiagnosticsReport } from './diagnostics.js';
-export type { ExpectedMcpStartupStatus, ExpectedMcpToolCall, McpStartupStatusEvidence, McpToolCallEvidence, } from './mcp-evidence.js';
+export type { ExpectedMcpStartupStatus, ExpectedMcpToolCall, McpStartupStatusEvidence, McpToolCallEvidence, McpApprovalEvidence, ExpectedMcpApproval, McpInvocationResult, } from './mcp-evidence.js';
 export type { McpPolicyDenialReason, McpToolCallRequest, McpToolPolicyDecision, } from './mcp-safety.js';
-export type { ToolEvent } from '../tool-events.js';
+export type { ToolEvent, McpToolCallClassification } from '../tool-events.js';
 export type { LLMPort, EvalRuntime } from './eval-runtime.js';
 export { createLLMClient, ProviderNotSupportedError } from '../utils/llm.js';
 export type { CreateLLMClientOptions, LLMProviderAdapter, TokenUsage as LLMTokenUsage } from '../utils/llm.js';

package/dist/sdk/index.js

@@ -3,7 +3,7 @@ export { createAgent } from './agent.js';
 export { resolveAgentName, resolveCodexTransport, InvalidTransportEnvError, } from './agent-resolution.js';
 export { AgentCrashError } from './agent-crash.js';
 export { check, score, judge, toolUsage } from './scorers.js';
-export { getMcpToolCall, isMcpToolCall, findMcpToolCalls, getMcpStartupStatus, isMcpStartupStatus, } from './mcp-evidence.js';
+export { getMcpToolCall, isMcpToolCall, findMcpToolCalls, getMcpStartupStatus, isMcpStartupStatus, getMcpApproval, isMcpApproval, findMcpApprovals, getMcpInvocation, wasMcpToolInvoked, } from './mcp-evidence.js';
 export { decideMcpToolCall, redactMcpSecrets, } from './mcp-safety.js';
 export { evaluate, EvalScorerError } from './evaluate.js';
 export { RUN_SNAPSHOT_VERSION, buildRunSnapshot, loadRunSnapshot, SnapshotParseError, SnapshotVersionError, WorkspaceMissingError, } from './snapshots.js';

package/dist/sdk/lifecycle.js

@@ -136,13 +136,12 @@ function synthesizeTrialFromAgent(agent) {
     const conversationEnd = [...agent.log].reverse().find((entry) => entry.type === 'conversation_end');
     const completionReason = conversationEnd?.completion_reason ?? (agent.log.some((entry) => entry.type === 'agent_result') ? 'completed' : undefined);
     return {
-        score: 1,
+        score: undefined,
         scorers: [],
         resultKind: 'synthetic_no_evaluation',
         ...(agent.executionMetadata ? { agent: agent.executionMetadata } : {}),
         trial: {
             trial_id: 0,
-            reward: 1,
             scorer_results: [],
             duration_ms: 0,
             n_commands: nCommands,
@@ -157,8 +156,9 @@ function synthesizeTrialFromAgent(agent) {
             completionDetail: conversationEnd?.completion_detail,
             turnDetails: conversationEnd?.turn_details,
             reactionsFired: conversationEnd?.reactions_fired,
-            score: 1,
+            score: undefined,
             scorers: [],
+            warnings: ['evaluate() was not called; no evaluation score is available'],
             log: agent.log,
         }),
     };

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

@@ -4,6 +4,7 @@ import type { AgentName, AgentTransport, Message } from './types.js';
 import type { McpSafetyOptions } from './mcp-safety.js';
 import type { LLMPort } from '../utils/llm-types.js';
 import type { AskBus } from './ask-bus/types.js';
+import type { CompiledMcpMockSession } from './mcp-mock-approvals.js';
 export interface ManagedSessionDeps {
     ws: Workspace;
     agentName: AgentName;
@@ -33,6 +34,8 @@ export interface ManagedSessionDeps {
     mcpSafety?: McpSafetyOptions;
     opencodeExecutable?: string;
     opencodeMcpToolNames?: string[];
+    /** Trusted pre-workspace compiled generated-MCP declaration. */
+    scriptedMcp?: CompiledMcpMockSession;
 }
 export interface ManagedSession {
     /** Full lifecycle: log start/result, push messages, check exit code. */

package/dist/sdk/managed-session.js

@@ -6,6 +6,7 @@ import { buildToolEventLogEntry } from './tool-event-log.js';
 import { planRuntimePolicies } from './runtime-policy.js';
 import { getVisibleAssistantMessage } from './visible-turn.js';
 import { createAskBus } from './ask-bus/bus.js';
+import { startScriptedMcpMockHost, } from '../providers/scripted-mcp-mock-host.js';
 export function createManagedSession(deps) {
     const { ws, agentName, timeoutSec, messages, log, model, conversationWindow, llm } = deps;
     const agentTimeoutMs = timeoutSec * 1000;
@@ -33,6 +34,10 @@ export function createManagedSession(deps) {
     let session = null;
     let setupDone = false;
     let currentSignal;
+    let scriptedHost;
+    let activeTurn = false;
+    let nextTurnNumber = 0;
+    let disposePromise;
     const runCommand = async (cmd) => {
         const result = await ws.exec(cmd, { signal: currentSignal });
         log.push({
@@ -46,34 +51,66 @@ export function createManagedSession(deps) {
         return result;
     };
     const executeTurn = async (message) => {
+        if (activeTurn)
+            throw new Error('A Pathgrade agent turn is already active');
         const remaining = deadlineMs - Date.now();
         if (remaining <= 0)
             throw new Error(`${label} timed out`);
-        return withAbortTimeout(async (signal) => {
-            currentSignal = signal;
-            if (!session) {
-                // Run auth setup commands before first agent turn
-                if (!setupDone) {
-                    for (const cmd of ws.setupCommands) {
-                        await ws.exec(cmd);
+        activeTurn = true;
+        try {
+            return await withAbortTimeout(async (signal) => {
+                currentSignal = signal;
+                if (!session) {
+                    // Run auth setup commands before first agent turn
+                    if (!setupDone) {
+                        for (const cmd of ws.setupCommands) {
+                            await ws.exec(cmd, { signal });
+                            signal.throwIfAborted();
+                        }
+                        setupDone = true;
+                    }
+                    // Carry the workspace's resolved env (from `prepareWorkspace
+                    // → resolveCredentials`) into the runtime handle so drivers
+                    // that auth through `Options.env` (notably the Claude SDK
+                    // driver) can lift Anthropic keys out. Drivers that only
+                    // need the workspace path keep using `getWorkspacePath`.
+                    const runtime = {
+                        handle: ws.path,
+                        workspacePath: ws.path,
+                        env: ws.env,
+                    };
+                    if (deps.scriptedMcp) {
+                        scriptedHost = await startScriptedMcpMockHost(deps.scriptedMcp);
+                        sessionOptions.scriptedMcpHost = scriptedHost;
+                    }
+                    try {
+                        session = await createAgentSession(agent, runtime, runCommand, sessionOptions);
+                    }
+                    catch (error) {
+                        await scriptedHost?.dispose();
+                        scriptedHost = undefined;
+                        throw error;
                     }
-                    setupDone = true;
                 }
-                // Carry the workspace's resolved env (from `prepareWorkspace
-                // → resolveCredentials`) into the runtime handle so drivers
-                // that auth through `Options.env` (notably the Claude SDK
-                // driver) can lift Anthropic keys out. Drivers that only
-                // need the workspace path keep using `getWorkspacePath`.
-                const runtime = {
-                    handle: ws.path,
-                    workspacePath: ws.path,
-                    env: ws.env,
-                };
-                session = await createAgentSession(agent, runtime, runCommand, sessionOptions);
-                return session.start({ message });
-            }
-            return session.reply({ message });
-        }, remaining, label);
+                const turnNumber = ++nextTurnNumber;
+                scriptedHost?.beginTurn(turnNumber);
+                const result = turnNumber === 1
+                    ? await session.start({ message })
+                    : await session.reply({ message });
+                if (scriptedHost) {
+                    const settled = scriptedHost.settleEvents(result.toolEvents);
+                    result.toolEvents = settled.events;
+                    if (settled.error) {
+                        return { ...result, exitCode: 1, rawOutput: settled.error.message };
+                    }
+                }
+                return result;
+            }, remaining, label);
+        }
+        finally {
+            activeTurn = false;
+            currentSignal = undefined;
+        }
     };
     return {
         async send(message) {
@@ -108,9 +145,17 @@ export function createManagedSession(deps) {
             return Math.max(0, deadlineMs - Date.now());
         },
         async dispose() {
-            if (!session)
-                return;
-            await session.dispose?.();
+            if (disposePromise)
+                return disposePromise;
+            disposePromise = (async () => {
+                try {
+                    await session?.dispose?.();
+                }
+                finally {
+                    await scriptedHost?.dispose();
+                }
+            })();
+            return disposePromise;
         },
         askBus,
     };

package/dist/sdk/mcp-event-input.d.ts

@@ -0,0 +1,3 @@
+import type { ToolEvent } from '../tool-events.js';
+export declare function attachOriginalMcpInput(event: ToolEvent, input: Record<string, unknown>): ToolEvent;
+export declare function getOriginalMcpInput(event: ToolEvent): Record<string, unknown> | undefined;

package/dist/sdk/mcp-event-input.js

@@ -0,0 +1,8 @@
+const originalInputs = new WeakMap();
+export function attachOriginalMcpInput(event, input) {
+    originalInputs.set(event, input);
+    return event;
+}
+export function getOriginalMcpInput(event) {
+    return originalInputs.get(event);
+}

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

@@ -1,4 +1,38 @@
 import type { ToolEvent } from '../tool-events.js';
+export type McpInvocationResult = {
+    serverName: string;
+    toolName: string;
+} & ({
+    invocation: 'confirmed';
+    outcome: 'completed' | 'tool_error';
+    source: 'typed_receipt';
+} | {
+    invocation: 'unknown';
+    outcome: 'protocol_error' | 'unknown';
+    source: 'typed_receipt';
+} | {
+    invocation: 'not_invoked';
+    outcome: 'user_denied' | 'policy_denied' | 'protocol_error';
+    source: 'typed_enforcement';
+} | {
+    invocation: 'not_invoked';
+    outcome: 'user_denied' | 'policy_denied' | 'unknown';
+    source: 'legacy_denial';
+});
+export interface McpApprovalEvidence {
+    serverName?: string;
+    toolName?: string;
+    decision?: 'approve' | 'deny';
+    outcome?: 'matched' | 'unmatched' | 'protocol_error';
+    arguments: Record<string, unknown>;
+    event: ToolEvent;
+}
+export interface ExpectedMcpApproval {
+    serverName?: string;
+    toolName?: string;
+    decision?: 'approve' | 'deny';
+    outcome?: 'matched' | 'unmatched' | 'protocol_error';
+}
 export interface McpToolCallEvidence {
     serverName: string;
     toolName: string;
@@ -25,5 +59,10 @@ export interface ExpectedMcpStartupStatus {
 export declare function getMcpToolCall(event: ToolEvent): McpToolCallEvidence | undefined;
 export declare function isMcpToolCall(event: ToolEvent, expected?: ExpectedMcpToolCall): boolean;
 export declare function findMcpToolCalls(events: readonly ToolEvent[], expected?: ExpectedMcpToolCall): McpToolCallEvidence[];
+export declare function getMcpApproval(event: ToolEvent): McpApprovalEvidence | undefined;
+export declare function isMcpApproval(event: ToolEvent, expected?: ExpectedMcpApproval): boolean;
+export declare function findMcpApprovals(events: readonly ToolEvent[], expected?: ExpectedMcpApproval): McpApprovalEvidence[];
+export declare function getMcpInvocation(event: ToolEvent): McpInvocationResult | undefined;
+export declare function wasMcpToolInvoked(event: ToolEvent): boolean | undefined;
 export declare function getMcpStartupStatus(event: ToolEvent): McpStartupStatusEvidence | undefined;
 export declare function isMcpStartupStatus(event: ToolEvent, expected?: ExpectedMcpStartupStatus): boolean;

package/dist/sdk/mcp-evidence.js

@@ -17,24 +17,83 @@ export function getMcpToolCall(event) {
 }
 export function isMcpToolCall(event, expected = {}) {
     const call = getMcpToolCall(event);
-    if (!call)
-        return false;
-    if (expected.serverName !== undefined && call.serverName !== expected.serverName)
-        return false;
-    if (expected.toolName !== undefined && call.toolName !== expected.toolName)
-        return false;
-    if (expected.status !== undefined && call.status !== expected.status)
-        return false;
-    if (expected.argumentsContaining && !containsArguments(call.arguments, expected.argumentsContaining)) {
-        return false;
-    }
-    return true;
+    return call !== undefined && matchesMcpToolCall(call, expected);
 }
 export function findMcpToolCalls(events, expected = {}) {
     return events
         .map((event) => getMcpToolCall(event))
         .filter((call) => call !== undefined && matchesMcpToolCall(call, expected));
 }
+export function getMcpApproval(event) {
+    if (event.action !== 'mcp_approval')
+        return undefined;
+    const args = event.arguments ?? {};
+    const serverName = typeof args.server === 'string' ? args.server : undefined;
+    const toolName = typeof args.tool === 'string' ? args.tool : undefined;
+    const decision = args.decision === 'approve' || args.decision === 'deny' ? args.decision : undefined;
+    const outcome = args.outcome === 'matched' || args.outcome === 'unmatched' || args.outcome === 'protocol_error'
+        ? args.outcome : undefined;
+    return { ...(serverName ? { serverName } : {}), ...(toolName ? { toolName } : {}),
+        ...(decision ? { decision } : {}), ...(outcome ? { outcome } : {}), arguments: args, event };
+}
+export function isMcpApproval(event, expected = {}) {
+    const approval = getMcpApproval(event);
+    return approval !== undefined && matchesMcpApproval(approval, expected);
+}
+function matchesMcpApproval(approval, expected) {
+    return (expected.serverName === undefined || approval.serverName === expected.serverName)
+        && (expected.toolName === undefined || approval.toolName === expected.toolName)
+        && (expected.decision === undefined || approval.decision === expected.decision)
+        && (expected.outcome === undefined || approval.outcome === expected.outcome);
+}
+export function findMcpApprovals(events, expected = {}) {
+    return events
+        .map((event) => getMcpApproval(event))
+        .filter((approval) => approval !== undefined && matchesMcpApproval(approval, expected));
+}
+export function getMcpInvocation(event) {
+    if (event.action !== 'mcp_tool_call')
+        return undefined;
+    const typed = event.mcp;
+    if (typed !== undefined) {
+        if (!validTypedMcp(typed))
+            return undefined;
+        return { ...typed, source: typed.invocation === 'not_invoked' ? 'typed_enforcement' : 'typed_receipt' };
+    }
+    const args = event.arguments ?? {};
+    const serverName = typeof args.server === 'string' && args.server ? args.server : undefined;
+    const toolName = typeof args.tool === 'string' && args.tool ? args.tool : undefined;
+    if (!serverName || !toolName)
+        return undefined;
+    const status = args.status;
+    if (status === 'user_denied' || status === 'policy_denied') {
+        return { serverName, toolName, invocation: 'not_invoked', outcome: status, source: 'legacy_denial' };
+    }
+    if (status === 'declined' || status === 'rejected') {
+        return { serverName, toolName, invocation: 'not_invoked', outcome: 'unknown', source: 'legacy_denial' };
+    }
+    return undefined;
+}
+export function wasMcpToolInvoked(event) {
+    const result = getMcpInvocation(event);
+    if (!result)
+        return undefined;
+    if (result.invocation === 'confirmed')
+        return true;
+    if (result.invocation === 'not_invoked')
+        return false;
+    return undefined;
+}
+function validTypedMcp(value) {
+    if (!value.serverName || !value.toolName)
+        return false;
+    if (value.invocation === 'confirmed')
+        return value.outcome === 'completed' || value.outcome === 'tool_error';
+    if (value.invocation === 'not_invoked') {
+        return value.outcome === 'user_denied' || value.outcome === 'policy_denied' || value.outcome === 'protocol_error';
+    }
+    return value.invocation === 'unknown' && (value.outcome === 'protocol_error' || value.outcome === 'unknown');
+}
 export function getMcpStartupStatus(event) {
     if (event.providerToolName !== 'mcpServer/startupStatus/updated')
         return undefined;

package/dist/sdk/mcp-mock-approvals.d.ts

@@ -0,0 +1,40 @@
+import type { MockMcpServerDescriptor } from '../core/mcp-mock.types.js';
+export type McpMockJsonValue = null | boolean | number | string | McpMockJsonValue[] | {
+    [key: string]: McpMockJsonValue;
+};
+export interface McpMockApprovalRule {
+    serverName: string;
+    toolName: string;
+    argumentsContaining?: Record<string, McpMockJsonValue>;
+    decision: 'approve' | 'deny';
+    label?: string;
+}
+export interface CompiledMcpTool {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    readOnlyHint?: boolean;
+    cases: readonly Readonly<{
+        when?: string;
+        response: McpMockJsonValue;
+    }>[];
+}
+export interface CompiledMcpServer {
+    name: string;
+    instructions?: string;
+    tools: ReadonlyMap<string, CompiledMcpTool>;
+}
+export interface CompiledMcpMockSession {
+    servers: ReadonlyMap<string, CompiledMcpServer>;
+    rules: readonly Readonly<McpMockApprovalRule>[];
+}
+export type ScriptedMcpProvider = 'codex' | 'claude';
+export declare function compileMcpMockApprovalSession(opts: {
+    mcpMock: MockMcpServerDescriptor | MockMcpServerDescriptor[];
+    rules: readonly McpMockApprovalRule[];
+    provider: ScriptedMcpProvider;
+}): CompiledMcpMockSession;
+export declare function matchesMcpApprovalArguments(actual: Record<string, McpMockJsonValue>, expected: Record<string, McpMockJsonValue> | undefined): boolean;
+export declare function canonicalizeMcpArguments(value: McpMockJsonValue): string;
+export declare function createMcpArgumentDigest(key: Buffer, value: McpMockJsonValue): string;
+export declare function createMcpReceiptKey(): Buffer;