@ekairos/events 1.22.39-beta.development.0 → 1.22.41-beta.development.0

package/dist/reactors/ai-sdk.step.js

@@ -13,7 +13,7 @@ async function readWorkflowMetadata() {
         return null;
     }
 }
-async function resolveWorkflowRunId(env, executionId) {
+async function resolveWorkflowRunId(runtime, executionId) {
     let runId = "";
     const meta = await readWorkflowMetadata();
     if (meta && meta.workflowRunId !== undefined && meta.workflowRunId !== null) {
@@ -21,9 +21,7 @@ async function resolveWorkflowRunId(env, executionId) {
     }
     if (!runId && executionId) {
         try {
-            const { getContextRuntime } = await import("../runtime.js");
-            const runtime = await getContextRuntime(env);
-            const db = runtime?.db;
+            const db = await runtime.db();
             if (db) {
                 const q = await db.query({
                     event_executions: {
@@ -135,7 +133,7 @@ export async function executeAiSdkReaction(params) {
         rejectFinish = reject;
     });
     const modelId = typeof params.model === "string" ? params.model : "";
-    const mappedProvider = modelId.includes("/") ? modelId.split("/")[0] : undefined;
+    const mappedProvider = modelId.includes("/") ? modelId.split("/")[0] || "ai-sdk" : "ai-sdk";
     const contextStepStreamWriter = params.contextStepStream?.getWriter();
     try {
         const uiStream = result
@@ -180,6 +178,11 @@ export async function executeAiSdkReaction(params) {
                         at: mapped.at,
                         sequence: mapped.sequence,
                         chunkType: mapped.chunkType,
+                        stepId: params.stepId,
+                        partId: mapped.partId,
+                        providerPartId: mapped.providerPartId,
+                        partType: mapped.partType,
+                        partSlot: mapped.partSlot,
                         provider: mapped.provider,
                         providerChunkType: mapped.providerChunkType,
                         actionRef: mapped.actionRef,
@@ -294,10 +297,10 @@ export async function executeAiSdkReaction(params) {
             rawProviderMetadata: providerMetadataJson,
         };
     try {
-        const runId = await resolveWorkflowRunId(params.env, params.executionId);
+        const runId = await resolveWorkflowRunId(params.runtime, params.executionId);
         if (runId && llm) {
             await writeContextTraceEvents({
-                env: params.env,
+                runtime: params.runtime,
                 events: [
                     {
                         workflowRunId: runId,

package/dist/reactors/scripted.reactor.d.ts

@@ -1,6 +1,9 @@
 import type { ModelMessage } from "ai";
+import type { DomainSchemaResult } from "@ekairos/domain";
 import type { ContextEnvironment } from "../context.config.js";
+import type { ContextRuntime } from "../context.runtime.js";
 import type { ContextItem } from "../context.store.js";
+import { eventsDomain } from "../schema.js";
 import type { ContextReactionLLM, ContextActionRequest, ContextReactor, ContextReactorParams } from "./types.js";
 type ScriptedReactionPayload = {
     assistantEvent?: Partial<ContextItem>;
@@ -8,10 +11,10 @@ type ScriptedReactionPayload = {
     messagesForModel?: ModelMessage[];
     llm?: ContextReactionLLM;
 };
-export type ScriptedReactorStep<Context = unknown, Env extends ContextEnvironment = ContextEnvironment> = ScriptedReactionPayload | ((params: ContextReactorParams<Context, Env>) => Promise<ScriptedReactionPayload> | ScriptedReactionPayload);
-export type CreateScriptedReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment> = {
-    steps: ScriptedReactorStep<Context, Env>[];
+export type ScriptedReactorStep<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = ScriptedReactionPayload | ((params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ScriptedReactionPayload> | ScriptedReactionPayload);
+export type CreateScriptedReactorOptions<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>> = {
+    steps: ScriptedReactorStep<Context, Env, RequiredDomain, Runtime>[];
     repeatLast?: boolean;
 };
-export declare function createScriptedReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment>(options: CreateScriptedReactorOptions<Context, Env>): ContextReactor<Context, Env>;
+export declare function createScriptedReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = ContextRuntime<Env>>(options: CreateScriptedReactorOptions<Context, Env, RequiredDomain, Runtime>): ContextReactor<Context, Env, RequiredDomain, Runtime>;
 export {};

package/dist/reactors/types.d.ts

@@ -1,10 +1,12 @@
 import type { ModelMessage, UIMessageChunk } from "ai";
+import type { DomainSchemaResult } from "@ekairos/domain";
 import type { ContextEnvironment } from "../context.config.js";
-import type { ContextRuntime } from "../context.runtime.js";
+import type { ContextTool } from "../context.action.js";
+import type { ContextRuntime, ContextRuntimeHandleForDomain } from "../context.runtime.js";
 import type { ContextModelInit } from "../context.engine.js";
 import type { ContextIdentifier, StoredContext, ContextItem } from "../context.store.js";
 import type { ContextSkillPackage } from "../context.skill.js";
-import type { SerializableActionSpec } from "../tools-to-model-tools.js";
+import { eventsDomain } from "../schema.js";
 export type ContextActionRequest = {
     actionRef: string;
     actionName: string;
@@ -32,9 +34,8 @@ export type ContextReactionResult = {
         state?: Record<string, unknown> | null;
     };
 };
-export type ContextReactorParams<Context = unknown, Env extends ContextEnvironment = ContextEnvironment> = {
-    runtime: ContextRuntime<Env>;
-    env: Env;
+export type ContextReactorParams<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = {
+    runtime: ContextRuntimeHandleForDomain<Env, RequiredDomain>;
     context: StoredContext<Context>;
     contextIdentifier: ContextIdentifier;
     /**
@@ -49,8 +50,7 @@ export type ContextReactorParams<Context = unknown, Env extends ContextEnvironme
     triggerEvent: ContextItem;
     model: ContextModelInit;
     systemPrompt: string;
-    actions: Record<string, unknown>;
-    actionSpecs: Record<string, SerializableActionSpec>;
+    actions: Record<string, ContextTool<Context, Env, RequiredDomain, Runtime>>;
     skills: ContextSkillPackage[];
     eventId: string;
     executionId: string;
@@ -64,4 +64,4 @@ export type ContextReactorParams<Context = unknown, Env extends ContextEnvironme
     writable?: WritableStream<UIMessageChunk>;
     persistReactionParts?: (parts: any[]) => Promise<void>;
 };
-export type ContextReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment> = (params: ContextReactorParams<Context, Env>) => Promise<ContextReactionResult>;
+export type ContextReactor<Context = unknown, Env extends ContextEnvironment = ContextEnvironment, RequiredDomain extends DomainSchemaResult = typeof eventsDomain, Runtime extends ContextRuntime<Env> = any> = (params: ContextReactorParams<Context, Env, RequiredDomain, Runtime>) => Promise<ContextReactionResult>;

package/dist/schema.d.ts

@@ -1,2 +1,273 @@
-import { type DomainSchemaResult } from "@ekairos/domain";
-export declare const eventsDomain: DomainSchemaResult;
+export declare const eventsDomain: import("@ekairos/domain").DomainSchemaResult<{
+    event_contexts: import("@instantdb/core").EntityDef<{
+        createdAt: import("@instantdb/core").DataAttrDef<Date, true, false, false>;
+        updatedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        key: import("@instantdb/core").DataAttrDef<string, false, true, true>;
+        name: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        content: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        reactor: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+    }, {}, unknown>;
+    event_items: import("@instantdb/core").EntityDef<{
+        channel: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        createdAt: import("@instantdb/core").DataAttrDef<Date, true, true, false>;
+        type: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        content: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+    }, {}, unknown>;
+    event_executions: import("@instantdb/core").EntityDef<{
+        createdAt: import("@instantdb/core").DataAttrDef<Date, true, false, false>;
+        updatedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        workflowRunId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        activeStreamId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        activeStreamClientId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        lastStreamId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        lastStreamClientId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+    }, {}, unknown>;
+    event_steps: import("@instantdb/core").EntityDef<{
+        createdAt: import("@instantdb/core").DataAttrDef<Date, true, true, false>;
+        updatedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        iteration: import("@instantdb/core").DataAttrDef<number, true, true, false>;
+        kind: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        actionName: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        actionInput: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        actionOutput: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        actionError: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        actionRequests: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        actionResults: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        continueLoop: import("@instantdb/core").DataAttrDef<boolean, false, false, false>;
+        errorText: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        streamId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        streamClientId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        streamStartedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        streamFinishedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        streamAbortReason: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+    }, {}, unknown>;
+    event_parts: import("@instantdb/core").EntityDef<{
+        key: import("@instantdb/core").DataAttrDef<string, true, true, true>;
+        stepId: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        idx: import("@instantdb/core").DataAttrDef<number, true, true, false>;
+        type: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        part: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        metadata: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+        updatedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+    }, {}, unknown>;
+    event_trace_events: import("@instantdb/core").EntityDef<{
+        key: import("@instantdb/core").DataAttrDef<string, true, true, true>;
+        workflowRunId: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        seq: import("@instantdb/core").DataAttrDef<number, true, true, false>;
+        eventId: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        eventKind: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        eventAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        ingestedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        orgId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        projectId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        contextKey: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        contextId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        executionId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        stepId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        contextEventId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        toolCallId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        partKey: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        partIdx: import("@instantdb/core").DataAttrDef<number, false, true, false>;
+        spanId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        parentSpanId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        isDeleted: import("@instantdb/core").DataAttrDef<boolean, false, false, false>;
+        aiProvider: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        aiModel: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        promptTokens: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        promptTokensCached: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        promptTokensUncached: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        completionTokens: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        totalTokens: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        latencyMs: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        cacheCostUsd: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        computeCostUsd: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        costUsd: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        payload: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+    }, {}, unknown>;
+    event_trace_runs: import("@instantdb/core").EntityDef<{
+        workflowRunId: import("@instantdb/core").DataAttrDef<string, true, true, true>;
+        orgId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        projectId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        firstEventAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        lastEventAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        lastIngestedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        eventsCount: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        payload: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+    }, {}, unknown>;
+    event_trace_spans: import("@instantdb/core").EntityDef<{
+        spanId: import("@instantdb/core").DataAttrDef<string, true, true, true>;
+        parentSpanId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        workflowRunId: import("@instantdb/core").DataAttrDef<string, true, true, false>;
+        executionId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        stepId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        kind: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        name: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        status: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        startedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        endedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        durationMs: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        payload: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+    }, {}, unknown>;
+    document_documents: import("@instantdb/core").EntityDef<{
+        name: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        mimeType: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        size: import("@instantdb/core").DataAttrDef<number, false, false, false>;
+        ownerId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        orgId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
+        createdAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        processedAt: import("@instantdb/core").DataAttrDef<Date, false, true, false>;
+        updatedAt: import("@instantdb/core").DataAttrDef<Date, false, false, false>;
+        lastJobId: import("@instantdb/core").DataAttrDef<string, false, false, false>;
+        content: import("@instantdb/core").DataAttrDef<any, false, false, false>;
+    }, {}, unknown>;
+}, {
+    contextItemsContext: {
+        readonly forward: {
+            readonly on: "event_items";
+            readonly has: "one";
+            readonly label: "context";
+        };
+        readonly reverse: {
+            readonly on: "event_contexts";
+            readonly has: "many";
+            readonly label: "items";
+        };
+    };
+    contextExecutionsContext: {
+        readonly forward: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "context";
+        };
+        readonly reverse: {
+            readonly on: "event_contexts";
+            readonly has: "many";
+            readonly label: "executions";
+        };
+    };
+    contextCurrentExecution: {
+        readonly forward: {
+            readonly on: "event_contexts";
+            readonly has: "one";
+            readonly label: "currentExecution";
+        };
+        readonly reverse: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "currentOf";
+        };
+    };
+    contextExecutionsTrigger: {
+        readonly forward: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "trigger";
+        };
+        readonly reverse: {
+            readonly on: "event_items";
+            readonly has: "many";
+            readonly label: "executionsAsTrigger";
+        };
+    };
+    contextExecutionsReaction: {
+        readonly forward: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "reaction";
+        };
+        readonly reverse: {
+            readonly on: "event_items";
+            readonly has: "many";
+            readonly label: "executionsAsReaction";
+        };
+    };
+    contextStepsExecution: {
+        readonly forward: {
+            readonly on: "event_steps";
+            readonly has: "one";
+            readonly label: "execution";
+        };
+        readonly reverse: {
+            readonly on: "event_executions";
+            readonly has: "many";
+            readonly label: "steps";
+        };
+    };
+    contextExecutionItems: {
+        readonly forward: {
+            readonly on: "event_items";
+            readonly has: "one";
+            readonly label: "execution";
+        };
+        readonly reverse: {
+            readonly on: "event_executions";
+            readonly has: "many";
+            readonly label: "items";
+        };
+    };
+    contextPartsStep: {
+        readonly forward: {
+            readonly on: "event_parts";
+            readonly has: "one";
+            readonly label: "step";
+        };
+        readonly reverse: {
+            readonly on: "event_steps";
+            readonly has: "many";
+            readonly label: "parts";
+        };
+    };
+    contextStepStream: {
+        readonly forward: {
+            readonly on: "event_steps";
+            readonly has: "one";
+            readonly label: "stream";
+        };
+        readonly reverse: {
+            readonly on: any;
+            readonly has: "many";
+            readonly label: "step";
+        };
+    };
+    contextExecutionActiveStream: {
+        readonly forward: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "activeStream";
+        };
+        readonly reverse: {
+            readonly on: any;
+            readonly has: "many";
+            readonly label: "activeOf";
+        };
+    };
+    contextExecutionLastStream: {
+        readonly forward: {
+            readonly on: "event_executions";
+            readonly has: "one";
+            readonly label: "lastStream";
+        };
+        readonly reverse: {
+            readonly on: any;
+            readonly has: "many";
+            readonly label: "lastOf";
+        };
+    };
+    documentFile: {
+        readonly forward: {
+            readonly on: "document_documents";
+            readonly has: "one";
+            readonly label: "file";
+        };
+        readonly reverse: {
+            readonly on: "$files";
+            readonly has: "one";
+            readonly label: "document";
+        };
+    };
+}, import("@instantdb/core").RoomsDef, {}, "events", "events">;

package/dist/schema.js

@@ -1,7 +1,7 @@
 import { i } from "@instantdb/core";
 import { domain } from "@ekairos/domain";
 export const eventsDomain = domain("events")
-    .schema({
+    .withSchema({
     entities: {
         event_contexts: i.entity({
             createdAt: i.date(),

package/dist/steps/store.steps.d.ts

@@ -2,6 +2,7 @@ import type { UIMessageChunk } from "ai";
 import type { ContextEnvironment } from "../context.config.js";
 import type { ContextRuntime } from "../context.runtime.js";
 import type { ContextExecution, ContextItem, ContextIdentifier, StoredContext, ContextStatus } from "../context.store.js";
+import { type PersistedContextStepStreamSession } from "./stream.steps.js";
 type RuntimeParams<Env extends ContextEnvironment = ContextEnvironment> = {
     runtime: ContextRuntime<Env>;
 };
@@ -9,6 +10,18 @@ export type ContextReviewRequest = {
     toolCallId: string;
     toolName?: string;
 };
+type ContextStepPatch = {
+    status?: "running" | "completed" | "failed";
+    kind?: "message" | "action_execute" | "action_result";
+    actionName?: string;
+    actionInput?: unknown;
+    actionOutput?: unknown;
+    actionError?: string;
+    actionRequests?: any;
+    actionResults?: any;
+    continueLoop?: boolean;
+    errorText?: string;
+};
 /**
  * Initializes/ensures the story context exists.
  *
@@ -97,6 +110,18 @@ export declare function updateExecutionWorkflowRun(params: {
     executionId: string;
     workflowRunId: string;
 }): Promise<void>;
+export declare function openReactionStep<C>(params: {
+    runtime: ContextRuntime<ContextEnvironment>;
+    contextIdentifier: ContextIdentifier;
+    content: C;
+    executionId: string;
+    iteration: number;
+}): Promise<{
+    stepId: string;
+    stream: PersistedContextStepStreamSession;
+    context: StoredContext<C>;
+    events: ContextItem[];
+}>;
 export declare function createContextStep(params: {
     runtime: ContextRuntime<ContextEnvironment>;
     executionId: string;
@@ -110,19 +135,21 @@ export declare function updateContextStep(params: {
     executionId?: string;
     contextId?: string;
     iteration?: number;
-    patch: {
-        status?: "running" | "completed" | "failed";
-        kind?: "message" | "action_execute" | "action_result";
-        actionName?: string;
-        actionInput?: unknown;
-        actionOutput?: unknown;
-        actionError?: string;
-        actionRequests?: any;
-        actionResults?: any;
-        continueLoop?: boolean;
-        errorText?: string;
-    };
+    patch: ContextStepPatch;
 }): Promise<void>;
+export declare function finalizeReactionStep(params: {
+    runtime: ContextRuntime<ContextEnvironment>;
+    session?: PersistedContextStepStreamSession | null;
+    stepId: string;
+    executionId?: string;
+    contextId?: string;
+    iteration?: number;
+    patch: ContextStepPatch;
+    reactionEventId?: string;
+    reactionEvent?: ContextItem;
+}): Promise<{
+    reactionEvent?: ContextItem;
+}>;
 export declare function linkItemToExecutionStep(params: {
     runtime: ContextRuntime<ContextEnvironment>;
     itemId: string;
@@ -136,4 +163,16 @@ export declare function saveContextPartsStep(params: {
     iteration?: number;
     parts: any[];
 }): Promise<void>;
+export declare function saveContextPartsAndUpdateReaction(params: {
+    runtime: ContextRuntime<ContextEnvironment>;
+    stepId: string;
+    executionId?: string;
+    contextId?: string;
+    iteration?: number;
+    parts: any[];
+    reactionEventId: string;
+    reactionEvent: ContextItem;
+}): Promise<{
+    reactionEvent: ContextItem;
+}>;
 export {};

package/dist/steps/store.steps.js

@@ -2,6 +2,7 @@ import { getContextRuntimeServices } from "../context.runtime.js";
 import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "../context.events.js";
 import { writeContextTraceEvents } from "./trace.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "../context.hooks.js";
+import { createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, } from "./stream.steps.js";
 async function getRuntimeAndEnv(params) {
     const env = params.runtime.env;
     const runtime = await getContextRuntimeServices(params.runtime);
@@ -510,6 +511,27 @@ export async function updateExecutionWorkflowRun(params) {
         ]);
     }
 }
+export async function openReactionStep(params) {
+    "use step";
+    const { runtime } = await getRuntimeAndEnv(params);
+    const { store } = runtime;
+    const step = await store.createStep({
+        executionId: params.executionId,
+        iteration: params.iteration,
+    });
+    const stream = await createPersistedContextStepStreamForRuntime(runtime, {
+        executionId: params.executionId,
+        stepId: step.id,
+    });
+    const context = await store.updateContextContent(params.contextIdentifier, params.content);
+    const events = await store.getItems(params.contextIdentifier);
+    return {
+        stepId: step.id,
+        stream,
+        context,
+        events,
+    };
+}
 export async function createContextStep(params) {
     "use step";
     const { runtime } = await getRuntimeAndEnv(params);
@@ -560,6 +582,74 @@ export async function updateContextStep(params) {
         ]);
     }
 }
+export async function finalizeReactionStep(params) {
+    "use step";
+    const { runtime, env } = await getRuntimeAndEnv(params);
+    const { store, db } = runtime;
+    if (params.session) {
+        await finalizePersistedContextStepStreamForRuntime({
+            runtime,
+            session: params.session,
+            mode: "close",
+        });
+    }
+    await store.updateStep(params.stepId, {
+        ...params.patch,
+        updatedAt: new Date(),
+    });
+    let savedReaction;
+    if (params.reactionEventId && params.reactionEvent) {
+        savedReaction = await store.updateItem(params.reactionEventId, params.reactionEvent);
+    }
+    const { runId } = await resolveWorkflowRunId({
+        env,
+        db,
+        executionId: params.executionId,
+    });
+    if (runId) {
+        const events = [
+            {
+                workflowRunId: runId,
+                eventId: `context_step:${String(params.stepId)}`,
+                eventKind: "context.step",
+                eventAt: new Date().toISOString(),
+                contextId: params.contextId,
+                executionId: params.executionId,
+                stepId: String(params.stepId),
+                payload: {
+                    status: params.patch.status,
+                    kind: params.patch.kind,
+                    actionName: params.patch.actionName,
+                    actionInput: params.patch.actionInput,
+                    actionOutput: params.patch.actionOutput,
+                    actionError: params.patch.actionError,
+                    iteration: params.iteration,
+                    actionRequests: params.patch.actionRequests,
+                    actionResults: params.patch.actionResults,
+                    continueLoop: params.patch.continueLoop,
+                    errorText: params.patch.errorText,
+                },
+            },
+        ];
+        if (savedReaction) {
+            events.push({
+                workflowRunId: runId,
+                eventId: `context_item:${String(savedReaction.id)}`,
+                eventKind: "context.item",
+                eventAt: new Date().toISOString(),
+                contextId: params.contextId,
+                executionId: params.executionId,
+                contextEventId: String(savedReaction.id),
+                payload: {
+                    ...savedReaction,
+                    direction: inferDirection(savedReaction),
+                },
+            });
+        }
+        await maybeWriteTraceEvents(env, events);
+    }
+    return { reactionEvent: savedReaction };
+}
 export async function linkItemToExecutionStep(params) {
     "use step";
     const { runtime } = await getRuntimeAndEnv(params);
@@ -596,3 +686,50 @@ export async function saveContextPartsStep(params) {
         await maybeWriteTraceEvents(env, events);
     }
 }
+export async function saveContextPartsAndUpdateReaction(params) {
+    "use step";
+    const { runtime, env } = await getRuntimeAndEnv(params);
+    const { store, db } = runtime;
+    await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
+    const savedReaction = await store.updateItem(params.reactionEventId, params.reactionEvent);
+    const { runId } = await resolveWorkflowRunId({
+        env,
+        db,
+        executionId: params.executionId,
+    });
+    if (runId) {
+        const events = [];
+        if (params.parts?.length) {
+            for (let idx = 0; idx < params.parts.length; idx += 1) {
+                const part = params.parts[idx];
+                events.push({
+                    workflowRunId: runId,
+                    eventId: `context_part:${String(params.stepId)}:${idx}`,
+                    eventKind: "context.part",
+                    eventAt: new Date().toISOString(),
+                    contextId: params.contextId,
+                    executionId: params.executionId,
+                    stepId: String(params.stepId),
+                    partKey: `${String(params.stepId)}:${idx}`,
+                    partIdx: idx,
+                    payload: part,
+                });
+            }
+        }
+        events.push({
+            workflowRunId: runId,
+            eventId: `context_item:${String(savedReaction.id)}`,
+            eventKind: "context.item",
+            eventAt: new Date().toISOString(),
+            contextId: params.contextId,
+            executionId: params.executionId,
+            contextEventId: String(savedReaction.id),
+            payload: {
+                ...savedReaction,
+                direction: inferDirection(savedReaction),
+            },
+        });
+        await maybeWriteTraceEvents(env, events);
+    }
+    return { reactionEvent: savedReaction };
+}