stitchkit 0.70.0 → 0.70.2

package/dist/testing.js

@@ -4,7 +4,7 @@ import {
 } from "./index-x1th9s8c.js";
 import {
   createApplication
-} from "./index-6wzr93cg.js";
+} from "./index-w0445741.js";
 import"./index-2k4yrqkc.js";
 import"./index-8eywc9zv.js";
 import {
@@ -12,7 +12,7 @@ import {
   RealtimeRequestInvalidAcknowledgementError,
   RealtimeRequestTimeoutError
 } from "./index-7b188kmz.js";
-import"./index-dk6e56g0.js";
+import"./index-7wpgrqa8.js";
 import {
   mcpProjectionCandidate,
   prepareProjectedMcpTools,
@@ -1389,72 +1389,90 @@ async function runManagedResourceConformance(config) {
   }
 }
 // src/testing/surface-conformance.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+
+// src/realtime/contract.ts
+import { z as z2 } from "zod";
+var RealtimeRejectDirectionSchema = z2.enum([
+  "client-inbound",
+  "client-outbound",
+  "server-inbound",
+  "server-outbound"
+]);
+var RealtimeRejectPhaseSchema = z2.enum(["arguments", "acknowledgement"]);
+var RealtimeRejectReasonSchema = z2.enum([
+  "unknown-event",
+  "invalid-arguments",
+  "invalid-acknowledgement-value",
+  "missing-acknowledgement",
+  "rejected-by-peer"
+]);
+var RealtimeRejectFaultSchema = z2.enum(["peer", "local"]);
 
 // src/testing/surface-manifest.ts
 import { createHash } from "node:crypto";
-import { z as z2 } from "zod";
-var HttpMethodSchema = z2.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
-var ToolTransportSchema = z2.enum(["MCP", "AGENT", "CLI"]);
-var SurfaceTransportSchema = z2.enum(["HTTP", "MCP", "AGENT", "CLI", "REALTIME"]);
-var SurfaceSchemaDigestsSchema = z2.object({
-  params: z2.string().nullable(),
-  input: z2.string().nullable(),
-  output: z2.string().nullable(),
-  multipart: z2.string().nullable()
+import { z as z3 } from "zod";
+var HttpMethodSchema = z3.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+var ToolTransportSchema = z3.enum(["MCP", "AGENT", "CLI"]);
+var SurfaceTransportSchema = z3.enum(["HTTP", "MCP", "AGENT", "CLI", "REALTIME"]);
+var SurfaceSchemaDigestsSchema = z3.object({
+  params: z3.string().nullable(),
+  input: z3.string().nullable(),
+  output: z3.string().nullable(),
+  multipart: z3.string().nullable()
 });
-var SurfaceManifestOperationSchema = z2.object({
-  kind: z2.enum(["contract", "runtime"]),
-  service: z2.string(),
-  action: z2.string(),
+var SurfaceManifestOperationSchema = z3.object({
+  kind: z3.enum(["contract", "runtime"]),
+  service: z3.string(),
+  action: z3.string(),
   method: HttpMethodSchema,
-  scope: z2.string().nullable(),
-  description: z2.string(),
+  scope: z3.string().nullable(),
+  description: z3.string(),
   schemas: SurfaceSchemaDigestsSchema,
-  http: z2.array(z2.object({ method: HttpMethodSchema, path: z2.string() }))
+  http: z3.array(z3.object({ method: HttpMethodSchema, path: z3.string() }))
 });
-var SurfaceManifestToolSchema = z2.object({
-  kind: z2.enum(["contract", "runtime"]),
-  service: z2.string(),
-  action: z2.string(),
-  name: z2.string(),
-  input: z2.string()
+var SurfaceManifestToolSchema = z3.object({
+  kind: z3.enum(["contract", "runtime"]),
+  service: z3.string(),
+  action: z3.string(),
+  name: z3.string(),
+  input: z3.string()
 });
-var SurfaceManifestToolSurfaceSchema = z2.object({
+var SurfaceManifestToolSurfaceSchema = z3.object({
   transport: ToolTransportSchema,
-  surface: z2.string().nullable(),
-  tools: z2.array(SurfaceManifestToolSchema)
+  surface: z3.string().nullable(),
+  tools: z3.array(SurfaceManifestToolSchema)
 });
-var SurfaceManifestCliCommandSchema = z2.object({
-  name: z2.string(),
-  description: z2.string(),
-  input: z2.string(),
-  output: z2.string().nullable()
+var SurfaceManifestCliCommandSchema = z3.object({
+  name: z3.string(),
+  description: z3.string(),
+  input: z3.string(),
+  output: z3.string().nullable()
 });
-var SurfaceManifestExtensionSchema = z2.object({
-  name: z2.string(),
+var SurfaceManifestExtensionSchema = z3.object({
+  name: z3.string(),
   transport: SurfaceTransportSchema
 });
-var SurfaceRealtimeSchemaPairSchema = z2.object({
-  input: z2.string(),
-  output: z2.string()
+var SurfaceRealtimeSchemaPairSchema = z3.object({
+  input: z3.string(),
+  output: z3.string()
 });
-var SurfaceManifestRealtimeEventSchema = z2.object({
-  contract: z2.string(),
-  direction: z2.enum(["serverToClient", "clientToServer"]),
-  event: z2.string(),
+var SurfaceManifestRealtimeEventSchema = z3.object({
+  contract: z3.string(),
+  direction: z3.enum(["serverToClient", "clientToServer"]),
+  event: z3.string(),
   args: SurfaceRealtimeSchemaPairSchema,
   acknowledgement: SurfaceRealtimeSchemaPairSchema.nullable()
 });
-var SurfaceManifestSchema = z2.object({
-  manifestVersion: z2.literal(2),
-  digestVersion: z2.literal(1),
-  operations: z2.array(SurfaceManifestOperationSchema),
-  toolSurfaces: z2.array(SurfaceManifestToolSurfaceSchema),
-  realtimeContracts: z2.array(z2.string()),
-  realtime: z2.array(SurfaceManifestRealtimeEventSchema),
-  cliOnly: z2.array(SurfaceManifestCliCommandSchema),
-  extensions: z2.array(SurfaceManifestExtensionSchema)
+var SurfaceManifestSchema = z3.object({
+  manifestVersion: z3.literal(2),
+  digestVersion: z3.literal(1),
+  operations: z3.array(SurfaceManifestOperationSchema),
+  toolSurfaces: z3.array(SurfaceManifestToolSurfaceSchema),
+  realtimeContracts: z3.array(z3.string()),
+  realtime: z3.array(SurfaceManifestRealtimeEventSchema),
+  cliOnly: z3.array(SurfaceManifestCliCommandSchema),
+  extensions: z3.array(SurfaceManifestExtensionSchema)
 });
 function compareCodepoints(left, right) {
   if (left < right)
@@ -1735,52 +1753,42 @@ actual: ${actual}`);
 }
 
 // src/testing/surface-conformance.ts
-var RealtimeRejectionObservationSchema = z3.object({
-  direction: z3.enum([
-    "client-inbound",
-    "client-outbound",
-    "server-inbound",
-    "server-outbound"
-  ]),
-  phase: z3.enum(["arguments", "acknowledgement"]),
-  reason: z3.enum([
-    "unknown-event",
-    "invalid-arguments",
-    "invalid-acknowledgement-value",
-    "missing-acknowledgement"
-  ]),
-  fault: z3.enum(["peer", "local"])
+var RealtimeRejectionObservationSchema = z4.object({
+  direction: RealtimeRejectDirectionSchema,
+  phase: RealtimeRejectPhaseSchema,
+  reason: RealtimeRejectReasonSchema,
+  fault: RealtimeRejectFaultSchema
 });
 var ObservationFields = {
-  code: z3.string().optional(),
-  data: z3.unknown().optional(),
-  diagnostic: z3.string().optional(),
-  handlerCalls: z3.number().int().nonnegative().optional()
+  code: z4.string().optional(),
+  data: z4.unknown().optional(),
+  diagnostic: z4.string().optional(),
+  handlerCalls: z4.number().int().nonnegative().optional()
 };
-var RealtimeDisconnectObservationSchema = z3.object({
-  phase: z3.enum(["before-invoke", "in-flight"])
+var RealtimeDisconnectObservationSchema = z4.object({
+  phase: z4.enum(["before-invoke", "in-flight"])
 });
-var TransportObservationSchema = z3.discriminatedUnion("outcome", [
-  z3.object({ outcome: z3.literal("success"), ...ObservationFields }),
-  z3.object({ outcome: z3.literal("validation_error"), ...ObservationFields }),
-  z3.object({ outcome: z3.literal("domain_error"), ...ObservationFields }),
-  z3.object({ outcome: z3.literal("aborted"), ...ObservationFields }),
-  z3.object({
-    outcome: z3.literal("realtime_rejected"),
+var TransportObservationSchema = z4.discriminatedUnion("outcome", [
+  z4.object({ outcome: z4.literal("success"), ...ObservationFields }),
+  z4.object({ outcome: z4.literal("validation_error"), ...ObservationFields }),
+  z4.object({ outcome: z4.literal("domain_error"), ...ObservationFields }),
+  z4.object({ outcome: z4.literal("aborted"), ...ObservationFields }),
+  z4.object({
+    outcome: z4.literal("realtime_rejected"),
     ...ObservationFields,
     rejection: RealtimeRejectionObservationSchema
   }),
-  z3.object({
-    outcome: z3.literal("disconnected"),
+  z4.object({
+    outcome: z4.literal("disconnected"),
     ...ObservationFields,
     disconnect: RealtimeDisconnectObservationSchema
   }),
-  z3.object({ outcome: z3.literal("timeout"), ...ObservationFields })
+  z4.object({ outcome: z4.literal("timeout"), ...ObservationFields })
 ]);
 function scenarioOutcome(scenario) {
   if (scenario === "event" || scenario === "acknowledgement")
     return "success";
-  if (scenario === "invalid_arguments" || scenario === "invalid_acknowledgement") {
+  if (scenario === "invalid_arguments" || scenario === "invalid_acknowledgement" || scenario === "peer_rejection") {
     return "realtime_rejected";
   }
   if (scenario === "disconnected" || scenario === "in_flight_disconnect") {
@@ -1799,6 +1807,9 @@ function assertScenarioExpectation(scenario, expected) {
   if (scenario === "invalid_arguments" && expected.handlerCalls !== 0) {
     throw new TypeError('Realtime probe scenario "invalid_arguments" requires handlerCalls: 0');
   }
+  if (scenario === "peer_rejection" && (expected.outcome !== "realtime_rejected" || expected.rejection.reason !== "rejected-by-peer")) {
+    throw new TypeError('Realtime probe scenario "peer_rejection" requires a rejected-by-peer outcome');
+  }
   if (expected.outcome === "disconnected") {
     const phase = scenario === "disconnected" ? "before-invoke" : "in-flight";
     if (expected.disconnect.phase !== phase) {
@@ -2087,35 +2098,35 @@ function createHandlerTestClients(config) {
   return createClients(config.contracts, createTestClientConfig(config), config.contractConfig);
 }
 export {
-  ManagedResourceConformanceError,
-  ManagedResourceConformancePhaseSchema,
-  ManagedResourceConformanceScenarioIdSchema,
-  ManagedResourceConformanceScenarioSchema,
-  ManagedResourceConformanceTraceEntrySchema,
-  ManagedResourceConformanceTraceOutcomeSchema,
-  RealtimeDisconnectObservationSchema,
-  RealtimeRejectionObservationSchema,
-  SurfaceManifestExtensionSchema,
-  SurfaceManifestOperationSchema,
-  SurfaceManifestRealtimeEventSchema,
-  SurfaceManifestSchema,
-  SurfaceManifestToolSchema,
-  SurfaceManifestToolSurfaceSchema,
-  SurfaceRealtimeSchemaPairSchema,
-  SurfaceSchemaDigestsSchema,
-  TransportObservationSchema,
-  assertSurfaceDiscovery,
-  assertSurfaceManifestSnapshot,
-  buildSurfaceManifest,
-  createAgentRaceBarrier,
-  createAgentRaceDriver,
-  createAgentRaceTrace,
-  createHandlerTestClient,
-  createHandlerTestClients,
-  createRealtimeProbeDriver,
-  defineRealtimeProbe,
-  runAgentStoreConformance,
-  runManagedResourceConformance,
+  serializeSurfaceValue,
   runSurfaceProbes,
-  serializeSurfaceValue
+  runManagedResourceConformance,
+  runAgentStoreConformance,
+  defineRealtimeProbe,
+  createRealtimeProbeDriver,
+  createHandlerTestClients,
+  createHandlerTestClient,
+  createAgentRaceTrace,
+  createAgentRaceDriver,
+  createAgentRaceBarrier,
+  buildSurfaceManifest,
+  assertSurfaceManifestSnapshot,
+  assertSurfaceDiscovery,
+  TransportObservationSchema,
+  SurfaceSchemaDigestsSchema,
+  SurfaceRealtimeSchemaPairSchema,
+  SurfaceManifestToolSurfaceSchema,
+  SurfaceManifestToolSchema,
+  SurfaceManifestSchema,
+  SurfaceManifestRealtimeEventSchema,
+  SurfaceManifestOperationSchema,
+  SurfaceManifestExtensionSchema,
+  RealtimeRejectionObservationSchema,
+  RealtimeDisconnectObservationSchema,
+  ManagedResourceConformanceTraceOutcomeSchema,
+  ManagedResourceConformanceTraceEntrySchema,
+  ManagedResourceConformanceScenarioSchema,
+  ManagedResourceConformanceScenarioIdSchema,
+  ManagedResourceConformancePhaseSchema,
+  ManagedResourceConformanceError
 };

package/dist/tools.js

@@ -2666,62 +2666,62 @@ function summarizeTransports(surface) {
   };
 }
 export {
-  AsyncOperationCancelResultSchema,
-  EXT_APPS_BUNDLE_PLACEHOLDER,
-  McpAnnotationsSchema,
-  McpMediaContentSchema,
-  PORTABLE_JSON_SCHEMA_FORMATS,
-  PROTECTED_RESOURCE_PATH,
-  RESOURCE_MIME_TYPE,
-  ToolExecutionControlError,
-  UploadToolInputSchema,
-  ViewFileErrorSchema,
-  ViewFileInputSchema,
-  ViewFileOutputSchema,
-  bindContractAsyncOperation,
-  bindStdioProcessSignals,
-  buildMcpServer,
-  buildToolManifest,
-  coerceJsonArgs,
-  collectTools,
-  composeToolLifecycle,
-  createAsyncOperationSnapshotSchema,
-  createCli,
-  createMcpHandler,
-  createMcpHttpRoute,
-  createRuntimeToolFactory,
-  createSecureClientMetadataFetcher,
-  createStdioMcpServer,
-  createToolInvoker,
-  createToolLogger,
-  createToolkit,
-  defineAsyncOperation,
-  defineAsyncOperationContract,
-  defineCliCommand,
-  defineDownloadTool,
-  defineRuntimeTool,
-  defineUploadTool,
-  defineViewFileTool,
-  defineWaitTool,
-  findNonPortableFormats,
-  findUntypedProperties,
-  flattenToolJsonSchema,
-  inlineMcpAppBundle,
-  isToolExecutionControlError,
-  listContractToolNames,
-  listToolNames,
-  mountAgent,
-  mountDownload,
-  mountMcp,
-  mountMcpResource,
-  mountOAuthProvider,
-  mountUpload,
-  mountViewFile,
-  mountWait,
-  oauthProtectedResourceRoute,
-  protectedResourceMetadataUrl,
-  resolveMedia,
-  summarizeTransports,
+  wwwAuthenticateHeader,
   validateMcpSchemas,
-  wwwAuthenticateHeader
+  summarizeTransports,
+  resolveMedia,
+  protectedResourceMetadataUrl,
+  oauthProtectedResourceRoute,
+  mountWait,
+  mountViewFile,
+  mountUpload,
+  mountOAuthProvider,
+  mountMcpResource,
+  mountMcp,
+  mountDownload,
+  mountAgent,
+  listToolNames,
+  listContractToolNames,
+  isToolExecutionControlError,
+  inlineMcpAppBundle,
+  flattenToolJsonSchema,
+  findUntypedProperties,
+  findNonPortableFormats,
+  defineWaitTool,
+  defineViewFileTool,
+  defineUploadTool,
+  defineRuntimeTool,
+  defineDownloadTool,
+  defineCliCommand,
+  defineAsyncOperationContract,
+  defineAsyncOperation,
+  createToolkit,
+  createToolLogger,
+  createToolInvoker,
+  createStdioMcpServer,
+  createSecureClientMetadataFetcher,
+  createRuntimeToolFactory,
+  createMcpHttpRoute,
+  createMcpHandler,
+  createCli,
+  createAsyncOperationSnapshotSchema,
+  composeToolLifecycle,
+  collectTools,
+  coerceJsonArgs,
+  buildToolManifest,
+  buildMcpServer,
+  bindStdioProcessSignals,
+  bindContractAsyncOperation,
+  ViewFileOutputSchema,
+  ViewFileInputSchema,
+  ViewFileErrorSchema,
+  UploadToolInputSchema,
+  ToolExecutionControlError,
+  RESOURCE_MIME_TYPE,
+  PROTECTED_RESOURCE_PATH,
+  PORTABLE_JSON_SCHEMA_FORMATS,
+  McpMediaContentSchema,
+  McpAnnotationsSchema,
+  EXT_APPS_BUNDLE_PLACEHOLDER,
+  AsyncOperationCancelResultSchema
 };