@kortyx/stream 0.3.0 → 0.3.1

package/dist/client/stream-from-route.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamFromRoute = streamFromRoute;
-const read_stream_1 = require("./read-stream");
-const toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
-const 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* (0, read_stream_1.readStream)(response.body);
-}

package/dist/index.d.ts.map

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

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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,45 +0,0 @@
-"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

@@ -1,4 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,16 +0,0 @@
-"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.map

@@ -1 +0,0 @@
-{"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

@@ -1,74 +0,0 @@
-"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() }),
-]);

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

@@ -1,465 +0,0 @@
-import { z } from "zod";
-export declare const StreamResultSchema: z.ZodObject<{
-    chunks: z.ZodArray<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";
-    }>]>, "many">;
-    transitionTo: z.ZodOptional<z.ZodString>;
-    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        message: z.ZodString;
-        code: z.ZodOptional<z.ZodString>;
-        cause: z.ZodOptional<z.ZodUnknown>;
-    }, "strip", z.ZodTypeAny, {
-        code?: string;
-        message?: string;
-        cause?: unknown;
-    }, {
-        code?: string;
-        message?: string;
-        cause?: unknown;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    transitionTo?: string;
-    payload?: Record<string, any>;
-    error?: {
-        code?: string;
-        message?: string;
-        cause?: unknown;
-    };
-    chunks?: ({
-        type?: "structured-data";
-        dataType?: "jobs";
-        node?: string;
-        data?: {
-            jobs?: {
-                id?: string;
-                title?: string;
-                company?: string;
-                location?: string;
-                match?: number;
-            }[];
-            reasoning?: string;
-        };
-    } | {
-        type?: "session";
-        sessionId?: string;
-    } | {
-        message?: string;
-        type?: "status";
-        node?: string;
-    } | {
-        type?: "message";
-        node?: string;
-        content?: string;
-    } | {
-        type?: "text-start";
-        node?: string;
-    } | {
-        type?: "text-delta";
-        node?: string;
-        delta?: string;
-    } | {
-        type?: "text-end";
-        node?: string;
-    } | {
-        type?: "tool-result";
-        node?: string;
-        content?: unknown;
-        tool?: string;
-    } | {
-        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?: "transition";
-        transitionTo?: string;
-        payload?: any;
-    } | {
-        type?: "done";
-        data?: any;
-    } | {
-        message?: string;
-        type?: "error";
-    })[];
-}, {
-    transitionTo?: string;
-    payload?: Record<string, any>;
-    error?: {
-        code?: string;
-        message?: string;
-        cause?: unknown;
-    };
-    chunks?: ({
-        type?: "structured-data";
-        dataType?: "jobs";
-        node?: string;
-        data?: {
-            jobs?: {
-                id?: string;
-                title?: string;
-                company?: string;
-                location?: string;
-                match?: number;
-            }[];
-            reasoning?: string;
-        };
-    } | {
-        type?: "session";
-        sessionId?: string;
-    } | {
-        message?: string;
-        type?: "status";
-        node?: string;
-    } | {
-        type?: "message";
-        node?: string;
-        content?: string;
-    } | {
-        type?: "text-start";
-        node?: string;
-    } | {
-        type?: "text-delta";
-        node?: string;
-        delta?: string;
-    } | {
-        type?: "text-end";
-        node?: string;
-    } | {
-        type?: "tool-result";
-        node?: string;
-        content?: unknown;
-        tool?: string;
-    } | {
-        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?: "transition";
-        transitionTo?: string;
-        payload?: any;
-    } | {
-        type?: "done";
-        data?: any;
-    } | {
-        message?: string;
-        type?: "error";
-    })[];
-}>;
-export type StreamResult = z.infer<typeof StreamResultSchema>;
-//# sourceMappingURL=stream-result.d.ts.map

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

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