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

package/dist/stores/instant.store.js

@@ -121,7 +121,7 @@ export class InstantStore {
             id: String(row?.id ?? ""),
             key: typeof row?.key === "string" ? row.key : null,
             name: typeof row?.name === "string" ? row.name : null,
-            status: (typeof row?.status === "string" ? row.status : "open"),
+            status: (typeof row?.status === "string" ? row.status : "idle"),
             createdAt: row?.createdAt instanceof Date ? row.createdAt : new Date(row?.createdAt ?? Date.now()),
             updatedAt: row?.updatedAt instanceof Date ? row.updatedAt : row?.updatedAt ? new Date(row.updatedAt) : undefined,
         };
@@ -253,7 +253,7 @@ export class InstantStore {
             this.db.tx.thread_threads[threadId].create({
                 createdAt: new Date(),
                 updatedAt: new Date(),
-                status: "open",
+                status: "idle",
                 key,
             }),
         ]);
@@ -424,7 +424,7 @@ export class InstantStore {
         ];
         if (context.threadId) {
             const thread = await this.getThread({ id: context.threadId });
-            const nextThreadStatus = (status === "closed" ? "closed" : status);
+            const nextThreadStatus = "idle";
             if (thread && thread.status !== nextThreadStatus) {
                 assertThreadTransition(thread.status, nextThreadStatus);
             }
@@ -484,10 +484,10 @@ export class InstantStore {
             });
             throw error;
         }
-        const persisted = await this.getItem(event.id);
-        if (!persisted)
-            throw new Error("InstantStore: failed to read event after save");
-        return persisted;
+        return {
+            ...event,
+            status: "stored",
+        };
     }
     async updateItem(eventId, event) {
         const current = await this.getItem(eventId);
@@ -495,10 +495,11 @@ export class InstantStore {
             assertItemTransition(current.status, event.status);
         }
         await this.db.transact([this.db.tx.thread_items[eventId].update(event)]);
-        const persisted = await this.getItem(eventId);
-        if (!persisted)
-            throw new Error("InstantStore: event not found after update");
-        return persisted;
+        return {
+            ...current,
+            ...event,
+            id: eventId,
+        };
     }
     async getItem(eventId) {
         const res = await this.db.query({
@@ -559,6 +560,13 @@ export class InstantStore {
             status: "executing",
         });
         const txs = [execCreate];
+        if (context.status !== "open") {
+            assertContextTransition(context.status, "open");
+            txs.push(this.db.tx.thread_contexts[context.id].update({
+                status: "open",
+                updatedAt: new Date(),
+            }));
+        }
         txs.push(this.db.tx.thread_executions[executionId].link({ context: context.id }));
         txs.push(this.db.tx.thread_executions[executionId].link({ thread: thread.id }));
         txs.push(this.db.tx.thread_contexts[context.id].link({ currentExecution: executionId }));
@@ -603,17 +611,19 @@ export class InstantStore {
         if (currentExecutionStatus !== status) {
             assertExecutionTransition(currentExecutionStatus, status);
         }
-        if (context.status !== "open") {
-            assertContextTransition(context.status, "open");
+        if (context.status !== "closed") {
+            assertContextTransition(context.status, "closed");
         }
-        const nextThreadStatus = status === "failed" ? "failed" : "open";
+        const nextThreadStatus = "idle";
         if (thread.status !== nextThreadStatus) {
             assertThreadTransition(thread.status, nextThreadStatus);
         }
         const txs = [];
         txs.push(this.db.tx.thread_executions[executionId].update({ status, updatedAt: new Date() }));
-        // Update context status back to "open" when execution completes
-        txs.push(this.db.tx.thread_contexts[context.id].update({ status: "open", updatedAt: new Date() }));
+        txs.push(this.db.tx.thread_contexts[context.id].update({
+            status: "closed",
+            updatedAt: new Date(),
+        }));
         txs.push(this.db.tx.thread_threads[thread.id].update({
             status: nextThreadStatus,
             updatedAt: new Date(),
@@ -622,14 +632,11 @@ export class InstantStore {
     }
     async createStep(params) {
         const stepId = id();
-        const eventId = id();
         const txs = [
             this.db.tx.thread_steps[stepId].create({
                 createdAt: new Date(),
                 status: "running",
                 iteration: params.iteration,
-                executionId: params.executionId,
-                eventId,
             }),
         ];
         txs.push(this.db.tx.thread_steps[stepId].link({ execution: params.executionId }));
@@ -643,14 +650,13 @@ export class InstantStore {
                     executionId: params.executionId,
                     iteration: params.iteration,
                     stepId,
-                    eventId,
                 },
                 txs,
                 error,
             });
             throw error;
         }
-        return { id: stepId, eventId };
+        return { id: stepId };
     }
     async updateStep(stepId, patch) {
         if (patch.status) {
@@ -697,76 +703,16 @@ export class InstantStore {
         await this.db.transact(txs);
     }
     async itemsToModelMessages(events) {
-        // Prefer parts-first reconstruction from thread_parts via the producing step.
-        const eventIds = events.map((e) => String(e.id)).filter(Boolean);
-        let eventsWithParts = events;
-        if (eventIds.length) {
-            try {
-                // 1) Get steps for these events (eventId is stored on thread_steps)
-                const stepsRes = await this.db.query({
-                    thread_steps: {
-                        $: {
-                            where: { eventId: { $in: eventIds } },
-                            fields: ["id", "eventId"],
-                            limit: 2000,
-                        },
-                    },
-                });
-                const steps = stepsRes.thread_steps ?? [];
-                const stepIdByEventId = new Map();
-                const stepIds = [];
-                for (const s of steps) {
-                    const sid = String(s.id);
-                    const eid = String(s.eventId);
-                    if (sid && eid) {
-                        stepIdByEventId.set(eid, sid);
-                        stepIds.push(sid);
-                    }
-                }
-                // 2) Load parts for those steps
-                const partsByStepId = new Map();
-                if (stepIds.length) {
-                    const partsRes = await this.db.query({
-                        thread_parts: {
-                            $: {
-                                where: { stepId: { $in: stepIds } },
-                                order: { idx: "asc" },
-                                limit: 5000,
-                            },
-                        },
-                    });
-                    const rows = partsRes.thread_parts ?? [];
-                    for (const r of rows) {
-                        const sid = String(r.stepId);
-                        const arr = partsByStepId.get(sid) ?? [];
-                        arr.push(r.part);
-                        partsByStepId.set(sid, arr);
-                    }
-                }
-                // 3) Attach parts onto events
-                eventsWithParts = events.map((e) => {
-                    const eid = String(e.id);
-                    const sid = stepIdByEventId.get(eid);
-                    if (!sid)
-                        return e;
-                    const parts = partsByStepId.get(sid);
-                    if (!parts || parts.length === 0)
-                        return e;
-                    return { ...e, content: { ...(e?.content ?? {}), parts } };
-                });
-            }
-            catch {
-                // If schema not pushed yet (or table absent), fallback to embedded parts.
-                eventsWithParts = events;
-            }
-        }
+        // `thread_steps` only links to execution.
+        // Item reconstruction uses embedded `item.content.parts` as source for model messages.
+        const eventsWithParts = events;
         // Default behavior for Instant-backed stories:
-        // - Expand file parts into derived `output_text` events (persisting parsed content into document_documents)
+        // - Expand file parts into derived `message` items (persisting parsed content into document_documents)
         // - Then convert expanded events to model messages
         const expanded = await expandEventsWithInstantDocuments({
             db: this.db,
             events: eventsWithParts,
-            derivedEventType: "output_text",
+            derivedEventType: "output",
         });
         return await convertItemsToModelMessages(expanded);
     }

package/dist/thread.contract.d.ts

@@ -2,28 +2,36 @@ export type Transition<From extends string, To extends string> = {
     from: From;
     to: To;
 };
-export declare const THREAD_STATUSES: readonly ["open", "streaming", "closed", "failed"];
+export declare const THREAD_STATUSES: readonly ["idle", "streaming"];
 export type ThreadThreadStatus = (typeof THREAD_STATUSES)[number];
-export declare const THREAD_CONTEXT_STATUSES: readonly ["open", "streaming", "closed"];
+export declare const THREAD_CONTEXT_STATUSES: readonly ["open", "closed"];
 export type ThreadContextStatus = (typeof THREAD_CONTEXT_STATUSES)[number];
 export declare const THREAD_EXECUTION_STATUSES: readonly ["executing", "completed", "failed"];
 export type ThreadExecutionStatus = (typeof THREAD_EXECUTION_STATUSES)[number];
 export declare const THREAD_STEP_STATUSES: readonly ["running", "completed", "failed"];
 export type ThreadStepStatus = (typeof THREAD_STEP_STATUSES)[number];
+export declare const THREAD_STEP_KINDS: readonly ["message", "action_execute", "action_result"];
+export type ThreadStepKind = (typeof THREAD_STEP_KINDS)[number];
 export declare const THREAD_ITEM_STATUSES: readonly ["stored", "pending", "completed"];
 export type ThreadItemStatus = (typeof THREAD_ITEM_STATUSES)[number];
-export declare const THREAD_ITEM_TYPES: readonly ["input_text", "output_text", "ekairos:system"];
+export declare const THREAD_ITEM_TYPES: readonly ["input", "output"];
 export type ThreadItemType = (typeof THREAD_ITEM_TYPES)[number];
 export declare const THREAD_CHANNELS: readonly ["web", "whatsapp", "email"];
 export type ThreadChannel = (typeof THREAD_CHANNELS)[number];
 export declare const THREAD_TRACE_EVENT_KINDS: readonly ["workflow.run", "workflow.step", "thread.run", "thread.context", "thread.execution", "thread.item", "thread.review", "thread.step", "thread.part", "thread.llm"];
 export type ThreadTraceEventKind = (typeof THREAD_TRACE_EVENT_KINDS)[number];
-export declare const THREAD_STREAM_CHUNK_TYPES: readonly ["data-context-id", "data-context-substate", "data-thread-ping", "tool-output-available", "tool-output-error", "finish"];
+export declare const THREAD_STREAM_LIFECYCLE_CHUNK_TYPES: readonly ["chunk.start", "chunk.start_step", "chunk.finish_step", "chunk.finish"];
+export declare const THREAD_STREAM_TEXT_CHUNK_TYPES: readonly ["chunk.text_start", "chunk.text_delta", "chunk.text_end"];
+export declare const THREAD_STREAM_REASONING_CHUNK_TYPES: readonly ["chunk.reasoning_start", "chunk.reasoning_delta", "chunk.reasoning_end"];
+export declare const THREAD_STREAM_ACTION_CHUNK_TYPES: readonly ["chunk.action_input_start", "chunk.action_input_delta", "chunk.action_input_available", "chunk.action_output_available", "chunk.action_output_error"];
+export declare const THREAD_STREAM_SOURCE_CHUNK_TYPES: readonly ["chunk.source_url", "chunk.source_document", "chunk.file"];
+export declare const THREAD_STREAM_METADATA_CHUNK_TYPES: readonly ["chunk.message_metadata", "chunk.response_metadata"];
+export declare const THREAD_STREAM_ERROR_CHUNK_TYPES: readonly ["chunk.error", "chunk.unknown"];
+export declare const THREAD_STREAM_CHUNK_TYPES: readonly ["chunk.start", "chunk.start_step", "chunk.finish_step", "chunk.finish", "chunk.text_start", "chunk.text_delta", "chunk.text_end", "chunk.reasoning_start", "chunk.reasoning_delta", "chunk.reasoning_end", "chunk.action_input_start", "chunk.action_input_delta", "chunk.action_input_available", "chunk.action_output_available", "chunk.action_output_error", "chunk.source_url", "chunk.source_document", "chunk.file", "chunk.message_metadata", "chunk.response_metadata", "chunk.error", "chunk.unknown"];
 export type ThreadStreamChunkType = (typeof THREAD_STREAM_CHUNK_TYPES)[number];
-export declare const THREAD_CONTEXT_SUBSTATE_KEYS: readonly ["actions"];
-export type ThreadContextSubstateKey = (typeof THREAD_CONTEXT_SUBSTATE_KEYS)[number];
-export type ThreadTransition = Transition<"open" | "streaming" | "failed", "open" | "streaming" | "closed" | "failed">;
-export type ContextTransition = Transition<"open" | "streaming", "streaming" | "open" | "closed">;
+export declare function isThreadStreamChunkType(value: string): value is ThreadStreamChunkType;
+export type ThreadTransition = Transition<"idle" | "streaming", "idle" | "streaming">;
+export type ContextTransition = Transition<"open" | "closed", "open" | "closed">;
 export type ExecutionTransition = Transition<"executing", "completed" | "failed">;
 export type StepTransition = Transition<"running", "completed" | "failed">;
 export type ItemTransition = Transition<"stored" | "pending", "pending" | "completed">;

package/dist/thread.contract.js

@@ -1,9 +1,17 @@
-export const THREAD_STATUSES = ["open", "streaming", "closed", "failed"];
-export const THREAD_CONTEXT_STATUSES = ["open", "streaming", "closed"];
+export const THREAD_STATUSES = ["idle", "streaming"];
+export const THREAD_CONTEXT_STATUSES = ["open", "closed"];
 export const THREAD_EXECUTION_STATUSES = ["executing", "completed", "failed"];
 export const THREAD_STEP_STATUSES = ["running", "completed", "failed"];
+export const THREAD_STEP_KINDS = [
+    "message",
+    "action_execute",
+    "action_result",
+];
 export const THREAD_ITEM_STATUSES = ["stored", "pending", "completed"];
-export const THREAD_ITEM_TYPES = ["input_text", "output_text", "ekairos:system"];
+export const THREAD_ITEM_TYPES = [
+    "input",
+    "output",
+];
 export const THREAD_CHANNELS = ["web", "whatsapp", "email"];
 export const THREAD_TRACE_EVENT_KINDS = [
     "workflow.run",
@@ -17,27 +25,61 @@ export const THREAD_TRACE_EVENT_KINDS = [
     "thread.part",
     "thread.llm",
 ];
+export const THREAD_STREAM_LIFECYCLE_CHUNK_TYPES = [
+    "chunk.start",
+    "chunk.start_step",
+    "chunk.finish_step",
+    "chunk.finish",
+];
+export const THREAD_STREAM_TEXT_CHUNK_TYPES = [
+    "chunk.text_start",
+    "chunk.text_delta",
+    "chunk.text_end",
+];
+export const THREAD_STREAM_REASONING_CHUNK_TYPES = [
+    "chunk.reasoning_start",
+    "chunk.reasoning_delta",
+    "chunk.reasoning_end",
+];
+export const THREAD_STREAM_ACTION_CHUNK_TYPES = [
+    "chunk.action_input_start",
+    "chunk.action_input_delta",
+    "chunk.action_input_available",
+    "chunk.action_output_available",
+    "chunk.action_output_error",
+];
+export const THREAD_STREAM_SOURCE_CHUNK_TYPES = [
+    "chunk.source_url",
+    "chunk.source_document",
+    "chunk.file",
+];
+export const THREAD_STREAM_METADATA_CHUNK_TYPES = [
+    "chunk.message_metadata",
+    "chunk.response_metadata",
+];
+export const THREAD_STREAM_ERROR_CHUNK_TYPES = [
+    "chunk.error",
+    "chunk.unknown",
+];
 export const THREAD_STREAM_CHUNK_TYPES = [
-    "data-context-id",
-    "data-context-substate",
-    "data-thread-ping",
-    "tool-output-available",
-    "tool-output-error",
-    "finish",
-];
-export const THREAD_CONTEXT_SUBSTATE_KEYS = ["actions"];
+    ...THREAD_STREAM_LIFECYCLE_CHUNK_TYPES,
+    ...THREAD_STREAM_TEXT_CHUNK_TYPES,
+    ...THREAD_STREAM_REASONING_CHUNK_TYPES,
+    ...THREAD_STREAM_ACTION_CHUNK_TYPES,
+    ...THREAD_STREAM_SOURCE_CHUNK_TYPES,
+    ...THREAD_STREAM_METADATA_CHUNK_TYPES,
+    ...THREAD_STREAM_ERROR_CHUNK_TYPES,
+];
+export function isThreadStreamChunkType(value) {
+    return THREAD_STREAM_CHUNK_TYPES.includes(value);
+}
 export const THREAD_THREAD_TRANSITIONS = [
-    { from: "open", to: "streaming" },
-    { from: "streaming", to: "open" },
-    { from: "streaming", to: "closed" },
-    { from: "streaming", to: "failed" },
-    { from: "failed", to: "open" },
+    { from: "idle", to: "streaming" },
+    { from: "streaming", to: "idle" },
 ];
 export const THREAD_CONTEXT_TRANSITIONS = [
-    { from: "open", to: "streaming" },
-    { from: "streaming", to: "open" },
     { from: "open", to: "closed" },
-    { from: "streaming", to: "closed" },
+    { from: "closed", to: "open" },
 ];
 export const THREAD_EXECUTION_TRANSITIONS = [
     { from: "executing", to: "completed" },

package/dist/thread.d.ts

@@ -1,3 +1,3 @@
 export { Thread, type ThreadOptions, type ThreadStreamOptions, type ShouldContinue, type ThreadShouldContinueArgs, } from "./thread.engine.js";
 export { thread, createThread, type ThreadConfig, type ThreadInstance, type RegistrableThreadBuilder, } from "./thread.builder.js";
-export { createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ThreadReactor, type ThreadReactorParams, type ThreadReactionResult, type ThreadReactionToolCall, type ThreadReactionLLM, } from "./thread.reactor.js";
+export { createAiSdkReactor, createScriptedReactor, type CreateAiSdkReactorOptions, type CreateScriptedReactorOptions, type ScriptedReactorStep, type ThreadReactor, type ThreadReactorParams, type ThreadReactionResult, type ThreadActionRequest, type ThreadReactionLLM, } from "./thread.reactor.js";

package/dist/thread.engine.d.ts

@@ -13,12 +13,8 @@ export interface ThreadOptions<Context = any, Env extends ThreadEnvironment = Th
         context: StoredContext<Context>;
     }) => void | Promise<void>;
     onEventCreated?: (event: ThreadItem) => void | Promise<void>;
-    onToolCallExecuted?: (executionEvent: any) => void | Promise<void>;
-    onEnd?: (lastEvent: ThreadItem) => void | {
-        end?: boolean;
-    } | Promise<void | {
-        end?: boolean;
-    }>;
+    onActionExecuted?: (executionEvent: any) => void | Promise<void>;
+    onEnd?: (lastEvent: ThreadItem) => void | boolean | Promise<void | boolean>;
 }
 export interface ThreadStreamOptions {
     /**
@@ -134,9 +130,17 @@ export type ThreadShouldContinueArgs<Context = any, Env extends ThreadEnvironmen
      */
     reactionEvent: ThreadItem;
     assistantEvent: ThreadItem;
-    toolCalls: any[];
-    toolExecutionResults: Array<{
-        tc: any;
+    actionRequests: Array<{
+        actionRef: string;
+        actionName: string;
+        input: unknown;
+    }>;
+    actionResults: Array<{
+        actionRequest: {
+            actionRef: string;
+            actionName: string;
+            input: unknown;
+        };
         success: boolean;
         output: any;
         errorText?: string;