stitchkit 0.67.0 → 0.68.1

package/dist/{index-svqhcrrj.js → index-2ve29dzn.js}

@@ -1,9 +1,14 @@
 import {
-  inputIsQuery
-} from "./index-48ffdxgk.js";
+  DEFAULT_STREAM_LINE_BYTES,
+  inputIsQuery,
+  parseSSE,
+  readBoundedUtf8Lines
+} from "./index-v5bayx1z.js";
 import {
+  ContractStreamFrameSchema,
+  DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   parseTrailingWildcard
-} from "./index-pzyt11ch.js";
+} from "./index-9ky9hhg3.js";
 import {
   isRecord,
   mapObject,
@@ -250,8 +255,8 @@ class ApiError extends Error {
   details;
   hint;
   traceId;
-  constructor(code, status = 0, details, message, hint, traceId) {
-    super(message ?? `API Error: ${code}`);
+  constructor(code, status = 0, details, message, hint, traceId, options) {
+    super(message ?? `API Error: ${code}`, options);
     this.code = code;
     this.status = status;
     this.details = details;
@@ -277,10 +282,103 @@ function parseApiErrorBody(body) {
     hint: typeof error.hint === "string" ? error.hint : undefined
   };
 }
+// src/browser/stream.ts
+function parseFailure(raw, error, onParseError) {
+  const failure = error instanceof Error ? error : new Error(String(error));
+  if (!onParseError)
+    throw failure;
+  onParseError(raw, failure);
+}
+async function* parseNDJSON(response, options) {
+  try {
+    for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES)) {
+      const line = (rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine).trim();
+      if (line === "")
+        continue;
+      try {
+        yield JSON.parse(line);
+      } catch (error) {
+        parseFailure(line, error, options?.onParseError);
+      }
+    }
+  } catch (error) {
+    parseFailure("", error, options?.onParseError);
+  }
+}
+
+// src/browser/contract-stream.ts
+function sourceFor(response, descriptor) {
+  const options = {
+    maxLineBytes: descriptor.maxFrameBytes ?? DEFAULT_CONTRACT_STREAM_FRAME_BYTES
+  };
+  return descriptor.format === "sse" ? parseSSE(response, options) : parseNDJSON(response, options);
+}
+async function* readContractStream(response, descriptor, abort) {
+  let ended = false;
+  let terminalSeen = descriptor.terminal === undefined;
+  try {
+    for await (const raw of sourceFor(response, descriptor)) {
+      const parsedFrame = ContractStreamFrameSchema.safeParse(raw);
+      if (!parsedFrame.success) {
+        throw new ApiError("STREAM_PROTOCOL_ERROR", 0, undefined, "Stream frame did not match the protocol envelope");
+      }
+      const frame = parsedFrame.data;
+      if (frame.type === "error") {
+        throw new ApiError(frame.error.code, 0, frame.error.details, frame.error.message, frame.error.hint);
+      }
+      if (frame.type === "end") {
+        if (!terminalSeen) {
+          throw new ApiError("STREAM_TERMINAL_MISSING", 0, undefined, "Stream completed before its declared terminal item");
+        }
+        ended = true;
+        return;
+      }
+      const parsedItem = descriptor.item.safeParse(frame.data);
+      if (!parsedItem.success) {
+        throw new ApiError("STREAM_ITEM_INVALID", 0, undefined, "Stream item did not match its contract");
+      }
+      const item = parsedItem.data;
+      if (descriptor.terminal?.safeParse(item).success)
+        terminalSeen = true;
+      yield item;
+    }
+    if (!ended) {
+      throw new ApiError("STREAM_TRUNCATED", 0, undefined, "Stream ended without its protocol terminal frame");
+    }
+  } finally {
+    abort();
+  }
+}
+
+class OwnedContractStream {
+  #inner;
+  #abort;
+  constructor(inner, abort) {
+    this.#inner = inner;
+    this.#abort = abort;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  next() {
+    return this.#inner.next();
+  }
+  return() {
+    this.#abort();
+    return this.#inner.return(undefined);
+  }
+  throw(error) {
+    this.#abort();
+    return this.#inner.throw(error);
+  }
+}
+function parseContractStream(response, descriptor, abort) {
+  return new OwnedContractStream(readContractStream(response, descriptor, abort), abort);
+}
 
 // src/browser/client.ts
 function withTimeout(options, endpoint) {
-  const responseType = endpoint.rawResponse ? "response" : endpoint.output ? undefined : "void";
+  const responseType = endpoint.rawResponse || "stream" in endpoint ? "response" : endpoint.output ? undefined : "void";
   if (endpoint.timeout === undefined && responseType === undefined)
     return options;
   return {
@@ -289,9 +387,23 @@ function withTimeout(options, endpoint) {
     ...responseType && { responseType }
   };
 }
-function withOutput(endpoint, result) {
+function withOutput(endpoint, result, abortStream) {
   if (endpoint.rawResponse)
     return result;
+  if ("stream" in endpoint && endpoint.stream) {
+    return result.then((value) => {
+      if (!(value instanceof Response)) {
+        abortStream?.();
+        throw new Error("Streaming endpoint did not return a Response");
+      }
+      return parseContractStream(value, endpoint.stream, abortStream ?? (() => {
+        return;
+      }));
+    }, (error) => {
+      abortStream?.();
+      throw error;
+    });
+  }
   const schema = endpoint.output;
   return result.then((value) => {
     if (!schema) {
@@ -341,20 +453,26 @@ function createHttpExecutor(endpoint, prefix, client, config) {
   const httpMethod = endpoint.method.toLowerCase();
   return (requestArgs, options) => {
     const plan = planClientRequest(endpoint, prefix, requestArgs, config);
+    const streamAbort = "stream" in endpoint ? new AbortController : undefined;
+    const requestOptions = streamAbort ? {
+      ...options,
+      signal: options?.signal ? AbortSignal.any([options.signal, streamAbort.signal]) : streamAbort.signal
+    } : options;
+    const finishStream = streamAbort ? () => streamAbort.abort() : undefined;
     if (endpoint.multipart) {
       if (httpMethod === "get" || httpMethod === "head" || httpMethod === "delete") {
         throw new Error(`Multipart endpoint ${endpoint.method} ${endpoint.path} must be POST / PUT / PATCH`);
       }
       const formData = buildMultipartForm(endpoint.multipart, plan.remainingArgs);
-      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, formData, withTimeout(options, endpoint)));
+      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, formData, withTimeout(requestOptions, endpoint)), finishStream);
     }
     if (httpMethod === "get" || httpMethod === "head") {
-      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, withTimeout(options, endpoint)));
+      return withOutput(endpoint, client[httpMethod](plan.relativeUrl, withTimeout(requestOptions, endpoint)), finishStream);
     }
     if (httpMethod === "delete") {
-      return withOutput(endpoint, client.delete(plan.relativeUrl, withTimeout(options, endpoint)));
+      return withOutput(endpoint, client.delete(plan.relativeUrl, withTimeout(requestOptions, endpoint)), finishStream);
     }
-    return withOutput(endpoint, client[httpMethod](plan.relativeUrl, Object.keys(plan.remainingArgs).length > 0 ? plan.remainingArgs : undefined, withTimeout(options, endpoint)));
+    return withOutput(endpoint, client[httpMethod](plan.relativeUrl, Object.keys(plan.remainingArgs).length > 0 ? plan.remainingArgs : undefined, withTimeout(requestOptions, endpoint)), finishStream);
   };
 }
 function createFetchExecutor(endpoint, prefix, config, contractConfig) {
@@ -366,7 +484,32 @@ function createFetchExecutor(endpoint, prefix, config, contractConfig) {
       Accept: "application/json",
       ...typeof config.headers === "function" ? config.headers() : config.headers
     };
-    const cancellation = createRequestCancellation(options?.signal, endpoint.timeout ?? config.timeout ?? 30000);
+    const streamAbort = "stream" in endpoint ? new AbortController : undefined;
+    const requestSignal = streamAbort ? options?.signal ? AbortSignal.any([options.signal, streamAbort.signal]) : streamAbort.signal : options?.signal;
+    const openTimeoutMs = endpoint.timeout ?? config.timeout ?? 30000;
+    const cancellation = streamAbort ? {
+      signal: requestSignal,
+      async run(operation) {
+        let timedOut = false;
+        const timer = setTimeout(() => {
+          timedOut = true;
+          streamAbort.abort(new DOMException("Request timed out", "TimeoutError"));
+        }, openTimeoutMs);
+        try {
+          if (options?.signal?.aborted)
+            throw new RequestCancellationError("caller");
+          return await operation(requestSignal);
+        } catch (error) {
+          if (timedOut)
+            throw new RequestCancellationError("timeout");
+          if (options?.signal?.aborted)
+            throw new RequestCancellationError("caller");
+          throw error;
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+    } : createRequestCancellation(requestSignal, openTimeoutMs);
     const hasBody = endpoint.method !== "GET" && endpoint.method !== "HEAD" && endpoint.method !== "DELETE" && !endpoint.multipart && endpoint.input && Object.keys(plan.remainingArgs).length > 0;
     if (hasBody)
       headers["Content-Type"] = "application/json";
@@ -385,6 +528,9 @@ function createFetchExecutor(endpoint, prefix, config, contractConfig) {
         }
         if (endpoint.rawResponse)
           return res;
+        if ("stream" in endpoint && endpoint.stream) {
+          return parseContractStream(res, endpoint.stream, () => streamAbort?.abort());
+        }
         if (!endpoint.output) {
           const text = await res.text();
           if (text.length > 0) {
@@ -401,7 +547,7 @@ function createFetchExecutor(endpoint, prefix, config, contractConfig) {
       if (ApiError.is(error))
         throw error;
       const message = error instanceof Error ? error.message : undefined;
-      throw new ApiError("UNKNOWN_ERROR", 0, message ? { message } : undefined, message);
+      throw new ApiError("UNKNOWN_ERROR", 0, message ? { message } : undefined, message, undefined, undefined, { cause: error });
     }
   };
 }

package/dist/index-69m2278y.js

@@ -0,0 +1,115 @@
+import {
+  isUnsafeKey,
+  resolveTraceContext
+} from "./index-9ky9hhg3.js";
+import {
+  isRecord
+} from "./index-smpbdg6k.js";
+
+// src/server/request.ts
+function generateTraceId() {
+  return `${Date.now().toString(36)}-${crypto.randomUUID().slice(0, 8)}`;
+}
+function resolveTraceId(req) {
+  const header = req.headers.get("x-request-id") ?? req.headers.get("x-trace-id");
+  const trimmed = header?.trim();
+  if (trimmed && trimmed.length <= 128 && /^[\w.-]+$/.test(trimmed)) {
+    return trimmed;
+  }
+  return generateTraceId();
+}
+function resolveSocketIp(req, server) {
+  if (typeof server === "object" && server !== null && "requestIP" in server && typeof server.requestIP === "function") {
+    const addr = server.requestIP(req);
+    if (isRecord(addr) && typeof addr.address === "string" && addr.address) {
+      return addr.address;
+    }
+  }
+  if ("ip" in req && typeof req.ip === "string" && req.ip)
+    return req.ip;
+  return;
+}
+function extractIp(req, options = {}) {
+  if (options.trustProxy) {
+    const forwarded = req.headers.get("x-forwarded-for");
+    if (forwarded)
+      return (forwarded.split(",")[0] ?? "").trim().replace(/^::ffff:/, "");
+    const realIp = req.headers.get("x-real-ip");
+    if (realIp)
+      return realIp.trim().replace(/^::ffff:/, "");
+  }
+  return (options.socketIp ?? "").replace(/^::ffff:/, "");
+}
+function getClientInfo(req, options = {}) {
+  return {
+    ipAddress: extractIp(req, options) || undefined,
+    userAgent: req.headers.get("user-agent") ?? undefined
+  };
+}
+function parseQueryParams(url) {
+  const query = {};
+  for (const key of new Set(url.searchParams.keys())) {
+    if (isUnsafeKey(key))
+      continue;
+    const values = url.searchParams.getAll(key);
+    const [first] = values;
+    query[key] = values.length === 1 && first !== undefined ? first : values;
+  }
+  return query;
+}
+
+// src/observability/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage;
+function runWithRequestContext(ctx, fn) {
+  return storage.run(ctx, fn);
+}
+function getRequestContext() {
+  return storage.getStore();
+}
+function getTraceId() {
+  return storage.getStore()?.trace.traceId;
+}
+function getUserId() {
+  return storage.getStore()?.userId;
+}
+function setRequestUser(userId) {
+  const ctx = storage.getStore();
+  if (ctx)
+    ctx.userId = userId;
+}
+function setRequestEndpoint(serviceName, action) {
+  const ctx = storage.getStore();
+  if (ctx) {
+    ctx.serviceName = serviceName;
+    ctx.action = action;
+  }
+}
+function setRequestDimensions(dimensions) {
+  const ctx = storage.getStore();
+  if (ctx)
+    ctx.dimensions = { ...ctx.dimensions, ...dimensions };
+}
+function setRequestError(error) {
+  const ctx = storage.getStore();
+  if (ctx)
+    ctx.error = error;
+}
+function wrapInRequestContext(handler, options = {}) {
+  return (req, server) => {
+    const ctx = {
+      trace: resolveTraceContext(req),
+      source: "http",
+      method: req.method,
+      path: new URL(req.url, "http://localhost").pathname,
+      startedAt: process.hrtime.bigint(),
+      ...getClientInfo(req, {
+        trustProxy: options.trustProxy,
+        socketIp: resolveSocketIp(req, server)
+      })
+    };
+    return runWithRequestContext(ctx, () => handler(req, server));
+  };
+}
+
+export { generateTraceId, resolveTraceId, resolveSocketIp, extractIp, getClientInfo, parseQueryParams, runWithRequestContext, getRequestContext, getTraceId, getUserId, setRequestUser, setRequestEndpoint, setRequestDimensions, setRequestError, wrapInRequestContext };

package/dist/{index-physbf4z.js → index-6wzr93cg.js}

@@ -11,7 +11,7 @@ import {
 } from "./index-dk6e56g0.js";
 import {
   AppError
-} from "./index-xxye8j3k.js";
+} from "./index-0w9abg87.js";
 
 // src/application/graph.ts
 function resolveResourceGraph(resources) {

package/dist/index-7etq650s.js

@@ -0,0 +1,75 @@
+import {
+  executeToolMethod
+} from "./index-cz32amcb.js";
+import {
+  assertToolExtensionCompatible,
+  projectToolSurface
+} from "./index-vkk06pv1.js";
+import {
+  mergeSchemas,
+  rebuildObject
+} from "./index-6djpbnda.js";
+
+// src/tools/mount.ts
+import { z } from "zod";
+function applyExtend(base, extra) {
+  if (base instanceof z.ZodObject) {
+    assertToolExtensionCompatible(base, extra);
+    return rebuildObject(base, { ...extra, ...base.shape });
+  }
+  return z.intersection(z.object(extra), base);
+}
+function contractToolMountable(projected, extend) {
+  const method = projected.source;
+  const baseArgumentSchema = mergeSchemas(method.paramsSchema, method.inputSchema);
+  const argumentSchema = projected.shouldExtend && extend ? applyExtend(baseArgumentSchema, extend.schema) : baseArgumentSchema;
+  return {
+    method,
+    name: projected.name,
+    argumentSchema,
+    presentationSchema: projected.presentationSchema,
+    shouldExtend: projected.shouldExtend
+  };
+}
+function collectTools(service, transport, config = {}) {
+  const { extend, flattenUnionInput = false, assertNames = true } = config;
+  const tools = [];
+  for (const projected of projectToolSurface({ services: [service] }, transport === "HTTP" ? "AGENT" : transport, {
+    extend,
+    flattenUnionInput,
+    assertNames,
+    assertUniqueNames: false
+  })) {
+    if (projected.kind !== "contract")
+      continue;
+    tools.push(contractToolMountable(projected, extend));
+  }
+  return tools;
+}
+function createToolRunner(config) {
+  const extension = config.extend ? {
+    schema: z.object(config.extend.schema),
+    resolve: config.extend.resolve
+  } : undefined;
+  return async function runOneToolCall(tool, rawArgs, context) {
+    return executeToolMethod(tool.method, tool.name, rawArgs, { ...config.context, ...context, source: config.source }, config.hooks, config.lifecycle, config.coerceJsonArgs ?? true, config.onOutputStrip ? (paths) => config.onOutputStrip?.(tool.name, paths) : undefined, tool.shouldExtend ? extension : undefined);
+  };
+}
+function formatToolError(result, toolName, errorHint) {
+  const err = { error: result.code };
+  if (result.details)
+    err.details = result.details;
+  const hints = [];
+  if (result.hint)
+    hints.push(result.hint);
+  if (errorHint && toolName) {
+    const global = errorHint(toolName, result.code);
+    if (global)
+      hints.push(global);
+  }
+  if (hints.length > 0)
+    err._hint = hints.join(" ");
+  return err;
+}
+
+export { contractToolMountable, collectTools, createToolRunner, formatToolError };