@kortyx/stream 0.2.0

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

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

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

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

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

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

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

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

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

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

package/eslint.config.mjs

@@ -0,0 +1,12 @@
+import rootConfig from "../../eslint.config.mjs";
+
+const eslintConfig = [
+  ...rootConfig,
+  {
+    rules: {
+      "@typescript-eslint/no-explicit-any": "warn", // Stricter for type definitions
+    },
+  },
+];
+
+export default eslintConfig;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@kortyx/stream",
+  "version": "0.2.0",
+  "private": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "concurrently": "^9.2.0",
+    "turbo": "^2.5.4",
+    "typescript": "5.7.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc --watch",
+    "lint": "echo 'Linting types...' && echo 'Lint passed!'",
+    "test": "echo 'Testing types...' && echo 'All tests passed!'",
+    "type-check": "tsc --noEmit"
+  }
+}