@ekairos/dataset 1.22.49-beta.development.0 → 1.22.51-beta.development.0

package/dist/file/file-dataset.agent.js

@@ -1,7 +1,7 @@
-import { createContext, didToolExecute, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL } from "@ekairos/events";
+import { createContext, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL } from "@ekairos/events";
 import { runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep } from "../sandbox/steps.js";
 import { createGenerateSchemaTool } from "./generateSchema.tool.js";
-import { createCompleteDatasetTool } from "../completeDataset.tool.js";
+import { createCompleteDatasetTool, didCompleteDatasetSucceed } from "../completeDataset.tool.js";
 import { createExecuteCommandTool } from "../executeCommand.tool.js";
 import { createClearDatasetTool } from "../clearDataset.tool.js";
 import { buildFileDatasetPrompt } from "./prompts.js";
@@ -10,16 +10,24 @@ import { id } from "@instantdb/admin";
 import { getDatasetWorkstation } from "../datasetFiles.js";
 import { readInstantFileStep } from "./steps.js";
 import { datasetGetByIdStep } from "../dataset/steps.js";
-import { createEventsReactRuntime } from "../eventsReactRuntime.js";
-async function initializeSandbox(env, sandboxId, datasetId, fileId, state) {
+async function awaitContextRun(run) {
+    if (!run)
+        return;
+    if (run.returnValue) {
+        await run.returnValue;
+        return;
+    }
+    await run;
+}
+async function initializeSandbox(runtime, sandboxId, datasetId, fileId, state) {
     if (state.initialized) {
         return state.filePath;
     }
-    console.log(`[FileParseStory ${datasetId}] Initializing sandbox...`);
-    await ensurePreviewScriptsAvailable(env, sandboxId);
-    console.log(`[FileParseStory ${datasetId}] Installing Python dependencies...`);
+    console.log(`[FileParseContext ${datasetId}] Initializing sandbox...`);
+    await ensurePreviewScriptsAvailable(runtime, sandboxId);
+    console.log(`[FileParseContext ${datasetId}] Installing Python dependencies...`);
     const pipInstall = await runDatasetSandboxCommandStep({
-        env,
+        runtime,
         sandboxId,
         cmd: "python",
         args: ["-m", "pip", "install", "pandas", "openpyxl", "--quiet", "--upgrade"],
@@ -28,12 +36,12 @@ async function initializeSandbox(env, sandboxId, datasetId, fileId, state) {
     if (installStderr && (installStderr.includes("ERROR") || installStderr.includes("FAILED"))) {
         throw new Error(`pip install failed: ${installStderr.substring(0, 300)}`);
     }
-    console.log(`[FileParseStory ${datasetId}] Fetching file from InstantDB...`);
-    const file = await readInstantFileStep({ env, fileId });
-    console.log(`[FileParseStory ${datasetId}] Creating dataset workstation...`);
+    console.log(`[FileParseContext ${datasetId}] Fetching file from InstantDB...`);
+    const file = await readInstantFileStep({ runtime, fileId });
+    console.log(`[FileParseContext ${datasetId}] Creating dataset workstation...`);
     const workstation = getDatasetWorkstation(datasetId);
     await runDatasetSandboxCommandStep({
-        env,
+        runtime,
         sandboxId,
         cmd: "mkdir",
         args: ["-p", workstation],
@@ -42,7 +50,7 @@ async function initializeSandbox(env, sandboxId, datasetId, fileId, state) {
     const fileExtension = fileName.includes(".") ? fileName.substring(fileName.lastIndexOf(".")) : "";
     const sandboxFilePath = `${workstation}/${fileId}${fileExtension}`;
     await writeDatasetSandboxFilesStep({
-        env,
+        runtime,
         sandboxId,
         files: [
             {
@@ -51,14 +59,14 @@ async function initializeSandbox(env, sandboxId, datasetId, fileId, state) {
             },
         ],
     });
-    console.log(`[FileParseStory ${datasetId}] ✅ Workstation created: ${workstation}`);
-    console.log(`[FileParseStory ${datasetId}] ✅ File saved: ${sandboxFilePath}`);
+    console.log(`[FileParseContext ${datasetId}] ✅ Workstation created: ${workstation}`);
+    console.log(`[FileParseContext ${datasetId}] ✅ File saved: ${sandboxFilePath}`);
     state.filePath = sandboxFilePath;
     state.initialized = true;
     return sandboxFilePath;
 }
 /**
- * FileParseStory
+ * FileParseContext
  *
  * Uso:
  * - Crear una instancia con `fileId`, `instructions` y un `sandbox`
@@ -67,27 +75,27 @@ async function initializeSandbox(env, sandboxId, datasetId, fileId, state) {
  *
  * Internamente corre un Context (`createContext("file.parse")`) que itera hasta que se ejecuta el tool `completeDataset`.
  */
-function createFileParseStoryDefinition(params) {
+function createFileParseContextDefinition(params) {
     const datasetId = params.datasetId ?? id();
     const model = params.model ?? "openai/gpt-5";
-    let storyBuilder = createContext("file.parse")
-        .context(async (stored, env) => {
+    let contextBuilder = createContext("file.parse")
+        .context(async (stored, _env, runtime) => {
         const previous = stored?.content ?? {};
         const sandboxState = previous?.sandboxState ?? { initialized: false, filePath: "" };
         const sandboxId = previous?.sandboxId ?? params.sandboxId ?? "";
         if (!sandboxId) {
             throw new Error("dataset_sandbox_required");
         }
-        const sandboxFilePath = await initializeSandbox(env, sandboxId, datasetId, params.fileId, sandboxState);
+        const sandboxFilePath = await initializeSandbox(runtime, sandboxId, datasetId, params.fileId, sandboxState);
         let filePreview = undefined;
         try {
-            filePreview = await generateFilePreview(env, sandboxId, sandboxFilePath, datasetId);
+            filePreview = await generateFilePreview(runtime, sandboxId, sandboxFilePath, datasetId);
         }
         catch {
             // optional
         }
         let schema = null;
-        const datasetResult = await datasetGetByIdStep({ env, datasetId });
+        const datasetResult = await datasetGetByIdStep({ runtime, datasetId });
         if (datasetResult.ok && datasetResult.data.schema)
             schema = datasetResult.data.schema;
         const ctx = {
@@ -128,57 +136,57 @@ function createFileParseStoryDefinition(params) {
             base,
         ].join("\n");
     })
-        .actions(async (_stored, env) => {
+        .actions(async (_stored, _env, runtime) => {
         const existingSchema = _stored?.content?.ctx?.schema?.schema;
         const actions = {
             executeCommand: createExecuteCommandTool({
                 datasetId,
                 sandboxId: _stored?.content?.sandboxId ?? params.sandboxId ?? "",
-                env,
+                runtime,
             }),
             completeDataset: createCompleteDatasetTool({
                 datasetId,
                 sandboxId: _stored?.content?.sandboxId ?? params.sandboxId ?? "",
-                env,
+                runtime,
             }),
             clearDataset: createClearDatasetTool({
                 datasetId,
                 sandboxId: _stored?.content?.sandboxId ?? params.sandboxId ?? "",
-                env,
+                runtime,
             }),
         };
         if (!existingSchema) {
             actions.generateSchema = createGenerateSchemaTool({
                 datasetId,
                 fileId: params.fileId,
-                env,
+                runtime,
             });
         }
         return actions;
     })
         .shouldContinue(({ reactionEvent }) => {
-        return !didToolExecute(reactionEvent, "completeDataset");
+        return !didCompleteDatasetSucceed(reactionEvent);
     });
     if (params.reactor) {
-        storyBuilder = storyBuilder.reactor(params.reactor);
+        contextBuilder = contextBuilder.reactor(params.reactor);
     }
     else {
-        storyBuilder = storyBuilder.model(model);
+        contextBuilder = contextBuilder.model(model);
     }
-    const story = storyBuilder.build();
-    return { datasetId, story };
+    const context = contextBuilder.build();
+    return { datasetId, context };
 }
 /**
  * Factory (DX-first):
  *
  * Usage:
- *   const { datasetId } = await createFileParseStory(fileId, { instructions }).parse(env)
+ *   const { datasetId } = await createFileParseContext(fileId, { instructions }).parse(runtime)
  *
- * - No `db` is accepted/stored (workflow-safe).
- * - All I/O happens in `"use step"` functions via Ekairos runtime (`getContextRuntime(env).db`).
- * - `parse()` is the entrypoint; it calls `story.react(...)` internally.
+ * - Uses the caller runtime; no secondary runtime is created.
+ * - All I/O happens in `"use step"` functions via the provided Ekairos runtime.
+ * - `parse()` is the entrypoint; it calls `context.react(...)` internally.
  */
-export function createFileParseStory(fileId, opts) {
+export function createFileParseContext(fileId, opts) {
     const params = {
         fileId,
         instructions: opts?.instructions,
@@ -187,30 +195,29 @@ export function createFileParseStory(fileId, opts) {
         model: opts?.model,
         reactor: opts?.reactor,
     };
-    const { datasetId, story } = createFileParseStoryDefinition(params);
+    const { datasetId, context } = createFileParseContextDefinition(params);
     return {
         datasetId,
-        async parse(env, prompt) {
+        async parse(runtime, options = {}) {
             const triggerEvent = {
                 id: id(),
                 type: INPUT_TEXT_ITEM_TYPE,
                 channel: WEB_CHANNEL,
                 createdAt: new Date().toISOString(),
                 content: {
-                    parts: [{ type: "text", text: prompt ?? "generate a dataset for this file" }],
+                    parts: [{ type: "text", text: options.prompt ?? "generate a dataset for this file" }],
                 },
             };
-            const runtime = createEventsReactRuntime((env ?? {}));
-            const shell = await story.react(triggerEvent, {
-                runtime,
+            const shell = await context.react(triggerEvent, {
+                runtime: runtime,
                 context: { key: `dataset:${datasetId}` },
-                durable: false,
+                durable: options.durable ?? false,
                 options: { silent: true, preventClose: true, sendFinish: false, maxIterations: 20, maxModelSteps: 5 },
             });
-            await shell.run;
+            await awaitContextRun(shell.run);
             return { datasetId };
         },
-        // Optional: expose the built story for advanced callers (not required for parse DX)
-        story,
+        // Optional: expose the built context for advanced callers (not required for parse DX)
+        context,
     };
 }

package/dist/file/filepreview.d.ts

@@ -34,6 +34,6 @@ interface PreviewOptions {
     tailLines?: number;
     midLines?: number;
 }
-export declare function ensurePreviewScriptsAvailable(env: any, sandboxId: string): Promise<void>;
-export declare function generateFilePreview(env: any, sandboxId: string, sandboxFilePath: string, datasetId: string, options?: PreviewOptions): Promise<FilePreviewContext>;
+export declare function ensurePreviewScriptsAvailable(runtime: any, sandboxId: string): Promise<void>;
+export declare function generateFilePreview(runtime: any, sandboxId: string, sandboxFilePath: string, datasetId: string, options?: PreviewOptions): Promise<FilePreviewContext>;
 export {};

package/dist/file/filepreview.js

@@ -41,7 +41,7 @@ function validateScriptResult(result, context) {
         throw new Error(`${context} failed: ${stderr.substring(0, 500)}`);
     }
 }
-export async function ensurePreviewScriptsAvailable(env, sandboxId) {
+export async function ensurePreviewScriptsAvailable(runtime, sandboxId) {
     if (preparedSandboxIds.has(sandboxId)) {
         return;
     }
@@ -53,7 +53,7 @@ export async function ensurePreviewScriptsAvailable(env, sandboxId) {
     const setupPromise = (async () => {
         try {
             await runDatasetSandboxCommandStep({
-                env,
+                runtime,
                 sandboxId,
                 cmd: "mkdir",
                 args: ["-p", SANDBOX_SCRIPT_DIRECTORY],
@@ -79,7 +79,7 @@ export async function ensurePreviewScriptsAvailable(env, sandboxId) {
         }
         if (filesToWrite.length > 0) {
             await writeDatasetSandboxFilesStep({
-                env,
+                runtime,
                 sandboxId,
                 files: filesToWrite,
             });
@@ -95,13 +95,13 @@ export async function ensurePreviewScriptsAvailable(env, sandboxId) {
         throw error;
     }
 }
-export async function generateFilePreview(env, sandboxId, sandboxFilePath, datasetId, options = {}) {
+export async function generateFilePreview(runtime, sandboxId, sandboxFilePath, datasetId, options = {}) {
     const context = {
         totalRows: 0,
     };
     try {
-        await ensurePreviewScriptsAvailable(env, sandboxId);
-        const metadataResult = await runScript(env, sandboxId, "file_metadata.py", [sandboxFilePath], "Extracts file metadata: name, extension, size, row count estimate, column count, and header preview");
+        await ensurePreviewScriptsAvailable(runtime, sandboxId);
+        const metadataResult = await runScript(runtime, sandboxId, "file_metadata.py", [sandboxFilePath], "Extracts file metadata: name, extension, size, row count estimate, column count, and header preview");
         context.metadata = metadataResult;
         let isExcel = false;
         if (metadataResult.stdout) {
@@ -127,23 +127,23 @@ export async function generateFilePreview(env, sandboxId, sandboxFilePath, datas
         const midScript = isExcel ? "preview_mid_excel.py" : "preview_mid_csv.py";
         if (totalRows <= headLines) {
             console.log(`[Dataset ${datasetId}] File has ${totalRows} rows, reading all with head only`);
-            const headResult = await runScript(env, sandboxId, headScript, [sandboxFilePath, String(totalRows)], `Reads the first ${totalRows} rows (entire file)`);
+            const headResult = await runScript(runtime, sandboxId, headScript, [sandboxFilePath, String(totalRows)], `Reads the first ${totalRows} rows (entire file)`);
             validateScriptResult(headResult, `preview_head for ${datasetId}`);
             context.head = headResult;
             return context;
         }
         if (headLines + tailLines >= totalRows) {
             console.log(`[Dataset ${datasetId}] Head + tail would cover entire file (${totalRows} rows), reading all with head only`);
-            const headResult = await runScript(env, sandboxId, headScript, [sandboxFilePath, String(totalRows)], `Reads the first ${totalRows} rows (entire file)`);
+            const headResult = await runScript(runtime, sandboxId, headScript, [sandboxFilePath, String(totalRows)], `Reads the first ${totalRows} rows (entire file)`);
             validateScriptResult(headResult, `preview_head for ${datasetId}`);
             context.head = headResult;
             return context;
         }
         console.log(`[Dataset ${datasetId}] Reading head (${headLines} rows) and tail (${tailLines} rows) from ${totalRows} total rows`);
-        const headResult = await runScript(env, sandboxId, headScript, [sandboxFilePath, String(headLines)], `Reads the first ${headLines} rows of the file`);
+        const headResult = await runScript(runtime, sandboxId, headScript, [sandboxFilePath, String(headLines)], `Reads the first ${headLines} rows of the file`);
         validateScriptResult(headResult, `preview_head for ${datasetId}`);
         context.head = headResult;
-        const tailResult = await runScript(env, sandboxId, tailScript, [sandboxFilePath, String(tailLines)], `Reads the last ${tailLines} rows of the file`);
+        const tailResult = await runScript(runtime, sandboxId, tailScript, [sandboxFilePath, String(tailLines)], `Reads the last ${tailLines} rows of the file`);
         validateScriptResult(tailResult, `preview_tail for ${datasetId}`);
         context.tail = tailResult;
         const midLines = options.midLines || DEFAULT_MID_LINES;
@@ -152,7 +152,7 @@ export async function generateFilePreview(env, sandboxId, sandboxFilePath, datas
             const midStart = headLines;
             const midEnd = totalRows - tailLines;
             console.log(`[Dataset ${datasetId}] Large gap (${gapSize} rows), adding mid sample (${midLines} rows)`);
-            const midResult = await runScript(env, sandboxId, midScript, [sandboxFilePath, String(midStart), String(midEnd), String(midLines)], `Samples ${midLines} rows from the middle section (rows ${midStart + 1} to ${midEnd})`);
+            const midResult = await runScript(runtime, sandboxId, midScript, [sandboxFilePath, String(midStart), String(midEnd), String(midLines)], `Samples ${midLines} rows from the middle section (rows ${midStart + 1} to ${midEnd})`);
             validateScriptResult(midResult, `preview_mid for ${datasetId}`);
             context.mid = midResult;
         }
@@ -162,7 +162,7 @@ export async function generateFilePreview(env, sandboxId, sandboxFilePath, datas
     }
     return context;
 }
-async function runScript(env, sandboxId, scriptName, args, description) {
+async function runScript(runtime, sandboxId, scriptName, args, description) {
     const scriptPath = `${SANDBOX_SCRIPT_DIRECTORY}/${scriptName}`;
     const command = `python ${scriptPath} ${args.join(" ")}`;
     let scriptContent = "";
@@ -175,7 +175,7 @@ async function runScript(env, sandboxId, scriptName, args, description) {
     }
     try {
         const result = await runDatasetSandboxCommandStep({
-            env,
+            runtime,
             sandboxId,
             cmd: "python",
             args: [scriptPath, ...args],

package/dist/file/generateSchema.tool.d.ts

@@ -2,9 +2,9 @@ interface GenerateSchemaToolParams {
     datasetId: string;
     isNested?: boolean;
     fileId?: string;
-    env: any;
+    runtime: any;
 }
-export declare function createGenerateSchemaTool({ datasetId, isNested, fileId, env }: GenerateSchemaToolParams): import("ai").Tool<{
+export declare function createGenerateSchemaTool({ datasetId, isNested, fileId, runtime }: GenerateSchemaToolParams): import("ai").Tool<{
     schemaTitle: string;
     schemaDescription: string;
     schemaJson: string;

package/dist/file/generateSchema.tool.js

@@ -1,7 +1,7 @@
 import { tool } from "ai";
 import { z } from "zod";
 import { datasetUpdateSchemaStep } from "../dataset/steps.js";
-export function createGenerateSchemaTool({ datasetId, isNested, fileId, env }) {
+export function createGenerateSchemaTool({ datasetId, isNested, fileId, runtime }) {
     return tool({
         description: `Generate a formal JSON schema for a SINGLE RECORD (row) from the file. This schema describes the structure of ONE record, not the entire dataset or array of records. Requirements:
 1. Schema describes ONE RECORD structure only (no array wrappers)
@@ -72,7 +72,7 @@ export function createGenerateSchemaTool({ datasetId, isNested, fileId, env }) {
                 console.log(`[Dataset ${datasetId}] Schema JSON:`);
                 console.log(JSON.stringify(parsedSchema, null, 2));
                 const updateResult = await datasetUpdateSchemaStep({
-                    env,
+                    runtime,
                     datasetId,
                     schema: schemaData,
                     status: "schema_complete",

package/dist/file/prompts.d.ts

@@ -1,2 +1,2 @@
-import { FileParseStoryContext } from "./file-dataset.agent.js";
-export declare function buildFileDatasetPrompt(context: FileParseStoryContext): string;
+import { FileParseContext } from "./file-dataset.agent.js";
+export declare function buildFileDatasetPrompt(context: FileParseContext): string;

package/dist/file/prompts.js

@@ -147,6 +147,8 @@ function buildInstructions(context) {
             .ele("Action").txt("Use the provided schema as the output contract for every row in output.jsonl").up()
             .ele("Requirements")
             .ele("Requirement").txt("Every output row must conform exactly to the provided schema").up()
+            .ele("Requirement").txt("Every data object MUST use the exact property names from the provided JSON Schema required/properties keys").up()
+            .ele("Requirement").txt("Do not translate, localize, rename, camelize differently, or infer alternative field names. Field names are a technical contract; only field values may preserve the source language").up()
             .ele("Requirement").txt("Do not call generateSchema when a schema is already provided").up()
             .up()
             .up();
@@ -170,6 +172,7 @@ function buildInstructions(context) {
         .ele("Requirements")
         .ele("Requirement").txt("Parse ALL data rows/records from the file (exclude header sections and metadata)").up()
         .ele("Requirement").txt("Output JSONL format: each line is {\"type\": \"row\", \"data\": {...record...}}").up()
+        .ele("Requirement").txt("When a schema is provided, each data object must contain the exact required schema keys and must not use translated or synonymous keys").up()
         .ele("Requirement").txt("Extract ONLY data records; skip any header lines, summary sections, or file metadata").up()
         .ele("Requirement").txt(`Save output to: ${outputPath}`).up()
         .ele("Requirement").txt("Use descriptive scriptName in snake_case (e.g., 'parse_csv_to_jsonl')").up()
@@ -177,11 +180,13 @@ function buildInstructions(context) {
         .up()
         .ele("Step", { number: "4", name: "Complete and Validate" })
         .ele("Action").txt("Call completeDataset to validate the dataset").up()
-        .ele("Behavior").txt("Validates that output.jsonl exists and all records conform to the schema stored in database. Returns error details if validation fails.").up()
+        .ele("Behavior").txt("Validates that output.jsonl exists and all records conform to the schema stored in database. Returns success:false with validation details if validation fails. If validation fails, inspect validation errors, rewrite output.jsonl, and call completeDataset again. Do not stop until completeDataset returns success:true.").up()
         .up()
         .up()
         .ele("Rules")
         .ele("Rule").txt("Schema defines ONE DATA RECORD structure (not array, not header)").up()
+        .ele("Rule").txt("Schema property names are authoritative. Never translate or rename keys such as itemName, quantity, or unit into the source language").up()
+        .ele("Rule").txt("Original/source language applies to extracted values only, not to JSON object keys").up()
         .ele("Rule").txt("Datasets contain ONLY data records; exclude all header sections and file metadata").up()
         .ele("Rule").txt("JSONL format: each line = separate JSON object representing one data record").up()
         .ele("Rule").txt("FilePreview shows raw file content - use Script to understand data extraction").up()

package/dist/file/steps.d.ts

@@ -1,5 +1,5 @@
 export declare function readInstantFileStep(params: {
-    env: any;
+    runtime: any;
     fileId: string;
 }): Promise<{
     url: string;

package/dist/file/steps.js

@@ -1,7 +1,13 @@
-import { getContextRuntime } from "@ekairos/events/runtime";
+async function getRuntimeDb(runtime) {
+    if (!runtime) {
+        throw new Error("Dataset file step requires runtime.");
+    }
+    const db = runtime.db;
+    return typeof db === "function" ? await db.call(runtime) : db;
+}
 export async function readInstantFileStep(params) {
     "use step";
-    const db = (await getContextRuntime(params.env)).db;
+    const db = await getRuntimeDb(params.runtime);
     const fileQuery = await db.query({
         $files: { $: { where: { id: params.fileId }, limit: 1 } },
     });

package/dist/index.d.ts

@@ -3,4 +3,3 @@ export * from "./domain.js";
 export * from "./materializeDataset.tool.js";
 export * from "./schema.js";
 export * from "./service.js";
-export * from "./skill.js";

package/dist/index.js

@@ -3,4 +3,3 @@ export * from "./domain.js";
 export * from "./materializeDataset.tool.js";
 export * from "./schema.js";
 export * from "./service.js";
-export * from "./skill.js";

package/dist/query/queryDomain.d.ts

@@ -1,8 +1,8 @@
-import type { QueryDomainStepInput, QueryDomainStepResult } from "./queryDomain.step.js";
-export type QueryDomainInput = QueryDomainStepInput;
+import { type QueryDomainStepInput, type QueryDomainStepResult } from "./queryDomain.step.js";
+export type QueryDomainInput = Omit<QueryDomainStepInput, "runtime">;
 export type QueryDomainResult = QueryDomainStepResult;
 /**
  * Workflow-compatible domain query.
  * Always returns a dataset + preview rows.
  */
-export declare function queryDomain(input: QueryDomainInput): Promise<QueryDomainResult>;
+export declare function queryDomain(runtime: any, input: QueryDomainInput): Promise<QueryDomainResult>;

package/dist/query/queryDomain.js

@@ -1,9 +1,9 @@
+import { queryDomainStep } from "./queryDomain.step.js";
 /**
  * Workflow-compatible domain query.
  * Always returns a dataset + preview rows.
  */
-export async function queryDomain(input) {
+export async function queryDomain(runtime, input) {
     "use step";
-    const { queryDomainStep } = await import("./queryDomain.step.js");
-    return await queryDomainStep(input);
+    return await queryDomainStep({ runtime, ...input });
 }

package/dist/query/queryDomain.step.d.ts

@@ -1,4 +1,5 @@
 export type QueryDomainStepInput = {
+    runtime: any;
     query: Record<string, any>;
     explanation: string;
     title?: string;

package/dist/query/queryDomain.step.js

@@ -1,5 +1,4 @@
 import { id as newId } from "@instantdb/admin";
-import { getContextRuntime, getContextEnv } from "@ekairos/events/runtime";
 import { DatasetService } from "../service.js";
 function normalizeRows(result) {
     if (!result || typeof result !== "object")
@@ -46,11 +45,16 @@ function inferSchema(rows) {
     }
     return { schema };
 }
+async function getRuntimeDb(runtime) {
+    if (!runtime) {
+        throw new Error("Dataset query step requires runtime.");
+    }
+    const db = runtime.db;
+    return typeof db === "function" ? await db.call(runtime) : db;
+}
 export async function queryDomainStep(params) {
     "use step";
-    const env = await getContextEnv();
-    const runtime = await getContextRuntime(env);
-    const db = runtime.db;
+    const db = await getRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     const datasetId = params.datasetId ?? newId();
     const queryResult = await db.query(params.query);

package/dist/sandbox/steps.d.ts

@@ -1,6 +1,6 @@
 export type DatasetSandboxId = string;
 export type CreateDatasetSandboxParams = {
-    runtime?: string;
+    sandboxRuntime?: string;
     timeoutMs?: number;
     ports?: number[];
     resources?: {
@@ -15,18 +15,18 @@ export type DatasetSandboxRunCommandResult = {
     stderr: string;
 };
 export declare function createDatasetSandboxStep(params: {
-    env: any;
+    runtime: any;
 } & CreateDatasetSandboxParams): Promise<{
     sandboxId: DatasetSandboxId;
 }>;
 export declare function runDatasetSandboxCommandStep(params: {
-    env: any;
+    runtime: any;
     sandboxId: DatasetSandboxId;
     cmd: string;
     args?: string[];
 }): Promise<DatasetSandboxRunCommandResult>;
 export declare function writeDatasetSandboxFilesStep(params: {
-    env: any;
+    runtime: any;
     sandboxId: DatasetSandboxId;
     files: Array<{
         path: string;
@@ -34,13 +34,13 @@ export declare function writeDatasetSandboxFilesStep(params: {
     }>;
 }): Promise<void>;
 export declare function readDatasetSandboxFileStep(params: {
-    env: any;
+    runtime: any;
     sandboxId: DatasetSandboxId;
     path: string;
 }): Promise<{
     contentBase64: string;
 }>;
 export declare function stopDatasetSandboxStep(params: {
-    env: any;
+    runtime: any;
     sandboxId: DatasetSandboxId;
 }): Promise<void>;

package/dist/sandbox/steps.js

@@ -2,12 +2,19 @@ import { execFile } from "node:child_process";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { promisify } from "node:util";
-import { getContextRuntime } from "@ekairos/events/runtime";
+import { SandboxService } from "@ekairos/sandbox";
 const execFileAsync = promisify(execFile);
 const localSandboxRoots = new Map();
 function isLocalDatasetSandboxMode() {
     return String(process.env.DATASET_TEST_LOCAL_SANDBOX ?? "").trim() === "1";
 }
+async function getRuntimeDb(runtime) {
+    if (!runtime) {
+        throw new Error("Dataset sandbox step requires runtime.");
+    }
+    const db = runtime.db;
+    return typeof db === "function" ? await db.call(runtime) : db;
+}
 function getLocalSandboxRoot(sandboxId) {
     return (localSandboxRoots.get(sandboxId) ||
         path.resolve(process.cwd(), "test-results", "dataset-sandboxes", sandboxId));
@@ -63,10 +70,11 @@ export async function createDatasetSandboxStep(params) {
         await ensureLocalSandboxRoot(sandboxId);
         return { sandboxId };
     }
-    const db = (await getContextRuntime(params.env)).db;
-    const { SandboxService } = (await import("@ekairos/sandbox"));
+    const db = await getRuntimeDb(params.runtime);
     const service = new SandboxService(db);
-    const created = await service.createSandbox(params);
+    const sandboxParams = { ...params, runtime: params.sandboxRuntime };
+    delete sandboxParams.sandboxRuntime;
+    const created = await service.createSandbox(sandboxParams);
     if (!created.ok)
         throw new Error(created.error);
     return { sandboxId: created.data.sandboxId };
@@ -80,8 +88,7 @@ export async function runDatasetSandboxCommandStep(params) {
             args: params.args,
         });
     }
-    const db = (await getContextRuntime(params.env)).db;
-    const { SandboxService } = (await import("@ekairos/sandbox"));
+    const db = await getRuntimeDb(params.runtime);
     const service = new SandboxService(db);
     const result = await service.runCommand(params.sandboxId, params.cmd, params.args ?? []);
     if (!result.ok)
@@ -101,8 +108,7 @@ export async function writeDatasetSandboxFilesStep(params) {
         }
         return;
     }
-    const db = (await getContextRuntime(params.env)).db;
-    const { SandboxService } = (await import("@ekairos/sandbox"));
+    const db = await getRuntimeDb(params.runtime);
     const service = new SandboxService(db);
     const result = await service.writeFiles(params.sandboxId, params.files);
     if (!result.ok)
@@ -114,8 +120,7 @@ export async function readDatasetSandboxFileStep(params) {
         const content = await fs.readFile(params.path);
         return { contentBase64: Buffer.from(content).toString("base64") };
     }
-    const db = (await getContextRuntime(params.env)).db;
-    const { SandboxService } = (await import("@ekairos/sandbox"));
+    const db = await getRuntimeDb(params.runtime);
     const service = new SandboxService(db);
     const result = await service.readFile(params.sandboxId, params.path);
     if (!result.ok)
@@ -130,8 +135,7 @@ export async function stopDatasetSandboxStep(params) {
         localSandboxRoots.delete(params.sandboxId);
         return;
     }
-    const db = (await getContextRuntime(params.env)).db;
-    const { SandboxService } = (await import("@ekairos/sandbox"));
+    const db = await getRuntimeDb(params.runtime);
     const service = new SandboxService(db);
     const result = await service.stopSandbox(params.sandboxId);
     if (!result.ok)

package/dist/transform/filepreview.d.ts

@@ -18,5 +18,5 @@ export type TransformSourcePreviewContext = {
 interface PreviewOptions {
     headLines?: number;
 }
-export declare function generateSourcePreview(env: any, sandboxId: string, sourcePath: string, datasetId: string, options?: PreviewOptions): Promise<TransformSourcePreviewContext>;
+export declare function generateSourcePreview(runtime: any, sandboxId: string, sourcePath: string, datasetId: string, options?: PreviewOptions): Promise<TransformSourcePreviewContext>;
 export {};