stitchkit 0.100.2 → 0.100.3

package/dist/{index-e01r054k.js → index-45tdvqa3.js}

@@ -1,30 +1,30 @@
 import {
-  deriveCodeChallenge
-} from "./index-hr4tzbwq.js";
+  unauthorized2
+} from "./index-n53mswt3.js";
 import {
-  base64UrlToBytes,
-  bytesToBase64Url
-} from "./index-rxfy4cq7.js";
+  deriveCodeChallenge2
+} from "./index-ap3gqe56.js";
 import {
-  unauthorized
-} from "./index-2vtcmrj9.js";
+  bytesToBase64Url,
+  base64UrlToBytes
+} from "./index-dwfv9a85.js";
 import {
   safeJsonParse
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/server/middleware/jwt.ts
 var MAX_TOKEN_BYTES = 8192;
-async function verifyJwt(token, secret, options = {}) {
+async function verifyJwt2(token, secret, options = {}) {
   if (!secret)
     throw new Error("verifyJwt: a non-empty secret is required");
   if (token.length > MAX_TOKEN_BYTES)
-    throw unauthorized("Token too large");
+    throw unauthorized2("Token too large");
   const [headerB64, payloadB64, signatureB64] = token.split(".");
   if (!headerB64 || !payloadB64 || !signatureB64)
-    throw unauthorized("Invalid token format");
+    throw unauthorized2("Invalid token format");
   let header;
   let payloadRaw;
   let signature;
@@ -34,45 +34,45 @@ async function verifyJwt(token, secret, options = {}) {
     payloadRaw = safeJsonParse(decoder.decode(base64UrlToBytes(payloadB64)));
     signature = base64UrlToBytes(signatureB64);
   } catch {
-    throw unauthorized("Malformed token");
+    throw unauthorized2("Malformed token");
   }
   if (!isRecord(payloadRaw))
-    throw unauthorized("Malformed token");
+    throw unauthorized2("Malformed token");
   const payload = payloadRaw;
   if (header.alg !== "HS256")
-    throw unauthorized("Unsupported token algorithm");
+    throw unauthorized2("Unsupported token algorithm");
   const encoder = new TextEncoder;
   const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["verify"]);
   const data = encoder.encode(`${headerB64}.${payloadB64}`);
   const valid = await crypto.subtle.verify("HMAC", key, signature, data);
   if (!valid)
-    throw unauthorized("Invalid token signature");
+    throw unauthorized2("Invalid token signature");
   const leeway = options.leewaySeconds ?? 60;
   const now = Date.now() / 1000;
   if ("exp" in payload) {
     if (typeof payload.exp !== "number")
-      throw unauthorized("Malformed token");
+      throw unauthorized2("Malformed token");
     if (payload.exp < now - leeway)
-      throw unauthorized("Token expired");
+      throw unauthorized2("Token expired");
   }
   if ("nbf" in payload) {
     if (typeof payload.nbf !== "number")
-      throw unauthorized("Malformed token");
+      throw unauthorized2("Malformed token");
     if (payload.nbf > now + leeway)
-      throw unauthorized("Token not yet valid");
+      throw unauthorized2("Token not yet valid");
   }
   if (options.issuer !== undefined && payload.iss !== options.issuer) {
-    throw unauthorized("Token issuer mismatch");
+    throw unauthorized2("Token issuer mismatch");
   }
   if (options.audience !== undefined) {
     const aud = payload.aud;
     const ok = Array.isArray(aud) ? aud.includes(options.audience) : aud === options.audience;
     if (!ok)
-      throw unauthorized("Token audience mismatch");
+      throw unauthorized2("Token audience mismatch");
   }
   return payload;
 }
-async function signJwt(payload, secret, options = {}) {
+async function signJwt2(payload, secret, options = {}) {
   if (!secret)
     throw new Error("signJwt: a non-empty secret is required");
   const now = Math.floor(Date.now() / 1000);
@@ -95,11 +95,11 @@ async function signJwt(payload, secret, options = {}) {
 }
 
 // src/server/middleware/pkce.ts
-async function verifyPkce(verifier, challenge) {
+async function verifyPkce2(verifier, challenge) {
   if (!verifier || !challenge)
     return false;
-  const derived = await deriveCodeChallenge(verifier);
+  const derived = await deriveCodeChallenge2(verifier);
   return derived === challenge;
 }
 
-export { verifyJwt, signJwt, verifyPkce };
+export { verifyJwt2, signJwt2, verifyPkce2 };

package/dist/{index-dce5wxcq.js → index-4s0fep5q.js}

@@ -1,20 +1,20 @@
 // src/realtime/request.ts
 import { z } from "zod";
-var RealtimeRequestPhaseSchema = z.enum([
+var RealtimeRequestPhaseSchema2 = z.enum([
   "engine-handoff",
   "engine-ack-received",
   "settled",
   "timeout",
   "disconnected"
 ]);
-var RealtimeRequestPhaseEventSchema = z.object({
+var RealtimeRequestPhaseEventSchema2 = z.object({
   requestId: z.string().min(1),
   event: z.string().min(1),
-  phase: RealtimeRequestPhaseSchema,
+  phase: RealtimeRequestPhaseSchema2,
   elapsedMs: z.number().nonnegative()
 }).strict();
 
-class RealtimeRequestTimeoutError extends Error {
+class RealtimeRequestTimeoutError2 extends Error {
   code = "REALTIME_REQUEST_TIMEOUT";
   event;
   timeoutMs;
@@ -26,7 +26,7 @@ class RealtimeRequestTimeoutError extends Error {
   }
 }
 
-class RealtimeRequestDisconnectedError extends Error {
+class RealtimeRequestDisconnectedError2 extends Error {
   code = "REALTIME_REQUEST_DISCONNECTED";
   event;
   constructor(event) {
@@ -36,7 +36,7 @@ class RealtimeRequestDisconnectedError extends Error {
   }
 }
 
-class RealtimeRequestInvalidAcknowledgementError extends Error {
+class RealtimeRequestInvalidAcknowledgementError2 extends Error {
   code = "REALTIME_REQUEST_INVALID_ACKNOWLEDGEMENT";
   event;
   constructor(event, cause) {
@@ -46,7 +46,7 @@ class RealtimeRequestInvalidAcknowledgementError extends Error {
   }
 }
 
-class RealtimeRequestRejectedError extends Error {
+class RealtimeRequestRejectedError2 extends Error {
   code = "REALTIME_REQUEST_REJECTED";
   event;
   reason;
@@ -60,4 +60,4 @@ class RealtimeRequestRejectedError extends Error {
   }
 }
 
-export { RealtimeRequestPhaseSchema, RealtimeRequestPhaseEventSchema, RealtimeRequestTimeoutError, RealtimeRequestDisconnectedError, RealtimeRequestInvalidAcknowledgementError, RealtimeRequestRejectedError };
+export { RealtimeRequestPhaseSchema2, RealtimeRequestPhaseEventSchema2, RealtimeRequestTimeoutError2, RealtimeRequestDisconnectedError2, RealtimeRequestInvalidAcknowledgementError2, RealtimeRequestRejectedError2 };

package/dist/index-50ejfz75.js

@@ -0,0 +1,9 @@
+// src/application/resource.ts
+function managedResourceDependencyId2(dependency) {
+  return typeof dependency === "string" ? dependency : dependency.id;
+}
+function defineManagedResource2(resource) {
+  return resource;
+}
+
+export { managedResourceDependencyId2, defineManagedResource2 };

package/dist/{index-m9zn6cpq.js → index-5107q189.js}

@@ -1,11 +1,11 @@
 // src/tools/operations/async-operation-contract.ts
 import { z } from "zod";
-var AsyncOperationCancelResultSchema = z.discriminatedUnion("outcome", [
+var AsyncOperationCancelResultSchema2 = z.discriminatedUnion("outcome", [
   z.object({ outcome: z.literal("accepted") }),
   z.object({ outcome: z.literal("already_terminal") }),
   z.object({ outcome: z.literal("rejected"), reason: z.string().min(1) })
 ]);
-function createAsyncOperationSnapshotSchema(config) {
+function createAsyncOperationSnapshotSchema2(config) {
   const progress = config.progress ? { progress: config.progress.optional() } : {};
   return z.discriminatedUnion("phase", [
     z.object({ phase: z.literal("pending"), ...progress }),
@@ -18,34 +18,34 @@ function createAsyncOperationSnapshotSchema(config) {
 // src/tools/transfer/view-file-contract.ts
 import { z as z2 } from "zod";
 var MAX_VIEW_FILES = 20;
-var McpAnnotationsSchema = z2.object({
+var McpAnnotationsSchema2 = z2.object({
   audience: z2.array(z2.enum(["user", "assistant"])).optional(),
   priority: z2.number().optional()
 });
-var McpMediaContentSchema = z2.discriminatedUnion("type", [
+var McpMediaContentSchema2 = z2.discriminatedUnion("type", [
   z2.object({ type: z2.literal("text"), text: z2.string() }),
   z2.object({
     type: z2.literal("image"),
     data: z2.string(),
     mimeType: z2.string(),
-    annotations: McpAnnotationsSchema.optional()
+    annotations: McpAnnotationsSchema2.optional()
   }),
   z2.object({
     type: z2.literal("audio"),
     data: z2.string(),
     mimeType: z2.string(),
-    annotations: McpAnnotationsSchema.optional()
+    annotations: McpAnnotationsSchema2.optional()
   })
 ]);
-var ViewFileErrorSchema = z2.object({
+var ViewFileErrorSchema2 = z2.object({
   path: z2.string(),
   message: z2.string()
 });
-var ViewFileOutputSchema = z2.object({
-  content: z2.array(McpMediaContentSchema),
-  errors: z2.array(ViewFileErrorSchema)
+var ViewFileOutputSchema2 = z2.object({
+  content: z2.array(McpMediaContentSchema2),
+  errors: z2.array(ViewFileErrorSchema2)
 });
-var ViewFileInputSchema = z2.object({
+var ViewFileInputSchema2 = z2.object({
   paths: z2.union([z2.string(), z2.array(z2.string()).max(MAX_VIEW_FILES)]).describe("Media URL(s) or file path(s) to view")
 });
-export { AsyncOperationCancelResultSchema, createAsyncOperationSnapshotSchema, McpAnnotationsSchema, McpMediaContentSchema, ViewFileErrorSchema, ViewFileOutputSchema, ViewFileInputSchema };
+export { AsyncOperationCancelResultSchema2, createAsyncOperationSnapshotSchema2, McpAnnotationsSchema2, McpMediaContentSchema2, ViewFileErrorSchema2, ViewFileOutputSchema2, ViewFileInputSchema2 };

package/dist/{index-sbdmyz75.js → index-5cc6r990.js}

@@ -1,7 +1,7 @@
 // src/internal/within-dir.ts
 import { realpath } from "node:fs/promises";
 import { sep } from "node:path";
-function isWithinDir(root, target) {
+function isWithinDir2(root, target) {
   const base = root.endsWith(sep) ? root.slice(0, -sep.length) : root;
   return target === root || target === base || target.startsWith(base + sep);
 }
@@ -12,7 +12,7 @@ async function realPathWithinDir(root, target) {
   ]);
   if (realRoot === null || realTarget === null)
     return null;
-  return isWithinDir(realRoot, realTarget) ? realTarget : null;
+  return isWithinDir2(realRoot, realTarget) ? realTarget : null;
 }
 
-export { isWithinDir, realPathWithinDir };
+export { isWithinDir2, realPathWithinDir };

package/dist/index-6k1svmjh.js

@@ -0,0 +1,141 @@
+import {
+  isRecord
+} from "./index-9jfdm5tg.js";
+
+// src/telegram/send-failure.ts
+var BY_DESCRIPTION = [
+  [/bot was blocked by the user|bot was kicked/i, "blocked-by-user"],
+  [/user is deactivated|account is deactivated/i, "user-deactivated"],
+  [/can'?t initiate conversation|need to start a conversation/i, "not-started"],
+  [/chat not found|peer_id_invalid|user not found/i, "chat-not-found"],
+  [/too many requests|retry later|flood/i, "rate-limited"],
+  [
+    /message is too long|can'?t parse entities|message text is empty|wrong file identifier|button_url_invalid/i,
+    "message-invalid"
+  ]
+];
+var RETRYABLE = new Set([
+  "rate-limited",
+  "server-error"
+]);
+var UNREACHABLE = new Set([
+  "blocked-by-user",
+  "user-deactivated",
+  "chat-not-found",
+  "not-started"
+]);
+function numberAt(value, keys) {
+  if (!isRecord(value))
+    return;
+  for (const key of keys) {
+    const candidate = value[key];
+    if (typeof candidate === "number" && Number.isFinite(candidate))
+      return candidate;
+  }
+  return;
+}
+function statusOf(value, depth = 0) {
+  if (!isRecord(value) || depth > 4)
+    return;
+  const direct = numberAt(value, ["error_code", "statusCode", "status"]);
+  if (direct !== undefined && direct >= 400 && direct < 600)
+    return direct;
+  const nested = value.cause ?? value.response ?? value.error;
+  return nested === value ? undefined : statusOf(nested, depth + 1);
+}
+function retryAfterOf(value, depth = 0) {
+  if (!isRecord(value) || depth > 4)
+    return;
+  const direct = numberAt(value.parameters, ["retry_after"]);
+  if (direct !== undefined)
+    return direct;
+  const nested = value.cause ?? value.response ?? value.error;
+  return nested === value ? undefined : retryAfterOf(nested, depth + 1);
+}
+function descriptionOf(value, depth = 0) {
+  if (typeof value === "string")
+    return value;
+  if (value instanceof Error) {
+    const nested = isRecord(value) ? descriptionOf(value.cause, depth + 1) : "";
+    return `${value.message} ${nested}`.trim();
+  }
+  if (!isRecord(value) || depth > 4)
+    return "";
+  const own = typeof value.description === "string" ? value.description : "";
+  const message = typeof value.message === "string" ? value.message : "";
+  const nested = descriptionOf(value.cause ?? value.response ?? value.error, depth + 1);
+  return [own, message, nested].filter(Boolean).join(" ");
+}
+function classifyTelegramSendFailure2(error) {
+  const status = statusOf(error);
+  const retryAfterSeconds = retryAfterOf(error);
+  const description = descriptionOf(error);
+  if (retryAfterSeconds !== undefined) {
+    return {
+      reason: "rate-limited",
+      ...status !== undefined && { status },
+      retryAfterSeconds,
+      retryable: true,
+      recipientUnreachable: false,
+      evidence: "parameters"
+    };
+  }
+  for (const [pattern, reason] of BY_DESCRIPTION) {
+    if (pattern.test(description)) {
+      return {
+        reason,
+        ...status !== undefined && { status },
+        retryable: RETRYABLE.has(reason),
+        recipientUnreachable: UNREACHABLE.has(reason),
+        evidence: "description"
+      };
+    }
+  }
+  if (status === 429) {
+    return {
+      reason: "rate-limited",
+      status,
+      retryable: true,
+      recipientUnreachable: false,
+      evidence: "status"
+    };
+  }
+  if (status !== undefined && status >= 500) {
+    return {
+      reason: "server-error",
+      status,
+      retryable: true,
+      recipientUnreachable: false,
+      evidence: "status"
+    };
+  }
+  return {
+    reason: "unknown",
+    ...status !== undefined && { status },
+    retryable: false,
+    recipientUnreachable: false,
+    evidence: "none"
+  };
+}
+var EDIT_REFUSALS = [
+  [/message is not modified/i, "not-modified"],
+  [
+    /message to (edit|delete) not found|message_id_invalid|message identifier is not specified/i,
+    "message-gone"
+  ],
+  [
+    /message can'?t be (edited|deleted)|there is no (text|caption) in the message to edit/i,
+    "message-locked"
+  ],
+  [/query is too old|query id is invalid/i, "query-expired"]
+];
+function classifyTelegramEditRefusal(error) {
+  const description = descriptionOf(error);
+  for (const [pattern, refusal] of EDIT_REFUSALS) {
+    if (pattern.test(description))
+      return refusal;
+  }
+  return "other";
+}
+
+export { classifyTelegramSendFailure2, classifyTelegramEditRefusal };

package/dist/{index-c6bxbsnc.js → index-7kxw1awn.js}

@@ -1,9 +1,9 @@
 import {
   loadDarwinBinding
-} from "./index-zjjyynm3.js";
+} from "./index-d4pa2bgs.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/internal/exclusive-lock.ts
 import { constants } from "node:fs";

package/dist/{index-0r0fbk7z.js → index-7z9ym7t8.js}

@@ -1,21 +1,21 @@
 import {
-  toJsonSchema
-} from "./index-eqqvgdb3.js";
+  AppError2
+} from "./index-n53mswt3.js";
 import {
   validateDeclaredOutput
-} from "./index-znfs20ss.js";
+} from "./index-b2bz0kdm.js";
 import {
-  AppError
-} from "./index-2vtcmrj9.js";
+  toJsonSchema
+} from "./index-ct75c3at.js";
 import {
   serializeCanonicalJson
-} from "./index-k5hsfc3j.js";
+} from "./index-zsvzhjtk.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/tools/schema/portable-formats.ts
-var PORTABLE_JSON_SCHEMA_FORMATS = new Set([
+var PORTABLE_JSON_SCHEMA_FORMATS2 = new Set([
   "date",
   "time",
   "date-time",
@@ -40,8 +40,8 @@ function keywordPath(prefix, keyword) {
     return `${prefix}${keyword}`;
   return prefix ? `${prefix}.${keyword}` : keyword;
 }
-function findNonPortableFormats(schema, allowFormats = []) {
-  const allowed = new Set([...PORTABLE_JSON_SCHEMA_FORMATS, ...allowFormats]);
+function findNonPortableFormats2(schema, allowFormats = []) {
+  const allowed = new Set([...PORTABLE_JSON_SCHEMA_FORMATS2, ...allowFormats]);
   const found = [];
   const pending = [{ value: schema, path: "" }];
   while (pending.length > 0) {
@@ -408,14 +408,14 @@ function flattenNode(node) {
     if (!variant)
       continue;
     const labels = discriminator.values[index] ?? [];
-    const required2 = requiredKeys(variant);
+    const required = requiredKeys(variant);
     if (!isRecord(variant.properties))
       continue;
     for (const [key, rawSchema] of Object.entries(variant.properties)) {
       if (key === discriminator.key || !isRecord(rawSchema))
         continue;
       const entries = perKey.get(key) ?? [];
-      entries.push({ schema: rawSchema, labels, required: required2.has(key) });
+      entries.push({ schema: rawSchema, labels, required: required.has(key) });
       perKey.set(key, entries);
     }
   }
@@ -463,7 +463,7 @@ function flattenNode(node) {
   result.additionalProperties = variants.every((variant) => variant.additionalProperties === false) ? false : {};
   return result;
 }
-function flattenToolJsonSchema(schema) {
+function flattenToolJsonSchema2(schema) {
   const result = rebuild(schema);
   return isRecord(result) ? result : {};
 }
@@ -487,7 +487,7 @@ var TYPE_KEYWORDS2 = ["type", "enum", "const", "anyOf", "oneOf", "allOf", "$ref"
 function saysWhatItIs(schema) {
   return TYPE_KEYWORDS2.some((keyword) => schema[keyword] !== undefined);
 }
-function findUntypedProperties(schema, prefix = "") {
+function findUntypedProperties2(schema, prefix = "") {
   if (!isRecord(schema))
     return [];
   const found = [];
@@ -503,18 +503,18 @@ function findUntypedProperties(schema, prefix = "") {
             ...typeof description === "string" && { description }
           });
         }
-        found.push(...findUntypedProperties(value, path));
+        found.push(...findUntypedProperties2(value, path));
       }
     }
   }
   for (const key of ["items", "additionalProperties"]) {
     const child = schema[key];
     if (isRecord(child))
-      found.push(...findUntypedProperties(child, prefix));
+      found.push(...findUntypedProperties2(child, prefix));
     if (Array.isArray(child)) {
       for (const entry of child) {
         if (isRecord(entry))
-          found.push(...findUntypedProperties(entry, prefix));
+          found.push(...findUntypedProperties2(entry, prefix));
       }
     }
   }
@@ -523,7 +523,7 @@ function findUntypedProperties(schema, prefix = "") {
     if (Array.isArray(child)) {
       for (const entry of child) {
         if (isRecord(entry))
-          found.push(...findUntypedProperties(entry, prefix));
+          found.push(...findUntypedProperties2(entry, prefix));
       }
     }
   }
@@ -531,7 +531,7 @@ function findUntypedProperties(schema, prefix = "") {
   if (isRecord(patterned)) {
     for (const value of Object.values(patterned)) {
       if (isRecord(value))
-        found.push(...findUntypedProperties(value, prefix));
+        found.push(...findUntypedProperties2(value, prefix));
     }
   }
   for (const key of ["$defs", "definitions"]) {
@@ -540,14 +540,14 @@ function findUntypedProperties(schema, prefix = "") {
       continue;
     for (const definition of Object.values(container)) {
       if (isRecord(definition))
-        found.push(...findUntypedProperties(definition, prefix));
+        found.push(...findUntypedProperties2(definition, prefix));
     }
   }
   for (const key of ["allOf", "anyOf", "oneOf"]) {
     const branches = schema[key];
     if (Array.isArray(branches)) {
       for (const branch of branches)
-        found.push(...findUntypedProperties(branch, prefix));
+        found.push(...findUntypedProperties2(branch, prefix));
     }
   }
   return found;
@@ -576,7 +576,7 @@ function projectToolView(options) {
     try {
       projected = Reflect.apply(view.project, undefined, [options.full, options.call]);
     } catch (error) {
-      const failure = new AppError("INTERNAL_SERVER_ERROR", `${options.operation} toolView.project threw`, 500);
+      const failure = new AppError2("INTERNAL_SERVER_ERROR", `${options.operation} toolView.project threw`, 500);
       failure.cause = error;
       throw failure;
     }
@@ -584,7 +584,7 @@ function projectToolView(options) {
       Promise.resolve(projected).catch(() => {
         return;
       });
-      throw new AppError("INTERNAL_SERVER_ERROR", `${options.operation} toolView.project returned a Promise — it must be synchronous`, 500);
+      throw new AppError2("INTERNAL_SERVER_ERROR", `${options.operation} toolView.project returned a Promise — it must be synchronous`, 500);
     }
     if (projected === undefined) {
       return {
@@ -875,7 +875,7 @@ function schemaFromZod(schema, unrepresentable, flatten) {
   if (!schema)
     return;
   const json = toJsonSchema(schema, "input", unrepresentable, "draft-07");
-  return flatten ? flattenToolJsonSchema(json) : json;
+  return flatten ? flattenToolJsonSchema2(json) : json;
 }
 function buildToolPresentationSchema(config) {
   const unrepresentable = config.unrepresentable ?? "any";
@@ -1162,7 +1162,7 @@ function prepareProjectedMcpTools(tools, config = {}) {
     }
     if (config.schemaValidation?.requireTypedProperties) {
       const allowed = new Set(config.schemaValidation.allowUntyped ?? []);
-      for (const untyped of findUntypedProperties(inputSchema)) {
+      for (const untyped of findUntypedProperties2(inputSchema)) {
         const path = `${tool.name}.${untyped.path}`;
         if (allowed.has(path))
           continue;
@@ -1171,7 +1171,7 @@ function prepareProjectedMcpTools(tools, config = {}) {
       }
     }
     if (config.schemaValidation?.requirePortableFormats) {
-      for (const finding of findNonPortableFormats(inputSchema, config.schemaValidation.allowFormats)) {
+      for (const finding of findNonPortableFormats2(inputSchema, config.schemaValidation.allowFormats)) {
         reportIncompatible(`MCP tool "${tool.name}" — input property "${finding.path}" uses non-portable JSON Schema format "${finding.format}". Use a portable pattern/schema, or list the format in \`allowFormats\` only when every MCP client supports it.`, policy === "skip" ? "warn" : policy, config.logger, failures);
       }
     }
@@ -1182,7 +1182,7 @@ function prepareProjectedMcpTools(tools, config = {}) {
         const output = toJsonSchema(outputSchema, "output");
         compatibleOutput = outputSchema;
         if (config.schemaValidation?.requirePortableFormats) {
-          for (const finding of findNonPortableFormats(output, config.schemaValidation.allowFormats)) {
+          for (const finding of findNonPortableFormats2(output, config.schemaValidation.allowFormats)) {
             reportIncompatible(`MCP tool "${tool.name}" — output property "${finding.path}" uses non-portable JSON Schema format "${finding.format}". Use a portable pattern/schema, or list the format in \`allowFormats\` only when every MCP client supports it.`, policy === "skip" ? "warn" : policy, config.logger, failures);
           }
         }
@@ -1204,4 +1204,4 @@ function prepareProjectedMcpTools(tools, config = {}) {
   return prepared;
 }
 
-export { toolSurfaceOutputSchema, applyToolViewDefaults, projectToolView, objectShapeKeys, rebuildObject, mergeSchemas, staticInputRounds, validateMcpRoundPolicy, validateResolvedInputRounds, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS, findNonPortableFormats, declaresDraft07, withDefsDialect, flattenToolJsonSchema, buildToolPresentationSchema, presentationMetadata, findUntypedProperties, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };
+export { toolSurfaceOutputSchema, applyToolViewDefaults, projectToolView, objectShapeKeys, rebuildObject, mergeSchemas, staticInputRounds, validateMcpRoundPolicy, validateResolvedInputRounds, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS2, findNonPortableFormats2, declaresDraft07, withDefsDialect, flattenToolJsonSchema2, buildToolPresentationSchema, presentationMetadata, findUntypedProperties2, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };

package/dist/{index-p7hgdyhb.js → index-814xpr6d.js}

@@ -1,6 +1,6 @@
 // src/realtime/contract.ts
 import { z } from "zod";
-function defineRealtimeContract(contract) {
+function defineRealtimeContract2(contract) {
   return contract;
 }
 var RealtimeRejectDirectionSchema = z.enum([
@@ -19,4 +19,4 @@ var RealtimeRejectReasonSchema = z.enum([
 ]);
 var RealtimeRejectFaultSchema = z.enum(["peer", "local"]);
 
-export { defineRealtimeContract, RealtimeRejectDirectionSchema, RealtimeRejectPhaseSchema, RealtimeRejectReasonSchema, RealtimeRejectFaultSchema };
+export { defineRealtimeContract2, RealtimeRejectDirectionSchema, RealtimeRejectPhaseSchema, RealtimeRejectReasonSchema, RealtimeRejectFaultSchema };