@ekairos/dataset 1.22.46-beta.development.0 → 1.22.48-beta.development.0

package/dist/dataset/steps.js

@@ -1,32 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDatasetServiceDb = getDatasetServiceDb;
-exports.datasetGetByIdStep = datasetGetByIdStep;
-exports.datasetReadOutputJsonlStep = datasetReadOutputJsonlStep;
-exports.datasetUpdateSchemaStep = datasetUpdateSchemaStep;
-exports.datasetUploadOutputFileStep = datasetUploadOutputFileStep;
-exports.datasetUpdateStatusStep = datasetUpdateStatusStep;
-exports.datasetClearStep = datasetClearStep;
-exports.datasetPreviewRowsStep = datasetPreviewRowsStep;
-const runtime_1 = require("@ekairos/events/runtime");
-const service_1 = require("../service");
+import { getContextRuntime, getContextEnv } from "@ekairos/events/runtime";
+import { DatasetService } from "../service.js";
 async function resolveEnv(env) {
-    return env ?? (await (0, runtime_1.getContextEnv)());
+    return env ?? (await getContextEnv());
 }
-async function getDatasetServiceDb(env) {
+export async function getDatasetServiceDb(env) {
     "use step";
-    const runtime = (await (0, runtime_1.getContextRuntime)(await resolveEnv(env)));
+    const runtime = (await getContextRuntime(await resolveEnv(env)));
     return runtime.db;
 }
-async function datasetGetByIdStep(params) {
+export async function datasetGetByIdStep(params) {
     "use step";
-    const db = (await (0, runtime_1.getContextRuntime)(await resolveEnv(params.env))).db;
-    const service = new service_1.DatasetService(db);
+    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const service = new DatasetService(db);
     return await service.getDatasetById(params.datasetId);
 }
-async function datasetReadOutputJsonlStep(params) {
+export async function datasetReadOutputJsonlStep(params) {
     "use step";
-    const db = (await (0, runtime_1.getContextRuntime)(await resolveEnv(params.env))).db;
+    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
     for (let attempt = 1; attempt <= 20; attempt++) {
         const query = await db.query({
             dataset_datasets: {
@@ -45,29 +35,29 @@ async function datasetReadOutputJsonlStep(params) {
     }
     throw new Error("Dataset output file not found");
 }
-async function datasetUpdateSchemaStep(params) {
+export async function datasetUpdateSchemaStep(params) {
     "use step";
-    const db = (await (0, runtime_1.getContextRuntime)(await resolveEnv(params.env))).db;
-    const service = new service_1.DatasetService(db);
+    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const service = new DatasetService(db);
     return await service.updateDatasetSchema({
         datasetId: params.datasetId,
         schema: params.schema,
         status: params.status,
     });
 }
-async function datasetUploadOutputFileStep(params) {
+export async function datasetUploadOutputFileStep(params) {
     "use step";
-    const db = (await (0, runtime_1.getContextRuntime)(await resolveEnv(params.env))).db;
-    const service = new service_1.DatasetService(db);
+    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const service = new DatasetService(db);
     return await service.uploadDatasetOutputFile({
         datasetId: params.datasetId,
         fileBuffer: params.fileBuffer,
     });
 }
-async function datasetUpdateStatusStep(params) {
+export async function datasetUpdateStatusStep(params) {
     "use step";
-    const db = (await (0, runtime_1.getContextRuntime)(await resolveEnv(params.env))).db;
-    const service = new service_1.DatasetService(db);
+    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const service = new DatasetService(db);
     return await service.updateDatasetStatus({
         datasetId: params.datasetId,
         status: params.status,
@@ -75,20 +65,19 @@ async function datasetUpdateStatusStep(params) {
         actualGeneratedRowCount: params.actualGeneratedRowCount,
     });
 }
-async function datasetClearStep(params) {
+export async function datasetClearStep(params) {
     "use step";
-    const db = (await (0, runtime_1.getContextRuntime)(await resolveEnv(params.env))).db;
-    const service = new service_1.DatasetService(db);
+    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const service = new DatasetService(db);
     return await service.clearDataset(params.datasetId);
 }
-async function datasetPreviewRowsStep(params) {
+export async function datasetPreviewRowsStep(params) {
     "use step";
-    const db = (await (0, runtime_1.getContextRuntime)(await resolveEnv(params.env))).db;
-    const service = new service_1.DatasetService(db);
+    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const service = new DatasetService(db);
     const rowsResult = await service.previewRows(params.datasetId, params.limit ?? 20);
     if (!rowsResult.ok) {
         throw new Error(rowsResult.error);
     }
     return { rows: rowsResult.data };
 }
-//# sourceMappingURL=steps.js.map

package/dist/dataset.d.ts

@@ -1,4 +1,3 @@
-import type { AnyDatasetRuntime, DatasetBuilder, DatasetBuilderOptions, DatasetRuntimeHandle } from "./builder/types";
-export type { AnyDatasetRuntime, CompatibleSourceDomain, DatasetBuilder, DatasetBuilderOptions, DatasetBuildOptions, DatasetBuildResult, DatasetExistingSource, DatasetExistingSourceInput, DatasetFileSource, DatasetFileSourceInput, DatasetMode, DatasetOutput, DatasetQuerySourceInput, DatasetReader, DatasetReaderResult, DatasetRuntimeEnv, DatasetRuntimeHandle, DatasetSchemaInput, DatasetTextSource, DatasetSourceInput, DatasetTextSourceInput, } from "./builder/types";
+import type { AnyDatasetRuntime, DatasetBuilder, DatasetBuilderOptions, DatasetRuntimeHandle } from "./builder/types.js";
+export type { AnyDatasetRuntime, CompatibleSourceDomain, DatasetBuilder, DatasetBuilderOptions, DatasetBuildOptions, DatasetBuildResult, DatasetExistingSource, DatasetExistingSourceInput, DatasetFileSource, DatasetFileSourceInput, DatasetMode, DatasetOutput, DatasetQuerySourceInput, DatasetReader, DatasetReaderResult, DatasetRuntimeEnv, DatasetRuntimeHandle, DatasetSchemaInput, DatasetTextSource, DatasetSourceInput, DatasetTextSourceInput, } from "./builder/types.js";
 export declare function dataset<Runtime extends AnyDatasetRuntime>(runtime: Runtime & DatasetRuntimeHandle<Runtime>, options?: DatasetBuilderOptions): DatasetBuilder<Runtime>;
-//# sourceMappingURL=dataset.d.ts.map

package/dist/dataset.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataset = dataset;
-const admin_1 = require("@instantdb/admin");
-const instructions_1 = require("./builder/instructions");
-const materialize_1 = require("./builder/materialize");
-const persistence_1 = require("./builder/persistence");
-function dataset(runtime, options = {}) {
+import { id as newId } from "@instantdb/admin";
+import { buildObjectOutputInstructions } from "./builder/instructions.js";
+import { materializeDerivedDataset, materializeQuerySource, materializeSingleFileLikeSource, } from "./builder/materialize.js";
+import { finalizeBuildResult } from "./builder/persistence.js";
+export function dataset(runtime, options = {}) {
     const datasetId = normalizeDatasetId(options.datasetId);
     const typedRuntime = runtime;
     const state = {
@@ -107,14 +104,14 @@ function dataset(runtime, options = {}) {
                 ? {
                     ...state,
                     first: true,
-                    instructions: (0, instructions_1.buildObjectOutputInstructions)(state.instructions),
+                    instructions: buildObjectOutputInstructions(state.instructions),
                 }
                 : state;
             const onlySource = effectiveState.sources[0];
             const isSingleSource = effectiveState.sources.length === 1;
             const hasInstructions = Boolean(String(effectiveState.instructions ?? "").trim());
             if (isSingleSource && onlySource.kind === "query" && !hasInstructions) {
-                await (0, materialize_1.materializeQuerySource)(effectiveState.runtime, onlySource, {
+                await materializeQuerySource(effectiveState.runtime, onlySource, {
                     datasetId: targetDatasetId,
                     sandboxId: effectiveState.sandboxId,
                     schema: effectiveState.outputSchema,
@@ -122,7 +119,7 @@ function dataset(runtime, options = {}) {
                     instructions: effectiveState.instructions,
                     first: effectiveState.first,
                 });
-                return finalizeOutputResult(await (0, persistence_1.finalizeBuildResult)(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
+                return finalizeOutputResult(await finalizeBuildResult(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
             }
             if (isSingleSource && (onlySource.kind === "file" || onlySource.kind === "text")) {
                 if (!effectiveState.sandboxId) {
@@ -131,8 +128,8 @@ function dataset(runtime, options = {}) {
                 if (!effectiveState.reactor) {
                     throw new Error("dataset_reactor_required");
                 }
-                await (0, materialize_1.materializeSingleFileLikeSource)(effectiveState, onlySource, targetDatasetId);
-                return finalizeOutputResult(await (0, persistence_1.finalizeBuildResult)(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
+                await materializeSingleFileLikeSource(effectiveState, onlySource, targetDatasetId);
+                return finalizeOutputResult(await finalizeBuildResult(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
             }
             if (!effectiveState.sandboxId) {
                 throw new Error("dataset_sandbox_required");
@@ -140,14 +137,14 @@ function dataset(runtime, options = {}) {
             if (!effectiveState.reactor) {
                 throw new Error("dataset_reactor_required");
             }
-            await (0, materialize_1.materializeDerivedDataset)(effectiveState, targetDatasetId);
-            return finalizeOutputResult(await (0, persistence_1.finalizeBuildResult)(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
+            await materializeDerivedDataset(effectiveState, targetDatasetId);
+            return finalizeOutputResult(await finalizeBuildResult(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
         },
     };
     return api;
 }
 function normalizeDatasetId(datasetId) {
-    const normalized = String(datasetId ?? (0, admin_1.id)()).trim();
+    const normalized = String(datasetId ?? newId()).trim();
     if (!normalized) {
         throw new Error("dataset_id_required");
     }
@@ -161,4 +158,3 @@ function finalizeOutputResult(result, output) {
         object: result.firstRow ?? null,
     };
 }
-//# sourceMappingURL=dataset.js.map

package/dist/datasetFiles.d.ts

@@ -2,4 +2,3 @@ export declare const DATASET_OUTPUT_FILE_NAME = "output.jsonl";
 export declare function getDatasetWorkdirBase(): string;
 export declare function getDatasetWorkstation(datasetId: string): string;
 export declare function getDatasetOutputPath(datasetId: string): string;
-//# sourceMappingURL=datasetFiles.d.ts.map

package/dist/datasetFiles.js

@@ -1,17 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DATASET_OUTPUT_FILE_NAME = void 0;
-exports.getDatasetWorkdirBase = getDatasetWorkdirBase;
-exports.getDatasetWorkstation = getDatasetWorkstation;
-exports.getDatasetOutputPath = getDatasetOutputPath;
-exports.DATASET_OUTPUT_FILE_NAME = "output.jsonl";
+export const DATASET_OUTPUT_FILE_NAME = "output.jsonl";
 const DEFAULT_VERCEL_WORKDIR_BASE = "/vercel/sandbox/datasets";
 const DEFAULT_DAYTONA_WORKDIR_BASE = "/home/daytona/.ekairos/datasets";
 const DEFAULT_SPRITES_WORKDIR_BASE = "/workspace/.ekairos/datasets";
 function trimTrailingSlash(value) {
     return value.endsWith("/") ? value.slice(0, -1) : value;
 }
-function getDatasetWorkdirBase() {
+export function getDatasetWorkdirBase() {
     const explicit = String(process.env.DATASET_SANDBOX_WORKDIR_BASE ?? "").trim();
     if (explicit)
         return trimTrailingSlash(explicit);
@@ -24,10 +18,9 @@ function getDatasetWorkdirBase() {
         return DEFAULT_SPRITES_WORKDIR_BASE;
     return DEFAULT_VERCEL_WORKDIR_BASE;
 }
-function getDatasetWorkstation(datasetId) {
+export function getDatasetWorkstation(datasetId) {
     return `${getDatasetWorkdirBase()}/${datasetId}`;
 }
-function getDatasetOutputPath(datasetId) {
-    return `${getDatasetWorkstation(datasetId)}/${exports.DATASET_OUTPUT_FILE_NAME}`;
+export function getDatasetOutputPath(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/${DATASET_OUTPUT_FILE_NAME}`;
 }
-//# sourceMappingURL=datasetFiles.js.map

package/dist/domain.d.ts

@@ -1,2 +1 @@
-export { datasetDomain } from "./schema";
-//# sourceMappingURL=domain.d.ts.map
+export { datasetDomain } from "./schema.js";

package/dist/domain.js

@@ -1,6 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.datasetDomain = void 0;
-var schema_1 = require("./schema");
-Object.defineProperty(exports, "datasetDomain", { enumerable: true, get: function () { return schema_1.datasetDomain; } });
-//# sourceMappingURL=domain.js.map
+export { datasetDomain } from "./schema.js";

package/dist/eventsReactRuntime.d.ts

@@ -19,4 +19,3 @@ export type EventsReactRuntime<Env extends Record<string, unknown>> = {
     };
 };
 export declare function createEventsReactRuntime<Env extends Record<string, unknown>>(env: Env): EventsReactRuntime<Env>;
-//# sourceMappingURL=eventsReactRuntime.d.ts.map

package/dist/eventsReactRuntime.js

@@ -1,21 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEventsReactRuntime = createEventsReactRuntime;
-const events_1 = require("@ekairos/events");
-const runtime_1 = require("@ekairos/events/runtime");
-function createEventsReactRuntime(env) {
+import { eventsDomain } from "@ekairos/events";
+import { getContextRuntime } from "@ekairos/events/runtime";
+export function createEventsReactRuntime(env) {
     const meta = () => ({
-        domain: events_1.eventsDomain,
-        schema: events_1.eventsDomain.toInstantSchema(),
-        context: typeof events_1.eventsDomain.context === "function" ? events_1.eventsDomain.context() : undefined,
-        contextString: typeof events_1.eventsDomain.contextString === "function"
-            ? events_1.eventsDomain.contextString()
+        domain: eventsDomain,
+        schema: eventsDomain.toInstantSchema(),
+        context: typeof eventsDomain.context === "function" ? eventsDomain.context() : undefined,
+        contextString: typeof eventsDomain.contextString === "function"
+            ? eventsDomain.contextString()
             : undefined,
     });
     const runtime = {
         env,
         async db() {
-            const resolved = (await (0, runtime_1.getContextRuntime)(env));
+            const resolved = (await getContextRuntime(env));
             return resolved.db;
         },
         async resolve() {
@@ -26,4 +23,3 @@ function createEventsReactRuntime(env) {
     };
     return runtime;
 }
-//# sourceMappingURL=eventsReactRuntime.js.map

package/dist/executeCommand.tool.d.ts

@@ -32,4 +32,3 @@ export declare function createExecuteCommandTool({ datasetId, sandboxId, env }:
     error?: undefined;
 }>;
 export {};
-//# sourceMappingURL=executeCommand.tool.d.ts.map

package/dist/executeCommand.tool.js

@@ -1,24 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExecuteCommandTool = createExecuteCommandTool;
-const ai_1 = require("ai");
-const zod_1 = require("zod");
-const steps_1 = require("./sandbox/steps");
-const datasetFiles_1 = require("./datasetFiles");
+import { tool } from "ai";
+import { z } from "zod";
+import { runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep } from "./sandbox/steps.js";
+import { getDatasetWorkstation } from "./datasetFiles.js";
 // To keep responses predictable for big data scenarios, we cap stdout/stderr.
 // The tool's return payload exposes stdout (capped) plus the on-disk script path.
 const MAX_STDOUT_CHARS = 20000;
 const MAX_STDERR_CHARS = 5000;
-function createExecuteCommandTool({ datasetId, sandboxId, env }) {
-    return (0, ai_1.tool)({
+export function createExecuteCommandTool({ datasetId, sandboxId, env }) {
+    return tool({
         description: "Execute Python scripts in the sandbox. Always saves script to a file before executing. The tool's output is EXACTLY the script's stdout and includes the script file path for traceability. CRITICAL: Print concise, human-readable summaries only; do NOT print raw large data. For big results, write artifacts to files in the workstation and print their file paths. Always include progress/result prints (e.g., 'Processing file X...', 'Found Y records', 'Generated output.csv').",
-        inputSchema: zod_1.z.object({
-            pythonCode: zod_1.z.string().describe("Python code to execute. Saved to a file before running. MANDATORY: Use print() to report progress and final results. Keep prints concise; avoid dumping rows/JSON. For large outputs, write to files in the workstation directory and print only file paths and brief summaries."),
-            scriptName: zod_1.z.string().describe("Name for the script file in snake_case (e.g., 'inspect_file', 'parse_csv', 'generate_dataset'). A UUID will be appended automatically."),
+        inputSchema: z.object({
+            pythonCode: z.string().describe("Python code to execute. Saved to a file before running. MANDATORY: Use print() to report progress and final results. Keep prints concise; avoid dumping rows/JSON. For large outputs, write to files in the workstation directory and print only file paths and brief summaries."),
+            scriptName: z.string().describe("Name for the script file in snake_case (e.g., 'inspect_file', 'parse_csv', 'generate_dataset'). A UUID will be appended automatically."),
         }),
         execute: async ({ pythonCode, scriptName }) => {
             const uuid = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-            const workstation = (0, datasetFiles_1.getDatasetWorkstation)(datasetId);
+            const workstation = getDatasetWorkstation(datasetId);
             const scriptFile = `${workstation}/${scriptName}-${uuid}.py`;
             console.log(`[Dataset ${datasetId}] ========================================`);
             console.log(`[Dataset ${datasetId}] Tool: executeCommand`);
@@ -27,7 +24,7 @@ function createExecuteCommandTool({ datasetId, sandboxId, env }) {
             console.log(`[Dataset ${datasetId}] Code length: ${pythonCode.length} chars`);
             console.log(`[Dataset ${datasetId}] ========================================`);
             try {
-                await (0, steps_1.writeDatasetSandboxFilesStep)({
+                await writeDatasetSandboxFilesStep({
                     env,
                     sandboxId,
                     files: [
@@ -39,7 +36,7 @@ function createExecuteCommandTool({ datasetId, sandboxId, env }) {
                 });
                 console.log(`[Dataset ${datasetId}] Script written to: ${scriptFile}`);
                 console.log(`[Dataset ${datasetId}] Executing: python ${scriptFile}`);
-                const result = await (0, steps_1.runDatasetSandboxCommandStep)({
+                const result = await runDatasetSandboxCommandStep({
                     env,
                     sandboxId,
                     cmd: "python",
@@ -127,4 +124,3 @@ function createExecuteCommandTool({ datasetId, sandboxId, env }) {
         },
     });
 }
-//# sourceMappingURL=executeCommand.tool.js.map

package/dist/file/file-dataset.agent.d.ts

@@ -1,5 +1,5 @@
 import { createContext, type ContextReactor } from "@ekairos/events";
-import { FilePreviewContext } from "./filepreview";
+import { FilePreviewContext } from "./filepreview.js";
 export type FileParseStoryContext = {
     datasetId: string;
     fileId: string;
@@ -65,4 +65,3 @@ export declare function createFileParseStory<Env extends {
     }>;
     story: any;
 };
-//# sourceMappingURL=file-dataset.agent.d.ts.map

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

@@ -1,27 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFileParseStory = createFileParseStory;
-const events_1 = require("@ekairos/events");
-const steps_1 = require("../sandbox/steps");
-const generateSchema_tool_1 = require("./generateSchema.tool");
-const completeDataset_tool_1 = require("../completeDataset.tool");
-const executeCommand_tool_1 = require("../executeCommand.tool");
-const clearDataset_tool_1 = require("../clearDataset.tool");
-const prompts_1 = require("./prompts");
-const filepreview_1 = require("./filepreview");
-const admin_1 = require("@instantdb/admin");
-const datasetFiles_1 = require("../datasetFiles");
-const steps_2 = require("./steps");
-const steps_3 = require("../dataset/steps");
-const eventsReactRuntime_1 = require("../eventsReactRuntime");
+import { createContext, didToolExecute, 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 { createExecuteCommandTool } from "../executeCommand.tool.js";
+import { createClearDatasetTool } from "../clearDataset.tool.js";
+import { buildFileDatasetPrompt } from "./prompts.js";
+import { generateFilePreview, ensurePreviewScriptsAvailable } from "./filepreview.js";
+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) {
     if (state.initialized) {
         return state.filePath;
     }
     console.log(`[FileParseStory ${datasetId}] Initializing sandbox...`);
-    await (0, filepreview_1.ensurePreviewScriptsAvailable)(env, sandboxId);
+    await ensurePreviewScriptsAvailable(env, sandboxId);
     console.log(`[FileParseStory ${datasetId}] Installing Python dependencies...`);
-    const pipInstall = await (0, steps_1.runDatasetSandboxCommandStep)({
+    const pipInstall = await runDatasetSandboxCommandStep({
         env,
         sandboxId,
         cmd: "python",
@@ -32,10 +29,10 @@ async function initializeSandbox(env, sandboxId, datasetId, fileId, state) {
         throw new Error(`pip install failed: ${installStderr.substring(0, 300)}`);
     }
     console.log(`[FileParseStory ${datasetId}] Fetching file from InstantDB...`);
-    const file = await (0, steps_2.readInstantFileStep)({ env, fileId });
+    const file = await readInstantFileStep({ env, fileId });
     console.log(`[FileParseStory ${datasetId}] Creating dataset workstation...`);
-    const workstation = (0, datasetFiles_1.getDatasetWorkstation)(datasetId);
-    await (0, steps_1.runDatasetSandboxCommandStep)({
+    const workstation = getDatasetWorkstation(datasetId);
+    await runDatasetSandboxCommandStep({
         env,
         sandboxId,
         cmd: "mkdir",
@@ -44,7 +41,7 @@ async function initializeSandbox(env, sandboxId, datasetId, fileId, state) {
     const fileName = file.contentDisposition ?? "";
     const fileExtension = fileName.includes(".") ? fileName.substring(fileName.lastIndexOf(".")) : "";
     const sandboxFilePath = `${workstation}/${fileId}${fileExtension}`;
-    await (0, steps_1.writeDatasetSandboxFilesStep)({
+    await writeDatasetSandboxFilesStep({
         env,
         sandboxId,
         files: [
@@ -71,9 +68,9 @@ 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) {
-    const datasetId = params.datasetId ?? (0, admin_1.id)();
+    const datasetId = params.datasetId ?? id();
     const model = params.model ?? "openai/gpt-5";
-    let storyBuilder = (0, events_1.createContext)("file.parse")
+    let storyBuilder = createContext("file.parse")
         .context(async (stored, env) => {
         const previous = stored?.content ?? {};
         const sandboxState = previous?.sandboxState ?? { initialized: false, filePath: "" };
@@ -84,13 +81,13 @@ function createFileParseStoryDefinition(params) {
         const sandboxFilePath = await initializeSandbox(env, sandboxId, datasetId, params.fileId, sandboxState);
         let filePreview = undefined;
         try {
-            filePreview = await (0, filepreview_1.generateFilePreview)(env, sandboxId, sandboxFilePath, datasetId);
+            filePreview = await generateFilePreview(env, sandboxId, sandboxFilePath, datasetId);
         }
         catch {
             // optional
         }
         let schema = null;
-        const datasetResult = await (0, steps_3.datasetGetByIdStep)({ env, datasetId });
+        const datasetResult = await datasetGetByIdStep({ env, datasetId });
         if (datasetResult.ok && datasetResult.data.schema)
             schema = datasetResult.data.schema;
         const ctx = {
@@ -118,7 +115,7 @@ function createFileParseStoryDefinition(params) {
     })
         .narrative(async (stored) => {
         const ctx = stored?.content?.ctx;
-        const base = (0, prompts_1.buildFileDatasetPrompt)(ctx);
+        const base = buildFileDatasetPrompt(ctx);
         const userInstructions = String(ctx?.instructions ?? "").trim();
         if (!userInstructions)
             return base;
@@ -134,24 +131,24 @@ function createFileParseStoryDefinition(params) {
         .actions(async (_stored, env) => {
         const existingSchema = _stored?.content?.ctx?.schema?.schema;
         const actions = {
-            executeCommand: (0, executeCommand_tool_1.createExecuteCommandTool)({
+            executeCommand: createExecuteCommandTool({
                 datasetId,
                 sandboxId: _stored?.content?.sandboxId ?? params.sandboxId ?? "",
                 env,
             }),
-            completeDataset: (0, completeDataset_tool_1.createCompleteDatasetTool)({
+            completeDataset: createCompleteDatasetTool({
                 datasetId,
                 sandboxId: _stored?.content?.sandboxId ?? params.sandboxId ?? "",
                 env,
             }),
-            clearDataset: (0, clearDataset_tool_1.createClearDatasetTool)({
+            clearDataset: createClearDatasetTool({
                 datasetId,
                 sandboxId: _stored?.content?.sandboxId ?? params.sandboxId ?? "",
                 env,
             }),
         };
         if (!existingSchema) {
-            actions.generateSchema = (0, generateSchema_tool_1.createGenerateSchemaTool)({
+            actions.generateSchema = createGenerateSchemaTool({
                 datasetId,
                 fileId: params.fileId,
                 env,
@@ -160,7 +157,7 @@ function createFileParseStoryDefinition(params) {
         return actions;
     })
         .shouldContinue(({ reactionEvent }) => {
-        return !(0, events_1.didToolExecute)(reactionEvent, "completeDataset");
+        return !didToolExecute(reactionEvent, "completeDataset");
     });
     if (params.reactor) {
         storyBuilder = storyBuilder.reactor(params.reactor);
@@ -181,7 +178,7 @@ function createFileParseStoryDefinition(params) {
  * - All I/O happens in `"use step"` functions via Ekairos runtime (`getContextRuntime(env).db`).
  * - `parse()` is the entrypoint; it calls `story.react(...)` internally.
  */
-function createFileParseStory(fileId, opts) {
+export function createFileParseStory(fileId, opts) {
     const params = {
         fileId,
         instructions: opts?.instructions,
@@ -195,15 +192,15 @@ function createFileParseStory(fileId, opts) {
         datasetId,
         async parse(env, prompt) {
             const triggerEvent = {
-                id: (0, admin_1.id)(),
-                type: events_1.INPUT_TEXT_ITEM_TYPE,
-                channel: events_1.WEB_CHANNEL,
+                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" }],
                 },
             };
-            const runtime = (0, eventsReactRuntime_1.createEventsReactRuntime)((env ?? {}));
+            const runtime = createEventsReactRuntime((env ?? {}));
             const shell = await story.react(triggerEvent, {
                 runtime,
                 context: { key: `dataset:${datasetId}` },
@@ -217,4 +214,3 @@ function createFileParseStory(fileId, opts) {
         story,
     };
 }
-//# sourceMappingURL=file-dataset.agent.js.map

package/dist/file/filepreview.d.ts

@@ -37,4 +37,3 @@ interface PreviewOptions {
 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 {};
-//# sourceMappingURL=filepreview.d.ts.map

package/dist/file/filepreview.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensurePreviewScriptsAvailable = ensurePreviewScriptsAvailable;
-exports.generateFilePreview = generateFilePreview;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const steps_1 = require("../sandbox/steps");
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep } from "../sandbox/steps.js";
 const DEFAULT_HEAD_LINES = 50;
 const DEFAULT_TAIL_LINES = 20;
 const DEFAULT_MID_LINES = 20;
@@ -21,7 +18,7 @@ const PYTHON_SCRIPT_FILES = [
 function resolveScriptPath(scriptName) {
     // Prefer local scripts in src/ (tests/dev), and after build the scripts are copied to dist/
     // at the same relative path, so this works in both environments.
-    return (0, path_1.join)(__dirname, "scripts", scriptName);
+    return join(dirname(fileURLToPath(import.meta.url)), "scripts", scriptName);
 }
 const preparedSandboxIds = new Set();
 const sandboxSetupPromises = new Map();
@@ -37,7 +34,7 @@ function validateScriptResult(result, context) {
         throw new Error(`${context} failed: ${stderr.substring(0, 500)}`);
     }
 }
-async function ensurePreviewScriptsAvailable(env, sandboxId) {
+export async function ensurePreviewScriptsAvailable(env, sandboxId) {
     if (preparedSandboxIds.has(sandboxId)) {
         return;
     }
@@ -48,7 +45,7 @@ async function ensurePreviewScriptsAvailable(env, sandboxId) {
     }
     const setupPromise = (async () => {
         try {
-            await (0, steps_1.runDatasetSandboxCommandStep)({
+            await runDatasetSandboxCommandStep({
                 env,
                 sandboxId,
                 cmd: "mkdir",
@@ -62,7 +59,7 @@ async function ensurePreviewScriptsAvailable(env, sandboxId) {
         for (const scriptName of PYTHON_SCRIPT_FILES) {
             try {
                 const scriptPath = resolveScriptPath(scriptName);
-                const fileBuffer = (0, fs_1.readFileSync)(scriptPath);
+                const fileBuffer = readFileSync(scriptPath);
                 filesToWrite.push({
                     path: `${SANDBOX_SCRIPT_DIRECTORY}/${scriptName}`,
                     contentBase64: Buffer.from(fileBuffer).toString("base64"),
@@ -74,7 +71,7 @@ async function ensurePreviewScriptsAvailable(env, sandboxId) {
             }
         }
         if (filesToWrite.length > 0) {
-            await (0, steps_1.writeDatasetSandboxFilesStep)({
+            await writeDatasetSandboxFilesStep({
                 env,
                 sandboxId,
                 files: filesToWrite,
@@ -91,7 +88,7 @@ async function ensurePreviewScriptsAvailable(env, sandboxId) {
         throw error;
     }
 }
-async function generateFilePreview(env, sandboxId, sandboxFilePath, datasetId, options = {}) {
+export async function generateFilePreview(env, sandboxId, sandboxFilePath, datasetId, options = {}) {
     const context = {
         totalRows: 0,
     };
@@ -164,13 +161,13 @@ async function runScript(env, sandboxId, scriptName, args, description) {
     let scriptContent = "";
     try {
         const localScriptPath = resolveScriptPath(scriptName);
-        scriptContent = (0, fs_1.readFileSync)(localScriptPath, 'utf-8');
+        scriptContent = readFileSync(localScriptPath, 'utf-8');
     }
     catch (error) {
         console.warn(`Failed to read script ${scriptName}:`, error);
     }
     try {
-        const result = await (0, steps_1.runDatasetSandboxCommandStep)({
+        const result = await runDatasetSandboxCommandStep({
             env,
             sandboxId,
             cmd: "python",
@@ -194,4 +191,3 @@ async function runScript(env, sandboxId, scriptName, args, description) {
         };
     }
 }
-//# sourceMappingURL=filepreview.js.map