@ekairos/thread 1.22.3 → 1.22.4-beta.feature-thread-unify.0

package/dist/thread.stream.d.ts

@@ -0,0 +1,119 @@
+import { type ThreadContextStatus, type ThreadExecutionStatus, type ThreadItemStatus, type ThreadStepStatus, type ThreadStreamChunkType, type ThreadThreadStatus } from "./thread.contract.js";
+type IsoDateString = string;
+type ThreadStreamEventBase = {
+    type: string;
+    at: IsoDateString;
+};
+export type ContextCreatedEvent = ThreadStreamEventBase & {
+    type: "context.created";
+    contextId: string;
+    threadId: string;
+    status: ThreadContextStatus;
+};
+export type ContextResolvedEvent = ThreadStreamEventBase & {
+    type: "context.resolved";
+    contextId: string;
+    threadId: string;
+    status: ThreadContextStatus;
+};
+export type ContextStatusChangedEvent = ThreadStreamEventBase & {
+    type: "context.status.changed";
+    contextId: string;
+    threadId: string;
+    from: ThreadContextStatus;
+    to: ThreadContextStatus;
+};
+export type ThreadCreatedEvent = ThreadStreamEventBase & {
+    type: "thread.created";
+    threadId: string;
+    status: ThreadThreadStatus;
+};
+export type ThreadResolvedEvent = ThreadStreamEventBase & {
+    type: "thread.resolved";
+    threadId: string;
+    status: ThreadThreadStatus;
+};
+export type ThreadStatusChangedEvent = ThreadStreamEventBase & {
+    type: "thread.status.changed";
+    threadId: string;
+    from: ThreadThreadStatus;
+    to: ThreadThreadStatus;
+};
+export type ExecutionCreatedEvent = ThreadStreamEventBase & {
+    type: "execution.created";
+    executionId: string;
+    contextId: string;
+    threadId: string;
+    status: ThreadExecutionStatus;
+};
+export type ExecutionStatusChangedEvent = ThreadStreamEventBase & {
+    type: "execution.status.changed";
+    executionId: string;
+    contextId: string;
+    threadId: string;
+    from: ThreadExecutionStatus;
+    to: ThreadExecutionStatus;
+};
+export type ThreadFinishedEvent = ThreadStreamEventBase & {
+    type: "thread.finished";
+    threadId: string;
+    contextId: string;
+    executionId: string;
+    result: "completed" | "failed";
+};
+export type ItemCreatedEvent = ThreadStreamEventBase & {
+    type: "item.created";
+    itemId: string;
+    contextId: string;
+    threadId: string;
+    executionId?: string;
+    status: ThreadItemStatus;
+};
+export type ItemStatusChangedEvent = ThreadStreamEventBase & {
+    type: "item.status.changed";
+    itemId: string;
+    executionId?: string;
+    from: ThreadItemStatus;
+    to: ThreadItemStatus;
+};
+export type StepCreatedEvent = ThreadStreamEventBase & {
+    type: "step.created";
+    stepId: string;
+    executionId: string;
+    iteration: number;
+    status: ThreadStepStatus;
+};
+export type StepStatusChangedEvent = ThreadStreamEventBase & {
+    type: "step.status.changed";
+    stepId: string;
+    executionId: string;
+    from: ThreadStepStatus;
+    to: ThreadStepStatus;
+};
+export type PartCreatedEvent = ThreadStreamEventBase & {
+    type: "part.created";
+    partKey: string;
+    stepId: string;
+    idx: number;
+    part?: unknown;
+};
+export type PartUpdatedEvent = ThreadStreamEventBase & {
+    type: "part.updated";
+    partKey: string;
+    stepId: string;
+    idx: number;
+    part?: unknown;
+};
+export type ChunkEmittedEvent = ThreadStreamEventBase & {
+    type: "chunk.emitted";
+    chunkType: ThreadStreamChunkType;
+    contextId: string;
+    executionId?: string;
+    stepId?: string;
+    data?: unknown;
+};
+export type ThreadStreamEvent = ContextCreatedEvent | ContextResolvedEvent | ContextStatusChangedEvent | ThreadCreatedEvent | ThreadResolvedEvent | ThreadStatusChangedEvent | ExecutionCreatedEvent | ExecutionStatusChangedEvent | ThreadFinishedEvent | ItemCreatedEvent | ItemStatusChangedEvent | StepCreatedEvent | StepStatusChangedEvent | PartCreatedEvent | PartUpdatedEvent | ChunkEmittedEvent;
+export declare function parseThreadStreamEvent(value: unknown): ThreadStreamEvent;
+export declare function assertThreadStreamTransitions(event: ThreadStreamEvent): void;
+export declare function validateThreadStreamTimeline(events: readonly ThreadStreamEvent[]): void;
+export {};

package/dist/thread.stream.js

@@ -0,0 +1,152 @@
+import { assertContextTransition, assertExecutionTransition, assertItemTransition, assertStepTransition, assertThreadTransition, } from "./thread.contract.js";
+function assertObject(value, label) {
+    if (!value || typeof value !== "object") {
+        throw new Error(`Invalid ${label}: expected object.`);
+    }
+}
+function assertString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Invalid ${label}: expected non-empty string.`);
+    }
+}
+function assertNumber(value, label) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new Error(`Invalid ${label}: expected number.`);
+    }
+}
+export function parseThreadStreamEvent(value) {
+    assertObject(value, "thread stream event");
+    assertString(value.type, "thread stream event.type");
+    assertString(value.at, "thread stream event.at");
+    const type = value.type;
+    switch (type) {
+        case "context.created":
+        case "context.resolved": {
+            assertString(value.contextId, `${type}.contextId`);
+            assertString(value.threadId, `${type}.threadId`);
+            assertString(value.status, `${type}.status`);
+            return value;
+        }
+        case "context.status.changed": {
+            assertString(value.contextId, `${type}.contextId`);
+            assertString(value.threadId, `${type}.threadId`);
+            assertString(value.from, `${type}.from`);
+            assertString(value.to, `${type}.to`);
+            return value;
+        }
+        case "thread.created":
+        case "thread.resolved": {
+            assertString(value.threadId, `${type}.threadId`);
+            assertString(value.status, `${type}.status`);
+            return value;
+        }
+        case "thread.status.changed": {
+            assertString(value.threadId, `${type}.threadId`);
+            assertString(value.from, `${type}.from`);
+            assertString(value.to, `${type}.to`);
+            return value;
+        }
+        case "execution.created": {
+            assertString(value.executionId, `${type}.executionId`);
+            assertString(value.contextId, `${type}.contextId`);
+            assertString(value.threadId, `${type}.threadId`);
+            assertString(value.status, `${type}.status`);
+            return value;
+        }
+        case "execution.status.changed": {
+            assertString(value.executionId, `${type}.executionId`);
+            assertString(value.contextId, `${type}.contextId`);
+            assertString(value.threadId, `${type}.threadId`);
+            assertString(value.from, `${type}.from`);
+            assertString(value.to, `${type}.to`);
+            return value;
+        }
+        case "thread.finished": {
+            assertString(value.threadId, `${type}.threadId`);
+            assertString(value.contextId, `${type}.contextId`);
+            assertString(value.executionId, `${type}.executionId`);
+            assertString(value.result, `${type}.result`);
+            return value;
+        }
+        case "item.created": {
+            assertString(value.itemId, `${type}.itemId`);
+            assertString(value.contextId, `${type}.contextId`);
+            assertString(value.threadId, `${type}.threadId`);
+            assertString(value.status, `${type}.status`);
+            if (value.executionId !== undefined) {
+                assertString(value.executionId, `${type}.executionId`);
+            }
+            return value;
+        }
+        case "item.status.changed": {
+            assertString(value.itemId, `${type}.itemId`);
+            assertString(value.from, `${type}.from`);
+            assertString(value.to, `${type}.to`);
+            if (value.executionId !== undefined) {
+                assertString(value.executionId, `${type}.executionId`);
+            }
+            return value;
+        }
+        case "step.created": {
+            assertString(value.stepId, `${type}.stepId`);
+            assertString(value.executionId, `${type}.executionId`);
+            assertNumber(value.iteration, `${type}.iteration`);
+            assertString(value.status, `${type}.status`);
+            return value;
+        }
+        case "step.status.changed": {
+            assertString(value.stepId, `${type}.stepId`);
+            assertString(value.executionId, `${type}.executionId`);
+            assertString(value.from, `${type}.from`);
+            assertString(value.to, `${type}.to`);
+            return value;
+        }
+        case "part.created":
+        case "part.updated": {
+            assertString(value.partKey, `${type}.partKey`);
+            assertString(value.stepId, `${type}.stepId`);
+            assertNumber(value.idx, `${type}.idx`);
+            return value;
+        }
+        case "chunk.emitted": {
+            assertString(value.chunkType, `${type}.chunkType`);
+            assertString(value.contextId, `${type}.contextId`);
+            if (value.executionId !== undefined) {
+                assertString(value.executionId, `${type}.executionId`);
+            }
+            if (value.stepId !== undefined) {
+                assertString(value.stepId, `${type}.stepId`);
+            }
+            return value;
+        }
+        default: {
+            throw new Error(`Unsupported thread stream event type: ${type}`);
+        }
+    }
+}
+export function assertThreadStreamTransitions(event) {
+    switch (event.type) {
+        case "context.status.changed":
+            assertContextTransition(event.from, event.to);
+            return;
+        case "thread.status.changed":
+            assertThreadTransition(event.from, event.to);
+            return;
+        case "execution.status.changed":
+            assertExecutionTransition(event.from, event.to);
+            return;
+        case "item.status.changed":
+            assertItemTransition(event.from, event.to);
+            return;
+        case "step.status.changed":
+            assertStepTransition(event.from, event.to);
+            return;
+        default:
+            return;
+    }
+}
+export function validateThreadStreamTimeline(events) {
+    for (const event of events) {
+        assertThreadStreamTransitions(event);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/thread",
-  "version": "1.22.3",
+  "version": "1.22.4-beta.feature-thread-unify.0",
   "description": "Pulzar Thread - Workflow-based AI Threads",
   "type": "module",
   "main": "dist/index.js",
@@ -106,11 +106,14 @@
     "dev": "tsc -p tsconfig.json --watch",
     "watch": "tsc -p tsconfig.json --watch",
     "clean": "node -e \"require('fs').rmSync('dist', {recursive:true, force:true})\"",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run -c vitest.config.mts",
+    "test:ai-sdk-reactor": "vitest run -c vitest.config.mts src/tests/thread.ai-sdk-reactor.instant.test.ts",
+    "test:scripted-reactor": "vitest run -c vitest.config.mts src/tests/thread.scripted-reactor.instant.test.ts"
   },
   "dependencies": {
     "@ai-sdk/openai": "^2.0.52",
-    "@ekairos/domain": "^1.22.3",
+    "@ekairos/domain": "^1.22.4-beta.feature-thread-unify.0",
     "@instantdb/admin": "0.22.126",
     "@instantdb/core": "0.22.126",
     "@vercel/mcp-adapter": "^1.0.0",
@@ -125,9 +128,12 @@
     "zod": "^4.1.8"
   },
   "devDependencies": {
+    "@ekairos/testing": "workspace:*",
     "@ekairos/tsconfig": "workspace:*",
     "@types/node": "^24.5.0",
     "@types/react": "^19.2.2",
+    "dotenv": "^17.2.3",
+    "vitest": "^3.2.4",
     "typescript": "^5.9.2"
   }
 }