@ekairos/thread 1.22.4-beta.feature-thread-unify.0 → 1.22.4-beta.feature-core-thread-registry-sync.0

package/dist/thread.events.d.ts

@@ -1,8 +1,8 @@
 import { type ModelMessage, type UIMessage } from "ai";
 import type { ThreadItem } from "./thread.store.js";
-export declare const INPUT_TEXT_ITEM_TYPE = "input_text";
-export declare const OUTPUT_TEXT_ITEM_TYPE = "output_text";
-export declare const SYSTEM_TEXT_ITEM_TYPE = "ekairos:system";
+export declare const INPUT_ITEM_TYPE = "input";
+export declare const OUTPUT_ITEM_TYPE = "output";
+export declare const INPUT_TEXT_ITEM_TYPE = "input";
 export declare const WEB_CHANNEL = "web";
 export declare const AGENT_CHANNEL = "whatsapp";
 export declare const EMAIL_CHANNEL = "email";

package/dist/thread.events.js

@@ -1,7 +1,7 @@
 import { convertToModelMessages } from "ai";
-export const INPUT_TEXT_ITEM_TYPE = "input_text";
-export const OUTPUT_TEXT_ITEM_TYPE = "output_text";
-export const SYSTEM_TEXT_ITEM_TYPE = "ekairos:system";
+export const INPUT_ITEM_TYPE = "input";
+export const OUTPUT_ITEM_TYPE = "output";
+export const INPUT_TEXT_ITEM_TYPE = INPUT_ITEM_TYPE;
 export const WEB_CHANNEL = "web";
 export const AGENT_CHANNEL = "whatsapp";
 export const EMAIL_CHANNEL = "email";
@@ -12,7 +12,7 @@ export function createUserItemFromUIMessages(messages) {
     const lastMessage = messages[messages.length - 1];
     return {
         id: lastMessage.id,
-        type: INPUT_TEXT_ITEM_TYPE,
+        type: INPUT_ITEM_TYPE,
         channel: WEB_CHANNEL,
         content: {
             parts: lastMessage.parts,
@@ -27,7 +27,7 @@ export function createAssistantItemFromUIMessages(itemId, messages) {
     const lastMessage = messages[messages.length - 1];
     return {
         id: itemId,
-        type: OUTPUT_TEXT_ITEM_TYPE,
+        type: OUTPUT_ITEM_TYPE,
         channel: WEB_CHANNEL,
         content: {
             parts: lastMessage.parts,
@@ -36,28 +36,19 @@ export function createAssistantItemFromUIMessages(itemId, messages) {
     };
 }
 export function convertToUIMessage(item) {
-    let role;
-    if (item.type === INPUT_TEXT_ITEM_TYPE) {
-        role = "user";
-    }
-    else if (item.type === SYSTEM_TEXT_ITEM_TYPE) {
-        role = "system";
-    }
-    else {
-        role = "assistant";
-    }
+    const role = item.type === INPUT_ITEM_TYPE ? "user" : "assistant";
     const parts = Array.isArray(item.content.parts)
         ? item.content.parts
         : [];
     return {
         id: item.id,
-        role: role,
+        role,
         parts,
         metadata: {
             channel: item.channel,
             type: item.type,
             createdAt: item.createdAt,
-        }
+        },
     };
 }
 /**
@@ -92,25 +83,11 @@ function normalizeModelMessageContentToParts(content) {
     return [content];
 }
 export function convertModelMessageToItem(itemId, message) {
-    let type;
-    switch (message.message.role) {
-        case "user":
-            type = INPUT_TEXT_ITEM_TYPE;
-            break;
-        case "assistant":
-            type = OUTPUT_TEXT_ITEM_TYPE;
-            break;
-        case "system":
-            type = SYSTEM_TEXT_ITEM_TYPE;
-            break;
-        default:
-            // Fallback for roles not mapped to our item types (e.g. tool).
-            type = OUTPUT_TEXT_ITEM_TYPE;
-            break;
-    }
+    const role = message.message.role;
+    const type = role === "user" ? INPUT_ITEM_TYPE : OUTPUT_ITEM_TYPE;
     return {
         id: itemId,
-        type: type,
+        type,
         channel: WEB_CHANNEL,
         content: {
             parts: normalizeModelMessageContentToParts(message.message.content),

package/dist/thread.reactor.d.ts

@@ -1,3 +1,3 @@
 export { createAiSdkReactor, type CreateAiSdkReactorOptions, } from "./reactors/ai-sdk.reactor.js";
 export { createScriptedReactor, type CreateScriptedReactorOptions, type ScriptedReactorStep, } from "./reactors/scripted.reactor.js";
-export type { ThreadReactor, ThreadReactorParams, ThreadReactionResult, ThreadReactionToolCall, ThreadReactionLLM, } from "./reactors/types.js";
+export type { ThreadReactor, ThreadReactorParams, ThreadReactionResult, ThreadActionRequest, ThreadReactionLLM, } from "./reactors/types.js";

package/dist/thread.store.d.ts

@@ -1,5 +1,5 @@
 import type { ModelMessage } from "ai";
-import type { ThreadThreadStatus, ThreadContextStatus, ThreadExecutionStatus, ThreadStepStatus as ContractThreadStepStatus, ThreadItemStatus, ThreadItemType, ThreadChannel } from "./thread.contract.js";
+import type { ThreadThreadStatus, ThreadContextStatus, ThreadExecutionStatus, ThreadStepStatus as ContractThreadStepStatus, ThreadStepKind, ThreadItemStatus, ThreadItemType, ThreadChannel } from "./thread.contract.js";
 /**
  * ## thread.store.ts
  *
@@ -57,12 +57,13 @@ export type ThreadStep = {
     updatedAt?: Date;
     status: ThreadStepStatus;
     iteration: number;
-    executionId: string;
-    triggerEventId?: string;
-    reactionEventId?: string;
-    eventId: string;
-    toolCalls?: any;
-    toolExecutionResults?: any;
+    kind?: ThreadStepKind;
+    actionName?: string;
+    actionInput?: unknown;
+    actionOutput?: unknown;
+    actionError?: string;
+    actionRequests?: any;
+    actionResults?: any;
     continueLoop?: boolean;
     errorText?: string;
 };
@@ -92,12 +93,11 @@ export interface ThreadStore {
         iteration: number;
     }): Promise<{
         id: string;
-        eventId: string;
     }>;
     /**
      * Updates a persisted thread step with completion metadata (tools, errors, continue signal, etc).
      */
-    updateStep(stepId: string, patch: Partial<Pick<ThreadStep, "status" | "toolCalls" | "toolExecutionResults" | "continueLoop" | "errorText" | "updatedAt">>): Promise<void>;
+    updateStep(stepId: string, patch: Partial<Pick<ThreadStep, "status" | "kind" | "actionName" | "actionInput" | "actionOutput" | "actionError" | "actionRequests" | "actionResults" | "continueLoop" | "errorText" | "updatedAt">>): Promise<void>;
     /**
      * Persists normalized parts for a given step (parts-first).
      * The item keeps `content.parts` for back-compat, but the source-of-truth can be `thread_parts`.

package/dist/thread.stream.d.ts

@@ -1,4 +1,4 @@
-import { type ThreadContextStatus, type ThreadExecutionStatus, type ThreadItemStatus, type ThreadStepStatus, type ThreadStreamChunkType, type ThreadThreadStatus } from "./thread.contract.js";
+import type { ThreadContextStatus, ThreadItemStatus, ThreadItemType, ThreadStepKind, ThreadStepStatus, ThreadStreamChunkType, ThreadThreadStatus } from "./thread.contract.js";
 type IsoDateString = string;
 type ThreadStreamEventBase = {
     type: string;
@@ -16,12 +16,22 @@ export type ContextResolvedEvent = ThreadStreamEventBase & {
     threadId: string;
     status: ThreadContextStatus;
 };
-export type ContextStatusChangedEvent = ThreadStreamEventBase & {
-    type: "context.status.changed";
+export type ContextOpenedEvent = ThreadStreamEventBase & {
+    type: "context.opened";
+    contextId: string;
+    threadId: string;
+    status: "open";
+};
+export type ContextClosedEvent = ThreadStreamEventBase & {
+    type: "context.closed";
+    contextId: string;
+    threadId: string;
+    status: "closed";
+};
+export type ContextContentUpdatedEvent = ThreadStreamEventBase & {
+    type: "context.content_updated";
     contextId: string;
     threadId: string;
-    from: ThreadContextStatus;
-    to: ThreadContextStatus;
 };
 export type ThreadCreatedEvent = ThreadStreamEventBase & {
     type: "thread.created";
@@ -33,33 +43,36 @@ export type ThreadResolvedEvent = ThreadStreamEventBase & {
     threadId: string;
     status: ThreadThreadStatus;
 };
-export type ThreadStatusChangedEvent = ThreadStreamEventBase & {
-    type: "thread.status.changed";
+export type ThreadStreamingStartedEvent = ThreadStreamEventBase & {
+    type: "thread.streaming_started";
+    threadId: string;
+    status: "streaming";
+};
+export type ThreadIdleEvent = ThreadStreamEventBase & {
+    type: "thread.idle";
     threadId: string;
-    from: ThreadThreadStatus;
-    to: ThreadThreadStatus;
+    status: "idle";
 };
 export type ExecutionCreatedEvent = ThreadStreamEventBase & {
     type: "execution.created";
     executionId: string;
     contextId: string;
     threadId: string;
-    status: ThreadExecutionStatus;
+    status: "executing";
 };
-export type ExecutionStatusChangedEvent = ThreadStreamEventBase & {
-    type: "execution.status.changed";
+export type ExecutionCompletedEvent = ThreadStreamEventBase & {
+    type: "execution.completed";
     executionId: string;
     contextId: string;
     threadId: string;
-    from: ThreadExecutionStatus;
-    to: ThreadExecutionStatus;
+    status: "completed";
 };
-export type ThreadFinishedEvent = ThreadStreamEventBase & {
-    type: "thread.finished";
-    threadId: string;
-    contextId: string;
+export type ExecutionFailedEvent = ThreadStreamEventBase & {
+    type: "execution.failed";
     executionId: string;
-    result: "completed" | "failed";
+    contextId: string;
+    threadId: string;
+    status: "failed";
 };
 export type ItemCreatedEvent = ThreadStreamEventBase & {
     type: "item.created";
@@ -68,41 +81,82 @@ export type ItemCreatedEvent = ThreadStreamEventBase & {
     threadId: string;
     executionId?: string;
     status: ThreadItemStatus;
+    itemType?: ThreadItemType;
 };
-export type ItemStatusChangedEvent = ThreadStreamEventBase & {
-    type: "item.status.changed";
+export type ItemUpdatedEvent = ThreadStreamEventBase & {
+    type: "item.updated";
     itemId: string;
+    contextId: string;
+    threadId: string;
     executionId?: string;
-    from: ThreadItemStatus;
-    to: ThreadItemStatus;
+    status?: ThreadItemStatus;
+};
+export type ItemPendingEvent = ThreadStreamEventBase & {
+    type: "item.pending";
+    itemId: string;
+    contextId: string;
+    threadId: string;
+    executionId?: string;
+    status: "pending";
+};
+export type ItemCompletedEvent = ThreadStreamEventBase & {
+    type: "item.completed";
+    itemId: string;
+    contextId: string;
+    threadId: string;
+    executionId?: string;
+    status: "completed";
 };
 export type StepCreatedEvent = ThreadStreamEventBase & {
     type: "step.created";
     stepId: string;
     executionId: string;
     iteration: number;
-    status: ThreadStepStatus;
+    status: "running";
 };
-export type StepStatusChangedEvent = ThreadStreamEventBase & {
-    type: "step.status.changed";
+export type StepUpdatedEvent = ThreadStreamEventBase & {
+    type: "step.updated";
     stepId: string;
     executionId: string;
-    from: ThreadStepStatus;
-    to: ThreadStepStatus;
+    iteration?: number;
+    status?: ThreadStepStatus;
+    kind?: ThreadStepKind;
+    actionName?: string;
+};
+export type StepCompletedEvent = ThreadStreamEventBase & {
+    type: "step.completed";
+    stepId: string;
+    executionId: string;
+    iteration?: number;
+    status: "completed";
+};
+export type StepFailedEvent = ThreadStreamEventBase & {
+    type: "step.failed";
+    stepId: string;
+    executionId: string;
+    iteration?: number;
+    status: "failed";
+    errorText?: string;
 };
 export type PartCreatedEvent = ThreadStreamEventBase & {
     type: "part.created";
     partKey: string;
     stepId: string;
     idx: number;
-    part?: unknown;
+    partType?: string;
+    partPreview?: string;
+    partState?: string;
+    partToolCallId?: string;
 };
 export type PartUpdatedEvent = ThreadStreamEventBase & {
     type: "part.updated";
     partKey: string;
     stepId: string;
     idx: number;
-    part?: unknown;
+    partType?: string;
+    partPreview?: string;
+    partState?: string;
+    partToolCallId?: string;
 };
 export type ChunkEmittedEvent = ThreadStreamEventBase & {
     type: "chunk.emitted";
@@ -110,10 +164,23 @@ export type ChunkEmittedEvent = ThreadStreamEventBase & {
     contextId: string;
     executionId?: string;
     stepId?: string;
+    itemId?: string;
+    partKey?: string;
+    actionRef?: string;
+    provider?: string;
+    providerChunkType?: string;
+    sequence: number;
     data?: unknown;
-};
-export type ThreadStreamEvent = ContextCreatedEvent | ContextResolvedEvent | ContextStatusChangedEvent | ThreadCreatedEvent | ThreadResolvedEvent | ThreadStatusChangedEvent | ExecutionCreatedEvent | ExecutionStatusChangedEvent | ThreadFinishedEvent | ItemCreatedEvent | ItemStatusChangedEvent | StepCreatedEvent | StepStatusChangedEvent | PartCreatedEvent | PartUpdatedEvent | ChunkEmittedEvent;
+    raw?: unknown;
+};
+export type ContextEvent = ContextCreatedEvent | ContextResolvedEvent | ContextOpenedEvent | ContextClosedEvent | ContextContentUpdatedEvent;
+export type ThreadEvent = ThreadCreatedEvent | ThreadResolvedEvent | ThreadStreamingStartedEvent | ThreadIdleEvent;
+export type ExecutionEvent = ExecutionCreatedEvent | ExecutionCompletedEvent | ExecutionFailedEvent;
+export type ItemEvent = ItemCreatedEvent | ItemUpdatedEvent | ItemPendingEvent | ItemCompletedEvent;
+export type StepEvent = StepCreatedEvent | StepUpdatedEvent | StepCompletedEvent | StepFailedEvent;
+export type PartEvent = PartCreatedEvent | PartUpdatedEvent;
+export type ThreadStreamEvent = ContextEvent | ThreadEvent | ExecutionEvent | ItemEvent | StepEvent | PartEvent | ChunkEmittedEvent;
 export declare function parseThreadStreamEvent(value: unknown): ThreadStreamEvent;
-export declare function assertThreadStreamTransitions(event: ThreadStreamEvent): void;
+export declare function assertThreadStreamTransitions(_event: ThreadStreamEvent): void;
 export declare function validateThreadStreamTimeline(events: readonly ThreadStreamEvent[]): void;
 export {};

package/dist/thread.stream.js

@@ -1,4 +1,4 @@
-import { assertContextTransition, assertExecutionTransition, assertItemTransition, assertStepTransition, assertThreadTransition, } from "./thread.contract.js";
+import { isThreadStreamChunkType } from "./thread.contract.js";
 function assertObject(value, label) {
     if (!value || typeof value !== "object") {
         throw new Error(`Invalid ${label}: expected object.`);
@@ -14,6 +14,16 @@ function assertNumber(value, label) {
         throw new Error(`Invalid ${label}: expected number.`);
     }
 }
+function assertOptionalString(value, label) {
+    if (value !== undefined) {
+        assertString(value, label);
+    }
+}
+function assertOptionalNumber(value, label) {
+    if (value !== undefined) {
+        assertNumber(value, label);
+    }
+}
 export function parseThreadStreamEvent(value) {
     assertObject(value, "thread stream event");
     assertString(value.type, "thread stream event.type");
@@ -27,64 +37,59 @@ export function parseThreadStreamEvent(value) {
             assertString(value.status, `${type}.status`);
             return value;
         }
-        case "context.status.changed": {
+        case "context.opened":
+        case "context.closed": {
             assertString(value.contextId, `${type}.contextId`);
             assertString(value.threadId, `${type}.threadId`);
-            assertString(value.from, `${type}.from`);
-            assertString(value.to, `${type}.to`);
+            assertString(value.status, `${type}.status`);
             return value;
         }
-        case "thread.created":
-        case "thread.resolved": {
+        case "context.content_updated": {
+            assertString(value.contextId, `${type}.contextId`);
             assertString(value.threadId, `${type}.threadId`);
-            assertString(value.status, `${type}.status`);
             return value;
         }
-        case "thread.status.changed": {
+        case "thread.created":
+        case "thread.resolved":
+        case "thread.streaming_started":
+        case "thread.idle": {
             assertString(value.threadId, `${type}.threadId`);
-            assertString(value.from, `${type}.from`);
-            assertString(value.to, `${type}.to`);
+            assertString(value.status, `${type}.status`);
             return value;
         }
-        case "execution.created": {
+        case "execution.created":
+        case "execution.completed":
+        case "execution.failed": {
             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`);
+        case "item.created": {
+            assertString(value.itemId, `${type}.itemId`);
             assertString(value.contextId, `${type}.contextId`);
             assertString(value.threadId, `${type}.threadId`);
-            assertString(value.from, `${type}.from`);
-            assertString(value.to, `${type}.to`);
+            assertString(value.status, `${type}.status`);
+            assertOptionalString(value.executionId, `${type}.executionId`);
+            assertOptionalString(value.itemType, `${type}.itemType`);
             return value;
         }
-        case "thread.finished": {
-            assertString(value.threadId, `${type}.threadId`);
+        case "item.updated": {
+            assertString(value.itemId, `${type}.itemId`);
             assertString(value.contextId, `${type}.contextId`);
-            assertString(value.executionId, `${type}.executionId`);
-            assertString(value.result, `${type}.result`);
+            assertString(value.threadId, `${type}.threadId`);
+            assertOptionalString(value.executionId, `${type}.executionId`);
+            assertOptionalString(value.status, `${type}.status`);
             return value;
         }
-        case "item.created": {
+        case "item.pending":
+        case "item.completed": {
             assertString(value.itemId, `${type}.itemId`);
             assertString(value.contextId, `${type}.contextId`);
             assertString(value.threadId, `${type}.threadId`);
+            assertOptionalString(value.executionId, `${type}.executionId`);
             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": {
@@ -94,11 +99,25 @@ export function parseThreadStreamEvent(value) {
             assertString(value.status, `${type}.status`);
             return value;
         }
-        case "step.status.changed": {
+        case "step.updated": {
+            assertString(value.stepId, `${type}.stepId`);
+            assertString(value.executionId, `${type}.executionId`);
+            if (value.iteration !== undefined)
+                assertNumber(value.iteration, `${type}.iteration`);
+            assertOptionalString(value.status, `${type}.status`);
+            assertOptionalString(value.kind, `${type}.kind`);
+            assertOptionalString(value.actionName, `${type}.actionName`);
+            return value;
+        }
+        case "step.completed":
+        case "step.failed": {
             assertString(value.stepId, `${type}.stepId`);
             assertString(value.executionId, `${type}.executionId`);
-            assertString(value.from, `${type}.from`);
-            assertString(value.to, `${type}.to`);
+            if (value.iteration !== undefined)
+                assertNumber(value.iteration, `${type}.iteration`);
+            assertString(value.status, `${type}.status`);
+            if (type === "step.failed")
+                assertOptionalString(value.errorText, `${type}.errorText`);
             return value;
         }
         case "part.created":
@@ -106,44 +125,34 @@ export function parseThreadStreamEvent(value) {
             assertString(value.partKey, `${type}.partKey`);
             assertString(value.stepId, `${type}.stepId`);
             assertNumber(value.idx, `${type}.idx`);
+            assertOptionalString(value.partType, `${type}.partType`);
+            assertOptionalString(value.partPreview, `${type}.partPreview`);
+            assertOptionalString(value.partState, `${type}.partState`);
+            assertOptionalString(value.partToolCallId, `${type}.partToolCallId`);
             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`);
+            if (!isThreadStreamChunkType(value.chunkType)) {
+                throw new Error(`Invalid ${type}.chunkType: ${String(value.chunkType)}`);
             }
+            assertString(value.contextId, `${type}.contextId`);
+            assertOptionalString(value.executionId, `${type}.executionId`);
+            assertOptionalString(value.stepId, `${type}.stepId`);
+            assertOptionalString(value.itemId, `${type}.itemId`);
+            assertOptionalString(value.partKey, `${type}.partKey`);
+            assertOptionalString(value.actionRef, `${type}.actionRef`);
+            assertOptionalString(value.provider, `${type}.provider`);
+            assertOptionalString(value.providerChunkType, `${type}.providerChunkType`);
+            assertOptionalNumber(value.sequence, `${type}.sequence`);
             return value;
         }
-        default: {
+        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 assertThreadStreamTransitions(_event) {
+    return;
 }
 export function validateThreadStreamTimeline(events) {
     for (const event of events) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/thread",
-  "version": "1.22.4-beta.feature-thread-unify.0",
+  "version": "1.22.4-beta.feature-core-thread-registry-sync.0",
   "description": "Pulzar Thread - Workflow-based AI Threads",
   "type": "module",
   "main": "dist/index.js",
@@ -109,11 +109,12 @@
     "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:ai-sdk-reactor:real": "vitest run -c vitest.config.mts src/tests/thread.ai-sdk-reactor.real.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.4-beta.feature-thread-unify.0",
+    "@ekairos/domain": "^1.22.4-beta.feature-core-thread-registry-sync.0",
     "@instantdb/admin": "0.22.126",
     "@instantdb/core": "0.22.126",
     "@vercel/mcp-adapter": "^1.0.0",