@kortyx/stream 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# @chatbot-core/types
+
+## [0.2.0](https://github.com/kortyx-io/kortyx/compare/stream-v0.1.2...stream-v0.2.0) (2026-01-21)
+
+
+### Features
+
+* create kortyx packages ([fb9d281](https://github.com/kortyx-io/kortyx/commit/fb9d281e92e885fcfc2948dc1ee9701e881f7321))
+
+## 0.1.2
+
+### Patch Changes
+
+- Merge branch 'optimization/chat-flow-with-interrupt' into 'main'
+
+  Automatically generated changeset based on detected changes.
+
+## 0.1.1
+
+### Patch Changes
+
+- Merge branch 'fix/stream-ui' into 'main'
+
+  Automatically generated changeset based on detected changes.
+
+## 0.2.1
+
+### Patch Changes
+
+- Merge branch 'fix/ts-problem' into 'master'
+
+  Automatically generated changeset based on detected changes.

package/dist/client/read-stream.d.ts

@@ -0,0 +1,3 @@
+import type { StreamChunk } from "../types/stream-chunk";
+export declare function readStream(body: ReadableStream<Uint8Array> | null): AsyncGenerator<StreamChunk, void, void>;
+//# sourceMappingURL=read-stream.d.ts.map

package/dist/client/read-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-stream.d.ts","sourceRoot":"","sources":["../../src/client/read-stream.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAKzD,wBAAuB,UAAU,CAC/B,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,GACtC,cAAc,CAAC,WAAW,EAAE,IAAI,EAAE,IAAI,CAAC,CA2BzC"}

package/dist/client/read-stream.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStream = readStream;
+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);
+            }
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./client/read-stream";
+export * from "./server/create-stream-response";
+export * from "./types/stream-chunk";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,sBAAsB,CAAC;AAGrC,cAAc,iCAAiC,CAAC;AAChD,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client/read-stream"), exports);
+__exportStar(require("./server/create-stream-response"), exports);
+__exportStar(require("./types/stream-chunk"), exports);

package/dist/server/create-stream-response.d.ts

@@ -0,0 +1,9 @@
+import type { StreamChunk } from "../types/stream-chunk";
+export declare const STREAM_HEADERS: {
+    "content-type": string;
+    "cache-control": string;
+    connection: string;
+    "x-accel-buffering": string;
+};
+export declare function createStreamResponse(stream: AsyncIterable<StreamChunk>): Response;
+//# sourceMappingURL=create-stream-response.d.ts.map

package/dist/server/create-stream-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-stream-response.d.ts","sourceRoot":"","sources":["../../src/server/create-stream-response.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,eAAO,MAAM,cAAc;;;;;CAK1B,CAAC;AAmBF,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,GACjC,QAAQ,CAwBV"}

package/dist/server/create-stream-response.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STREAM_HEADERS = void 0;
+exports.createStreamResponse = createStreamResponse;
+exports.STREAM_HEADERS = {
+    "content-type": "text/event-stream",
+    "cache-control": "no-cache",
+    connection: "keep-alive",
+    "x-accel-buffering": "no",
+};
+class JsonToSseTransformStream extends TransformStream {
+    constructor() {
+        super({
+            transform(part, controller) {
+                controller.enqueue(`data: ${JSON.stringify(part)}\n\n`);
+            },
+            flush(controller) {
+                controller.enqueue("data: [DONE]\n\n");
+            },
+        });
+    }
+}
+function createStreamResponse(stream) {
+    const readable = new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const chunk of stream) {
+                    controller.enqueue(chunk);
+                }
+            }
+            catch (err) {
+                controller.enqueue({
+                    type: "error",
+                    message: String(err?.message ?? err),
+                });
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+    return new Response(readable
+        .pipeThrough(new JsonToSseTransformStream())
+        .pipeThrough(new TextEncoderStream()), { headers: exports.STREAM_HEADERS });
+}

package/dist/server/json-to-sse.d.ts

@@ -0,0 +1,4 @@
+export declare class JsonToSseTransformStream extends TransformStream<unknown, string> {
+    constructor();
+}
+//# sourceMappingURL=json-to-sse.d.ts.map

package/dist/server/json-to-sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-to-sse.d.ts","sourceRoot":"","sources":["../../src/server/json-to-sse.ts"],"names":[],"mappings":"AACA,qBAAa,wBAAyB,SAAQ,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC;;CAW7E"}

package/dist/server/json-to-sse.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonToSseTransformStream = void 0;
+class JsonToSseTransformStream extends TransformStream {
+    constructor() {
+        super({
+            transform(part, controller) {
+                controller.enqueue(`data: ${JSON.stringify(part)}\n\n`);
+            },
+            flush(controller) {
+                controller.enqueue("data: [DONE]\n\n");
+            },
+        });
+    }
+}
+exports.JsonToSseTransformStream = JsonToSseTransformStream;

package/dist/types/stream-chunk.d.ts

@@ -0,0 +1,286 @@
+import { z } from "zod";
+export declare const StreamChunkSchema: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"session">;
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type?: "session";
+    sessionId?: string;
+}, {
+    type?: "session";
+    sessionId?: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"status">;
+    message: z.ZodString;
+    node: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message?: string;
+    type?: "status";
+    node?: string;
+}, {
+    message?: string;
+    type?: "status";
+    node?: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"message">;
+    content: z.ZodString;
+    node: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: "message";
+    node?: string;
+    content?: string;
+}, {
+    type?: "message";
+    node?: string;
+    content?: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"text-start">;
+    node: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: "text-start";
+    node?: string;
+}, {
+    type?: "text-start";
+    node?: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"text-delta">;
+    delta: z.ZodString;
+    node: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: "text-delta";
+    node?: string;
+    delta?: string;
+}, {
+    type?: "text-delta";
+    node?: string;
+    delta?: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"text-end">;
+    node: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: "text-end";
+    node?: string;
+}, {
+    type?: "text-end";
+    node?: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-result">;
+    tool: z.ZodOptional<z.ZodString>;
+    node: z.ZodOptional<z.ZodString>;
+    content: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    type?: "tool-result";
+    node?: string;
+    content?: unknown;
+    tool?: string;
+}, {
+    type?: "tool-result";
+    node?: string;
+    content?: unknown;
+    tool?: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"interrupt">;
+    requestId: z.ZodString;
+    resumeToken: z.ZodString;
+    workflow: z.ZodOptional<z.ZodString>;
+    node: z.ZodOptional<z.ZodString>;
+    input: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        multiple: z.ZodBoolean;
+        question: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodNever, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        options?: never[];
+        kind?: "text";
+        multiple?: boolean;
+        question?: string;
+    }, {
+        options?: never[];
+        kind?: "text";
+        multiple?: boolean;
+        question?: string;
+    }>, z.ZodObject<{
+        kind: z.ZodEnum<["choice", "multi-choice"]>;
+        multiple: z.ZodBoolean;
+        question: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            label?: string;
+            description?: string;
+        }, {
+            id?: string;
+            label?: string;
+            description?: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        options?: {
+            id?: string;
+            label?: string;
+            description?: string;
+        }[];
+        kind?: "choice" | "multi-choice";
+        multiple?: boolean;
+        question?: string;
+    }, {
+        options?: {
+            id?: string;
+            label?: string;
+            description?: string;
+        }[];
+        kind?: "choice" | "multi-choice";
+        multiple?: boolean;
+        question?: string;
+    }>]>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "interrupt";
+    node?: string;
+    requestId?: string;
+    resumeToken?: string;
+    workflow?: string;
+    input?: {
+        options?: never[];
+        kind?: "text";
+        multiple?: boolean;
+        question?: string;
+    } | {
+        options?: {
+            id?: string;
+            label?: string;
+            description?: string;
+        }[];
+        kind?: "choice" | "multi-choice";
+        multiple?: boolean;
+        question?: string;
+    };
+    meta?: Record<string, unknown>;
+}, {
+    type?: "interrupt";
+    node?: string;
+    requestId?: string;
+    resumeToken?: string;
+    workflow?: string;
+    input?: {
+        options?: never[];
+        kind?: "text";
+        multiple?: boolean;
+        question?: string;
+    } | {
+        options?: {
+            id?: string;
+            label?: string;
+            description?: string;
+        }[];
+        kind?: "choice" | "multi-choice";
+        multiple?: boolean;
+        question?: string;
+    };
+    meta?: Record<string, unknown>;
+}>, z.ZodDiscriminatedUnion<"dataType", [z.ZodObject<{
+    type: z.ZodLiteral<"structured-data">;
+    dataType: z.ZodLiteral<"jobs">;
+    node: z.ZodOptional<z.ZodString>;
+    data: z.ZodObject<{
+        jobs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            company: z.ZodString;
+            location: z.ZodString;
+            match: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            title?: string;
+            company?: string;
+            location?: string;
+            match?: number;
+        }, {
+            id?: string;
+            title?: string;
+            company?: string;
+            location?: string;
+            match?: number;
+        }>, "many">;
+        reasoning: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        jobs?: {
+            id?: string;
+            title?: string;
+            company?: string;
+            location?: string;
+            match?: number;
+        }[];
+        reasoning?: string;
+    }, {
+        jobs?: {
+            id?: string;
+            title?: string;
+            company?: string;
+            location?: string;
+            match?: number;
+        }[];
+        reasoning?: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type?: "structured-data";
+    dataType?: "jobs";
+    node?: string;
+    data?: {
+        jobs?: {
+            id?: string;
+            title?: string;
+            company?: string;
+            location?: string;
+            match?: number;
+        }[];
+        reasoning?: string;
+    };
+}, {
+    type?: "structured-data";
+    dataType?: "jobs";
+    node?: string;
+    data?: {
+        jobs?: {
+            id?: string;
+            title?: string;
+            company?: string;
+            location?: string;
+            match?: number;
+        }[];
+        reasoning?: string;
+    };
+}>]>, z.ZodObject<{
+    type: z.ZodLiteral<"transition">;
+    transitionTo: z.ZodString;
+    payload: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    type?: "transition";
+    transitionTo?: string;
+    payload?: any;
+}, {
+    type?: "transition";
+    transitionTo?: string;
+    payload?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"done">;
+    data: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    type?: "done";
+    data?: any;
+}, {
+    type?: "done";
+    data?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message?: string;
+    type?: "error";
+}, {
+    message?: string;
+    type?: "error";
+}>]>;
+export type StreamChunk = z.infer<typeof StreamChunkSchema>;
+//# sourceMappingURL=stream-chunk.d.ts.map

package/dist/types/stream-chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-chunk.d.ts","sourceRoot":"","sources":["../../src/types/stream-chunk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAyE5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/types/stream-chunk.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamChunkSchema = void 0;
+const zod_1 = require("zod");
+const structured_data_1 = require("./structured-data");
+exports.StreamChunkSchema = zod_1.z.union([
+    zod_1.z.object({
+        type: zod_1.z.literal("session"),
+        sessionId: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("status"),
+        message: zod_1.z.string(),
+        node: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("message"),
+        content: zod_1.z.string(),
+        node: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("text-start"),
+        node: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("text-delta"),
+        delta: zod_1.z.string(),
+        node: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("text-end"),
+        node: zod_1.z.string().optional(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("tool-result"),
+        tool: zod_1.z.string().optional(),
+        node: zod_1.z.string().optional(),
+        content: zod_1.z.unknown(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("interrupt"),
+        requestId: zod_1.z.string(),
+        resumeToken: zod_1.z.string(),
+        workflow: zod_1.z.string().optional(),
+        node: zod_1.z.string().optional(),
+        input: zod_1.z.discriminatedUnion("kind", [
+            zod_1.z.object({
+                kind: zod_1.z.literal("text"),
+                multiple: zod_1.z.boolean(),
+                question: zod_1.z.string().optional(),
+                options: zod_1.z.array(zod_1.z.never()).optional(),
+            }),
+            zod_1.z.object({
+                kind: zod_1.z.enum(["choice", "multi-choice"]),
+                multiple: zod_1.z.boolean(),
+                question: zod_1.z.string(),
+                options: zod_1.z.array(zod_1.z.object({
+                    id: zod_1.z.string(),
+                    label: zod_1.z.string(),
+                    description: zod_1.z.string().optional(),
+                })),
+            }),
+        ]),
+        meta: zod_1.z.record(zod_1.z.unknown()).optional(),
+    }),
+    structured_data_1.StructuredDataChunkSchema,
+    zod_1.z.object({
+        type: zod_1.z.literal("transition"),
+        transitionTo: zod_1.z.string(),
+        payload: zod_1.z.any().optional(),
+    }),
+    zod_1.z.object({ type: zod_1.z.literal("done"), data: zod_1.z.any().optional() }),
+    zod_1.z.object({ type: zod_1.z.literal("error"), message: zod_1.z.string() }),
+]);