eval-quality 1.4.2 → 3.0.0

package/dist/core/preflight/plan.js

@@ -8,11 +8,14 @@
  * the operation and the witness themselves: there is nothing to look an
  * identifier up in at reduce time.
  */
-import { checkInputsAgainstShape, isApiWitnessInputs, } from '../compile/sensitivity-witness.js';
-import { declaresNoRequiredKeys, isCommandOperation, } from '../declared-inputs.js';
+import { isSupportedInterfaceKind, SUPPORTED_KINDS_CLAUSE, } from '../compile/interface-inventory.js';
+import { checkSchemaVersion } from '../compile/schema-version.js';
+import { checkInputsAgainstShape, isApiWitnessInputs, isMcpWitnessInputs, } from '../compile/sensitivity-witness.js';
+import { declaresNoRequiredKeys, isCommandOperation, isMcpOperation, } from '../declared-inputs.js';
 import { referenceSetKeysOf } from '../evaluate/evidence-resolution.js';
 import { StructuralFailure } from '../failure-codes.js';
 import { operationsOf } from '../schemas/interface.js';
+import { PROBE_SCHEMA_VERSION, PROBE_SCHEMA_VERSION_CONSEQUENCE, } from '../schemas/probe.js';
 import { referenceSetMembers } from './witness-evidence.js';
 const requestOf = (legId, interfaceId, operation, inputs) => {
     // NFR9's correlation by identifier: the port echoes these back, and they
@@ -22,6 +25,21 @@ const requestOf = (legId, interfaceId, operation, inputs) => {
         interfaceId,
         operationId: operation.operationId,
     };
+    const operationPath = `EvalContract.permittedInterfaces[logicalId=${interfaceId}].operations[operationId=${operation.operationId}]`;
+    if (isMcpOperation(operation)) {
+        if (!isMcpWitnessInputs(inputs)) {
+            throw new StructuralFailure('undeclared-mandatory-input', operationPath, `leg "${legId}" supplies channels a tool call does not carry (AD-10, AD-19)`);
+        }
+        return {
+            ...correlation,
+            kind: 'mcp',
+            toolName: operation.toolName,
+            channels: { arguments: inputs.arguments },
+        };
+    }
+    if (isMcpWitnessInputs(inputs)) {
+        throw new StructuralFailure('undeclared-mandatory-input', operationPath, `leg "${legId}" supplies a tool call's arguments to an operation that is not a tool call (AD-10, AD-19)`);
+    }
     if (isCommandOperation(operation)) {
         if (isApiWitnessInputs(inputs)) {
             throw new StructuralFailure('undeclared-mandatory-input', `EvalContract.permittedInterfaces[logicalId=${interfaceId}].operations[operationId=${operation.operationId}]`, `leg "${legId}" supplies transport channels to an operation that runs behind a command (AD-10, AD-19)`);
@@ -104,6 +122,7 @@ const EMPTY_INPUTS = {
     header: {},
     body: { kind: 'absent' },
 };
+const EMPTY_MCP_INPUTS = { arguments: {} };
 /**
  * The inputs a control leg sends. A witness supplies them when the operation has
  * one; an operation AD-10 exempts has no required key to fill, so empty inputs
@@ -124,7 +143,11 @@ const controlInputs = (operation) => {
     // port sends what the operation's own channels name.
     if (!declaresNoRequiredKeys(operation))
         return null;
-    return isCommandOperation(operation) ? EMPTY_COMMAND_INPUTS : EMPTY_INPUTS;
+    if (isCommandOperation(operation))
+        return EMPTY_COMMAND_INPUTS;
+    if (isMcpOperation(operation))
+        return EMPTY_MCP_INPUTS;
+    return EMPTY_INPUTS;
 };
 const targetOf = (iface, operation) => {
     const inputs = controlInputs(operation);
@@ -181,11 +204,25 @@ const selectControl = (contract, permittedInterfaces) => {
  */
 export const planPreflight = (input) => {
     const { contract, probes, runId } = input;
+    // First, and before any check reads a probe. AD-11 makes an unequal stamp a
+    // rejection rather than a degraded read, and every rule below is written
+    // against this version's field shapes. `compile` performs the same check for
+    // the contract; this is the probe's reader, since a probe reaches no other
+    // core stage on the pre-flight path.
+    for (const probe of probes) {
+        checkSchemaVersion({
+            stamped: probe.schemaVersion,
+            accepted: PROBE_SCHEMA_VERSION,
+            artifactPath: `Probe[probeId=${probe.probeId}].schemaVersion`,
+            consequence: PROBE_SCHEMA_VERSION_CONSEQUENCE,
+        });
+    }
     for (const iface of contract.permittedInterfaces) {
         // Already thrown at compile; asserted again because the plan is
-        // reachable from a caller who assembled a contract by hand.
-        if (iface.kind !== 'api' && iface.kind !== 'cli') {
-            throw new StructuralFailure('unsupported-interface-kind', `EvalContract.permittedInterfaces[logicalId=${iface.logicalId}].kind`, `"${iface.kind}" is not supported; "api" and "cli" are (AD-10)`);
+        // reachable from a caller who assembled a contract by hand. Reads the
+        // compile gate's own tuple, so opening a kind moves one literal.
+        if (!isSupportedInterfaceKind(iface.kind)) {
+            throw new StructuralFailure('unsupported-interface-kind', `EvalContract.permittedInterfaces[logicalId=${iface.logicalId}].kind`, `"${iface.kind}" is not supported; ${SUPPORTED_KINDS_CLAUSE} (AD-10)`);
         }
     }
     const permittedInterfaces = contract.permittedInterfaces;

package/dist/core/preflight/projection.d.ts

@@ -2,7 +2,7 @@ import type { AnyOperation } from '../schemas/interface.ts';
 import type { ProbeObservation, ProbeObservedBody } from '../schemas/port-messages.ts';
 export declare const PREFLIGHT_ARTIFACT_PATH = "PreflightVerdict";
 /**
- * The five fields and no others. Response headers are outside the projection
+ * The closed projection, and nothing outside it. Response headers are outside
  * because `volatilePointers` is a `DescriptorPointer` and the response
  * descriptor is body-scoped, so no declaration can mark a header volatile, and
  * unprunable headers would fail the repeated-read immutability branch on any
@@ -12,6 +12,13 @@ export declare const PREFLIGHT_ARTIFACT_PATH = "PreflightVerdict";
  * header digest identically, and a witness relation can read a header this
  * projection cannot see. The projection says what the fixture is; a relation
  * addressing a header is the author asserting that header is stable.
+ *
+ * `status`, `exitCode` and `toolError` are one family, one per kind, each
+ * `null` off its own kind. All three answer whether the call went through, and
+ * the projection's test for membership is whether a declaration can prune the
+ * field: none of the three can be. A projection blind to the tool error flag
+ * would digest two legs identical when one errored and one did not, which is
+ * the state-reset check reporting a reset that never happened.
  */
 export type ProjectedObservation = {
     readonly legId: string;
@@ -21,6 +28,8 @@ export type ProjectedObservation = {
     readonly status: number | null;
     /** the process exit code, or `null` on an interface that does. */
     readonly exitCode: number | null;
+    /** the tool call's error flag, or `null` off an interface that calls one. */
+    readonly toolError: boolean | null;
     readonly body: ProbeObservedBody;
 };
 /**

package/dist/core/preflight/projection.js

@@ -74,18 +74,22 @@ export function projectObservation(observation, operation, artifactPath) {
     // The channel the operation's descriptor describes is the one AD-10's
     // relation reads, so it is the one the volatile pointers are pruned from.
     // Off an interface that speaks HTTP that is the response body; off a
-    // command it is the stream or the file the operation nominates.
+    // command it is the stream or the file the operation nominates; off a tool
+    // call it is the structured result, which is the kind's only body channel.
     const observed = observation.kind === 'api'
         ? observation.body
-        : describedChannelOf(observation, operation);
+        : observation.kind === 'mcp'
+            ? observation.result
+            : describedChannelOf(observation, operation);
     return {
         legId: observation.probeId,
         interfaceId: observation.interfaceId,
         operationId: observation.operationId,
-        // A command has no transport status. `null` is what a reader of this
-        // field asks about, and every such reader already handles it.
+        // Each of the three reads `null` off its own kind. Every reader of these
+        // fields already asks about `null`.
         status: observation.kind === 'api' ? observation.status : null,
-        exitCode: observation.kind === 'api' ? null : observation.exitCode,
+        exitCode: observation.kind === 'cli' ? observation.exitCode : null,
+        toolError: observation.kind === 'mcp' ? observation.isError : null,
         body: pruneVolatile(observed, operation.volatilePointers, artifactPath),
     };
 }

package/dist/core/preflight/reduce.js

@@ -22,8 +22,9 @@ const ANOMALOUS_STATUS = 400;
 /**
  * What makes a control leg anomalous, in the vocabulary of the kind it ran
  * against, or `null` when nothing does. A command's analogue of a 4xx is a
- * non-zero exit: both are the system saying the call did not go through, and
- * AD-10's clean-control check is about exactly that.
+ * non-zero exit and a tool call's is the envelope's error flag: all three are
+ * the system saying the call did not go through, and AD-10's clean-control
+ * check is about exactly that.
  */
 function anomalyOf(observation) {
     if (observation.kind === 'api') {
@@ -31,6 +32,9 @@ function anomalyOf(observation) {
             ? `status ${observation.status}`
             : null;
     }
+    if (observation.kind === 'mcp') {
+        return observation.isError ? 'a reported tool error' : null;
+    }
     return observation.exitCode === 0 ? null : `exit code ${observation.exitCode}`;
 }
 /**

package/dist/core/preflight/witness-evidence.js

@@ -4,6 +4,7 @@
  * unchanged. This module supplies the `Observation` shape they read and a
  * collection predicate scoped to one operation.
  */
+import { isMcpWitnessInputs } from '../compile/sensitivity-witness.js';
 import { descriptorArtifactOf, descriptorChannelOf, } from '../declared-inputs.js';
 import { makeResolveOperand } from '../evaluate/evidence-resolution.js';
 import { resolveCheck, } from '../evaluate/resolution.js';
@@ -40,6 +41,7 @@ const callInputsOf = (inputs) => {
         option: null,
         environment: null,
         stdin: null,
+        arguments: null,
     };
     if ('body' in inputs) {
         return {
@@ -50,6 +52,13 @@ const callInputsOf = (inputs) => {
             body: inputs.body.kind === 'json' ? asJsonObject(inputs.body.value) : null,
         };
     }
+    // A tool call supplies one channel, so `arguments` carries the whole of what
+    // the leg sent and the other eight read `null`. That is the channel
+    // `checkExpressionLegChannel` admits `call-inputs` against for an mcp
+    // operation, so a relation over `/interactions/{legId}/call-inputs/arguments`
+    // resolves what the leg supplied.
+    if (isMcpWitnessInputs(inputs))
+        return { ...empty, arguments: inputs.arguments };
     return {
         ...empty,
         argument: inputs.argument,
@@ -89,20 +98,33 @@ export function evidenceOf(projected, observation, inputs, operation) {
         callInputs: callInputsOf(inputs),
         // The projected body is whichever channel the operation's descriptor
         // describes, so it lands on the channel a relation addresses. Both are
-        // filled from the same projection rather than one being derived from
-        // the other, and every channel the leg did not observe is written down
-        // as unobserved rather than left to a default.
-        responseBody: observation.kind === 'api' ? bodyValue(body) : null,
+        // filled from the same projection, and every channel the leg did not
+        // observe is written down here as unobserved. A tool call's structured
+        // result is a response body and lands where an api body does; the
+        // command streams are the one projected body that goes elsewhere.
+        responseBody: observation.kind === 'cli' ? null : bodyValue(body),
         responseHeaders: observation.kind === 'api' ? observation.headers : null,
-        responseStatus: observation.kind === 'api' ? observation.status : null,
-        stdout: observation.kind === 'api' || descriptorChannel !== 'stdout'
+        // A tool call has no transport status, so the channel AD-26 fixed as a
+        // number carries the envelope's error flag instead: 1 when the tool
+        // reported an error and 0 when it did not. The projection is spelled
+        // here because a 0 in a field typed `number | null` is otherwise
+        // indistinguishable from a transport status of zero, and an oracle
+        // asserting that a tool reported no error reads this value.
+        responseStatus: observation.kind === 'api'
+            ? observation.status
+            : observation.kind === 'mcp'
+                ? observation.isError
+                    ? 1
+                    : 0
+                : null,
+        stdout: observation.kind !== 'cli' || descriptorChannel !== 'stdout'
             ? ABSENT_CHANNEL
             : body,
-        stderr: observation.kind === 'api' || descriptorChannel !== 'stderr'
+        stderr: observation.kind !== 'cli' || descriptorChannel !== 'stderr'
             ? ABSENT_CHANNEL
             : body,
-        exitCode: observation.kind === 'api' ? null : observation.exitCode,
-        artifacts: observation.kind === 'api' || describedArtifact === null
+        exitCode: observation.kind === 'cli' ? observation.exitCode : null,
+        artifacts: observation.kind !== 'cli' || describedArtifact === null
             ? {}
             : { [describedArtifact]: body },
     };

package/dist/core/schemas/artifact.d.ts

@@ -209,6 +209,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                         witnessId: z.ZodString;
                         channel: z.ZodEnum<{
                             argument: "argument";
+                            arguments: "arguments";
                             body: "body";
                             environment: "environment";
                             option: "option";
@@ -241,6 +242,8 @@ export declare const INTERCHANGE_ARTIFACTS: {
                                 }, z.core.$strict>, z.ZodObject<{
                                     kind: z.ZodLiteral<"absent">;
                                 }, z.core.$strict>], "kind">;
+                            }, z.core.$strict>, z.ZodObject<{
+                                arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                             }, z.core.$strict>]>;
                         }, z.core.$strict>>;
                         relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -350,6 +353,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                         witnessId: z.ZodString;
                         channel: z.ZodEnum<{
                             argument: "argument";
+                            arguments: "arguments";
                             body: "body";
                             environment: "environment";
                             option: "option";
@@ -382,6 +386,8 @@ export declare const INTERCHANGE_ARTIFACTS: {
                                 }, z.core.$strict>, z.ZodObject<{
                                     kind: z.ZodLiteral<"absent">;
                                 }, z.core.$strict>], "kind">;
+                            }, z.core.$strict>, z.ZodObject<{
+                                arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                             }, z.core.$strict>]>;
                         }, z.core.$strict>>;
                         relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -392,55 +398,10 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 kind: z.ZodLiteral<"mcp">;
                 operations: z.ZodArray<z.ZodObject<{
                     operationId: z.ZodString;
-                    method: z.ZodEnum<{
-                        DELETE: "DELETE";
-                        GET: "GET";
-                        HEAD: "HEAD";
-                        OPTIONS: "OPTIONS";
-                        PATCH: "PATCH";
-                        POST: "POST";
-                        PUT: "PUT";
-                    }>;
-                    pathTemplate: z.ZodString;
+                    toolName: z.ZodString;
                     stateChangeMarker: z.ZodBoolean;
                     requestShape: z.ZodObject<{
-                        path: z.ZodObject<{
-                            requiredKeys: z.ZodArray<z.ZodString>;
-                            permittedKeys: z.ZodArray<z.ZodString>;
-                            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
-                                array: "array";
-                                boolean: "boolean";
-                                null: "null";
-                                number: "number";
-                                object: "object";
-                                string: "string";
-                            }>>>;
-                        }, z.core.$strict>;
-                        query: z.ZodObject<{
-                            requiredKeys: z.ZodArray<z.ZodString>;
-                            permittedKeys: z.ZodArray<z.ZodString>;
-                            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
-                                array: "array";
-                                boolean: "boolean";
-                                null: "null";
-                                number: "number";
-                                object: "object";
-                                string: "string";
-                            }>>>;
-                        }, z.core.$strict>;
-                        header: z.ZodObject<{
-                            requiredKeys: z.ZodArray<z.ZodString>;
-                            permittedKeys: z.ZodArray<z.ZodString>;
-                            types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
-                                array: "array";
-                                boolean: "boolean";
-                                null: "null";
-                                number: "number";
-                                object: "object";
-                                string: "string";
-                            }>>>;
-                        }, z.core.$strict>;
-                        body: z.ZodObject<{
+                        arguments: z.ZodObject<{
                             requiredKeys: z.ZodArray<z.ZodString>;
                             permittedKeys: z.ZodArray<z.ZodString>;
                             types: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodEnum<{
@@ -453,6 +414,9 @@ export declare const INTERCHANGE_ARTIFACTS: {
                             }>>>;
                         }, z.core.$strict>;
                     }, z.core.$strict>;
+                    descriptorChannel: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"structured-result">;
+                    }, z.core.$strict>], "kind">;
                     responseDescriptor: z.ZodObject<{
                         requiredKeys: z.ZodArray<z.ZodString>;
                         permittedKeys: z.ZodArray<z.ZodString>;
@@ -491,6 +455,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                         witnessId: z.ZodString;
                         channel: z.ZodEnum<{
                             argument: "argument";
+                            arguments: "arguments";
                             body: "body";
                             environment: "environment";
                             option: "option";
@@ -523,6 +488,8 @@ export declare const INTERCHANGE_ARTIFACTS: {
                                 }, z.core.$strict>, z.ZodObject<{
                                     kind: z.ZodLiteral<"absent">;
                                 }, z.core.$strict>], "kind">;
+                            }, z.core.$strict>, z.ZodObject<{
+                                arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                             }, z.core.$strict>]>;
                         }, z.core.$strict>>;
                         relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -637,6 +604,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                         witnessId: z.ZodString;
                         channel: z.ZodEnum<{
                             argument: "argument";
+                            arguments: "arguments";
                             body: "body";
                             environment: "environment";
                             option: "option";
@@ -669,6 +637,8 @@ export declare const INTERCHANGE_ARTIFACTS: {
                                 }, z.core.$strict>, z.ZodObject<{
                                     kind: z.ZodLiteral<"absent">;
                                 }, z.core.$strict>], "kind">;
+                            }, z.core.$strict>, z.ZodObject<{
+                                arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                             }, z.core.$strict>]>;
                         }, z.core.$strict>>;
                         relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -785,6 +755,19 @@ export declare const INTERCHANGE_ARTIFACTS: {
                     }, z.core.$strict>, z.ZodObject<{
                         principal: z.ZodString;
                     }, z.core.$strict>]>>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    arguments: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                        literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        matcher: z.ZodEnum<{
+                            any: "any";
+                            "type-violating": "type-violating";
+                        }>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        captured: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        principal: z.ZodString;
+                    }, z.core.$strict>]>>>;
                 }, z.core.$strict>]>;
                 after: z.ZodNullable<z.ZodString>;
                 cardinality: z.ZodEnum<{
@@ -851,6 +834,8 @@ export declare const INTERCHANGE_ARTIFACTS: {
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"absent">;
                     }, z.core.$strict>], "kind">;
+                }, z.core.$strict>, z.ZodObject<{
+                    arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                 }, z.core.$strict>]>;
             }, z.core.$strict>>;
         }, z.core.$strict>;
@@ -1076,6 +1061,7 @@ export declare const INTERCHANGE_ARTIFACTS: {
                     option: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
                     environment: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
                     stdin: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
+                    arguments: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
                 }, z.core.$strict>;
                 responseBody: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>>;
                 responseHeaders: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
@@ -1148,7 +1134,6 @@ export declare const INTERCHANGE_ARTIFACTS: {
                 truncationBound: z.ZodNullable<z.ZodInt>;
                 reportedIncomplete: z.ZodBoolean;
             }, z.core.$strict>;
-            invalidReason: z.ZodNullable<z.ZodString>;
         }, z.core.$strict>;
         readonly priorArt: 'h0-run-result';
         readonly carriesLineage: true;
@@ -1440,6 +1425,8 @@ export declare const INTERCHANGE_ARTIFACTS: {
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"absent">;
                         }, z.core.$strict>], "kind">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                     }, z.core.$strict>]>;
                     relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
                 }, z.core.$strict>>;
@@ -1636,6 +1623,8 @@ export declare const INTERCHANGE_ARTIFACTS: {
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"absent">;
                         }, z.core.$strict>], "kind">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        arguments: z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>;
                     }, z.core.$strict>]>;
                     relation: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
                 }, z.core.$strict>>;
@@ -1718,13 +1707,20 @@ export declare const INTERCHANGE_ARTIFACTS: {
                                     "type-violating": "type-violating";
                                 }>;
                             }, z.core.$strict>]>>>;
+                            arguments: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
                         }, z.core.$strict>;
                     }, z.core.$strict>;
                     predicate: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
                 }, z.core.$strict>;
                 interfaceKind: z.ZodEnum<{
                     api: "api";
-                    mcp: "mcp";
                     web: "web";
                 }>;
                 method: z.ZodEnum<{
@@ -1815,6 +1811,14 @@ export declare const INTERCHANGE_ARTIFACTS: {
                                     "type-violating": "type-violating";
                                 }>;
                             }, z.core.$strict>]>>>;
+                            arguments: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
                         }, z.core.$strict>;
                     }, z.core.$strict>;
                     predicate: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
@@ -1824,6 +1828,98 @@ export declare const INTERCHANGE_ARTIFACTS: {
                     executable: z.ZodString;
                     subcommandPath: z.ZodArray<z.ZodString>;
                 }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                observableChannel: z.ZodEnum<{
+                    artifact: "artifact";
+                    "call-inputs": "call-inputs";
+                    "exit-code": "exit-code";
+                    "response-body": "response-body";
+                    "response-headers": "response-headers";
+                    "response-status": "response-status";
+                    stderr: "stderr";
+                    stdout: "stdout";
+                }>;
+                condition: z.ZodObject<{
+                    selector: z.ZodObject<{
+                        inputBinding: z.ZodObject<{
+                            path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                            query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                            header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                            body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                            argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                            option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                            environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                            stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                            arguments: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                                literal: z.ZodType<import("./primitives.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonValue, unknown>>;
+                            }, z.core.$strict>, z.ZodObject<{
+                                matcher: z.ZodEnum<{
+                                    any: "any";
+                                    "type-violating": "type-violating";
+                                }>;
+                            }, z.core.$strict>]>>>;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>;
+                    predicate: z.ZodType<import("./expression.ts").Expression, unknown, z.core.$ZodTypeInternals<import("./expression.ts").Expression, unknown>>;
+                }, z.core.$strict>;
+                interfaceKind: z.ZodLiteral<"mcp">;
+                toolName: z.ZodString;
             }, z.core.$strict>]>>;
         }, z.core.$strict>], "expectedClean">;
         readonly priorArt: 'h0-ground-truth';