@ekairos/structure 1.21.83-beta.0 → 1.21.88-beta.0

package/dist/dataset/steps.js

@@ -1,8 +1,8 @@
 export async function structureGetOrCreateContextStep(params) {
     "use step";
     try {
-        const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-        const runtime = await resolveStoryRuntime(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 };
     }
@@ -14,8 +14,8 @@ export async function structureGetOrCreateContextStep(params) {
 export async function structureGetContextStep(params) {
     "use step";
     try {
-        const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-        const runtime = await resolveStoryRuntime(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" };
@@ -29,8 +29,8 @@ export async function structureGetContextStep(params) {
 export async function structureUpdateContextContentStep(params) {
     "use step";
     try {
-        const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-        const runtime = await resolveStoryRuntime(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 };
     }
@@ -42,8 +42,8 @@ export async function structureUpdateContextContentStep(params) {
 export async function structurePatchContextContentStep(params) {
     "use step";
     try {
-        const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-        const runtime = await resolveStoryRuntime(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 ?? {});
@@ -65,8 +65,8 @@ export async function structureUploadRowsOutputJsonlStep(params) {
     "use step";
     const startedAt = Date.now();
     try {
-        const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-        const runtime = await resolveStoryRuntime(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");
@@ -89,15 +89,15 @@ export async function structureLinkRowsOutputFileToContextStep(params) {
     "use step";
     const startedAt = Date.now();
     try {
-        const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-        const runtime = await resolveStoryRuntime(params.env);
+        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const runtime = await getThreadRuntime(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.context_contexts[ctxId].link({ structure_output_file: params.fileId })]);
+        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 };
     }
@@ -109,15 +109,15 @@ export async function structureLinkRowsOutputFileToContextStep(params) {
 export async function structureUnlinkRowsOutputFileFromContextStep(params) {
     "use step";
     try {
-        const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-        const runtime = await resolveStoryRuntime(params.env);
+        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const runtime = await getThreadRuntime(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.context_contexts[ctxId].unlink({ structure_output_file: params.fileId })]);
+        await db.transact([db.tx.thread_contexts[ctxId].unlink({ structure_output_file: params.fileId })]);
         return { ok: true };
     }
     catch (error) {
@@ -128,16 +128,16 @@ export async function structureUnlinkRowsOutputFileFromContextStep(params) {
 export async function structureGetContextWithRowsOutputFileStep(params) {
     "use step";
     try {
-        const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-        const runtime = await resolveStoryRuntime(params.env);
+        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const runtime = await getThreadRuntime(params.env);
         const db = runtime.db;
         const query = (await db.query({
-            context_contexts: {
+            thread_contexts: {
                 $: { where: { key: params.contextKey }, limit: 1 },
                 structure_output_file: {},
             },
         }));
-        const row = query.context_contexts?.[0];
+        const row = query.thread_contexts?.[0];
         if (!row)
             return { ok: false, error: "Context not found" };
         return { ok: true, data: row };
@@ -152,16 +152,16 @@ export async function structureReadRowsOutputJsonlStep(params) {
     const startedAt = Date.now();
     try {
         const contextKey = `structure:${params.structureId}`;
-        const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-        const runtime = await resolveStoryRuntime(params.env);
+        const { getThreadRuntime } = await import("@ekairos/thread/runtime");
+        const runtime = await getThreadRuntime(params.env);
         const db = runtime.db;
         const query = (await db.query({
-            context_contexts: {
+            thread_contexts: {
                 $: { where: { key: contextKey }, limit: 1 },
                 structure_output_file: {},
             },
         }));
-        const ctx = query.context_contexts?.[0];
+        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 { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-    const runtime = (await resolveStoryRuntime(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,6 +1,6 @@
 import { getDatasetOutputPath, getDatasetWorkstation } from "./datasetFiles.js";
 import { createDatasetSandboxStep, runDatasetSandboxCommandStep } from "./sandbox/steps.js";
-import { getStoryRuntime } from "./runtime.js";
+import { getThreadRuntime } from "./runtime.js";
 /**
  * Step 1/2:
  * Download the rows output.jsonl from Instant storage into a sandbox file.
@@ -37,16 +37,16 @@ export async function structureDownloadRowsOutputToSandboxStep(params) {
     if (exists.exitCode === 0) {
         return { sandboxId, localPath };
     }
-    const storyRuntime = await getStoryRuntime(params.env);
+    const storyRuntime = await getThreadRuntime(params.env);
     const db = storyRuntime.db;
     const contextKey = `structure:${params.structureId}`;
     const query = (await db.query({
-        context_contexts: {
+        thread_contexts: {
             $: { where: { key: contextKey }, limit: 1 },
             structure_output_file: {},
         },
     }));
-    const ctx = query.context_contexts?.[0];
+    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,6 +1,6 @@
 import { getDatasetOutputPath, getDatasetWorkstation } from "./datasetFiles.js";
 import { readDatasetSandboxFileStep, runDatasetSandboxCommandStep } from "./sandbox/steps.js";
-import { getStoryRuntime } 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.
@@ -84,7 +84,7 @@ export async function structureSplitRowsOutputToDatasetStep(params) {
         sandboxId: params.sandboxId,
         path: outPath,
     });
-    const storyRuntime = await getStoryRuntime(params.env);
+    const storyRuntime = await getThreadRuntime(params.env);
     const db = storyRuntime.db;
     const store = storyRuntime.store;
     const storagePath = `/structure/${params.childDatasetId}/output.jsonl`;
@@ -102,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 db.transact([db.tx.context_contexts[ctxId].link({ structure_output_file: 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: resolveStoryRuntime 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 getStoryRuntime(env: any): Promise<import("@ekairos/story/runtime").StoryRuntime>;
+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: resolveStoryRuntime 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 getStoryRuntime(env) {
-    const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-    return await resolveStoryRuntime(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 { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-    const db = (await resolveStoryRuntime(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 { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-    const db = (await resolveStoryRuntime(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 { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-    const db = (await resolveStoryRuntime(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 { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-    const db = (await resolveStoryRuntime(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 { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-    const db = (await resolveStoryRuntime(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 { storyDomain } from "@ekairos/story/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):
      *
-     * - `context_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: "context_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(storyDomain)
+    .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 `context_contexts` (Story 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,7 +1,7 @@
 /**
  * Back-compat helper for reading structure outputs outside the workflow runtime.
  *
- * IMPORTANT: The source of truth is `context_contexts` (Story 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,12 +14,12 @@ export class DatasetService {
         try {
             const key = this.contextKey(datasetId);
             const res = await this.db.query({
-                context_contexts: {
+                thread_contexts: {
                     $: { where: { key }, limit: 1 },
                     structure_output_file: {},
                 },
             });
-            const ctx = res.context_contexts?.[0];
+            const ctx = res.thread_contexts?.[0];
             if (!ctx)
                 return { ok: false, error: "Context not found" };
             return { ok: true, data: ctx };
@@ -44,12 +44,12 @@ export class DatasetService {
         try {
             const key = this.contextKey(datasetId);
             const res = await this.db.query({
-                context_contexts: {
+                thread_contexts: {
                     $: { where: { key }, limit: 1 },
                     structure_output_file: {},
                 },
             });
-            const ctx = res.context_contexts?.[0];
+            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)
@@ -90,13 +90,13 @@ export class DatasetService {
             const datasetId = params.id ?? createUuidV4();
             const key = this.contextKey(datasetId);
             const existing = await this.db.query({
-                context_contexts: { $: { where: { key }, limit: 1 } },
+                thread_contexts: { $: { where: { key }, limit: 1 } },
             });
-            const ctx = existing.context_contexts?.[0];
+            const ctx = existing.thread_contexts?.[0];
             if (ctx)
                 return { ok: true, data: { datasetId } };
             await this.db.transact([
-                this.db.tx.context_contexts[createUuidV4()].create({
+                this.db.tx.thread_contexts[createUuidV4()].create({
                     createdAt: new Date(),
                     content: {},
                     key,
@@ -134,13 +134,13 @@ export class DatasetService {
         try {
             const key = this.contextKey(params.datasetId);
             const res = await this.db.query({
-                context_contexts: { $: { where: { key }, limit: 1 } },
+                thread_contexts: { $: { where: { key }, limit: 1 } },
             });
-            const ctx = res?.context_contexts?.[0];
+            const ctx = res?.thread_contexts?.[0];
             const ctxId = ctx?.id;
             if (!ctxId)
                 return { ok: false, error: "Context not found" };
-            await this.db.transact([this.db.tx.context_contexts[ctxId].link({ structure_output_file: 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

@@ -22,11 +22,11 @@ export async function structureCommitFromEventsStep(params) {
     "use step";
     const contextKey = `structure:${params.structureId}`;
     try {
-        const { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-        const runtime = (await resolveStoryRuntime(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.getEvents({ key: contextKey });
+        const events = await store.getItems({ key: contextKey });
         const output = findLatestCompleteToolOutput(events ?? []);
         const out = output;
         if (!out || out.success !== true)
@@ -69,7 +69,7 @@ export async function structureCommitFromEventsStep(params) {
             const ctxId = ctx?.id;
             if (!ctxId)
                 return { ok: false, error: "Context not found" };
-            await db.transact(db.tx.context_contexts[ctxId].link({ structure_output_file: 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 { resolveStoryRuntime } = await import("@ekairos/story/runtime");
-    const runtime = (await resolveStoryRuntime(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,4 +1,4 @@
-import { createStory, didToolExecute, USER_MESSAGE_TYPE, WEB_CHANNEL } from "@ekairos/story";
+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";
@@ -266,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 = createStory("ekairos.structure")
+    const story = createThread("ekairos.structure")
         .context(async (stored, env) => {
         const prev = stored?.content ?? {};
         const sandboxState = prev.sandboxState ?? { initialized: false, sources: [] };
@@ -449,7 +449,7 @@ export function structure(env, opts) {
             function makeUserMessageEvent(text) {
                 return {
                     id: createUuidV4(),
-                    type: USER_MESSAGE_TYPE,
+                    type: INPUT_TEXT_ITEM_TYPE,
                     channel: WEB_CHANNEL,
                     createdAt: new Date().toISOString(),
                     content: { parts: [{ type: "text", text }] },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/structure",
-  "version": "1.21.83-beta.0",
+  "version": "1.21.88-beta.0",
   "description": "Ekairos Structure - Unified structured extraction (rows or object) from file/text/dataset inputs",
   "type": "module",
   "main": "dist/index.js",
@@ -36,25 +36,25 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ekairos/domain": "^1.21.83-beta.0",
-    "@ekairos/sandbox": "^1.21.78-beta.0",
-    "@instantdb/admin": "^0.22.13",
-    "@instantdb/core": "^0.22.13",
+    "@ekairos/domain": "^1.21.88-beta.0",
+    "@ekairos/sandbox": "^1.21.85-beta.0",
+    "@instantdb/admin": "0.22.126",
+    "@instantdb/core": "0.22.126",
     "ai": "^5.0.95",
     "ajv": "^8.17.1",
     "workflow": "4.0.1-beta.41",
     "zod": "^4.1.8"
   },
   "peerDependencies": {
-    "@ekairos/story": "^1.21.78-beta.0"
+    "@ekairos/thread": "workspace:*"
   },
   "devDependencies": {
-    "@ekairos/tsconfig": "workspace:*",
-    "@ekairos/story": "workspace:*",
     "@ekairos/sandbox": "workspace:*",
+    "@ekairos/thread": "workspace:*",
+    "@ekairos/tsconfig": "workspace:*",
     "@types/node": "^24.5.0",
+    "dotenv": "^17.2.2",
     "typescript": "^5.9.2",
-    "vitest": "^3.2.4",
-    "dotenv": "^17.2.2"
+    "vitest": "^3.2.4"
   }
 }