stitchkit 0.67.0 → 0.68.0

package/dist/{index-y91zd0ch.js → index-pr0qsmjy.js}

@@ -1,7 +1,7 @@
 import {
   isUnsafeKey,
   mergeMeta
-} from "./index-wd8g8z6e.js";
+} from "./index-9ky9hhg3.js";
 import {
   callRuntimeHandler,
   isRecord,
@@ -144,11 +144,12 @@ function bindContract(contract, handlers) {
       serviceName: contract.meta.prefix,
       key: String(key),
       toolName: "toolName" in endpoint ? endpoint.toolName : undefined,
-      expose: endpoint.rawResponse || endpoint.rawBody || endpoint.responseMeta ? HTTP_ONLY : endpoint.expose,
+      expose: endpoint.rawResponse || endpoint.rawBody || endpoint.responseMeta || "stream" in endpoint && endpoint.stream ? HTTP_ONLY : endpoint.expose,
       scope: endpoint.scope ?? groupScope,
       paramsSchema: endpoint.params,
       inputSchema: endpoint.input,
       outputSchema: endpoint.output,
+      stream: "stream" in endpoint ? endpoint.stream : undefined,
       multipart: endpoint.multipart,
       multipartReceivers: streamingHandler?.receivers,
       maxJsonBodyBytes: endpoint.maxJsonBodyBytes,

package/dist/index-v5bayx1z.js

@@ -0,0 +1,138 @@
+import {
+  normalizeError
+} from "./index-9ky9hhg3.js";
+
+// src/internal/bounded-lines.ts
+var DEFAULT_STREAM_LINE_BYTES = 1024 * 1024;
+function lineLimit(value) {
+  const resolved = value ?? DEFAULT_STREAM_LINE_BYTES;
+  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+    throw new TypeError("maxLineBytes must be a positive safe integer");
+  }
+  return resolved;
+}
+function joinBytes(left, right) {
+  if (left.byteLength === 0)
+    return right.slice();
+  const result = new Uint8Array(left.byteLength + right.byteLength);
+  result.set(left);
+  result.set(right, left.byteLength);
+  return result;
+}
+async function* readBoundedUtf8Lines(response, maxLineBytes) {
+  const reader = response.body?.getReader();
+  if (!reader)
+    return;
+  const limit = lineLimit(maxLineBytes);
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let pending = new Uint8Array;
+  try {
+    for (;; ) {
+      const chunk = await reader.read();
+      if (chunk.done)
+        break;
+      let start = 0;
+      for (let index = 0;index < chunk.value.byteLength; index += 1) {
+        if (chunk.value[index] !== 10)
+          continue;
+        const lineBytes = joinBytes(pending, chunk.value.slice(start, index));
+        if (lineBytes.byteLength > limit) {
+          throw new RangeError(`Stream line exceeds the ${limit} byte limit`);
+        }
+        yield decoder.decode(lineBytes);
+        pending = new Uint8Array;
+        start = index + 1;
+      }
+      pending = joinBytes(pending, chunk.value.slice(start));
+      if (pending.byteLength > limit) {
+        throw new RangeError(`Stream line exceeds the ${limit} byte limit`);
+      }
+    }
+    if (pending.byteLength > 0)
+      yield decoder.decode(pending);
+  } finally {
+    await reader.cancel().catch(() => {
+      return;
+    });
+    reader.releaseLock();
+  }
+}
+
+// src/server/stream.ts
+function streamSSE(generator) {
+  const encoder = new TextEncoder;
+  let cancelled = false;
+  const stream = new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const chunk of generator) {
+          if (cancelled)
+            return;
+          const data = JSON.stringify(chunk);
+          controller.enqueue(encoder.encode(`data: ${data}
+
+`));
+        }
+        if (cancelled)
+          return;
+        controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+        controller.close();
+      } catch (err) {
+        if (cancelled)
+          return;
+        const envelope = normalizeError(err).toJSON();
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(envelope)}
+
+`));
+        controller.close();
+      }
+    },
+    cancel() {
+      cancelled = true;
+      generator.return(undefined).catch(() => {
+        return;
+      });
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+async function* parseSSE(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;
+      if (!line.startsWith("data:"))
+        continue;
+      const data = line.slice(5).replace(/^ /, "");
+      if (data === "[DONE]")
+        return;
+      try {
+        yield JSON.parse(data);
+      } catch (error) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (!options?.onParseError)
+          throw failure;
+        options.onParseError(data, failure);
+      }
+    }
+  } catch (error) {
+    const failure = error instanceof Error ? error : new Error(String(error));
+    if (!options?.onParseError)
+      throw failure;
+    options.onParseError("", failure);
+  }
+}
+
+// src/internal/http-input.ts
+function inputIsQuery(method) {
+  return method === "GET" || method === "DELETE";
+}
+
+export { inputIsQuery, DEFAULT_STREAM_LINE_BYTES, readBoundedUtf8Lines, streamSSE, parseSSE };

package/dist/{index-mfw1pec7.js → index-wqyrvhzz.js}

@@ -2,20 +2,20 @@ import {
   contextContributionDelta,
   mergeContextContribution,
   prepareContextContribution
-} from "./index-y91zd0ch.js";
+} from "./index-pr0qsmjy.js";
 import {
   base64UrlToBytes,
   bytesToBase64Url,
   isUnsafeKey,
   safeJsonParse
-} from "./index-wd8g8z6e.js";
+} from "./index-9ky9hhg3.js";
 import {
   isRecord
 } from "./index-smpbdg6k.js";
 import {
   forbidden,
   unauthorized
-} from "./index-xxye8j3k.js";
+} from "./index-0w9abg87.js";
 
 // src/server/middleware/cookies.ts
 function parseCookies(header) {

package/dist/{index-svqhcrrj.js → index-zd4v31v2.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,
@@ -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) {