@ekairos/events 1.22.34-beta.development.0 → 1.22.35

package/dist/steps/stream.steps.js

@@ -1,4 +1,6 @@
-import { contextStreamByteLength, parseContextStepStreamChunk, } from "../context.step-stream.js";
+import { getContextRuntimeServices } from "../context.runtime.js";
+import { createContextStepStreamChunk, contextStreamByteLength, encodeContextStepStreamChunk, parseContextStepStreamChunk, } from "../context.step-stream.js";
+import { resolveContextPartChunkIdentity } from "../context.part-identity.js";
 export async function writeContextEvents(params) {
     "use step";
     const writable = params.writable;
@@ -14,7 +16,9 @@ export async function writeContextEvents(params) {
         }
     }
     finally {
-        writer.releaseLock();
+        if (typeof writer?.releaseLock === "function") {
+            writer.releaseLock();
+        }
     }
 }
 export async function closeContextStream(params) {
@@ -30,7 +34,9 @@ export async function closeContextStream(params) {
             await writer.write({ type: "finish" });
         }
         finally {
-            writer.releaseLock();
+            if (typeof writer?.releaseLock === "function") {
+                writer.releaseLock();
+            }
         }
     }
     if (!preventClose) {
@@ -43,6 +49,19 @@ function asRecord(value) {
 function asString(value) {
     return typeof value === "string" ? value.trim() : "";
 }
+function toJsonSafeRecord(value) {
+    if (typeof value === "undefined")
+        return undefined;
+    try {
+        const json = JSON.parse(JSON.stringify(value));
+        return json && typeof json === "object"
+            ? json
+            : { value: json };
+    }
+    catch {
+        return undefined;
+    }
+}
 function createUnsetStreamLinkTx(db, executionId, label, streamId) {
     try {
         return db.tx.event_executions[executionId].unlink({ [label]: streamId });
@@ -58,10 +77,7 @@ export function createContextStepStreamClientId(stepId) {
     }
     return `event-step:${normalized}`;
 }
-export async function createPersistedContextStepStream(params) {
-    "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
+export async function createPersistedContextStepStreamForRuntime(runtime, params) {
     const db = runtime?.db;
     if (!db?.streams?.createWriteStream) {
         throw new Error("InstantDB streams are not available on the configured runtime. Upgrade @instantdb/admin to a streams-capable version.");
@@ -101,11 +117,13 @@ export async function createPersistedContextStepStream(params) {
         stepId: params.stepId,
     };
 }
-async function finalizePersistedContextStepStream(params) {
+export async function createPersistedContextStepStream(params) {
     "use step";
-    const { getContextRuntime } = await import("../runtime.js");
-    const runtime = await getContextRuntime(params.env);
-    const db = runtime?.db;
+    const runtime = await getContextRuntimeServices(params.runtime);
+    return await createPersistedContextStepStreamForRuntime(runtime, params);
+}
+export async function finalizePersistedContextStepStreamForRuntime(params) {
+    const db = params.runtime?.db;
     const writer = params.session.stream.getWriter();
     try {
         if (params.mode === "abort") {
@@ -116,7 +134,9 @@ async function finalizePersistedContextStepStream(params) {
         }
     }
     finally {
-        writer.releaseLock();
+        if (typeof writer?.releaseLock === "function") {
+            writer.releaseLock();
+        }
     }
     const now = new Date();
     const txs = [
@@ -138,21 +158,124 @@ async function finalizePersistedContextStepStream(params) {
         txs.push(unsetActive);
     await db.transact(txs);
 }
+async function finalizePersistedContextStepStream(params) {
+    "use step";
+    const runtime = await getContextRuntimeServices(params.runtime);
+    return await finalizePersistedContextStepStreamForRuntime({
+        runtime,
+        session: params.session,
+        mode: params.mode,
+        abortReason: params.abortReason,
+    });
+}
 export async function closePersistedContextStepStream(params) {
     return await finalizePersistedContextStepStream({
-        env: params.env,
+        runtime: params.runtime,
         session: params.session,
         mode: "close",
     });
 }
 export async function abortPersistedContextStepStream(params) {
     return await finalizePersistedContextStepStream({
-        env: params.env,
+        runtime: params.runtime,
         session: params.session,
         mode: "abort",
         abortReason: params.reason,
     });
 }
+export async function writeActionResultPartChunksToSession(params) {
+    if (!params.session || params.actionResults.length === 0)
+        return [];
+    const writer = params.session.stream.getWriter();
+    const events = [];
+    const sequenceBase = Date.now();
+    try {
+        for (let index = 0; index < params.actionResults.length; index += 1) {
+            const result = params.actionResults[index];
+            const actionRef = String(result.actionRequest.actionRef || "");
+            const actionName = String(result.actionRequest.actionName || "");
+            if (!actionRef || !actionName)
+                continue;
+            const chunkType = result.success
+                ? "chunk.action_completed"
+                : "chunk.action_failed";
+            const identity = resolveContextPartChunkIdentity({
+                stepId: params.session.stepId,
+                provider: "ekairos",
+                providerPartId: actionRef,
+                chunkType,
+            });
+            if (!identity)
+                continue;
+            const data = result.success
+                ? {
+                    actionRef,
+                    actionCallId: actionRef,
+                    actionName,
+                    toolCallId: actionRef,
+                    toolName: actionName,
+                    output: toJsonSafeRecord(result.output),
+                }
+                : {
+                    actionRef,
+                    actionCallId: actionRef,
+                    actionName,
+                    toolCallId: actionRef,
+                    toolName: actionName,
+                    error: {
+                        message: String(result.errorText || "Action failed."),
+                    },
+                };
+            const at = new Date().toISOString();
+            const sequence = sequenceBase + index;
+            const persistedChunk = createContextStepStreamChunk({
+                at,
+                sequence,
+                chunkType,
+                stepId: params.session.stepId,
+                partId: identity.partId,
+                providerPartId: identity.providerPartId,
+                partType: identity.partType,
+                partSlot: identity.partSlot,
+                provider: "ekairos",
+                providerChunkType: result.success
+                    ? "action_completed"
+                    : "action_failed",
+                actionRef,
+                data,
+            });
+            await writer.write(encodeContextStepStreamChunk(persistedChunk, {
+                stepId: params.session.stepId,
+            }));
+            events.push({
+                type: "chunk.emitted",
+                at,
+                chunkType,
+                contextId: params.contextId,
+                executionId: params.executionId,
+                stepId: params.session.stepId,
+                itemId: params.itemId,
+                sequence,
+                provider: "ekairos",
+                providerChunkType: result.success
+                    ? "action_completed"
+                    : "action_failed",
+                actionRef,
+                partId: identity.partId,
+                providerPartId: identity.providerPartId,
+                partType: identity.partType,
+                partSlot: identity.partSlot,
+                data,
+            });
+        }
+    }
+    finally {
+        if (typeof writer?.releaseLock === "function") {
+            writer.releaseLock();
+        }
+    }
+    return events;
+}
 export async function readPersistedContextStepStream(params) {
     if (!params.db?.streams?.createReadStream) {
         throw new Error("InstantDB streams are not available on the provided runtime.");

package/dist/steps/trace.steps.d.ts

@@ -1,5 +1,6 @@
 import "../polyfills/dom-events.js";
 import type { ContextEnvironment } from "../context.config.js";
+import type { ContextRuntimeServiceHandle } from "../context.runtime.js";
 import type { TraceEventKind } from "../context.contract.js";
 export type ContextTraceEventWrite = {
     workflowRunId: string;
@@ -32,7 +33,8 @@ export type ContextTraceEventWrite = {
     payload?: unknown;
     testId?: string;
 };
-export declare function writeContextTraceEvents(params: {
-    env: ContextEnvironment;
+export declare function writeContextTraceEvents<Env extends ContextEnvironment = ContextEnvironment>(params: {
+    runtime?: ContextRuntimeServiceHandle;
+    env?: Env;
     events: ContextTraceEventWrite[];
 }): Promise<void>;

package/dist/steps/trace.steps.js

@@ -1,4 +1,5 @@
 import "../polyfills/dom-events.js";
+import { getContextRuntimeServices } from "../context.runtime.js";
 import { lookup } from "@instantdb/admin";
 function requireBaseUrl() {
     const baseUrl = process.env.EKAIROS_CORE_BASE_URL ||
@@ -17,6 +18,20 @@ function requireToken() {
     throw new Error("[context/trace] Missing EKAIROS_CLERK_API_KEY");
 }
 let jwtCache = null;
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function asTraceEnv(value) {
+    const record = asRecord(value);
+    if (Object.keys(record).length === 0)
+        return undefined;
+    return {
+        baseUrl: typeof record.baseUrl === "string" ? record.baseUrl : undefined,
+        apiKey: typeof record.apiKey === "string" ? record.apiKey : undefined,
+        projectId: typeof record.projectId === "string" ? record.projectId : undefined,
+        strict: record.strict === true,
+    };
+}
 function parseJwtExpMs(token) {
     const parts = token.split(".");
     if (parts.length !== 3)
@@ -46,8 +61,8 @@ async function getTraceAuthHeader(baseUrl, projectId) {
             body: JSON.stringify({ projectId }),
         });
         if (res.ok) {
-            const json = (await res.json());
-            const token = typeof json?.token === "string" ? json.token : "";
+            const json = asRecord(await res.json());
+            const token = typeof json.token === "string" ? json.token : "";
             const expMs = parseJwtExpMs(token) ?? now + 60 * 60 * 1000;
             if (token) {
                 jwtCache = { token, expMs };
@@ -78,19 +93,22 @@ async function readProjectId() {
 export async function writeContextTraceEvents(params) {
     if (!params.events?.length)
         return;
-    const envTrace = params.env?.traces;
+    const envRecord = asRecord(params.env);
+    const envTrace = asTraceEnv(envRecord.traces);
     // Tracing must NEVER break workflows by default.
     // Use EKAIROS_TRACES_STRICT=1 if you want to fail hard.
     const strict = envTrace?.strict === true || process.env.EKAIROS_TRACES_STRICT === "1";
     // 1) Local trace persistence (InstantDB source of truth).
     try {
-        const { getContextRuntime } = await import("../runtime.js");
-        const runtime = await getContextRuntime(params.env);
-        const db = runtime?.db;
+        if (!params.runtime) {
+            throw new Error("[context/trace] runtime is required");
+        }
+        const runtime = await getContextRuntimeServices(params.runtime);
+        const db = runtime.db;
         if (db) {
             const now = new Date();
-            const orgId = typeof params.env?.orgId === "string"
-                ? String(params.env.orgId)
+            const orgId = typeof envRecord.orgId === "string"
+                ? String(envRecord.orgId)
                 : "";
             const projectId = await readProjectId();
             const byRun = new Map();

package/dist/stores/instant.store.d.ts

@@ -1,7 +1,7 @@
 import "../polyfills/dom-events.js";
-import type { DomainSchemaResult } from "@ekairos/domain";
+import type { DomainLike } from "@ekairos/domain";
 import type { ModelMessage } from "ai";
-import type { ContextItem, ContextIdentifier, ContextStatus, StoredContext, ContextStore } from "../context.store.js";
+import type { ContextItem, ContextIdentifier, ContextResource, ContextStatus, StoredContextResource, StoredContext, ContextStore } from "../context.store.js";
 export { parseAndStoreDocument } from "./instant.document-parser.js";
 export { coerceDocumentTextPages, expandEventsWithInstantDocuments, } from "./instant.documents.js";
 export type InstantStoreDb = any;
@@ -14,8 +14,20 @@ export declare class InstantStore implements ContextStore {
     getOrCreateContext<C>(contextIdentifier: ContextIdentifier | null): Promise<StoredContext<C>>;
     getContext<C>(contextIdentifier: ContextIdentifier): Promise<StoredContext<C> | null>;
     updateContextContent<C>(contextIdentifier: ContextIdentifier, content: C): Promise<StoredContext<C>>;
+    updateContextDefinition<C>(contextIdentifier: ContextIdentifier, definition: {
+        description?: string | null;
+        goal?: string | null;
+    }): Promise<StoredContext<C>>;
+    updateContextReactor<C>(contextIdentifier: ContextIdentifier, reactor: {
+        kind: string;
+        state?: Record<string, unknown> | null;
+    }): Promise<StoredContext<C>>;
     updateContextStatus(contextIdentifier: ContextIdentifier, status: ContextStatus): Promise<void>;
     private resolveContext;
+    private normalizeContextResource;
+    private normalizeContextResources;
+    getContextResources(contextIdentifier: ContextIdentifier): Promise<StoredContextResource[]>;
+    upsertContextResources(contextIdentifier: ContextIdentifier, resources: ContextResource[]): Promise<StoredContextResource[]>;
     saveItem(contextIdentifier: ContextIdentifier, event: ContextItem): Promise<ContextItem>;
     updateItem(eventId: string, event: ContextItem): Promise<ContextItem>;
     getItem(eventId: string): Promise<ContextItem | null>;
@@ -34,14 +46,6 @@ export declare class InstantStore implements ContextStore {
     }>;
     updateStep(stepId: string, patch: Partial<{
         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;
         updatedAt: Date;
     }>): Promise<void>;
@@ -58,7 +62,7 @@ export declare class InstantStore implements ContextStore {
 export declare function createInstantStoreRuntime(params: {
     getDb: (orgId: string) => Promise<InstantStoreDb> | InstantStoreDb;
     getOrgId?: (env: Record<string, unknown>) => string;
-    domain?: DomainSchemaResult;
+    domain?: DomainLike;
 }): (env: Record<string, unknown>) => Promise<{
     store: InstantStore;
     db: InstantStoreDb;

package/dist/stores/instant.store.js

@@ -71,6 +71,43 @@ function ensureValidEntityId(value, label) {
     }
     return normalized;
 }
+function sanitizeInstantString(value) {
+    return value.includes("\u0000") ? value.replace(/\u0000/g, "") : value;
+}
+function isOpaqueJsonValue(value) {
+    return (value instanceof Date ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value));
+}
+function sanitizeInstantValue(value, seen = new WeakMap()) {
+    if (typeof value === "string") {
+        return sanitizeInstantString(value);
+    }
+    if (value === null || value === undefined || typeof value !== "object") {
+        return value;
+    }
+    if (isOpaqueJsonValue(value)) {
+        return value;
+    }
+    const cached = seen.get(value);
+    if (cached) {
+        return cached;
+    }
+    if (Array.isArray(value)) {
+        const out = [];
+        seen.set(value, out);
+        for (const item of value) {
+            out.push(sanitizeInstantValue(item, seen));
+        }
+        return out;
+    }
+    const out = {};
+    seen.set(value, out);
+    for (const [key, entryValue] of Object.entries(value)) {
+        out[sanitizeInstantString(key)] = sanitizeInstantValue(entryValue, seen);
+    }
+    return out;
+}
 function logInstantTransactFailure(params) {
     if (!shouldDebugInstantStore())
         return;
@@ -118,6 +155,12 @@ export class InstantStore {
                     ? new Date(row.updatedAt)
                     : undefined,
             content: row?.content ?? null,
+            description: typeof row?.description === "string" ? row.description : null,
+            goal: typeof row?.goal === "string" ? row.goal : null,
+            resources: this.normalizeContextResources(row?.resources),
+            reactor: row?.reactor && typeof row.reactor === "object"
+                ? row.reactor
+                : null,
         };
     }
     async ensureContextKey(context, expectedKey) {
@@ -144,6 +187,10 @@ export class InstantStore {
                 key,
                 status: "open_idle",
                 content: {},
+                description: undefined,
+                goal: undefined,
+                resources: [],
+                reactor: undefined,
             }),
         ]);
         const context = await this.getContext({ id: contextId });
@@ -203,6 +250,43 @@ export class InstantStore {
             throw new Error("InstantStore: context not found after update");
         return updated;
     }
+    async updateContextDefinition(contextIdentifier, definition) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        const update = {
+            updatedAt: new Date(),
+        };
+        if (definition.description !== undefined) {
+            update.description =
+                typeof definition.description === "string" ? definition.description : undefined;
+        }
+        if (definition.goal !== undefined) {
+            update.goal = typeof definition.goal === "string" ? definition.goal : undefined;
+        }
+        await this.db.transact([
+            this.db.tx.event_contexts[context.id].update(update),
+        ]);
+        const updated = await this.getContext({ id: context.id });
+        if (!updated)
+            throw new Error("InstantStore: context not found after definition update");
+        return updated;
+    }
+    async updateContextReactor(contextIdentifier, reactor) {
+        const context = await this.getContext(contextIdentifier);
+        if (!context?.id)
+            throw new Error("InstantStore: context not found");
+        await this.db.transact([
+            this.db.tx.event_contexts[context.id].update({
+                reactor: reactor,
+                updatedAt: new Date(),
+            }),
+        ]);
+        const updated = await this.getContext({ id: context.id });
+        if (!updated)
+            throw new Error("InstantStore: context not found after reactor update");
+        return updated;
+    }
     async updateContextStatus(contextIdentifier, status) {
         const context = await this.getContext(contextIdentifier);
         if (!context?.id)
@@ -223,8 +307,69 @@ export class InstantStore {
             throw new Error("InstantStore: context not found");
         return context;
     }
+    normalizeContextResource(resource) {
+        if (!resource || typeof resource !== "object")
+            return null;
+        const record = resource;
+        const key = typeof record.key === "string" ? record.key.trim() : "";
+        const type = typeof record.type === "string" ? record.type.trim() : "";
+        const name = typeof record.name === "string" ? record.name.trim() : "";
+        const description = typeof record.description === "string" ? record.description.trim() : "";
+        if (!key || !type || !name || !description)
+            return null;
+        return {
+            ...record,
+            key,
+            type,
+            name,
+            description,
+        };
+    }
+    normalizeContextResources(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value.flatMap((resource) => {
+            const normalized = this.normalizeContextResource(resource);
+            return normalized ? [normalized] : [];
+        });
+    }
+    async getContextResources(contextIdentifier) {
+        const context = await this.resolveContext(contextIdentifier);
+        return context.resources ?? [];
+    }
+    async upsertContextResources(contextIdentifier, resources) {
+        const context = await this.resolveContext(contextIdentifier);
+        const now = new Date();
+        const storedResources = [];
+        for (const resource of resources) {
+            const resourceKey = typeof resource.key === "string" ? resource.key.trim() : "";
+            const type = typeof resource.type === "string" ? resource.type.trim() : "";
+            const name = typeof resource.name === "string" ? resource.name.trim() : "";
+            const description = typeof resource.description === "string" ? resource.description.trim() : "";
+            if (!resourceKey || !type || !name || !description) {
+                throw new Error("InstantStore: context resources require key, type, name, and description.");
+            }
+            const sanitizedResource = sanitizeInstantValue(resource);
+            const storedResource = {
+                ...sanitizedResource,
+                key: resourceKey,
+                type,
+                name,
+                description,
+            };
+            storedResources.push(storedResource);
+        }
+        await this.db.transact([
+            this.db.tx.event_contexts[context.id].update({
+                resources: storedResources,
+                updatedAt: now,
+            }),
+        ]);
+        return await this.getContextResources({ id: context.id });
+    }
     async saveItem(contextIdentifier, event) {
         const eventId = ensureValidEntityId(event?.id, "event.id");
+        const sanitizedEvent = sanitizeInstantValue(event);
         const context = await this.resolveContext(contextIdentifier);
         const existing = await this.getItem(eventId);
         if (existing?.status && existing.status !== "stored") {
@@ -232,7 +377,7 @@ export class InstantStore {
         }
         const txs = [
             this.db.tx.event_items[eventId].update({
-                ...event,
+                ...sanitizedEvent,
                 id: eventId,
                 status: "stored",
             }),
@@ -258,7 +403,7 @@ export class InstantStore {
             throw error;
         }
         return {
-            ...event,
+            ...sanitizedEvent,
             id: eventId,
             status: "stored",
         };
@@ -268,10 +413,11 @@ export class InstantStore {
         if (current?.status && event.status && current.status !== event.status) {
             assertItemTransition(current.status, event.status);
         }
-        await this.db.transact([this.db.tx.event_items[eventId].update(event)]);
+        const sanitizedEvent = sanitizeInstantValue(event);
+        await this.db.transact([this.db.tx.event_items[eventId].update(sanitizedEvent)]);
         return {
             ...current,
-            ...event,
+            ...sanitizedEvent,
             id: eventId,
         };
     }
@@ -498,9 +644,12 @@ export class InstantStore {
             }
         }
         const update = {
-            ...patch,
             updatedAt: patch.updatedAt ?? new Date(),
         };
+        if (patch.status !== undefined)
+            update.status = patch.status;
+        if (patch.errorText !== undefined)
+            update.errorText = patch.errorText;
         await this.db.transact([this.db.tx.event_steps[stepId].update(update)]);
     }
     async linkItemToExecution(params) {
@@ -509,7 +658,7 @@ export class InstantStore {
         ]);
     }
     async saveStepParts(params) {
-        const parts = normalizePartsForPersistence(Array.isArray(params.parts) ? params.parts : []);
+        const parts = sanitizeInstantValue(normalizePartsForPersistence(Array.isArray(params.parts) ? params.parts : []));
         if (parts.length === 0)
             return;
         const txs = parts.map((part, idx) => {

package/dist/tools-to-model-tools.d.ts

@@ -1,4 +1,3 @@
-import { type Tool } from "ai";
 /**
  * Serializable "tool" shape to pass across the Workflow step boundary.
  *
@@ -6,14 +5,51 @@ import { type Tool } from "ai";
  * - Keep Zod/function values out of step arguments
  * - Convert tool input schemas to plain JSON Schema in workflow context
  */
-export type SerializableToolForModel = {
+export type SerializableFunctionActionSpec = {
+    type?: "function";
     description?: string;
     inputSchema: unknown;
+    outputSchema?: unknown;
+    providerOptions?: unknown;
 };
+export type SerializableProviderDefinedActionSpec = {
+    type: "provider-defined";
+    id: string;
+    name?: string;
+    args?: Record<string, unknown>;
+};
+export type SerializableActionSpec = SerializableFunctionActionSpec | SerializableProviderDefinedActionSpec;
+/**
+ * @deprecated Use SerializableActionSpec.
+ */
+export type SerializableToolForModel = SerializableActionSpec;
 /**
  * Convert AI SDK tools to a serializable representation that can be passed to `"use-step"` functions.
  *
  * This matches DurableAgent's internal `toolsToModelTools` behavior:
  * `inputSchema: asSchema(tool.inputSchema).jsonSchema`
  */
-export declare function toolsToModelTools(tools: Record<string, Tool>): Record<string, SerializableToolForModel>;
+export declare function actionsToActionSpecs(tools: Record<string, unknown>): Record<string, SerializableActionSpec>;
+export declare function actionSpecToAiSdkTool(name: string, spec: SerializableActionSpec, wrapJsonSchema: (schema: unknown) => unknown): {
+    type: "provider-defined";
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    description?: undefined;
+    inputSchema?: undefined;
+    outputSchema?: undefined;
+    providerOptions?: undefined;
+} | {
+    type: "function";
+    description: string | undefined;
+    inputSchema: unknown;
+    outputSchema: unknown;
+    providerOptions: unknown;
+    id?: undefined;
+    name?: undefined;
+    args?: undefined;
+};
+/**
+ * @deprecated Use actionsToActionSpecs.
+ */
+export declare const toolsToModelTools: typeof actionsToActionSpecs;