@ekairos/structure 1.22.4-beta.development.0 → 1.22.4-beta.feature-thread-unify.0

package/dist/dataset/steps.js

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

package/dist/rowsOutputPaging.js

@@ -1,7 +1,6 @@
 import { getDatasetOutputPath, getDatasetWorkstation } from "./datasetFiles.js";
 import { createDatasetSandboxStep, runDatasetSandboxCommandStep } from "./sandbox/steps.js";
-import { findStructureContextByKey } from "./contextPersistence.js";
-import { getContextRuntime } from "./runtime.js";
+import { getThreadRuntime } from "./runtime.js";
 /**
  * Step 1/2:
  * Download the rows output.jsonl from Instant storage into a sandbox file.
@@ -38,11 +37,16 @@ export async function structureDownloadRowsOutputToSandboxStep(params) {
     if (exists.exitCode === 0) {
         return { sandboxId, localPath };
     }
-    const storyRuntime = await getContextRuntime(params.env);
+    const storyRuntime = await getThreadRuntime(params.env);
     const db = storyRuntime.db;
     const contextKey = `structure:${params.structureId}`;
-    const persisted = await findStructureContextByKey(db, contextKey, { includeOutputFile: true });
-    const ctx = persisted?.row;
+    const query = (await db.query({
+        thread_contexts: {
+            $: { where: { key: contextKey }, limit: 1 },
+            structure_output_file: {},
+        },
+    }));
+    const ctx = query.thread_contexts?.[0];
     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,7 +1,6 @@
 import { getDatasetOutputPath, getDatasetWorkstation } from "./datasetFiles.js";
 import { readDatasetSandboxFileStep, runDatasetSandboxCommandStep } from "./sandbox/steps.js";
-import { linkStructureOutputFileToContextByKey } from "./contextPersistence.js";
-import { getContextRuntime } from "./runtime.js";
+import { getThreadRuntime } from "./runtime.js";
 /**
  * Step:
  * Split a sandbox-local `output.jsonl` into a child dataset (also `output.jsonl`) of up to `limit` ROW entries.
@@ -85,7 +84,7 @@ export async function structureSplitRowsOutputToDatasetStep(params) {
         sandboxId: params.sandboxId,
         path: outPath,
     });
-    const storyRuntime = await getContextRuntime(params.env);
+    const storyRuntime = await getThreadRuntime(params.env);
     const db = storyRuntime.db;
     const store = storyRuntime.store;
     const storagePath = `/structure/${params.childDatasetId}/output.jsonl`;
@@ -103,7 +102,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 linkStructureOutputFileToContextByKey(db, { contextKey, fileId });
+    await db.transact([db.tx.thread_contexts[ctxId].link({ structure_output_file: 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: getContextRuntime is not defined`.
+ *   causing `ReferenceError: getThreadRuntime is not defined`.
  * - Using a dynamic import keeps the symbol resolution local to the step runtime.
  */
-export declare function getContextRuntime(env: any): Promise<import("@ekairos/events/runtime").ContextRuntime>;
+export declare function getThreadRuntime(env: any): Promise<import("@ekairos/thread/runtime").ThreadRuntime>;

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: getContextRuntime is not defined`.
+ *   causing `ReferenceError: getThreadRuntime is not defined`.
  * - Using a dynamic import keeps the symbol resolution local to the step runtime.
  */
-export async function getContextRuntime(env) {
-    const { getContextRuntime } = await import("@ekairos/events/runtime");
-    return await getContextRuntime(env);
+export async function getThreadRuntime(env) {
+    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    return await getThreadRuntime(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 { getContextRuntime } = await import("@ekairos/events/runtime");
-    const db = (await getContextRuntime(env)).db;
+    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const db = (await getThreadRuntime(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 { getContextRuntime } = await import("@ekairos/events/runtime");
-    const db = (await getContextRuntime(params.env)).db;
+    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const db = (await getThreadRuntime(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 { getContextRuntime } = await import("@ekairos/events/runtime");
-    const db = (await getContextRuntime(params.env)).db;
+    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const db = (await getThreadRuntime(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 { getContextRuntime } = await import("@ekairos/events/runtime");
-    const db = (await getContextRuntime(params.env)).db;
+    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const db = (await getThreadRuntime(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 { getContextRuntime } = await import("@ekairos/events/runtime");
-    const db = (await getContextRuntime(params.env)).db;
+    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const db = (await getThreadRuntime(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 { eventsDomain } from "@ekairos/events/schema";
+import { threadDomain } from "@ekairos/thread/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):
      *
-     * - `event_contexts.structure_output_file` points to the `$files` record for `output.jsonl`.
+     * - `thread_contexts.structure_output_file` points to the `$files` record for `output.jsonl`.
      * - Reverse label is prefixed to avoid collisions across domains.
      */
     structureContextOutputFile: {
-        forward: { on: "event_contexts", has: "one", label: "structure_output_file" },
+        forward: { on: "thread_contexts", has: "one", label: "structure_output_file" },
         reverse: { on: "$files", has: "many", label: "structure_contexts" },
     },
 };
 const rooms = {};
 export const structureDomain = domain("structure")
-    .includes(eventsDomain)
+    .includes(threadDomain)
     .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 the persisted Story/Event context keyed by `structure:<id>`.
+ * IMPORTANT: The source of truth is `thread_contexts` (Story context) keyed by `structure:<id>`.
  */
 export declare class DatasetService {
     private readonly db;

package/dist/service.js

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

package/dist/steps/commitFromEvents.step.js

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

package/dist/steps/persistObjectFromStory.step.js

@@ -36,8 +36,8 @@ function extractJsonObject(text) {
 }
 export async function persistObjectResultFromStoryStep(params) {
     "use step";
-    const { getContextRuntime } = await import("@ekairos/events/runtime");
-    const runtime = (await getContextRuntime(params.env));
+    const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+    const runtime = (await getThreadRuntime(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 { createContext, didToolExecute, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL } from "@ekairos/events";
+import { createThread, didToolExecute, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL } from "@ekairos/thread";
 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, structurePatchContextContentStep, structureReadRowsOutputJsonlStep, } from "./dataset/steps.js";
+import { structureGetContextStep, structureGetContextWithRowsOutputFileStep, structureReadRowsOutputJsonlStep, } from "./dataset/steps.js";
 import { getWorkflowMetadata } from "workflow";
 import { buildStructurePrompt } from "./prompts.js";
 import { createExecuteCommandTool } from "./executeCommand.tool.js";
@@ -14,7 +14,6 @@ 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) => {
@@ -23,20 +22,6 @@ 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()
@@ -281,7 +266,7 @@ function createStructureStoryDefinition(config) {
     const model = config.model ?? "openai/gpt-5.2";
     const defaultSandboxConfig = getDefaultSandboxConfig(datasetId);
     const resolvedSandboxConfig = mergeSandboxConfig(defaultSandboxConfig, config.sandboxConfig);
-    const story = createContext("ekairos.structure")
+    const story = createThread("ekairos.structure")
         .context(async (stored, env) => {
         const prev = stored?.content ?? {};
         const sandboxState = prev.sandboxState ?? { initialized: false, sources: [] };
@@ -470,30 +455,6 @@ 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,
@@ -503,7 +464,6 @@ 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() {
@@ -525,137 +485,115 @@ export function structure(env, opts) {
                 return (content?.structure?.outputs?.object?.value !== undefined &&
                     content?.structure?.outputs?.object?.value !== null);
             }
-            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));
+            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")));
                     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));
+            }
+            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) {
                     ctx = await getContextOrThrow();
                 }
-                if (output === "rows" && !(await isRowsCompleted())) {
-                    throw new Error("Rows output not completed");
+                else {
                 }
-                if (output === "object" && !isObjectCompleted(ctx)) {
-                    const persisted = await persistObjectResultFromStoryStep({ env, datasetId });
-                    if (persisted.ok) {
-                        ctx = await getContextOrThrow();
+            }
+            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)) {
-                    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({
+                    if (!rowsSandboxRef) {
+                        rowsSandboxRef = await structureDownloadRowsOutputToSandboxStep({
                             env,
-                            sandboxId: rowsSandboxRef.sandboxId,
-                            localPath: rowsSandboxRef.localPath,
-                            cursor: params?.cursor,
-                            limit: params?.limit ?? 200,
+                            structureId: datasetId,
                         });
-                        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({
+                    }
+                    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({
                             env,
-                            sandboxId: rowsSandboxRef.sandboxId,
-                            localPath: rowsSandboxRef.localPath,
-                            cursor: params?.cursor,
-                            limit: params?.limit ?? 300,
-                            childDatasetId,
+                            structureId: datasetId,
                         });
-                        return {
-                            datasetId: res.datasetId,
-                            rowsWritten: res.rowsWritten,
-                            cursor: res.nextCursor,
-                            done: res.done,
+                    }
+                    const params = cursorOrParams && typeof cursorOrParams === "object" && ("cursor" in cursorOrParams || "limit" in cursorOrParams)
+                        ? cursorOrParams
+                        : {
+                            cursor: cursorOrParams,
+                            limit,
+                            datasetId: undefined,
                         };
-                    },
-                };
-                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;
-            }
+                    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 api;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/structure",
-  "version": "1.22.4-beta.development.0",
+  "version": "1.22.4-beta.feature-thread-unify.0",
   "description": "Ekairos Structure - Unified structured extraction (rows or object) from file/text/dataset inputs",
   "type": "module",
   "main": "dist/index.js",
@@ -36,8 +36,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ekairos/domain": "^1.22.4-beta.development.0",
-    "@ekairos/sandbox": "^1.22.4-beta.development.0",
+    "@ekairos/domain": "^1.22.4-beta.feature-thread-unify.0",
+    "@ekairos/sandbox": "^1.22.4-beta.feature-thread-unify.0",
     "@instantdb/admin": "0.22.126",
     "@instantdb/core": "0.22.126",
     "ai": "^5.0.95",
@@ -46,11 +46,11 @@
     "zod": "^4.1.8"
   },
   "peerDependencies": {
-    "@ekairos/events": "workspace:*"
+    "@ekairos/thread": "workspace:*"
   },
   "devDependencies": {
     "@ekairos/sandbox": "workspace:*",
-    "@ekairos/events": "workspace:*",
+    "@ekairos/thread": "workspace:*",
     "@ekairos/tsconfig": "workspace:*",
     "@types/node": "^24.5.0",
     "dotenv": "^17.2.2",

package/dist/contextPersistence.d.ts

@@ -1,29 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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/steps/ensureExecutionTrail.step.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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");
-    }
-}