stitchkit 0.56.0 → 0.56.2

package/dist/cli.js

@@ -5,14 +5,17 @@ import {
   emitResult,
   parseCliArgs,
   pollUntilDone
-} from "./index-escqg10p.js";
+} from "./index-zk5zn2nh.js";
+import"./index-sa2mbwa7.js";
 import"./index-sbdmyz75.js";
-import"./index-6y759j86.js";
+import"./index-1tkyng3g.js";
+import"./index-6djpbnda.js";
 import"./index-cby4ar3v.js";
-import"./index-j3dem06f.js";
-import"./index-5r13htq1.js";
+import"./index-7c0gkyvj.js";
+import"./index-ps5pxp3h.js";
 import"./index-6k1937bx.js";
-import"./index-7eq9va6e.js";
+import"./index-y2rb7dwx.js";
+import"./index-smpbdg6k.js";
 import"./index-1bx83sw4.js";
 export {
   DEFAULT_EXIT_CODES,

package/dist/index-0nc0cddp.js

@@ -0,0 +1,178 @@
+// src/observability/status.ts
+import { z } from "zod";
+var NonNegativeIntegerSchema = z.number().int().nonnegative();
+var ObservabilitySinkStatusSchema = z.object({
+  capacity: NonNegativeIntegerSchema,
+  received: NonNegativeIntegerSchema,
+  accepted: NonNegativeIntegerSchema,
+  filtered: NonNegativeIntegerSchema,
+  completed: NonNegativeIntegerSchema,
+  dropped: NonNegativeIntegerSchema,
+  failed: NonNegativeIntegerSchema,
+  preparationFailed: NonNegativeIntegerSchema,
+  preparing: NonNegativeIntegerSchema,
+  pending: NonNegativeIntegerSchema,
+  closed: z.boolean()
+}).readonly();
+var ObservabilityStatusObjectSchema = z.object({
+  request: ObservabilitySinkStatusSchema.optional(),
+  tools: ObservabilitySinkStatusSchema.optional(),
+  total: ObservabilitySinkStatusSchema
+});
+var ObservabilityStatusSchema = ObservabilityStatusObjectSchema.readonly();
+var ObservabilityDrainReportSchema = ObservabilityStatusObjectSchema.extend({
+  durationMs: z.number().nonnegative()
+}).readonly();
+var SUMMED_STATUS_KEYS = [
+  "capacity",
+  "received",
+  "accepted",
+  "filtered",
+  "completed",
+  "dropped",
+  "failed",
+  "preparationFailed",
+  "preparing",
+  "pending"
+];
+function aggregateObservabilityStatus(surfaces, closed) {
+  const totals = {
+    capacity: 0,
+    received: 0,
+    accepted: 0,
+    filtered: 0,
+    completed: 0,
+    dropped: 0,
+    failed: 0,
+    preparationFailed: 0,
+    preparing: 0,
+    pending: 0
+  };
+  for (const surface of surfaces) {
+    for (const key of SUMMED_STATUS_KEYS)
+      totals[key] += surface[key];
+  }
+  return ObservabilitySinkStatusSchema.parse({ ...totals, closed });
+}
+
+// src/internal/observability-sink.ts
+var DEFAULT_MAX_PENDING = 1000;
+function invokeIsolated(callback) {
+  if (!callback)
+    return;
+  Promise.resolve().then(callback).catch(() => {});
+}
+function createBoundedSinkManager(config) {
+  const maxPending = config.maxPending ?? DEFAULT_MAX_PENDING;
+  if (!Number.isSafeInteger(maxPending) || maxPending <= 0) {
+    throw new TypeError("Observability maxPending must be a positive safe integer");
+  }
+  let sequence = 0;
+  let closed = false;
+  let received = 0;
+  let accepted = 0;
+  let filtered = 0;
+  let completed = 0;
+  let dropped = 0;
+  let failed = 0;
+  let preparationFailed = 0;
+  let closePromise;
+  const preparing = new Map;
+  const writes = new Map;
+  const reportError = (error, event) => {
+    invokeIsolated(config.onSinkError ? () => config.onSinkError?.({ error, ...event !== undefined && { event } }) : undefined);
+  };
+  const reportDrop = (reason, event) => {
+    invokeIsolated(config.onDrop ? () => config.onDrop?.({ reason, event, pending: writes.size }) : undefined);
+  };
+  const admit = (id, event) => {
+    try {
+      if (config.filter && !config.filter(event)) {
+        filtered += 1;
+        return;
+      }
+    } catch (error) {
+      preparationFailed += 1;
+      reportError(error, event);
+      return;
+    }
+    if (writes.size >= maxPending) {
+      dropped += 1;
+      reportDrop("capacity", event);
+      return;
+    }
+    accepted += 1;
+    const write = Promise.resolve().then(() => config.write(event)).then(() => {
+      completed += 1;
+    }).catch((error) => {
+      failed += 1;
+      reportError(error, event);
+    }).finally(() => writes.delete(id));
+    writes.set(id, write);
+  };
+  const awaitGeneration = async (boundary) => {
+    const through = (values) => [...values].filter(([id]) => id <= boundary).map(([, value]) => value);
+    await Promise.allSettled(through(preparing));
+    await Promise.allSettled(through(writes));
+  };
+  return {
+    submit(produce) {
+      received += 1;
+      const id = ++sequence;
+      if (closed) {
+        Promise.resolve().then(produce).then((event) => {
+          dropped += 1;
+          reportDrop("closed", event);
+        }).catch((error) => {
+          preparationFailed += 1;
+          reportError(error);
+        });
+        return;
+      }
+      const preparation = Promise.resolve().then(produce).then((event) => admit(id, event)).catch((error) => {
+        preparationFailed += 1;
+        reportError(error);
+      }).finally(() => preparing.delete(id));
+      preparing.set(id, preparation);
+    },
+    flush() {
+      return awaitGeneration(sequence);
+    },
+    getStatus() {
+      return ObservabilitySinkStatusSchema.parse({
+        capacity: maxPending,
+        received,
+        accepted,
+        filtered,
+        completed,
+        dropped,
+        failed,
+        preparationFailed,
+        preparing: preparing.size,
+        pending: writes.size,
+        closed
+      });
+    },
+    close() {
+      if (closePromise)
+        return closePromise;
+      closed = true;
+      closePromise = awaitGeneration(sequence).then(() => ObservabilitySinkStatusSchema.parse({
+        capacity: maxPending,
+        received,
+        accepted,
+        filtered,
+        completed,
+        dropped,
+        failed,
+        preparationFailed,
+        preparing: preparing.size,
+        pending: writes.size,
+        closed
+      }));
+      return closePromise;
+    }
+  };
+}
+
+export { ObservabilitySinkStatusSchema, ObservabilityStatusSchema, ObservabilityDrainReportSchema, aggregateObservabilityStatus, createBoundedSinkManager };

package/dist/{index-6y759j86.js → index-1tkyng3g.js}

@@ -1,9 +1,12 @@
+import {
+  mergeSchemas
+} from "./index-6djpbnda.js";
 import {
   toJsonSchema
 } from "./index-cby4ar3v.js";
 import {
   isRecord
-} from "./index-7eq9va6e.js";
+} from "./index-smpbdg6k.js";
 
 // src/tools/portable-formats.ts
 var PORTABLE_JSON_SCHEMA_FORMATS = new Set([
@@ -557,57 +560,6 @@ function findUntypedProperties(schema, prefix = "") {
   return found;
 }
 
-// src/tools/schema.ts
-import { z } from "zod";
-function objectShapeKeys(schema) {
-  return schema instanceof z.ZodObject ? Object.keys(schema.shape) : [];
-}
-function keyPolicyOf(schema) {
-  return schema.def.catchall;
-}
-function rebuildObject(source, shape) {
-  return withKeyPolicy(z.object(shape), keyPolicyOf(source));
-}
-function withKeyPolicy(object, policy) {
-  if (policy === undefined)
-    return object;
-  return object.catchall(representable(policy));
-}
-function representable(policy) {
-  if (policy instanceof z.ZodNever || policy instanceof z.ZodUnknown)
-    return policy;
-  if (!(policy instanceof z.ZodType))
-    return z.unknown();
-  try {
-    toJsonSchema(policy, "input");
-    return policy;
-  } catch {
-    return z.unknown();
-  }
-}
-function mergeSchemas(paramsSchema, inputSchema) {
-  if (paramsSchema && !(paramsSchema instanceof z.ZodObject)) {
-    throw new Error("Tool params schema must be a z.object()");
-  }
-  const paramsObject = paramsSchema instanceof z.ZodObject ? paramsSchema : undefined;
-  if (!inputSchema) {
-    return paramsObject ?? z.object({});
-  }
-  if (inputSchema instanceof z.ZodObject) {
-    if (paramsObject) {
-      const conflicts = Object.keys(paramsObject.shape).filter((key) => (key in inputSchema.shape));
-      if (conflicts.length > 0) {
-        throw new Error(`Schema merge conflict: ${conflicts.join(", ")} appear in both params and input`);
-      }
-    }
-    return rebuildObject(inputSchema, {
-      ...paramsObject?.shape ?? {},
-      ...inputSchema.shape
-    });
-  }
-  return paramsObject ? z.intersection(paramsObject, inputSchema) : inputSchema;
-}
-
 // src/tools/names.ts
 var SINGULAR_EXCEPTIONS = new Set([
   "analytics",
@@ -674,7 +626,7 @@ function assertUniqueToolName(name, taken, surface) {
 }
 
 // src/tools/presentation.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 function withoutDialect(schema) {
   const result = {};
   for (const [key, value] of Object.entries(schema)) {
@@ -768,7 +720,7 @@ function buildToolPresentationSchema(config) {
     };
   }
   if (config.extendSchema) {
-    const extra = namespaceLocalReferences(schemaFromZod(z2.object(config.extendSchema), unrepresentable, flatten), "extend");
+    const extra = namespaceLocalReferences(schemaFromZod(z.object(config.extendSchema), unrepresentable, flatten), "extend");
     if (extra) {
       presentation = mergeObjectSchemas(withoutDialect(extra), withoutDialect(presentation), true);
     }
@@ -789,7 +741,7 @@ function presentationMetadata(schema) {
 }
 
 // src/tools/internal/surface-projector.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 
 // src/tools/mcp-round-policy.ts
 function validateMcpRoundPolicy(tool, policy, runtime) {
@@ -817,7 +769,7 @@ function validateMcpRoundPolicy(tool, policy, runtime) {
 
 // src/tools/internal/surface-projector.ts
 function assertToolExtensionCompatible(base, extra) {
-  if (!(base instanceof z3.ZodObject))
+  if (!(base instanceof z2.ZodObject))
     return;
   const conflicts = Object.keys(extra).filter((key) => (key in base.shape));
   if (conflicts.length > 0) {
@@ -1028,4 +980,4 @@ function prepareProjectedMcpTools(tools, config = {}) {
   return prepared;
 }
 
-export { objectShapeKeys, rebuildObject, mergeSchemas, validateMcpRoundPolicy, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS, findNonPortableFormats, flattenToolJsonSchema, buildToolPresentationSchema, presentationMetadata, findUntypedProperties, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };
+export { validateMcpRoundPolicy, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS, findNonPortableFormats, flattenToolJsonSchema, buildToolPresentationSchema, presentationMetadata, findUntypedProperties, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };

package/dist/{index-sm2tjx06.js → index-41wm56v0.js}

@@ -1,13 +1,13 @@
 import {
   isUnsafeKey,
   mergeMeta
-} from "./index-5r13htq1.js";
+} from "./index-ps5pxp3h.js";
 import {
   callRuntimeHandler,
   isRecord,
   transportResult,
   typedEntries
-} from "./index-7eq9va6e.js";
+} from "./index-smpbdg6k.js";
 
 // src/server/middleware/cors.ts
 var DEFAULT_CORS_ALLOW_HEADERS = "Content-Type, Authorization, X-Trace-Id, traceparent, tracestate";

package/dist/index-6djpbnda.js

@@ -0,0 +1,56 @@
+import {
+  toJsonSchema
+} from "./index-cby4ar3v.js";
+
+// src/tools/schema.ts
+import { z } from "zod";
+function objectShapeKeys(schema) {
+  return schema instanceof z.ZodObject ? Object.keys(schema.shape) : [];
+}
+function keyPolicyOf(schema) {
+  return schema.def.catchall;
+}
+function rebuildObject(source, shape) {
+  return withKeyPolicy(z.object(shape), keyPolicyOf(source));
+}
+function withKeyPolicy(object, policy) {
+  if (policy === undefined)
+    return object;
+  return object.catchall(representable(policy));
+}
+function representable(policy) {
+  if (policy instanceof z.ZodNever || policy instanceof z.ZodUnknown)
+    return policy;
+  if (!(policy instanceof z.ZodType))
+    return z.unknown();
+  try {
+    toJsonSchema(policy, "input");
+    return policy;
+  } catch {
+    return z.unknown();
+  }
+}
+function mergeSchemas(paramsSchema, inputSchema) {
+  if (paramsSchema && !(paramsSchema instanceof z.ZodObject)) {
+    throw new Error("Tool params schema must be a z.object()");
+  }
+  const paramsObject = paramsSchema instanceof z.ZodObject ? paramsSchema : undefined;
+  if (!inputSchema) {
+    return paramsObject ?? z.object({});
+  }
+  if (inputSchema instanceof z.ZodObject) {
+    if (paramsObject) {
+      const conflicts = Object.keys(paramsObject.shape).filter((key) => (key in inputSchema.shape));
+      if (conflicts.length > 0) {
+        throw new Error(`Schema merge conflict: ${conflicts.join(", ")} appear in both params and input`);
+      }
+    }
+    return rebuildObject(inputSchema, {
+      ...paramsObject?.shape ?? {},
+      ...inputSchema.shape
+    });
+  }
+  return paramsObject ? z.intersection(paramsObject, inputSchema) : inputSchema;
+}
+
+export { objectShapeKeys, rebuildObject, mergeSchemas };

package/dist/{index-j3dem06f.js → index-7c0gkyvj.js}

@@ -1,11 +1,13 @@
 import {
   AppError,
   isUnsafeKey
-} from "./index-5r13htq1.js";
+} from "./index-ps5pxp3h.js";
 import {
-  isRecord,
   resolveTraceContext
-} from "./index-7eq9va6e.js";
+} from "./index-y2rb7dwx.js";
+import {
+  isRecord
+} from "./index-smpbdg6k.js";
 
 // src/internal/errors.ts
 import { z } from "zod";

package/dist/{index-n4nfa7gh.js → index-9zn9fb4e.js}

@@ -7,7 +7,7 @@ import {
   defaultSignalSource,
   guardSignalCallback,
   reportSignalError
-} from "./index-sm2tjx06.js";
+} from "./index-41wm56v0.js";
 import {
   errorCode,
   extractIp,
@@ -23,19 +23,21 @@ import {
   setRequestError,
   validateDeclaredOutput,
   zodIssues
-} from "./index-j3dem06f.js";
+} from "./index-7c0gkyvj.js";
 import {
   AppError,
   badRequest,
   isUnsafeKey,
   safeJsonParse
-} from "./index-5r13htq1.js";
+} from "./index-ps5pxp3h.js";
 import {
-  isRecord,
   parseTrailingWildcard,
-  resolveTraceContext,
+  resolveTraceContext
+} from "./index-y2rb7dwx.js";
+import {
+  isRecord,
   transportResult
-} from "./index-7eq9va6e.js";
+} from "./index-smpbdg6k.js";
 import {
   __require
 } from "./index-1bx83sw4.js";
@@ -466,12 +468,20 @@ async function parseMultipart(req, descriptor, fieldsSchema, receivers) {
 }
 
 // src/server/request-body.ts
+function requestAbortReason(req) {
+  return req.signal.reason ?? new DOMException("The connection was closed", "AbortError");
+}
+function throwIfRequestAborted(req) {
+  if (req.signal.aborted)
+    throw requestAbortReason(req);
+}
 function assertJsonBodyLimit(maxBytes, owner) {
   if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)) {
     throw new Error(`${owner} must be a positive safe integer, received ${maxBytes}`);
   }
 }
 async function readRequestText(req, maxBytes) {
+  throwIfRequestAborted(req);
   if (maxBytes === undefined)
     return req.text();
   assertJsonBodyLimit(maxBytes, "maxJsonBodyBytes");
@@ -480,9 +490,25 @@ async function readRequestText(req, maxBytes) {
     return "";
   const chunks = [];
   let total = 0;
+  let rejectAbortedRead = (_reason) => {
+    return;
+  };
+  const abortedRead = new Promise((_resolve, reject) => {
+    rejectAbortedRead = reject;
+  });
+  const onAbort = () => {
+    const reason = requestAbortReason(req);
+    rejectAbortedRead(reason);
+    reader.cancel(reason).catch(() => {
+      return;
+    });
+  };
+  req.signal.addEventListener("abort", onAbort, { once: true });
+  if (req.signal.aborted)
+    onAbort();
   try {
     while (true) {
-      const { done, value } = await reader.read();
+      const { done, value } = await Promise.race([reader.read(), abortedRead]);
       if (done)
         break;
       total += value.byteLength;
@@ -493,7 +519,9 @@ async function readRequestText(req, maxBytes) {
       chunks.push(value);
     }
   } finally {
-    reader.releaseLock();
+    req.signal.removeEventListener("abort", onAbort);
+    if (!req.signal.aborted)
+      reader.releaseLock();
   }
   const bytes = new Uint8Array(total);
   let offset = 0;
@@ -630,6 +658,8 @@ function safePath(pathname) {
   return out;
 }
 function levelForStatus(status) {
+  if (status === 499)
+    return "info";
   if (status >= 500)
     return "error";
   if (status >= 400)
@@ -1037,6 +1067,29 @@ function validateRawRoutes(rawRoutes) {
 
 // src/server/create.ts
 var BODY_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var MAX_REQUEST_ABORT_CAUSE_DEPTH = 8;
+function containsRequestAbortReason(error, reason) {
+  let current = error;
+  const visited = new Set;
+  for (let depth = 0;depth <= MAX_REQUEST_ABORT_CAUSE_DEPTH; depth += 1) {
+    if (current === reason)
+      return true;
+    if (depth === MAX_REQUEST_ABORT_CAUSE_DEPTH || !isRecord(current))
+      return false;
+    if (visited.has(current))
+      return false;
+    visited.add(current);
+    current = current.cause;
+  }
+  return false;
+}
+function isClientClosedRequest(req, error) {
+  if (!req.signal.aborted)
+    return false;
+  if (isRecord(error) && error.name === "AbortError")
+    return true;
+  return req.signal.reason !== undefined && containsRequestAbortReason(error, req.signal.reason);
+}
 function createHandler(config) {
   const { cors, hooks, logging = false, observability, trustProxy = false } = config;
   if (cors)
@@ -1100,7 +1153,7 @@ function createHandler(config) {
       } catch {}
     }
     let completed = false;
-    const complete = (status, errorCode2) => {
+    const complete = (status, errorCode2, outcome) => {
       if (completed)
         return;
       completed = true;
@@ -1148,11 +1201,22 @@ function createHandler(config) {
       const context = getRequestContext();
       if (observability && context) {
         try {
-          observability.complete({ context, statusCode: status, durationMs, payload });
+          observability.complete({
+            context,
+            statusCode: status,
+            durationMs,
+            payload,
+            ...outcome !== undefined && { outcome }
+          });
         } catch {}
       }
     };
     const respondError = async (err, errCtx, endpoint) => {
+      if (isClientClosedRequest(req, err)) {
+        const response = applyCors(new Response(null, { status: 499, statusText: "Client Closed Request" }), cors, req);
+        complete(response.status, undefined, "cancelled");
+        return response;
+      }
       const recordFailure = (normalized) => {
         if (getRequestContext()?.error !== undefined)
           return;

package/dist/{index-xy8fmh6w.js → index-f6pymtqe.js}

@@ -2,7 +2,7 @@ import {
   contextContributionDelta,
   mergeContextContribution,
   prepareContextContribution
-} from "./index-sm2tjx06.js";
+} from "./index-41wm56v0.js";
 import {
   base64UrlToBytes,
   bytesToBase64Url,
@@ -10,10 +10,10 @@ import {
   isUnsafeKey,
   safeJsonParse,
   unauthorized
-} from "./index-5r13htq1.js";
+} from "./index-ps5pxp3h.js";
 import {
   isRecord
-} from "./index-7eq9va6e.js";
+} from "./index-smpbdg6k.js";
 
 // src/server/middleware/cookies.ts
 function parseCookies(header) {

package/dist/{index-jcc611vh.js → index-gnvzyw0k.js}

@@ -1,9 +1,9 @@
 import {
   isUnsafeKey
-} from "./index-5r13htq1.js";
+} from "./index-ps5pxp3h.js";
 import {
   isRecord
-} from "./index-7eq9va6e.js";
+} from "./index-smpbdg6k.js";
 
 // src/observability/sanitize.ts
 var SENSITIVE_WORDS = new Set([

package/dist/{index-qh4xevf5.js → index-mr617n62.js}

@@ -1,12 +1,14 @@
 import {
   inputIsQuery
 } from "./index-48ffdxgk.js";
+import {
+  parseTrailingWildcard
+} from "./index-y2rb7dwx.js";
 import {
   isRecord,
   mapObject,
-  parseTrailingWildcard,
   typedEntries
-} from "./index-7eq9va6e.js";
+} from "./index-smpbdg6k.js";
 
 // src/browser/cancellation.ts
 class RequestCancellationError extends Error {

package/dist/{index-5r13htq1.js → index-ps5pxp3h.js}

@@ -1,6 +1,6 @@
 import {
   parseTrailingWildcard
-} from "./index-7eq9va6e.js";
+} from "./index-y2rb7dwx.js";
 
 // src/contract/errors.ts
 var APP_ERROR_BRAND = Symbol.for("stitchkit.AppError");