@ekairos/thread 1.22.16-beta.feature-core-thread-registry-sync.0 → 1.22.18-beta.feature-core-thread-registry-sync.0

package/dist/thread.engine.js

@@ -3,10 +3,65 @@ import { registerThreadEnv } from "./env.js";
 import { applyToolExecutionResultToParts } from "./thread.toolcalls.js";
 import { toolsToModelTools } from "./tools-to-model-tools.js";
 import { createAiSdkReactor, } from "./thread.reactor.js";
-import { closeThreadStream, writeContextSubstate, writeThreadPing, writeToolOutputs, } from "./steps/stream.steps.js";
-import { completeExecution, createThreadStep, emitContextIdChunk, initializeContext, saveReactionItem, saveTriggerAndCreateExecution, saveThreadPartsStep, updateThreadStep, updateContextContent, updateItem, } from "./steps/store.steps.js";
+import { closeThreadStream, writeThreadEvents, } from "./steps/stream.steps.js";
+import { completeExecution, createThreadStep, initializeContext, saveReactionItem, saveTriggerAndCreateExecution, saveThreadPartsStep, updateThreadStep, updateContextContent, updateItem, } from "./steps/store.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "./thread.hooks.js";
 export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl };
+function nowIso() {
+    return new Date().toISOString();
+}
+function clipPreview(value, max = 240) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, max)}...`;
+}
+function summarizePartPreview(part) {
+    if (!part || typeof part !== "object")
+        return {};
+    const row = part;
+    const partType = typeof row.type === "string" ? row.type : "";
+    const partState = typeof row.state === "string" ? row.state : undefined;
+    const partToolCallId = typeof row.toolCallId === "string"
+        ? row.toolCallId
+        : typeof row.id === "string"
+            ? row.id
+            : undefined;
+    if (typeof row.text === "string" && row.text.trim().length > 0) {
+        return {
+            partPreview: clipPreview(row.text),
+            partState,
+            partToolCallId,
+        };
+    }
+    if (partType.startsWith("tool-")) {
+        const payload = {
+            tool: partType,
+            state: partState,
+            input: row.input,
+            output: row.output,
+            errorText: row.errorText,
+        };
+        return {
+            partPreview: clipPreview(JSON.stringify(payload)),
+            partState,
+            partToolCallId,
+        };
+    }
+    return {
+        partState,
+        partToolCallId,
+    };
+}
+function contextThreadIdOrNull(context) {
+    return typeof context.threadId === "string" && context.threadId.length > 0
+        ? context.threadId
+        : null;
+}
+async function emitThreadEvents(params) {
+    if (params.silent || params.events.length === 0)
+        return;
+    await writeThreadEvents({ events: params.events, writable: params.writable });
+}
 export class Thread {
     constructor(opts = {}, reactor) {
         this.opts = opts;
@@ -90,15 +145,6 @@ export class Thread {
             writable = getWritable({
                 namespace: `context:${String(currentContext.id)}`,
             });
-            // If the context was created in `initializeContext` (which didn't have a writable yet),
-            // re-emit the context id chunk now so clients can subscribe to the right persisted thread.
-            if (ctxResult.isNew) {
-                await emitContextIdChunk({
-                    env: params.env,
-                    contextId: String(currentContext.id),
-                    writable,
-                });
-            }
         }
         // Reactor/steps always receive a stream argument.
         // In silent mode (or when no workflow writable is available), we use an in-memory sink.
@@ -114,6 +160,27 @@ export class Thread {
             : params.contextIdentifier?.key
                 ? { key: params.contextIdentifier.key }
                 : { id: String(currentContext.id) };
+        const threadId = contextThreadIdOrNull(currentContext);
+        const resolvedThreadId = threadId ?? String(currentContext.id);
+        await emitThreadEvents({
+            silent,
+            writable,
+            events: [
+                {
+                    type: ctxResult.isNew ? "context.created" : "context.resolved",
+                    at: nowIso(),
+                    contextId: String(currentContext.id),
+                    threadId: resolvedThreadId,
+                    status: String(currentContext.status ?? "open"),
+                },
+                {
+                    type: ctxResult.isNew ? "thread.created" : "thread.resolved",
+                    at: nowIso(),
+                    threadId: resolvedThreadId,
+                    status: "idle",
+                },
+            ],
+        });
         if (ctxResult.isNew) {
             await story.opts.onContextCreated?.({ env: params.env, context: currentContext });
         }
@@ -123,11 +190,36 @@ export class Thread {
             contextIdentifier: contextSelector,
             triggerEvent,
         });
-        // Emit a simple ping chunk early so clients can validate that streaming works end-to-end.
-        // This should be ignored safely by clients that don't care about it.
-        if (!silent) {
-            await writeThreadPing({ label: "thread-start", writable });
-        }
+        await emitThreadEvents({
+            silent,
+            writable,
+            events: [
+                {
+                    type: "item.created",
+                    at: nowIso(),
+                    itemId: triggerEventId,
+                    contextId: String(currentContext.id),
+                    threadId: resolvedThreadId,
+                    status: "stored",
+                    itemType: "input",
+                    executionId,
+                },
+                {
+                    type: "thread.streaming_started",
+                    at: nowIso(),
+                    threadId: resolvedThreadId,
+                    status: "streaming",
+                },
+                {
+                    type: "execution.created",
+                    at: nowIso(),
+                    executionId,
+                    contextId: String(currentContext.id),
+                    threadId: resolvedThreadId,
+                    status: "executing",
+                },
+            ],
+        });
         let reactionEvent = null;
         // Latest persisted context state for this run (we keep it in memory; store is updated via steps).
         let updatedContext = currentContext;
@@ -135,6 +227,33 @@ export class Thread {
         const failExecution = async () => {
             try {
                 await completeExecution(params.env, contextSelector, executionId, "failed");
+                await emitThreadEvents({
+                    silent,
+                    writable,
+                    events: [
+                        {
+                            type: "execution.failed",
+                            at: nowIso(),
+                            executionId,
+                            contextId: String(currentContext.id),
+                            threadId: resolvedThreadId,
+                            status: "failed",
+                        },
+                        {
+                            type: "context.closed",
+                            at: nowIso(),
+                            contextId: String(currentContext.id),
+                            threadId: resolvedThreadId,
+                            status: "closed",
+                        },
+                        {
+                            type: "thread.idle",
+                            at: nowIso(),
+                            threadId: resolvedThreadId,
+                            status: "idle",
+                        },
+                    ],
+                });
             }
             catch {
                 // noop
@@ -157,9 +276,35 @@ export class Thread {
                     iteration: iter,
                 });
                 currentStepId = stepCreate.stepId;
+                await emitThreadEvents({
+                    silent,
+                    writable,
+                    events: [
+                        {
+                            type: "step.created",
+                            at: nowIso(),
+                            stepId: String(stepCreate.stepId),
+                            executionId,
+                            iteration: iter,
+                            status: "running",
+                        },
+                    ],
+                });
                 // Hook: Thread DSL `context()` (implemented by subclasses via `initialize()`)
                 const nextContent = await story.initialize(updatedContext, params.env);
                 updatedContext = await updateContextContent(params.env, contextSelector, nextContent);
+                await emitThreadEvents({
+                    silent,
+                    writable,
+                    events: [
+                        {
+                            type: "context.content_updated",
+                            at: nowIso(),
+                            contextId: String(updatedContext.id),
+                            threadId: String(contextThreadIdOrNull(updatedContext) ?? ""),
+                        },
+                    ],
+                });
                 await story.opts.onContextUpdated?.({ env: params.env, context: updatedContext });
                 // Hook: Thread DSL `narrative()` (implemented by subclasses via `buildSystemPrompt()`)
                 const systemPrompt = await story.buildSystemPrompt(updatedContext, params.env);
@@ -176,7 +321,7 @@ export class Thread {
                 // (step id) and then a second persisted assistant message (reaction id) with the same
                 // content once InstantDB updates.
                 const reactor = story.getReactor(updatedContext, params.env);
-                const { assistantEvent, toolCalls, messagesForModel } = await reactor({
+                const { assistantEvent, actionRequests, messagesForModel } = await reactor({
                     env: params.env,
                     context: updatedContext,
                     contextIdentifier: contextSelector,
@@ -196,17 +341,17 @@ export class Thread {
                     silent,
                     writable,
                 });
-                const reviewRequests = toolCalls.length > 0
-                    ? toolCalls.flatMap((tc) => {
-                        const toolDef = toolsAll[tc.toolName];
+                const reviewRequests = actionRequests.length > 0
+                    ? actionRequests.flatMap((actionRequest) => {
+                        const toolDef = toolsAll[actionRequest.actionName];
                         const auto = toolDef?.auto !== false;
-                        tc.auto = auto;
+                        actionRequest.auto = auto;
                         if (auto)
                             return [];
                         return [
                             {
-                                toolCallId: String(tc.toolCallId),
-                                toolName: String(tc.toolName ?? ""),
+                                toolCallId: String(actionRequest.actionRef),
+                                toolName: String(actionRequest.actionName ?? ""),
                             },
                         ];
                     })
@@ -232,6 +377,21 @@ export class Thread {
                     contextId: String(currentContext.id),
                     iteration: iter,
                 });
+                await emitThreadEvents({
+                    silent,
+                    writable,
+                    events: stepParts.map((part, idx) => ({
+                        type: "part.created",
+                        at: nowIso(),
+                        partKey: `${String(stepCreate.stepId)}:${idx}`,
+                        stepId: String(stepCreate.stepId),
+                        idx,
+                        partType: part && typeof part.type === "string"
+                            ? String(part.type)
+                            : undefined,
+                        ...summarizePartPreview(part),
+                    })),
+                });
                 // Persist/append the aggregated reaction event (stable `reactionEventId` for the execution).
                 if (!reactionEvent) {
                     const reactionPayload = {
@@ -243,6 +403,22 @@ export class Thread {
                         contextId: String(currentContext.id),
                         reviewRequests,
                     });
+                    await emitThreadEvents({
+                        silent,
+                        writable,
+                        events: [
+                            {
+                                type: "item.created",
+                                at: nowIso(),
+                                itemId: String(reactionEvent.id),
+                                contextId: String(currentContext.id),
+                                threadId: resolvedThreadId,
+                                executionId,
+                                status: "pending",
+                                itemType: "output",
+                            },
+                        ],
+                    });
                 }
                 else {
                     const existingReactionParts = Array.isArray(reactionEvent.content?.parts)
@@ -260,10 +436,62 @@ export class Thread {
                         status: "pending",
                     };
                     reactionEvent = await updateItem(params.env, reactionEvent.id, nextReactionEvent, { executionId, contextId: String(currentContext.id) });
+                    await emitThreadEvents({
+                        silent,
+                        writable,
+                        events: [
+                            {
+                                type: "item.updated",
+                                at: nowIso(),
+                                itemId: String(reactionEvent.id),
+                                contextId: String(currentContext.id),
+                                threadId: resolvedThreadId,
+                                executionId,
+                                status: "pending",
+                            },
+                        ],
+                    });
                 }
                 story.opts.onEventCreated?.(assistantEventEffective);
+                const firstActionRequest = actionRequests?.[0];
+                await updateThreadStep({
+                    env: params.env,
+                    stepId: stepCreate.stepId,
+                    patch: firstActionRequest
+                        ? {
+                            kind: "action_execute",
+                            actionName: typeof firstActionRequest.actionName === "string"
+                                ? firstActionRequest.actionName
+                                : undefined,
+                            actionInput: firstActionRequest.input,
+                        }
+                        : {
+                            kind: "message",
+                        },
+                    executionId,
+                    contextId: String(currentContext.id),
+                    iteration: iter,
+                });
+                await emitThreadEvents({
+                    silent,
+                    writable,
+                    events: [
+                        {
+                            type: "step.updated",
+                            at: nowIso(),
+                            stepId: String(stepCreate.stepId),
+                            executionId,
+                            iteration: iter,
+                            status: "running",
+                            kind: firstActionRequest ? "action_execute" : "message",
+                            actionName: firstActionRequest && typeof firstActionRequest.actionName === "string"
+                                ? firstActionRequest.actionName
+                                : undefined,
+                        },
+                    ],
+                });
                 // Done: no tool calls requested by the model
-                if (!toolCalls.length) {
+                if (!actionRequests.length) {
                     const endResult = await story.callOnEnd(assistantEventEffective);
                     if (endResult) {
                         // Mark iteration step completed (no tools)
@@ -272,20 +500,86 @@ export class Thread {
                             stepId: stepCreate.stepId,
                             patch: {
                                 status: "completed",
-                                toolCalls: [],
-                                toolExecutionResults: [],
+                                kind: "message",
+                                actionRequests: [],
+                                actionResults: [],
                                 continueLoop: false,
                             },
                             executionId,
                             contextId: String(currentContext.id),
                             iteration: iter,
                         });
+                        await emitThreadEvents({
+                            silent,
+                            writable,
+                            events: [
+                                {
+                                    type: "step.updated",
+                                    at: nowIso(),
+                                    stepId: String(stepCreate.stepId),
+                                    executionId,
+                                    iteration: iter,
+                                    status: "completed",
+                                    kind: "message",
+                                },
+                                {
+                                    type: "step.completed",
+                                    at: nowIso(),
+                                    stepId: String(stepCreate.stepId),
+                                    executionId,
+                                    iteration: iter,
+                                    status: "completed",
+                                },
+                            ],
+                        });
                         // Mark reaction event completed
                         await updateItem(params.env, reactionEventId, {
                             ...(reactionEvent ?? assistantEventEffective),
                             status: "completed",
                         }, { executionId, contextId: String(currentContext.id) });
+                        await emitThreadEvents({
+                            silent,
+                            writable,
+                            events: [
+                                {
+                                    type: "item.completed",
+                                    at: nowIso(),
+                                    itemId: String(reactionEventId),
+                                    contextId: String(currentContext.id),
+                                    threadId: resolvedThreadId,
+                                    executionId,
+                                    status: "completed",
+                                },
+                            ],
+                        });
                         await completeExecution(params.env, contextSelector, executionId, "completed");
+                        await emitThreadEvents({
+                            silent,
+                            writable,
+                            events: [
+                                {
+                                    type: "execution.completed",
+                                    at: nowIso(),
+                                    executionId,
+                                    contextId: String(currentContext.id),
+                                    threadId: resolvedThreadId,
+                                    status: "completed",
+                                },
+                                {
+                                    type: "context.closed",
+                                    at: nowIso(),
+                                    contextId: String(currentContext.id),
+                                    threadId: resolvedThreadId,
+                                    status: "closed",
+                                },
+                                {
+                                    type: "thread.idle",
+                                    at: nowIso(),
+                                    threadId: resolvedThreadId,
+                                    status: "idle",
+                                },
+                            ],
+                        });
                         if (!silent) {
                             await closeThreadStream({ preventClose, sendFinish, writable });
                         }
@@ -298,25 +592,22 @@ export class Thread {
                         };
                     }
                 }
-                // Execute tool calls (workflow context; tool implementations decide step vs workflow)
-                if (!silent && toolCalls.length) {
-                    await writeContextSubstate({ key: "actions", transient: true, writable });
-                }
-                const executionResults = await Promise.all(toolCalls.map(async (tc) => {
-                    const toolDef = toolsAll[tc.toolName];
+                // Execute actions (workflow context; action implementations decide step vs workflow)
+                const actionResults = await Promise.all(actionRequests.map(async (actionRequest) => {
+                    const toolDef = toolsAll[actionRequest.actionName];
                     if (!toolDef || typeof toolDef.execute !== "function") {
                         return {
-                            tc,
+                            actionRequest,
                             success: false,
                             output: null,
-                            errorText: `Tool "${tc.toolName}" not found or has no execute().`,
+                            errorText: `Action "${actionRequest.actionName}" not found or has no execute().`,
                         };
                     }
                     try {
-                        let toolArgs = tc.args;
+                        let actionInput = actionRequest.input;
                         if (toolDef?.auto === false) {
                             const { createHook, createWebhook } = await import("workflow");
-                            const toolCallId = String(tc.toolCallId);
+                            const toolCallId = String(actionRequest.actionRef);
                             const hookToken = toolApprovalHookToken({ executionId, toolCallId });
                             const webhookToken = toolApprovalWebhookToken({ executionId, toolCallId });
                             const hook = createHook({ token: hookToken });
@@ -330,67 +621,53 @@ export class Thread {
                                 : await approvalOrRequest.request.json().catch(() => null);
                             if (!approval || approval.approved !== true) {
                                 return {
-                                    tc,
+                                    actionRequest,
                                     success: false,
                                     output: null,
                                     errorText: approval && "comment" in approval && approval.comment
-                                        ? `Tool execution not approved: ${approval.comment}`
-                                        : "Tool execution not approved",
+                                        ? `Action execution not approved: ${approval.comment}`
+                                        : "Action execution not approved",
                                 };
                             }
                             if ("args" in approval && approval.args !== undefined) {
-                                toolArgs = approval.args;
+                                actionInput = approval.args;
                             }
                         }
-                        const output = await toolDef.execute(toolArgs, {
-                            toolCallId: tc.toolCallId,
+                        const output = await toolDef.execute(actionInput, {
+                            toolCallId: actionRequest.actionRef,
                             messages: messagesForModel,
                             eventId: reactionEventId,
                             executionId,
                             triggerEventId,
                             contextId: currentContext.id,
                         });
-                        return { tc, success: true, output };
+                        return { actionRequest, success: true, output };
                     }
                     catch (e) {
                         return {
-                            tc,
+                            actionRequest,
                             success: false,
                             output: null,
                             errorText: e instanceof Error ? e.message : String(e),
                         };
                     }
                 }));
-                // Emit tool outputs to the workflow stream (step)
-                if (!silent) {
-                    await writeToolOutputs({
-                        results: executionResults.map((r) => r.success
-                            ? { toolCallId: r.tc.toolCallId, success: true, output: r.output }
-                            : {
-                                toolCallId: r.tc.toolCallId,
-                                success: false,
-                                errorText: r.errorText,
-                            }),
-                        writable,
-                    });
-                }
-                // Clear action status once tool execution results have been emitted.
-                if (!silent && toolCalls.length) {
-                    await writeContextSubstate({ key: null, transient: true, writable });
-                }
-                // Merge tool results into persisted parts (so next LLM call can see them)
+                // Merge action results into persisted parts (so next LLM call can see them)
                 if (reactionEvent) {
                     let parts = Array.isArray(reactionEvent.content?.parts)
                         ? [...reactionEvent.content.parts]
                         : [];
-                    for (const r of executionResults) {
-                        parts = applyToolExecutionResultToParts(parts, r.tc, {
+                    for (const r of actionResults) {
+                        parts = applyToolExecutionResultToParts(parts, {
+                            toolCallId: r.actionRequest.actionRef,
+                            toolName: r.actionRequest.actionName,
+                        }, {
                             success: Boolean(r.success),
                             result: r.output,
                             message: r.errorText,
                         });
                     }
-                    const nextReactionEvent = {
+                    reactionEvent = {
                         ...reactionEvent,
                         content: {
                             ...reactionEvent.content,
@@ -398,12 +675,11 @@ export class Thread {
                         },
                         status: "pending",
                     };
-                    reactionEvent = await updateItem(params.env, reactionEventId, nextReactionEvent, { executionId, contextId: String(currentContext.id) });
                 }
                 // Callback for observability/integration
-                for (const r of executionResults) {
-                    await story.opts.onToolCallExecuted?.({
-                        toolCall: r.tc,
+                for (const r of actionResults) {
+                    await story.opts.onActionExecuted?.({
+                        actionRequest: r.actionRequest,
                         success: r.success,
                         output: r.output,
                         errorText: r.errorText,
@@ -419,8 +695,8 @@ export class Thread {
                     context: updatedContext,
                     reactionEvent: reactionEvent ?? assistantEventEffective,
                     assistantEvent: assistantEventEffective,
-                    toolCalls,
-                    toolExecutionResults: executionResults,
+                    actionRequests,
+                    actionResults: actionResults,
                 });
                 // Persist per-iteration step outcome (tools + continue signal)
                 await updateThreadStep({
@@ -428,20 +704,120 @@ export class Thread {
                     stepId: stepCreate.stepId,
                     patch: {
                         status: "completed",
-                        toolCalls,
-                        toolExecutionResults: executionResults,
+                        kind: actionRequests?.length ? "action_result" : "message",
+                        actionName: typeof actionResults?.[0]?.actionRequest?.actionName === "string"
+                            ? actionResults[0].actionRequest.actionName
+                            : undefined,
+                        actionInput: actionResults?.[0]?.actionRequest?.input,
+                        actionOutput: actionResults?.[0]?.success === true
+                            ? actionResults[0]?.output
+                            : undefined,
+                        actionError: actionResults?.[0]?.success === false
+                            ? String(actionResults[0]?.errorText ?? "action_execution_failed")
+                            : undefined,
+                        actionRequests,
+                        actionResults,
                         continueLoop: continueLoop !== false,
                     },
                     executionId,
                     contextId: String(currentContext.id),
                     iteration: iter,
                 });
+                await emitThreadEvents({
+                    silent,
+                    writable,
+                    events: [
+                        {
+                            type: "step.updated",
+                            at: nowIso(),
+                            stepId: String(stepCreate.stepId),
+                            executionId,
+                            iteration: iter,
+                            status: "completed",
+                            kind: actionRequests?.length ? "action_result" : "message",
+                            actionName: typeof actionResults?.[0]?.actionRequest?.actionName === "string"
+                                ? actionResults[0].actionRequest.actionName
+                                : undefined,
+                        },
+                        {
+                            type: "step.completed",
+                            at: nowIso(),
+                            stepId: String(stepCreate.stepId),
+                            executionId,
+                            iteration: iter,
+                            status: "completed",
+                        },
+                    ],
+                });
+                if (continueLoop !== false && reactionEvent) {
+                    reactionEvent = await updateItem(params.env, reactionEventId, {
+                        ...reactionEvent,
+                        status: "pending",
+                    }, { executionId, contextId: String(currentContext.id) });
+                    await emitThreadEvents({
+                        silent,
+                        writable,
+                        events: [
+                            {
+                                type: "item.updated",
+                                at: nowIso(),
+                                itemId: String(reactionEventId),
+                                contextId: String(currentContext.id),
+                                threadId: resolvedThreadId,
+                                executionId,
+                                status: "pending",
+                            },
+                        ],
+                    });
+                }
                 if (continueLoop === false) {
                     await updateItem(params.env, reactionEventId, {
                         ...(reactionEvent ?? assistantEventEffective),
                         status: "completed",
                     }, { executionId, contextId: String(currentContext.id) });
+                    await emitThreadEvents({
+                        silent,
+                        writable,
+                        events: [
+                            {
+                                type: "item.completed",
+                                at: nowIso(),
+                                itemId: String(reactionEventId),
+                                contextId: String(currentContext.id),
+                                threadId: resolvedThreadId,
+                                executionId,
+                                status: "completed",
+                            },
+                        ],
+                    });
                     await completeExecution(params.env, contextSelector, executionId, "completed");
+                    await emitThreadEvents({
+                        silent,
+                        writable,
+                        events: [
+                            {
+                                type: "execution.completed",
+                                at: nowIso(),
+                                executionId,
+                                contextId: String(currentContext.id),
+                                threadId: resolvedThreadId,
+                                status: "completed",
+                            },
+                            {
+                                type: "context.closed",
+                                at: nowIso(),
+                                contextId: String(currentContext.id),
+                                threadId: resolvedThreadId,
+                                status: "closed",
+                            },
+                            {
+                                type: "thread.idle",
+                                at: nowIso(),
+                                threadId: resolvedThreadId,
+                                status: "idle",
+                            },
+                        ],
+                    });
                     if (!silent) {
                         await closeThreadStream({ preventClose, sendFinish, writable });
                     }
@@ -470,6 +846,20 @@ export class Thread {
                         executionId,
                         contextId: String(currentContext.id),
                     });
+                    await emitThreadEvents({
+                        silent,
+                        writable,
+                        events: [
+                            {
+                                type: "step.failed",
+                                at: nowIso(),
+                                stepId: String(currentStepId),
+                                executionId,
+                                status: "failed",
+                                errorText: error instanceof Error ? error.message : String(error),
+                            },
+                        ],
+                    });
                 }
                 catch {
                     // noop
@@ -491,8 +881,6 @@ export class Thread {
         const result = await this.opts.onEnd(lastEvent);
         if (typeof result === "boolean")
             return result;
-        if (result && typeof result === "object" && "end" in result)
-            return Boolean(result.end);
         return true;
     }
 }