@kortyx/stream 0.2.3 → 0.3.1

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"}

package/dist/types/stream-result.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamResultSchema = void 0;
-const zod_1 = require("zod");
-const stream_chunk_1 = require("./stream-chunk");
-exports.StreamResultSchema = zod_1.z.object({
-    chunks: zod_1.z.array(stream_chunk_1.StreamChunkSchema),
-    transitionTo: zod_1.z.string().optional(),
-    payload: zod_1.z.record(zod_1.z.any()).optional(),
-    error: zod_1.z
-        .object({
-        message: zod_1.z.string(),
-        code: zod_1.z.string().optional(),
-        cause: zod_1.z.unknown().optional(),
-    })
-        .nullable()
-        .optional(),
-});

package/dist/types/structured-data/index.d.ts

@@ -1,76 +0,0 @@
-import { z } from "zod";
-export declare const StructuredDataChunkSchema: 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;
-    };
-}>]>;
-export type StructuredDataChunk = z.infer<typeof StructuredDataChunkSchema>;
-//# sourceMappingURL=index.d.ts.map

package/dist/types/structured-data/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/structured-data/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAepC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/types/structured-data/index.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructuredDataChunkSchema = void 0;
-const zod_1 = require("zod");
-const jobs_1 = require("./jobs");
-exports.StructuredDataChunkSchema = zod_1.z.discriminatedUnion("dataType", [
-    zod_1.z.object({
-        type: zod_1.z.literal("structured-data"),
-        dataType: zod_1.z.literal("jobs"),
-        node: zod_1.z.string().optional(),
-        data: jobs_1.JobsStructuredData,
-    }),
-]);

package/dist/types/structured-data/jobs.d.ts

@@ -1,43 +0,0 @@
-import { z } from "zod";
-export declare const JobsStructuredData: 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;
-}>;
-export type JobsStructuredData = z.infer<typeof JobsStructuredData>;
-//# sourceMappingURL=jobs.d.ts.map

package/dist/types/structured-data/jobs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jobs.d.ts","sourceRoot":"","sources":["../../../src/types/structured-data/jobs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW7B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/types/structured-data/jobs.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JobsStructuredData = void 0;
-const zod_1 = require("zod");
-exports.JobsStructuredData = zod_1.z.object({
-    jobs: zod_1.z.array(zod_1.z.object({
-        id: zod_1.z.string(),
-        title: zod_1.z.string(),
-        company: zod_1.z.string(),
-        location: zod_1.z.string(),
-        match: zod_1.z.number(),
-    })),
-    reasoning: zod_1.z.string().optional(),
-});