@kortyx/stream 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @chatbot-core/types
 
+## [0.4.0](https://github.com/kortyx-io/kortyx/compare/stream-v0.3.1...stream-v0.4.0) (2026-02-17)
+
+
+### Features
+
+* **hooks:** consolidate reason+interrupt contracts ([4716a4d](https://github.com/kortyx-io/kortyx/commit/4716a4d4739b4a71b7c6e84717c830cd9ff625a6))
+
+## [0.3.1](https://github.com/kortyx-io/kortyx/compare/stream-v0.3.0...stream-v0.3.1) (2026-02-17)
+
+
+### Bug Fixes
+
+* **build:** align package tsconfig with shared lib baseline ([48d2b57](https://github.com/kortyx-io/kortyx/commit/48d2b5765fefbb5fcbbe548e749e7b5f51b450b9))
+* **build:** wire tsup for publishable packages ([e7b1b5c](https://github.com/kortyx-io/kortyx/commit/e7b1b5c28af55becffc137233dd92d8953d7cb8e))
+* **dev:** restore tsc watch flow for local workspace ([4305823](https://github.com/kortyx-io/kortyx/commit/430582372cad466bf28af554042aa11bdb8bf027))
+
 ## [0.3.0](https://github.com/kortyx-io/kortyx/compare/stream-v0.2.3...stream-v0.3.0) (2026-02-17)
 
 

package/dist/{types/stream-chunk.d.ts → browser-BIAzFI3U.d.ts}

@@ -1,5 +1,6 @@
-import { z } from "zod";
-export declare const StreamChunkSchema: z.ZodUnion<[z.ZodObject<{
+import { z } from 'zod';
+
+declare const StreamChunkSchema: z.ZodUnion<[z.ZodObject<{
     type: z.ZodLiteral<"session">;
     sessionId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -35,33 +36,60 @@ export declare const StreamChunkSchema: z.ZodUnion<[z.ZodObject<{
 }>, z.ZodObject<{
     type: z.ZodLiteral<"text-start">;
     node: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    opId: z.ZodOptional<z.ZodString>;
+    segmentId: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     type?: "text-start";
+    id?: string;
+    opId?: string;
     node?: string;
+    segmentId?: string;
 }, {
     type?: "text-start";
+    id?: string;
+    opId?: string;
     node?: string;
+    segmentId?: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"text-delta">;
     delta: z.ZodString;
     node: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    opId: z.ZodOptional<z.ZodString>;
+    segmentId: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     type?: "text-delta";
+    id?: string;
+    opId?: string;
     node?: string;
+    segmentId?: string;
     delta?: string;
 }, {
     type?: "text-delta";
+    id?: string;
+    opId?: string;
     node?: string;
+    segmentId?: string;
     delta?: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"text-end">;
     node: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    opId: z.ZodOptional<z.ZodString>;
+    segmentId: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     type?: "text-end";
+    id?: string;
+    opId?: string;
     node?: string;
+    segmentId?: string;
 }, {
     type?: "text-end";
+    id?: string;
+    opId?: string;
     node?: string;
+    segmentId?: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"tool-result">;
     tool: z.ZodOptional<z.ZodString>;
@@ -83,25 +111,45 @@ export declare const StreamChunkSchema: z.ZodUnion<[z.ZodObject<{
     resumeToken: z.ZodString;
     workflow: z.ZodOptional<z.ZodString>;
     node: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    opId: z.ZodOptional<z.ZodString>;
+    schemaId: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodOptional<z.ZodString>;
     input: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"text">;
         multiple: z.ZodBoolean;
         question: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        schemaId: z.ZodOptional<z.ZodString>;
+        schemaVersion: z.ZodOptional<z.ZodString>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         options: z.ZodOptional<z.ZodArray<z.ZodNever, "many">>;
     }, "strip", z.ZodTypeAny, {
         options?: never[];
+        id?: string;
+        schemaId?: string;
+        schemaVersion?: string;
         kind?: "text";
         multiple?: boolean;
         question?: string;
+        meta?: Record<string, unknown>;
     }, {
         options?: never[];
+        id?: string;
+        schemaId?: string;
+        schemaVersion?: string;
         kind?: "text";
         multiple?: boolean;
         question?: string;
+        meta?: Record<string, unknown>;
     }>, z.ZodObject<{
         kind: z.ZodEnum<["choice", "multi-choice"]>;
         multiple: z.ZodBoolean;
         question: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        schemaId: z.ZodOptional<z.ZodString>;
+        schemaVersion: z.ZodOptional<z.ZodString>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         options: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             label: z.ZodString;
@@ -121,68 +169,106 @@ export declare const StreamChunkSchema: z.ZodUnion<[z.ZodObject<{
             label?: string;
             description?: string;
         }[];
+        id?: string;
+        schemaId?: string;
+        schemaVersion?: string;
         kind?: "choice" | "multi-choice";
         multiple?: boolean;
         question?: string;
+        meta?: Record<string, unknown>;
     }, {
         options?: {
             id?: string;
             label?: string;
             description?: string;
         }[];
+        id?: string;
+        schemaId?: string;
+        schemaVersion?: string;
         kind?: "choice" | "multi-choice";
         multiple?: boolean;
         question?: string;
+        meta?: Record<string, unknown>;
     }>]>;
     meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     type?: "interrupt";
+    id?: string;
+    schemaId?: string;
+    schemaVersion?: string;
+    opId?: string;
     node?: string;
     requestId?: string;
     resumeToken?: string;
     workflow?: string;
     input?: {
         options?: never[];
+        id?: string;
+        schemaId?: string;
+        schemaVersion?: string;
         kind?: "text";
         multiple?: boolean;
         question?: string;
+        meta?: Record<string, unknown>;
     } | {
         options?: {
             id?: string;
             label?: string;
             description?: string;
         }[];
+        id?: string;
+        schemaId?: string;
+        schemaVersion?: string;
         kind?: "choice" | "multi-choice";
         multiple?: boolean;
         question?: string;
+        meta?: Record<string, unknown>;
     };
     meta?: Record<string, unknown>;
 }, {
     type?: "interrupt";
+    id?: string;
+    schemaId?: string;
+    schemaVersion?: string;
+    opId?: string;
     node?: string;
     requestId?: string;
     resumeToken?: string;
     workflow?: string;
     input?: {
         options?: never[];
+        id?: string;
+        schemaId?: string;
+        schemaVersion?: string;
         kind?: "text";
         multiple?: boolean;
         question?: string;
+        meta?: Record<string, unknown>;
     } | {
         options?: {
             id?: string;
             label?: string;
             description?: string;
         }[];
+        id?: string;
+        schemaId?: string;
+        schemaVersion?: string;
         kind?: "choice" | "multi-choice";
         multiple?: boolean;
         question?: string;
+        meta?: Record<string, unknown>;
     };
     meta?: Record<string, unknown>;
-}>, z.ZodDiscriminatedUnion<"dataType", [z.ZodObject<{
+}>, z.ZodUnion<[z.ZodObject<{
     type: z.ZodLiteral<"structured-data">;
-    dataType: z.ZodLiteral<"jobs">;
+    mode: z.ZodOptional<z.ZodEnum<["final", "patch", "snapshot"]>>;
+    schemaId: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    opId: z.ZodOptional<z.ZodString>;
     node: z.ZodOptional<z.ZodString>;
+} & {
+    dataType: z.ZodLiteral<"jobs">;
     data: z.ZodObject<{
         jobs: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
@@ -225,7 +311,12 @@ export declare const StreamChunkSchema: z.ZodUnion<[z.ZodObject<{
     }>;
 }, "strip", z.ZodTypeAny, {
     type?: "structured-data";
+    id?: string;
     dataType?: "jobs";
+    mode?: "final" | "patch" | "snapshot";
+    schemaId?: string;
+    schemaVersion?: string;
+    opId?: string;
     node?: string;
     data?: {
         jobs?: {
@@ -239,7 +330,12 @@ export declare const StreamChunkSchema: z.ZodUnion<[z.ZodObject<{
     };
 }, {
     type?: "structured-data";
+    id?: string;
     dataType?: "jobs";
+    mode?: "final" | "patch" | "snapshot";
+    schemaId?: string;
+    schemaVersion?: string;
+    opId?: string;
     node?: string;
     data?: {
         jobs?: {
@@ -251,6 +347,37 @@ export declare const StreamChunkSchema: z.ZodUnion<[z.ZodObject<{
         }[];
         reasoning?: string;
     };
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"structured-data">;
+    dataType: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<["final", "patch", "snapshot"]>>;
+    schemaId: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    opId: z.ZodOptional<z.ZodString>;
+    node: z.ZodOptional<z.ZodString>;
+} & {
+    data: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    type?: "structured-data";
+    id?: string;
+    dataType?: string;
+    mode?: "final" | "patch" | "snapshot";
+    schemaId?: string;
+    schemaVersion?: string;
+    opId?: string;
+    node?: string;
+    data?: unknown;
+}, {
+    type?: "structured-data";
+    id?: string;
+    dataType?: string;
+    mode?: "final" | "patch" | "snapshot";
+    schemaId?: string;
+    schemaVersion?: string;
+    opId?: string;
+    node?: string;
+    data?: unknown;
 }>]>, z.ZodObject<{
     type: z.ZodLiteral<"transition">;
     transitionTo: z.ZodString;
@@ -282,5 +409,20 @@ export declare const StreamChunkSchema: z.ZodUnion<[z.ZodObject<{
     message?: string;
     type?: "error";
 }>]>;
-export type StreamChunk = z.infer<typeof StreamChunkSchema>;
-//# sourceMappingURL=stream-chunk.d.ts.map
+type StreamChunk = z.infer<typeof StreamChunkSchema>;
+
+/**
+ * Reads a server-sent event (SSE) Response body and yields StreamChunk objects.
+ */
+declare function readStream(body: ReadableStream<Uint8Array> | null): AsyncGenerator<StreamChunk, void, void>;
+
+interface StreamFromRouteArgs<TBody = unknown> {
+    endpoint: string;
+    body: TBody;
+    method?: string | undefined;
+    fetchImpl?: typeof fetch;
+    headers?: Record<string, string> | undefined;
+}
+declare function streamFromRoute<TBody = unknown>(args: StreamFromRouteArgs<TBody>): AsyncGenerator<StreamChunk, void, void>;
+
+export { type StreamChunk as S, StreamChunkSchema as a, type StreamFromRouteArgs as b, readStream as r, streamFromRoute as s };

package/dist/browser.d.ts

@@ -1,5 +1,2 @@
-export { readStream } from "./client/read-stream";
-export type { StreamFromRouteArgs } from "./client/stream-from-route";
-export { streamFromRoute } from "./client/stream-from-route";
-export type { StreamChunk } from "./types/stream-chunk";
-//# sourceMappingURL=browser.d.ts.map
+export { S as StreamChunk, b as StreamFromRouteArgs, r as readStream, s as streamFromRoute } from './browser-BIAzFI3U.js';
+import 'zod';

package/dist/browser.js

@@ -1,7 +1,100 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamFromRoute = exports.readStream = void 0;
-var read_stream_1 = require("./client/read-stream");
-Object.defineProperty(exports, "readStream", { enumerable: true, get: function () { return read_stream_1.readStream; } });
-var stream_from_route_1 = require("./client/stream-from-route");
-Object.defineProperty(exports, "streamFromRoute", { enumerable: true, get: function () { return stream_from_route_1.streamFromRoute; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  readStream: () => readStream,
+  streamFromRoute: () => streamFromRoute
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/client/read-stream.ts
+async function* readStream(body) {
+  if (!body) return;
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const parts = buffer.split("\n\n");
+    buffer = parts.pop() ?? "";
+    for (const part of parts) {
+      if (!part.startsWith("data: ")) continue;
+      const payload = part.slice(6);
+      if (payload.trim() === "[DONE]") return;
+      try {
+        yield JSON.parse(payload);
+      } catch (err) {
+        console.warn("Invalid JSON in stream chunk:", payload);
+        console.error(err);
+      }
+    }
+  }
+}
+
+// src/client/stream-from-route.ts
+var toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+var readErrorMessage = async (response) => {
+  let message = `Request failed (${response.status})`;
+  try {
+    const payload = await response.json();
+    if (payload && typeof payload === "object" && "error" in payload && typeof payload.error === "string") {
+      message = payload.error;
+    }
+  } catch {
+  }
+  return message;
+};
+async function* streamFromRoute(args) {
+  const fetchFn = args.fetchImpl ?? globalThis.fetch;
+  if (!fetchFn) {
+    yield { type: "error", message: "No fetch implementation available." };
+    yield { type: "done" };
+    return;
+  }
+  let response;
+  try {
+    response = await fetchFn(args.endpoint, {
+      method: args.method ?? "POST",
+      headers: {
+        "content-type": "application/json",
+        ...args.headers ?? {}
+      },
+      body: JSON.stringify(args.body)
+    });
+  } catch (error) {
+    yield { type: "error", message: toErrorMessage(error) };
+    yield { type: "done" };
+    return;
+  }
+  if (!response.ok) {
+    yield { type: "error", message: await readErrorMessage(response) };
+    yield { type: "done" };
+    return;
+  }
+  yield* readStream(response.body);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readStream,
+  streamFromRoute
+});
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/browser.ts","../src/client/read-stream.ts","../src/client/stream-from-route.ts"],"sourcesContent":["// Browser-safe exports for client bundles.\n// Keep this file free of Node-only imports (fs, path, etc).\n\nexport { readStream } from \"./client/read-stream\";\nexport type { StreamFromRouteArgs } from \"./client/stream-from-route\";\nexport { streamFromRoute } from \"./client/stream-from-route\";\nexport type { StreamChunk } from \"./types/stream-chunk\";\n","// packages/stream/src/client/read-stream.ts\nimport type { StreamChunk } from \"../types/stream-chunk\";\n\n/**\n * Reads a server-sent event (SSE) Response body and yields StreamChunk objects.\n */\nexport async function* readStream(\n  body: ReadableStream<Uint8Array> | null,\n): AsyncGenerator<StreamChunk, void, void> {\n  if (!body) return;\n\n  const reader = body.getReader();\n  const decoder = new TextDecoder(\"utf-8\");\n  let buffer = \"\";\n\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n\n    buffer += decoder.decode(value, { stream: true });\n    const parts = buffer.split(\"\\n\\n\");\n    buffer = parts.pop() ?? \"\";\n\n    for (const part of parts) {\n      if (!part.startsWith(\"data: \")) continue;\n      const payload = part.slice(6);\n      if (payload.trim() === \"[DONE]\") return;\n      try {\n        yield JSON.parse(payload) as StreamChunk;\n      } catch (err: any) {\n        console.warn(\"Invalid JSON in stream chunk:\", payload);\n        console.error(err);\n      }\n    }\n  }\n}\n","import type { StreamChunk } from \"../types/stream-chunk\";\nimport { readStream } from \"./read-stream\";\n\nexport interface StreamFromRouteArgs<TBody = unknown> {\n  endpoint: string;\n  body: TBody;\n  method?: string | undefined;\n  fetchImpl?: typeof fetch;\n  headers?: Record<string, string> | undefined;\n}\n\nconst toErrorMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error);\n\nconst readErrorMessage = async (response: Response): Promise<string> => {\n  let message = `Request failed (${response.status})`;\n  try {\n    const payload = (await response.json()) as unknown;\n    if (\n      payload &&\n      typeof payload === \"object\" &&\n      \"error\" in payload &&\n      typeof (payload as { error?: unknown }).error === \"string\"\n    ) {\n      message = (payload as { error: string }).error;\n    }\n  } catch {}\n  return message;\n};\n\nexport async function* streamFromRoute<TBody = unknown>(\n  args: StreamFromRouteArgs<TBody>,\n): AsyncGenerator<StreamChunk, void, void> {\n  const fetchFn = args.fetchImpl ?? globalThis.fetch;\n  if (!fetchFn) {\n    yield { type: \"error\", message: \"No fetch implementation available.\" };\n    yield { type: \"done\" };\n    return;\n  }\n\n  let response: Response;\n  try {\n    response = await fetchFn(args.endpoint, {\n      method: args.method ?? \"POST\",\n      headers: {\n        \"content-type\": \"application/json\",\n        ...(args.headers ?? {}),\n      },\n      body: JSON.stringify(args.body),\n    });\n  } catch (error) {\n    yield { type: \"error\", message: toErrorMessage(error) };\n    yield { type: \"done\" };\n    return;\n  }\n\n  if (!response.ok) {\n    yield { type: \"error\", message: await readErrorMessage(response) };\n    yield { type: \"done\" };\n    return;\n  }\n\n  yield* readStream(response.body);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMA,gBAAuB,WACrB,MACyC;AACzC,MAAI,CAAC,KAAM;AAEX,QAAM,SAAS,KAAK,UAAU;AAC9B,QAAM,UAAU,IAAI,YAAY,OAAO;AACvC,MAAI,SAAS;AAEb,SAAO,MAAM;AACX,UAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,QAAI,KAAM;AAEV,cAAU,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;AAChD,UAAM,QAAQ,OAAO,MAAM,MAAM;AACjC,aAAS,MAAM,IAAI,KAAK;AAExB,eAAW,QAAQ,OAAO;AACxB,UAAI,CAAC,KAAK,WAAW,QAAQ,EAAG;AAChC,YAAM,UAAU,KAAK,MAAM,CAAC;AAC5B,UAAI,QAAQ,KAAK,MAAM,SAAU;AACjC,UAAI;AACF,cAAM,KAAK,MAAM,OAAO;AAAA,MAC1B,SAAS,KAAU;AACjB,gBAAQ,KAAK,iCAAiC,OAAO;AACrD,gBAAQ,MAAM,GAAG;AAAA,MACnB;AAAA,IACF;AAAA,EACF;AACF;;;ACxBA,IAAM,iBAAiB,CAAC,UACtB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAEvD,IAAM,mBAAmB,OAAO,aAAwC;AACtE,MAAI,UAAU,mBAAmB,SAAS,MAAM;AAChD,MAAI;AACF,UAAM,UAAW,MAAM,SAAS,KAAK;AACrC,QACE,WACA,OAAO,YAAY,YACnB,WAAW,WACX,OAAQ,QAAgC,UAAU,UAClD;AACA,gBAAW,QAA8B;AAAA,IAC3C;AAAA,EACF,QAAQ;AAAA,EAAC;AACT,SAAO;AACT;AAEA,gBAAuB,gBACrB,MACyC;AACzC,QAAM,UAAU,KAAK,aAAa,WAAW;AAC7C,MAAI,CAAC,SAAS;AACZ,UAAM,EAAE,MAAM,SAAS,SAAS,qCAAqC;AACrE,UAAM,EAAE,MAAM,OAAO;AACrB;AAAA,EACF;AAEA,MAAI;AACJ,MAAI;AACF,eAAW,MAAM,QAAQ,KAAK,UAAU;AAAA,MACtC,QAAQ,KAAK,UAAU;AAAA,MACvB,SAAS;AAAA,QACP,gBAAgB;AAAA,QAChB,GAAI,KAAK,WAAW,CAAC;AAAA,MACvB;AAAA,MACA,MAAM,KAAK,UAAU,KAAK,IAAI;AAAA,IAChC,CAAC;AAAA,EACH,SAAS,OAAO;AACd,UAAM,EAAE,MAAM,SAAS,SAAS,eAAe,KAAK,EAAE;AACtD,UAAM,EAAE,MAAM,OAAO;AACrB;AAAA,EACF;AAEA,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,EAAE,MAAM,SAAS,SAAS,MAAM,iBAAiB,QAAQ,EAAE;AACjE,UAAM,EAAE,MAAM,OAAO;AACrB;AAAA,EACF;AAEA,SAAO,WAAW,SAAS,IAAI;AACjC;","names":[]}

package/dist/index.d.ts

@@ -1,5 +1,17 @@
-export * from "./client/read-stream";
-export * from "./client/stream-from-route";
-export * from "./server/create-stream-response";
-export * from "./types/stream-chunk";
-//# sourceMappingURL=index.d.ts.map
+import { S as StreamChunk } from './browser-BIAzFI3U.js';
+export { a as StreamChunkSchema, b as StreamFromRouteArgs, r as readStream, s as streamFromRoute } from './browser-BIAzFI3U.js';
+import 'zod';
+
+declare const STREAM_HEADERS: {
+    "content-type": string;
+    "cache-control": string;
+    connection: string;
+    "x-accel-buffering": string;
+};
+/**
+ * Turns an AsyncIterable<StreamChunk> into a streamed HTTP Response.
+ * Works in Node, Bun, Cloudflare, Edge, etc.
+ */
+declare function createStreamResponse(stream: AsyncIterable<StreamChunk>): Response;
+
+export { STREAM_HEADERS, StreamChunk, createStreamResponse };