@ekairos/structure 1.22.9-beta.feature-registry-sync-esolbay-agent.0 → 1.22.10-beta.development.0

package/dist/contextPersistence.d.ts

@@ -0,0 +1,29 @@
+declare const STRUCTURE_CONTEXT_ENTITIES: readonly ["event_contexts"];
+type StructureContextEntity = (typeof STRUCTURE_CONTEXT_ENTITIES)[number];
+type FindStructureContextParams = {
+    includeOutputFile?: boolean;
+};
+type FindStructureContextResult = {
+    entity: StructureContextEntity;
+    row: any;
+};
+export declare function findStructureContextByKey(db: any, key: string, params?: FindStructureContextParams): Promise<FindStructureContextResult | null>;
+export declare function createStructureContext(db: any, params: {
+    id: string;
+    key: string;
+    content?: Record<string, unknown>;
+    status?: string;
+    createdAt?: Date;
+}): Promise<{
+    entity: "event_contexts";
+    id: string;
+}>;
+export declare function linkStructureOutputFileToContextByKey(db: any, params: {
+    contextKey: string;
+    fileId: string;
+}): Promise<void>;
+export declare function unlinkStructureOutputFileFromContextByKey(db: any, params: {
+    contextKey: string;
+    fileId: string;
+}): Promise<void>;
+export {};

package/dist/contextPersistence.js

@@ -0,0 +1,62 @@
+const STRUCTURE_CONTEXT_ENTITIES = ["event_contexts"];
+function buildContextQuery(entity, key, includeOutputFile) {
+    return {
+        [entity]: {
+            $: { where: { key }, limit: 1 },
+            ...(includeOutputFile ? { structure_output_file: {} } : {}),
+        },
+    };
+}
+function preferredContextEntity(db) {
+    if (db?.tx?.event_contexts)
+        return "event_contexts";
+    throw new Error("No persisted context collection is available");
+}
+export async function findStructureContextByKey(db, key, params = {}) {
+    let lastError = null;
+    let queried = false;
+    for (const entity of STRUCTURE_CONTEXT_ENTITIES) {
+        try {
+            const res = await db.query(buildContextQuery(entity, key, Boolean(params.includeOutputFile)));
+            queried = true;
+            const row = res?.[entity]?.[0];
+            if (row)
+                return { entity, row };
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    if (!queried && lastError) {
+        throw lastError;
+    }
+    return null;
+}
+export async function createStructureContext(db, params) {
+    const entity = preferredContextEntity(db);
+    await db.transact([
+        db.tx[entity][params.id].create({
+            createdAt: params.createdAt ?? new Date(),
+            content: params.content ?? {},
+            key: params.key,
+            status: params.status ?? "open",
+        }),
+    ]);
+    return { entity, id: params.id };
+}
+export async function linkStructureOutputFileToContextByKey(db, params) {
+    const context = await findStructureContextByKey(db, params.contextKey);
+    const ctxId = context?.row?.id;
+    if (!context || !ctxId) {
+        throw new Error("Context not found");
+    }
+    await db.transact([db.tx[context.entity][ctxId].link({ structure_output_file: params.fileId })]);
+}
+export async function unlinkStructureOutputFileFromContextByKey(db, params) {
+    const context = await findStructureContextByKey(db, params.contextKey);
+    const ctxId = context?.row?.id;
+    if (!context || !ctxId) {
+        throw new Error("Context not found");
+    }
+    await db.transact([db.tx[context.entity][ctxId].unlink({ structure_output_file: params.fileId })]);
+}

package/dist/dataset/steps.js

@@ -1,8 +1,9 @@
+import { findStructureContextByKey, linkStructureOutputFileToContextByKey, unlinkStructureOutputFileFromContextByKey, } from "../contextPersistence.js";
 export async function structureGetOrCreateContextStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-        const runtime = await getThreadRuntime(params.env);
+        const { getContextRuntime } = await import("@ekairos/events/runtime");
+        const runtime = await getContextRuntime(params.env);
         const ctx = await runtime.store.getOrCreateContext({ key: params.contextKey });
         return { ok: true, data: ctx };
     }
@@ -14,8 +15,8 @@ export async function structureGetOrCreateContextStep(params) {
 export async function structureGetContextStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-        const runtime = await getThreadRuntime(params.env);
+        const { getContextRuntime } = await import("@ekairos/events/runtime");
+        const runtime = await getContextRuntime(params.env);
         const ctx = await runtime.store.getContext({ key: params.contextKey });
         if (!ctx)
             return { ok: false, error: "Context not found" };
@@ -29,8 +30,8 @@ export async function structureGetContextStep(params) {
 export async function structureUpdateContextContentStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-        const runtime = await getThreadRuntime(params.env);
+        const { getContextRuntime } = await import("@ekairos/events/runtime");
+        const runtime = await getContextRuntime(params.env);
         const updated = await runtime.store.updateContextContent({ key: params.contextKey }, params.content);
         return { ok: true, data: updated };
     }
@@ -42,8 +43,8 @@ export async function structureUpdateContextContentStep(params) {
 export async function structurePatchContextContentStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-        const runtime = await getThreadRuntime(params.env);
+        const { getContextRuntime } = await import("@ekairos/events/runtime");
+        const runtime = await getContextRuntime(params.env);
         const existing = await runtime.store.getOrCreateContext({ key: params.contextKey });
         const existingContent = (existing?.content ?? {});
         const existingStructure = (existingContent?.structure ?? {});
@@ -65,8 +66,8 @@ export async function structureUploadRowsOutputJsonlStep(params) {
     "use step";
     const startedAt = Date.now();
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-        const runtime = await getThreadRuntime(params.env);
+        const { getContextRuntime } = await import("@ekairos/events/runtime");
+        const runtime = await getContextRuntime(params.env);
         const db = runtime.db;
         const storagePath = `/structure/${params.structureId}/output.jsonl`;
         const fileBuffer = Buffer.from(params.contentBase64 ?? "", "base64");
@@ -89,15 +90,12 @@ export async function structureLinkRowsOutputFileToContextStep(params) {
     "use step";
     const startedAt = Date.now();
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-        const runtime = await getThreadRuntime(params.env);
+        const { getContextRuntime } = await import("@ekairos/events/runtime");
+        const runtime = await getContextRuntime(params.env);
         const store = runtime.store;
         const db = runtime.db;
-        const ctx = await store.getOrCreateContext({ key: params.contextKey });
-        const ctxId = ctx?.id;
-        if (!ctxId)
-            return { ok: false, error: "Context not found" };
-        await db.transact([db.tx.thread_contexts[ctxId].link({ structure_output_file: params.fileId })]);
+        await store.getOrCreateContext({ key: params.contextKey });
+        await linkStructureOutputFileToContextByKey(db, { contextKey: params.contextKey, fileId: params.fileId });
         console.log(`[structure:link-jsonl] contextKey=${params.contextKey} fileId=${params.fileId} elapsedMs=${Date.now() - startedAt}`);
         return { ok: true };
     }
@@ -109,15 +107,12 @@ export async function structureLinkRowsOutputFileToContextStep(params) {
 export async function structureUnlinkRowsOutputFileFromContextStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-        const runtime = await getThreadRuntime(params.env);
+        const { getContextRuntime } = await import("@ekairos/events/runtime");
+        const runtime = await getContextRuntime(params.env);
         const store = runtime.store;
         const db = runtime.db;
-        const ctx = await store.getOrCreateContext({ key: params.contextKey });
-        const ctxId = ctx?.id;
-        if (!ctxId)
-            return { ok: false, error: "Context not found" };
-        await db.transact([db.tx.thread_contexts[ctxId].unlink({ structure_output_file: params.fileId })]);
+        await store.getOrCreateContext({ key: params.contextKey });
+        await unlinkStructureOutputFileFromContextByKey(db, { contextKey: params.contextKey, fileId: params.fileId });
         return { ok: true };
     }
     catch (error) {
@@ -128,16 +123,11 @@ export async function structureUnlinkRowsOutputFileFromContextStep(params) {
 export async function structureGetContextWithRowsOutputFileStep(params) {
     "use step";
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-        const runtime = await getThreadRuntime(params.env);
+        const { getContextRuntime } = await import("@ekairos/events/runtime");
+        const runtime = await getContextRuntime(params.env);
         const db = runtime.db;
-        const query = (await db.query({
-            thread_contexts: {
-                $: { where: { key: params.contextKey }, limit: 1 },
-                structure_output_file: {},
-            },
-        }));
-        const row = query.thread_contexts?.[0];
+        const persisted = await findStructureContextByKey(db, params.contextKey, { includeOutputFile: true });
+        const row = persisted?.row;
         if (!row)
             return { ok: false, error: "Context not found" };
         return { ok: true, data: row };
@@ -152,16 +142,11 @@ export async function structureReadRowsOutputJsonlStep(params) {
     const startedAt = Date.now();
     try {
         const contextKey = `structure:${params.structureId}`;
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-        const runtime = await getThreadRuntime(params.env);
+        const { getContextRuntime } = await import("@ekairos/events/runtime");
+        const runtime = await getContextRuntime(params.env);
         const db = runtime.db;
-        const query = (await db.query({
-            thread_contexts: {
-                $: { where: { key: contextKey }, limit: 1 },
-                structure_output_file: {},
-            },
-        }));
-        const ctx = query.thread_contexts?.[0];
+        const persisted = await findStructureContextByKey(db, contextKey, { includeOutputFile: true });
+        const ctx = persisted?.row;
         if (!ctx)
             return { ok: false, error: "Context not found" };
         const linked = Array.isArray(ctx?.structure_output_file) ? ctx.structure_output_file[0] : ctx.structure_output_file;

package/dist/file/steps.js

@@ -1,7 +1,7 @@
 export async function readInstantFileStep(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-    const runtime = (await getThreadRuntime(params.env));
+    const { getContextRuntime } = await import("@ekairos/events/runtime");
+    const runtime = (await getContextRuntime(params.env));
     const db = runtime.db;
     const { DatasetService } = await import("../service.js");
     const service = new DatasetService(db);

package/dist/rowsOutputPaging.js

@@ -1,6 +1,7 @@
 import { getDatasetOutputPath, getDatasetWorkstation } from "./datasetFiles.js";
 import { createDatasetSandboxStep, runDatasetSandboxCommandStep } from "./sandbox/steps.js";
-import { getThreadRuntime } from "./runtime.js";
+import { findStructureContextByKey } from "./contextPersistence.js";
+import { getContextRuntime } from "./runtime.js";
 /**
  * Step 1/2:
  * Download the rows output.jsonl from Instant storage into a sandbox file.
@@ -37,16 +38,11 @@ export async function structureDownloadRowsOutputToSandboxStep(params) {
     if (exists.exitCode === 0) {
         return { sandboxId, localPath };
     }
-    const storyRuntime = await getThreadRuntime(params.env);
+    const storyRuntime = await getContextRuntime(params.env);
     const db = storyRuntime.db;
     const contextKey = `structure:${params.structureId}`;
-    const query = (await db.query({
-        thread_contexts: {
-            $: { where: { key: contextKey }, limit: 1 },
-            structure_output_file: {},
-        },
-    }));
-    const ctx = query.thread_contexts?.[0];
+    const persisted = await findStructureContextByKey(db, contextKey, { includeOutputFile: true });
+    const ctx = persisted?.row;
     const linked = Array.isArray(ctx?.structure_output_file) ? ctx.structure_output_file[0] : ctx.structure_output_file;
     const url = linked?.url;
     if (!url) {

package/dist/rowsOutputSplit.js

@@ -1,6 +1,7 @@
 import { getDatasetOutputPath, getDatasetWorkstation } from "./datasetFiles.js";
 import { readDatasetSandboxFileStep, runDatasetSandboxCommandStep } from "./sandbox/steps.js";
-import { getThreadRuntime } from "./runtime.js";
+import { linkStructureOutputFileToContextByKey } from "./contextPersistence.js";
+import { getContextRuntime } from "./runtime.js";
 /**
  * Step:
  * Split a sandbox-local `output.jsonl` into a child dataset (also `output.jsonl`) of up to `limit` ROW entries.
@@ -84,7 +85,7 @@ export async function structureSplitRowsOutputToDatasetStep(params) {
         sandboxId: params.sandboxId,
         path: outPath,
     });
-    const storyRuntime = await getThreadRuntime(params.env);
+    const storyRuntime = await getContextRuntime(params.env);
     const db = storyRuntime.db;
     const store = storyRuntime.store;
     const storagePath = `/structure/${params.childDatasetId}/output.jsonl`;
@@ -102,7 +103,7 @@ export async function structureSplitRowsOutputToDatasetStep(params) {
     if (!ctxId)
         throw new Error("Failed to create child dataset context");
     // Link the output file to the context (used by DatasetService.readRecordsFromFile).
-    await db.transact([db.tx.thread_contexts[ctxId].link({ structure_output_file: fileId })]);
+    await linkStructureOutputFileToContextByKey(db, { contextKey, fileId });
     // Patch metadata under `structure` namespace (never clobber Story runtime keys).
     const existingContent = (ctx?.content ?? {});
     const existingStructure = (existingContent?.structure ?? {});

package/dist/runtime.d.ts

@@ -3,7 +3,7 @@
  *
  * Why dynamic import?
  * - Some bundlers (notably Turbopack step bundles) can drop/hoist static imports in "use-step" modules,
- *   causing `ReferenceError: getThreadRuntime is not defined`.
+ *   causing `ReferenceError: getContextRuntime is not defined`.
  * - Using a dynamic import keeps the symbol resolution local to the step runtime.
  */
-export declare function getThreadRuntime(env: any): Promise<import("@ekairos/thread/runtime").ThreadRuntime>;
+export declare function getContextRuntime(env: any): Promise<import("@ekairos/events/runtime").ContextRuntime>;

package/dist/runtime.js

@@ -3,10 +3,10 @@
  *
  * Why dynamic import?
  * - Some bundlers (notably Turbopack step bundles) can drop/hoist static imports in "use-step" modules,
- *   causing `ReferenceError: getThreadRuntime is not defined`.
+ *   causing `ReferenceError: getContextRuntime is not defined`.
  * - Using a dynamic import keeps the symbol resolution local to the step runtime.
  */
-export async function getThreadRuntime(env) {
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-    return await getThreadRuntime(env);
+export async function getContextRuntime(env) {
+    const { getContextRuntime } = await import("@ekairos/events/runtime");
+    return await getContextRuntime(env);
 }

package/dist/sandbox/steps.js

@@ -104,8 +104,8 @@ export async function createDatasetSandboxStep(params) {
     "use step";
     const startedAt = Date.now();
     const { env, ...configInput } = params;
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-    const db = (await getThreadRuntime(env)).db;
+    const { getContextRuntime } = await import("@ekairos/events/runtime");
+    const db = (await getContextRuntime(env)).db;
     const { SandboxService } = (await import("@ekairos/sandbox"));
     const service = new SandboxService(db);
     const daytonaDefaults = getStructureDaytonaDefaults();
@@ -181,8 +181,8 @@ export async function createDatasetSandboxStep(params) {
 export async function runDatasetSandboxCommandStep(params) {
     "use step";
     const startedAt = Date.now();
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-    const db = (await getThreadRuntime(params.env)).db;
+    const { getContextRuntime } = await import("@ekairos/events/runtime");
+    const db = (await getContextRuntime(params.env)).db;
     const { SandboxService } = (await import("@ekairos/sandbox"));
     const service = new SandboxService(db);
     const result = await service.runCommand(params.sandboxId, params.cmd, params.args ?? []);
@@ -202,8 +202,8 @@ export async function runDatasetSandboxCommandStep(params) {
 export async function writeDatasetSandboxFilesStep(params) {
     "use step";
     const startedAt = Date.now();
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-    const db = (await getThreadRuntime(params.env)).db;
+    const { getContextRuntime } = await import("@ekairos/events/runtime");
+    const db = (await getContextRuntime(params.env)).db;
     const { SandboxService } = (await import("@ekairos/sandbox"));
     const service = new SandboxService(db);
     const result = await service.writeFiles(params.sandboxId, params.files);
@@ -233,8 +233,8 @@ export async function writeDatasetSandboxTextFileStep(params) {
 export async function readDatasetSandboxFileStep(params) {
     "use step";
     const startedAt = Date.now();
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-    const db = (await getThreadRuntime(params.env)).db;
+    const { getContextRuntime } = await import("@ekairos/events/runtime");
+    const db = (await getContextRuntime(params.env)).db;
     const { SandboxService } = (await import("@ekairos/sandbox"));
     const service = new SandboxService(db);
     const result = await service.readFile(params.sandboxId, params.path);
@@ -262,8 +262,8 @@ export async function readDatasetSandboxTextFileStep(params) {
 export async function stopDatasetSandboxStep(params) {
     "use step";
     const startedAt = Date.now();
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-    const db = (await getThreadRuntime(params.env)).db;
+    const { getContextRuntime } = await import("@ekairos/events/runtime");
+    const db = (await getContextRuntime(params.env)).db;
     const { SandboxService } = (await import("@ekairos/sandbox"));
     const service = new SandboxService(db);
     const result = await service.stopSandbox(params.sandboxId);

package/dist/schema.js

@@ -1,6 +1,6 @@
 import { i } from "@instantdb/core";
 import { domain } from "@ekairos/domain";
-import { threadDomain } from "@ekairos/thread/schema";
+import { eventsDomain } from "@ekairos/events/schema";
 import { sandboxDomain } from "@ekairos/sandbox/schema";
 const entities = {
     // Keep $files compatible with Instant's base file fields used by structure flows.
@@ -19,16 +19,16 @@ const links = {
     /**
      * Structure output link (rows):
      *
-     * - `thread_contexts.structure_output_file` points to the `$files` record for `output.jsonl`.
+     * - `event_contexts.structure_output_file` points to the `$files` record for `output.jsonl`.
      * - Reverse label is prefixed to avoid collisions across domains.
      */
     structureContextOutputFile: {
-        forward: { on: "thread_contexts", has: "one", label: "structure_output_file" },
+        forward: { on: "event_contexts", has: "one", label: "structure_output_file" },
         reverse: { on: "$files", has: "many", label: "structure_contexts" },
     },
 };
 const rooms = {};
 export const structureDomain = domain("structure")
-    .includes(threadDomain)
+    .includes(eventsDomain)
     .includes(sandboxDomain)
     .schema({ entities, links, rooms });

package/dist/service.d.ts

@@ -8,7 +8,7 @@ export type ServiceResult<T = any> = {
 /**
  * Back-compat helper for reading structure outputs outside the workflow runtime.
  *
- * IMPORTANT: The source of truth is `thread_contexts` (Story context) keyed by `structure:<id>`.
+ * IMPORTANT: The source of truth is the persisted Story/Event context keyed by `structure:<id>`.
  */
 export declare class DatasetService {
     private readonly db;

package/dist/service.js

@@ -1,7 +1,8 @@
+import { createStructureContext, findStructureContextByKey, linkStructureOutputFileToContextByKey, } from "./contextPersistence.js";
 /**
  * Back-compat helper for reading structure outputs outside the workflow runtime.
  *
- * IMPORTANT: The source of truth is `thread_contexts` (Story context) keyed by `structure:<id>`.
+ * IMPORTANT: The source of truth is the persisted Story/Event context keyed by `structure:<id>`.
  */
 export class DatasetService {
     constructor(db) {
@@ -13,13 +14,8 @@ export class DatasetService {
     async getDatasetById(datasetId) {
         try {
             const key = this.contextKey(datasetId);
-            const res = await this.db.query({
-                thread_contexts: {
-                    $: { where: { key }, limit: 1 },
-                    structure_output_file: {},
-                },
-            });
-            const ctx = res.thread_contexts?.[0];
+            const persisted = await findStructureContextByKey(this.db, key, { includeOutputFile: true });
+            const ctx = persisted?.row;
             if (!ctx)
                 return { ok: false, error: "Context not found" };
             return { ok: true, data: ctx };
@@ -43,13 +39,8 @@ export class DatasetService {
     async readRecordsFromFile(datasetId) {
         try {
             const key = this.contextKey(datasetId);
-            const res = await this.db.query({
-                thread_contexts: {
-                    $: { where: { key }, limit: 1 },
-                    structure_output_file: {},
-                },
-            });
-            const ctx = res.thread_contexts?.[0];
+            const persisted = await findStructureContextByKey(this.db, key, { includeOutputFile: true });
+            const ctx = persisted?.row;
             const linked = Array.isArray(ctx?.structure_output_file) ? ctx.structure_output_file[0] : ctx?.structure_output_file;
             const url = linked?.url;
             if (!url)
@@ -89,20 +80,14 @@ export class DatasetService {
         try {
             const datasetId = params.id ?? createUuidV4();
             const key = this.contextKey(datasetId);
-            const existing = await this.db.query({
-                thread_contexts: { $: { where: { key }, limit: 1 } },
-            });
-            const ctx = existing.thread_contexts?.[0];
+            const existing = await findStructureContextByKey(this.db, key);
+            const ctx = existing?.row;
             if (ctx)
                 return { ok: true, data: { datasetId } };
-            await this.db.transact([
-                this.db.tx.thread_contexts[createUuidV4()].create({
-                    createdAt: new Date(),
-                    content: {},
-                    key,
-                    status: "open",
-                }),
-            ]);
+            await createStructureContext(this.db, {
+                id: createUuidV4(),
+                key,
+            });
             return { ok: true, data: { datasetId } };
         }
         catch (error) {
@@ -133,14 +118,10 @@ export class DatasetService {
     async linkFileToDataset(params) {
         try {
             const key = this.contextKey(params.datasetId);
-            const res = await this.db.query({
-                thread_contexts: { $: { where: { key }, limit: 1 } },
-            });
-            const ctx = res?.thread_contexts?.[0];
-            const ctxId = ctx?.id;
-            if (!ctxId)
+            const persisted = await findStructureContextByKey(this.db, key);
+            if (!persisted?.row?.id)
                 return { ok: false, error: "Context not found" };
-            await this.db.transact([this.db.tx.thread_contexts[ctxId].link({ structure_output_file: params.fileId })]);
+            await linkStructureOutputFileToContextByKey(this.db, { contextKey: key, fileId: params.fileId });
             return { ok: true, data: undefined };
         }
         catch (error) {

package/dist/steps/commitFromEvents.step.js

@@ -1,3 +1,4 @@
+import { linkStructureOutputFileToContextByKey } from "../contextPersistence.js";
 function isToolCompletePart(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -22,8 +23,8 @@ export async function structureCommitFromEventsStep(params) {
     "use step";
     const contextKey = `structure:${params.structureId}`;
     try {
-        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-        const runtime = (await getThreadRuntime(params.env));
+        const { getContextRuntime } = await import("@ekairos/events/runtime");
+        const runtime = (await getContextRuntime(params.env));
         const store = runtime.store;
         const db = runtime.db;
         const events = await store.getItems({ key: contextKey });
@@ -66,10 +67,9 @@ export async function structureCommitFromEventsStep(params) {
                 },
             };
             // Link output file to context (domain-prefixed link)
-            const ctxId = ctx?.id;
-            if (!ctxId)
+            if (!ctx?.id)
                 return { ok: false, error: "Context not found" };
-            await db.transact(db.tx.thread_contexts[ctxId].link({ structure_output_file: out.fileId }));
+            await linkStructureOutputFileToContextByKey(db, { contextKey, fileId: out.fileId });
         }
         await store.updateContextContent({ key: contextKey }, { ...prevContent, structure: nextStructure });
         return { ok: true, data: { committed: true } };

package/dist/steps/ensureExecutionTrail.step.d.ts

@@ -0,0 +1,11 @@
+type EnsureExecutionTrailParams = {
+    env: any;
+    contextKey: string;
+    datasetId: string;
+    output: "rows" | "object";
+    requestItemId: string;
+    status: "success" | "failed";
+    error?: unknown;
+};
+export declare function ensureExecutionTrailStep(params: EnsureExecutionTrailParams): Promise<void>;
+export {};

package/dist/steps/ensureExecutionTrail.step.js

@@ -0,0 +1,100 @@
+function createTraceItemId(seed) {
+    let hashA = 2166136261;
+    let hashB = 2166136261;
+    for (let i = 0; i < seed.length; i += 1) {
+        const code = seed.charCodeAt(i);
+        hashA ^= code;
+        hashA = Math.imul(hashA, 16777619);
+        hashB ^= code + (i % 13);
+        hashB = Math.imul(hashB, 16777619);
+    }
+    const partA = (hashA >>> 0).toString(16).padStart(8, "0");
+    const partB = (hashB >>> 0).toString(16).padStart(8, "0");
+    const hex = `${partA}${partB}${partA}${partB}`;
+    const chars = hex.slice(0, 32).split("");
+    chars[12] = "4";
+    const variant = parseInt(chars[16], 16);
+    chars[16] = ((variant & 0x3) | 0x8).toString(16);
+    const normalized = chars.join("");
+    return `${normalized.slice(0, 8)}-${normalized.slice(8, 12)}-${normalized.slice(12, 16)}-${normalized.slice(16, 20)}-${normalized.slice(20, 32)}`;
+}
+function toSerializableError(error) {
+    if (!error)
+        return undefined;
+    if (typeof error === "string")
+        return error;
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+        };
+    }
+    return String(error);
+}
+export async function ensureExecutionTrailStep(params) {
+    "use step";
+    const { getContextRuntime } = await import("@ekairos/events/runtime");
+    const runtime = (await getContextRuntime(params.env));
+    const store = runtime.store;
+    if (!store?.saveItem ||
+        !store?.createExecution ||
+        !store?.linkItemToExecution ||
+        !store?.getItems) {
+        return;
+    }
+    const items = await store.getItems({ key: params.contextKey });
+    const hasRequest = items.some((item) => item?.id === params.requestItemId);
+    let requestItemId = params.requestItemId;
+    if (!hasRequest) {
+        const recreatedRequestItemId = createTraceItemId(`structure-trace:request:${params.contextKey}:${params.datasetId}:${params.requestItemId}`);
+        const requestItem = await store.saveItem({ key: params.contextKey }, {
+            id: recreatedRequestItemId,
+            type: "input",
+            channel: "web",
+            createdAt: new Date().toISOString(),
+            content: {
+                parts: [{ type: "text", text: "[structure-trace] request (recreated)" }],
+                structure_build: {
+                    datasetId: params.datasetId,
+                    status: "input",
+                },
+            },
+        });
+        if (!requestItem?.id)
+            return;
+        requestItemId = requestItem.id;
+    }
+    const outputItemId = createTraceItemId(`structure-trace:output:${params.contextKey}:${params.datasetId}:${params.status}:${params.output}`);
+    const outputItem = await store.saveItem({ key: params.contextKey }, {
+        id: outputItemId,
+        type: "output",
+        channel: "web",
+        createdAt: new Date().toISOString(),
+        content: {
+            parts: [
+                { type: "text", text: `structure:${params.datasetId} ${params.status}` },
+            ],
+            structure_build: {
+                datasetId: params.datasetId,
+                status: params.status,
+                output: params.output,
+                orgId: params.env?.orgId,
+                error: toSerializableError(params.error),
+            },
+        },
+    });
+    if (!outputItem?.id)
+        return;
+    const execution = await store.createExecution({ key: params.contextKey }, requestItemId, outputItem.id);
+    await store.linkItemToExecution({
+        itemId: requestItemId,
+        executionId: execution.id,
+    });
+    await store.linkItemToExecution({
+        itemId: outputItem.id,
+        executionId: execution.id,
+    });
+    if (store?.completeExecution) {
+        await store.completeExecution({ key: params.contextKey }, execution.id, "completed");
+    }
+}

package/dist/steps/persistObjectFromStory.step.js

@@ -36,8 +36,8 @@ function extractJsonObject(text) {
 }
 export async function persistObjectResultFromStoryStep(params) {
     "use step";
-    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
-    const runtime = (await getThreadRuntime(params.env));
+    const { getContextRuntime } = await import("@ekairos/events/runtime");
+    const runtime = (await getContextRuntime(params.env));
     const store = runtime.store;
     const contextKey = `structure:${params.datasetId}`;
     const events = await store.getEvents({ key: contextKey });

package/dist/structure.js

@@ -1,10 +1,10 @@
-import { createThread, didToolExecute, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL } from "@ekairos/thread";
+import { createContext, didToolExecute, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL } from "@ekairos/events";
 import { getDatasetOutputPath, getDatasetOutputSchemaPath, getDatasetWorkstation, getDaytonaVolumeMountPath, getDaytonaVolumeName, } from "./datasetFiles.js";
 import { structureDownloadRowsOutputToSandboxStep, structureReadRowsOutputPageFromSandboxStep, } from "./rowsOutputPaging.js";
 import { structureSplitRowsOutputToDatasetStep } from "./rowsOutputSplit.js";
 import { createDatasetSandboxStep, readDatasetSandboxFileStep, readDatasetSandboxTextFileStep, runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep, writeDatasetSandboxTextFileStep, } from "./sandbox/steps.js";
 import { readInstantFileStep } from "./file/steps.js";
-import { structureGetContextStep, structureGetContextWithRowsOutputFileStep, structureReadRowsOutputJsonlStep, } from "./dataset/steps.js";
+import { structureGetContextStep, structureGetContextWithRowsOutputFileStep, structurePatchContextContentStep, structureReadRowsOutputJsonlStep, } from "./dataset/steps.js";
 import { getWorkflowMetadata } from "workflow";
 import { buildStructurePrompt } from "./prompts.js";
 import { createExecuteCommandTool } from "./executeCommand.tool.js";
@@ -14,6 +14,7 @@ import { createCompleteRowsTool } from "./completeRows.tool.js";
 import { createCompleteObjectTool } from "./completeObject.tool.js";
 import { persistObjectResultFromStoryStep } from "./steps/persistObjectFromStory.step.js";
 import { structureCommitFromEventsStep } from "./steps/commitFromEvents.step.js";
+import { ensureExecutionTrailStep } from "./steps/ensureExecutionTrail.step.js";
 function createUuidV4() {
     // Pure JS uuidv4 (workflow-safe: avoids Node built-ins and @instantdb/admin)
     return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
@@ -22,6 +23,20 @@ function createUuidV4() {
         return v.toString(16);
     });
 }
+function toSerializableStructureError(error) {
+    if (!error)
+        return undefined;
+    if (typeof error === "string")
+        return error;
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack ? String(error.stack).slice(0, 2000) : undefined,
+        };
+    }
+    return String(error);
+}
 function assertRunningInsideWorkflow(params) {
     const bypassRaw = String(process.env.STRUCTURE_ALLOW_NON_WORKFLOW ?? "")
         .trim()
@@ -266,7 +281,7 @@ function createStructureStoryDefinition(config) {
     const model = config.model ?? "openai/gpt-5.2";
     const defaultSandboxConfig = getDefaultSandboxConfig(datasetId);
     const resolvedSandboxConfig = mergeSandboxConfig(defaultSandboxConfig, config.sandboxConfig);
-    const story = createThread("ekairos.structure")
+    const story = createContext("ekairos.structure")
         .context(async (stored, env) => {
         const prev = stored?.content ?? {};
         const sandboxState = prev.sandboxState ?? { initialized: false, sources: [] };
@@ -455,6 +470,30 @@ export function structure(env, opts) {
                     content: { parts: [{ type: "text", text }] },
                 };
             }
+            async function markBuildFailed(error) {
+                try {
+                    await structurePatchContextContentStep({
+                        env,
+                        contextKey,
+                        patch: {
+                            structure: {
+                                kind: "ekairos.structure",
+                                version: 1,
+                                structureId: datasetId,
+                                updatedAt: Date.now(),
+                                state: "failed",
+                                error: {
+                                    message: error instanceof Error ? error.message : String(error),
+                                    stage: "structure.build",
+                                },
+                            },
+                        },
+                    });
+                }
+                catch {
+                    // keep failure explicit even if persistence is partially unavailable
+                }
+            }
             async function runStory(evt) {
                 await story.react(evt, {
                     env,
@@ -464,6 +503,7 @@ export function structure(env, opts) {
                 // Tools are intentionally pure: persist completion outputs post-react by reading tool results from events.
                 const commit = await structureCommitFromEventsStep({ env, structureId: datasetId });
                 if (!commit.ok) {
+                    throw new Error(commit.error);
                 }
             }
             async function getContextOrThrow() {
@@ -485,115 +525,137 @@ export function structure(env, opts) {
                 return (content?.structure?.outputs?.object?.value !== undefined &&
                     content?.structure?.outputs?.object?.value !== null);
             }
-            await runStory(makeUserMessageEvent(userPrompt ?? "produce structured output"));
-            let ctx = await getContextOrThrow();
-            // Auto-mode: if schema is missing after the first pass, explicitly request investigation + generateSchema.
-            if (mode === "auto") {
-                const content = (ctx?.content ?? {});
-                const hasSchema = Boolean(content?.structure?.outputSchema?.schema);
-                if (!hasSchema) {
-                    await runStory(makeUserMessageEvent([
-                        "CRITICAL: You did not generate a schema yet.",
-                        "1) Investigate Sources using executeCommand (inspect paths, read files, infer structure).",
-                        "2) Call generateSchema.",
-                        "3) After schema is saved, produce the final output and call complete.",
-                    ].join("\n")));
+            const initialRequestEvent = makeUserMessageEvent(userPrompt ?? "produce structured output");
+            try {
+                await runStory(initialRequestEvent);
+                let ctx = await getContextOrThrow();
+                // Auto-mode: if schema is missing after the first pass, explicitly request investigation + generateSchema.
+                if (mode === "auto") {
+                    const content = (ctx?.content ?? {});
+                    const hasSchema = Boolean(content?.structure?.outputSchema?.schema);
+                    if (!hasSchema) {
+                        await runStory(makeUserMessageEvent([
+                            "CRITICAL: You did not generate a schema yet.",
+                            "1) Investigate Sources using executeCommand (inspect paths, read files, infer structure).",
+                            "2) Call generateSchema.",
+                            "3) After schema is saved, produce the final output and call complete.",
+                        ].join("\n")));
+                        ctx = await getContextOrThrow();
+                    }
+                }
+                const needsSecondPass = output === "rows" ? !(await isRowsCompleted()) : !isObjectCompleted(ctx);
+                if (needsSecondPass) {
+                    const followUpText = output === "rows"
+                        ? "Finalize now: write output.jsonl to OutputPath and call complete."
+                        : "Finalize now: call complete with summary and resultJson (inline JSON).";
+                    await runStory(makeUserMessageEvent(followUpText));
                     ctx = await getContextOrThrow();
                 }
-            }
-            const needsSecondPass = output === "rows" ? !(await isRowsCompleted()) : !isObjectCompleted(ctx);
-            if (needsSecondPass) {
-                const followUpText = output === "rows"
-                    ? "Finalize now: write output.jsonl to OutputPath and call complete."
-                    : "Finalize now: call complete with summary and resultJson (inline JSON).";
-                await runStory(makeUserMessageEvent(followUpText));
-                ctx = await getContextOrThrow();
-            }
-            const stillIncompleteAfterSecondPass = output === "rows" ? !(await isRowsCompleted()) : !isObjectCompleted(ctx);
-            if (stillIncompleteAfterSecondPass) {
-                const finalText = output === "rows"
-                    ? "CRITICAL: Do not do anything else. Ensure output.jsonl exists at OutputPath and immediately call complete."
-                    : "CRITICAL: Do not do anything else. Immediately call complete with summary and resultJson (inline JSON).";
-                await runStory(makeUserMessageEvent(finalText));
-                ctx = await getContextOrThrow();
-            }
-            if (output === "rows" && !(await isRowsCompleted())) {
-                throw new Error("Rows output not completed");
-            }
-            if (output === "object" && !isObjectCompleted(ctx)) {
-                const persisted = await persistObjectResultFromStoryStep({ env, datasetId });
-                if (persisted.ok) {
+                const stillIncompleteAfterSecondPass = output === "rows" ? !(await isRowsCompleted()) : !isObjectCompleted(ctx);
+                if (stillIncompleteAfterSecondPass) {
+                    const finalText = output === "rows"
+                        ? "CRITICAL: Do not do anything else. Ensure output.jsonl exists at OutputPath and immediately call complete."
+                        : "CRITICAL: Do not do anything else. Immediately call complete with summary and resultJson (inline JSON).";
+                    await runStory(makeUserMessageEvent(finalText));
                     ctx = await getContextOrThrow();
                 }
-                else {
+                if (output === "rows" && !(await isRowsCompleted())) {
+                    throw new Error("Rows output not completed");
                 }
-            }
-            if (output === "object" && !isObjectCompleted(ctx)) {
-                throw new Error("Object output not completed");
-            }
-            let rowsSandboxRef = null;
-            const reader = {
-                read: async (cursorOrParams, limit) => {
-                    if (output !== "rows") {
-                        throw new Error("reader.read() is only supported for output=rows");
+                if (output === "object" && !isObjectCompleted(ctx)) {
+                    const persisted = await persistObjectResultFromStoryStep({ env, datasetId });
+                    if (persisted.ok) {
+                        ctx = await getContextOrThrow();
                     }
-                    if (!rowsSandboxRef) {
-                        rowsSandboxRef = await structureDownloadRowsOutputToSandboxStep({
+                }
+                if (output === "object" && !isObjectCompleted(ctx)) {
+                    throw new Error("Object output not completed");
+                }
+                await ensureExecutionTrailStep({
+                    env,
+                    contextKey,
+                    datasetId,
+                    output,
+                    status: "success",
+                    requestItemId: initialRequestEvent.id,
+                });
+                let rowsSandboxRef = null;
+                const reader = {
+                    read: async (cursorOrParams, limit) => {
+                        if (output !== "rows") {
+                            throw new Error("reader.read() is only supported for output=rows");
+                        }
+                        if (!rowsSandboxRef) {
+                            rowsSandboxRef = await structureDownloadRowsOutputToSandboxStep({
+                                env,
+                                structureId: datasetId,
+                            });
+                        }
+                        const params = cursorOrParams && typeof cursorOrParams === "object" && ("cursor" in cursorOrParams || "limit" in cursorOrParams)
+                            ? cursorOrParams
+                            : { cursor: cursorOrParams, limit };
+                        const page = await structureReadRowsOutputPageFromSandboxStep({
                             env,
-                            structureId: datasetId,
+                            sandboxId: rowsSandboxRef.sandboxId,
+                            localPath: rowsSandboxRef.localPath,
+                            cursor: params?.cursor,
+                            limit: params?.limit ?? 200,
                         });
-                    }
-                    const params = cursorOrParams && typeof cursorOrParams === "object" && ("cursor" in cursorOrParams || "limit" in cursorOrParams)
-                        ? cursorOrParams
-                        : { cursor: cursorOrParams, limit };
-                    const page = await structureReadRowsOutputPageFromSandboxStep({
-                        env,
-                        sandboxId: rowsSandboxRef.sandboxId,
-                        localPath: rowsSandboxRef.localPath,
-                        cursor: params?.cursor,
-                        limit: params?.limit ?? 200,
-                    });
-                    return {
-                        rows: page.rows,
-                        cursor: page.nextCursor,
-                        done: page.done,
-                    };
-                },
-                split: async (cursorOrParams, limit) => {
-                    if (output !== "rows") {
-                        throw new Error("reader.split() is only supported for output=rows");
-                    }
-                    if (!rowsSandboxRef) {
-                        rowsSandboxRef = await structureDownloadRowsOutputToSandboxStep({
+                        return {
+                            rows: page.rows,
+                            cursor: page.nextCursor,
+                            done: page.done,
+                        };
+                    },
+                    split: async (cursorOrParams, limit) => {
+                        if (output !== "rows") {
+                            throw new Error("reader.split() is only supported for output=rows");
+                        }
+                        if (!rowsSandboxRef) {
+                            rowsSandboxRef = await structureDownloadRowsOutputToSandboxStep({
+                                env,
+                                structureId: datasetId,
+                            });
+                        }
+                        const params = cursorOrParams && typeof cursorOrParams === "object" && ("cursor" in cursorOrParams || "limit" in cursorOrParams)
+                            ? cursorOrParams
+                            : {
+                                cursor: cursorOrParams,
+                                limit,
+                                datasetId: undefined,
+                            };
+                        const childDatasetId = params?.datasetId ?? createUuidV4();
+                        const res = await structureSplitRowsOutputToDatasetStep({
                             env,
-                            structureId: datasetId,
+                            sandboxId: rowsSandboxRef.sandboxId,
+                            localPath: rowsSandboxRef.localPath,
+                            cursor: params?.cursor,
+                            limit: params?.limit ?? 300,
+                            childDatasetId,
                         });
-                    }
-                    const params = cursorOrParams && typeof cursorOrParams === "object" && ("cursor" in cursorOrParams || "limit" in cursorOrParams)
-                        ? cursorOrParams
-                        : {
-                            cursor: cursorOrParams,
-                            limit,
-                            datasetId: undefined,
+                        return {
+                            datasetId: res.datasetId,
+                            rowsWritten: res.rowsWritten,
+                            cursor: res.nextCursor,
+                            done: res.done,
                         };
-                    const childDatasetId = params?.datasetId ?? createUuidV4();
-                    const res = await structureSplitRowsOutputToDatasetStep({
-                        env,
-                        sandboxId: rowsSandboxRef.sandboxId,
-                        localPath: rowsSandboxRef.localPath,
-                        cursor: params?.cursor,
-                        limit: params?.limit ?? 300,
-                        childDatasetId,
-                    });
-                    return {
-                        datasetId: res.datasetId,
-                        rowsWritten: res.rowsWritten,
-                        cursor: res.nextCursor,
-                        done: res.done,
-                    };
-                },
-            };
-            return output === "object" ? { datasetId, reader, dataset: ctx } : { datasetId, reader };
+                    },
+                };
+                return output === "object" ? { datasetId, reader, dataset: ctx } : { datasetId, reader };
+            }
+            catch (error) {
+                await markBuildFailed(error);
+                await ensureExecutionTrailStep({
+                    env,
+                    contextKey,
+                    datasetId,
+                    output,
+                    status: "failed",
+                    requestItemId: initialRequestEvent.id,
+                    error: toSerializableStructureError(error),
+                });
+                throw error;
+            }
         },
     };
     return api;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/structure",
-  "version": "1.22.9-beta.feature-registry-sync-esolbay-agent.0",
+  "version": "1.22.10-beta.development.0",
   "description": "Ekairos Structure - Unified structured extraction (rows or object) from file/text/dataset inputs",
   "type": "module",
   "main": "dist/index.js",
@@ -36,21 +36,21 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ekairos/domain": "^1.22.9-beta.feature-registry-sync-esolbay-agent.0",
-    "@ekairos/sandbox": "^1.22.9-beta.feature-registry-sync-esolbay-agent.0",
+    "@ekairos/domain": "^1.22.10-beta.development.0",
+    "@ekairos/sandbox": "^1.22.10-beta.development.0",
     "@instantdb/admin": "0.22.126",
     "@instantdb/core": "0.22.126",
     "ai": "^5.0.95",
     "ajv": "^8.17.1",
-    "workflow": "4.1.0-beta.55",
-    "zod": "^4.1.8"
+    "workflow": "5.0.0-beta.1",
+    "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "@ekairos/thread": "workspace:*"
+    "@ekairos/events": "workspace:*"
   },
   "devDependencies": {
     "@ekairos/sandbox": "workspace:*",
-    "@ekairos/thread": "workspace:*",
+    "@ekairos/events": "workspace:*",
     "@ekairos/tsconfig": "workspace:*",
     "@types/node": "^24.5.0",
     "dotenv": "^17.2.2",