@ekairos/dataset 1.22.55-beta.development.0 → 1.22.57-beta.development.0

package/dist/completeDataset.tool.d.ts

@@ -49,4 +49,9 @@ export declare function didCompleteDatasetSucceed(event: {
         parts?: any[];
     };
 }): boolean;
+export declare function getDatasetFatalFailure(event: {
+    content?: {
+        parts?: any[];
+    };
+}): string | null;
 export {};

package/dist/completeDataset.tool.js

@@ -1,6 +1,6 @@
 import { tool } from "ai";
 import { z } from "zod";
-import { readDatasetSandboxFileStep, runDatasetSandboxCommandStep } from "./sandbox/steps.js";
+import { readDatasetSandboxFileStep, readDatasetSandboxTextFileStep, runDatasetSandboxCommandStep } from "./sandbox/steps.js";
 import Ajv from "ajv";
 import { getDatasetOutputPath, } from "./datasetFiles.js";
 import { datasetGetByIdStep, datasetUpdateStatusStep, datasetUploadOutputFileStep } from "./dataset/steps.js";
@@ -113,9 +113,12 @@ export function createCompleteDatasetTool({ datasetId, sandboxId, runtime }) {
                     message: "Empty file content",
                 };
             }
-            const fileBuffer = Buffer.from(fileRead.contentBase64, "base64");
             console.log(`[Dataset ${datasetId}] Uploading file to InstantDB storage`);
-            const uploadResult = await datasetUploadOutputFileStep({ runtime, datasetId, fileBuffer });
+            const uploadResult = await datasetUploadOutputFileStep({
+                runtime,
+                datasetId,
+                contentBase64: fileRead.contentBase64,
+            });
             if (!uploadResult.ok) {
                 console.error(`[Dataset ${datasetId}] File upload failed: ${uploadResult.error}`);
                 return {
@@ -176,6 +179,31 @@ export function didCompleteDatasetSucceed(event) {
         return false;
     });
 }
+export function getDatasetFatalFailure(event) {
+    const parts = Array.isArray(event?.content?.parts) ? event.content.parts : [];
+    for (const part of parts) {
+        let actionName;
+        let output;
+        if (part?.type === "action") {
+            actionName = part.content?.actionName;
+            output = part.content?.output;
+        }
+        else if (typeof part?.type === "string" && part.type.startsWith("tool-")) {
+            actionName = part.type.slice("tool-".length);
+            output = part.output ?? part.result;
+        }
+        if (!output || output.fatal !== true) {
+            continue;
+        }
+        const message = typeof output.error === "string" && output.error.trim()
+            ? output.error.trim()
+            : typeof output.message === "string" && output.message.trim()
+                ? output.message.trim()
+                : "Dataset action failed fatally";
+        return actionName ? `${actionName}: ${message}` : message;
+    }
+    return null;
+}
 async function ensureFileExists(runtime, sandboxId, path) {
     const result = await runDatasetSandboxCommandStep({
         runtime,
@@ -192,8 +220,8 @@ async function validateJsonlRows({ runtime, sandboxId, outputPath, validator, da
     let validRowCount = 0;
     let rowRecordCount = 0;
     console.log(`[Dataset ${datasetId}] Reading and validating JSONL file from sandbox`);
-    const fileRead = await readDatasetSandboxFileStep({ runtime, sandboxId, path: outputPath });
-    if (!fileRead.contentBase64) {
+    const fileRead = await readDatasetSandboxTextFileStep({ runtime, sandboxId, path: outputPath });
+    if (!fileRead.content) {
         console.log(`[Dataset ${datasetId}] Empty output file`);
         return {
             success: false,
@@ -205,8 +233,7 @@ async function validateJsonlRows({ runtime, sandboxId, outputPath, validator, da
             message: "output.jsonl is empty",
         };
     }
-    const fileContent = Buffer.from(fileRead.contentBase64, "base64").toString();
-    const lines = fileContent.split("\n");
+    const lines = fileRead.content.split("\n");
     console.log(`[Dataset ${datasetId}] Validating ${lines.length} lines`);
     for (let index = 0; index < lines.length; index++) {
         const line = lines[index];

package/dist/dataset/steps.d.ts

@@ -18,7 +18,7 @@ export declare function datasetUpdateSchemaStep(params: {
 export declare function datasetUploadOutputFileStep(params: {
     runtime: any;
     datasetId: string;
-    fileBuffer: Buffer;
+    contentBase64: string;
 }): Promise<import("../service.js").ServiceResult<{
     fileId: string;
     storagePath: string;

package/dist/dataset/steps.js

@@ -60,7 +60,7 @@ export async function datasetUploadOutputFileStep(params) {
     const service = new DatasetService(db);
     return await service.uploadDatasetOutputFile({
         datasetId: params.datasetId,
-        fileBuffer: params.fileBuffer,
+        fileBuffer: Buffer.from(params.contentBase64, "base64"),
     });
 }
 export async function datasetUpdateStatusStep(params) {

package/dist/dataset.js

@@ -1,6 +1,6 @@
 import { id as newId } from "@instantdb/admin";
 import { buildObjectOutputInstructions } from "./builder/instructions.js";
-import { getDatasetAgentMaterializers } from "./builder/agentMaterializers.js";
+import { materializeDerivedDataset, materializeSingleFileLikeSource, } from "./builder/materialize.js";
 import { materializeQuerySource } from "./builder/materializeQuery.js";
 import { finalizeBuildResult } from "./builder/persistence.js";
 export function dataset(runtime, options = {}) {
@@ -131,13 +131,13 @@ export function dataset(runtime, options = {}) {
                 if (!effectiveState.reactor) {
                     throw new Error("dataset_reactor_required");
                 }
-                await getDatasetAgentMaterializers().materializeSingleFileLikeSource(effectiveState, onlySource, targetDatasetId);
+                await materializeSingleFileLikeSource(effectiveState, onlySource, targetDatasetId);
                 return finalizeOutputResult(await finalizeBuildResult(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
             }
             if (!effectiveState.reactor) {
                 throw new Error("dataset_reactor_required");
             }
-            await getDatasetAgentMaterializers().materializeDerivedDataset(effectiveState, targetDatasetId);
+            await materializeDerivedDataset(effectiveState, targetDatasetId);
             return finalizeOutputResult(await finalizeBuildResult(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
         },
     };

package/dist/executeCommand.tool.d.ts

@@ -7,6 +7,20 @@ export declare function createExecuteCommandTool({ datasetId, sandboxId, runtime
     pythonCode: string;
     scriptName: string;
 }, {
+    success: boolean;
+    fatal: boolean;
+    status: string;
+    error: string;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    scriptPath: string;
+    stdoutTruncated: boolean;
+    stderrTruncated: boolean;
+    stdoutOriginalLength: number;
+    stderrOriginalLength: number;
+    message?: undefined;
+} | {
     success: boolean;
     exitCode: number;
     stdout: string;
@@ -17,6 +31,8 @@ export declare function createExecuteCommandTool({ datasetId, sandboxId, runtime
     stderrTruncated: boolean;
     stdoutOriginalLength: number;
     stderrOriginalLength: number;
+    fatal?: undefined;
+    status?: undefined;
     message?: undefined;
 } | {
     success: boolean;
@@ -29,6 +45,8 @@ export declare function createExecuteCommandTool({ datasetId, sandboxId, runtime
     stderrTruncated: boolean;
     stdoutOriginalLength: number;
     stderrOriginalLength: number;
+    fatal?: undefined;
+    status?: undefined;
     error?: undefined;
 }>;
 export {};

package/dist/executeCommand.tool.js

@@ -1,39 +1,81 @@
 import { tool } from "ai";
 import { z } from "zod";
-import { runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep } from "./sandbox/steps.js";
+import { runDatasetSandboxCommandStep, writeDatasetSandboxTextFilesStep } 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 normalizeScriptName(scriptName) {
+    const normalized = String(scriptName ?? "")
+        .trim()
+        .replace(/[^a-zA-Z0-9_.-]/g, "_")
+        .replace(/_+/g, "_")
+        .slice(0, 80);
+    return normalized || "script";
+}
+function stableScriptHash(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index++) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+}
 export function createExecuteCommandTool({ datasetId, sandboxId, runtime }) {
     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: 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."),
+            scriptName: z.string().describe("Name for the script file in snake_case (e.g., 'inspect_file', 'parse_csv', 'generate_dataset'). A deterministic suffix will be appended automatically."),
         }),
         execute: async ({ pythonCode, scriptName }) => {
-            const uuid = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
             const workstation = getDatasetWorkstation(datasetId);
-            const scriptFile = `${workstation}/${scriptName}-${uuid}.py`;
+            const normalizedScriptName = normalizeScriptName(scriptName);
+            const scriptHash = stableScriptHash(`${normalizedScriptName}\0${pythonCode}`);
+            const scriptFile = `${workstation}/${normalizedScriptName}-${scriptHash}.py`;
             console.log(`[Dataset ${datasetId}] ========================================`);
             console.log(`[Dataset ${datasetId}] Tool: executeCommand`);
-            console.log(`[Dataset ${datasetId}] Script: ${scriptName}`);
+            console.log(`[Dataset ${datasetId}] Script: ${normalizedScriptName}`);
             console.log(`[Dataset ${datasetId}] File: ${scriptFile}`);
             console.log(`[Dataset ${datasetId}] Code length: ${pythonCode.length} chars`);
             console.log(`[Dataset ${datasetId}] ========================================`);
             try {
-                await writeDatasetSandboxFilesStep({
+                await writeDatasetSandboxTextFilesStep({
                     runtime,
                     sandboxId,
                     files: [
                         {
                             path: scriptFile,
-                            contentBase64: Buffer.from(pythonCode, "utf-8").toString("base64"),
+                            content: pythonCode,
                         },
                     ],
                 });
+                const written = await runDatasetSandboxCommandStep({
+                    runtime,
+                    sandboxId,
+                    cmd: "test",
+                    args: ["-f", scriptFile],
+                });
+                if (written.exitCode !== 0) {
+                    const error = `Script write verification failed: ${scriptFile}`;
+                    console.error(`[Dataset ${datasetId}] ${error}`);
+                    console.error(`[Dataset ${datasetId}] ========================================`);
+                    return {
+                        success: false,
+                        fatal: true,
+                        status: "script_write_failed",
+                        error,
+                        stdout: written.stdout || "",
+                        stderr: written.stderr || "",
+                        exitCode: written.exitCode,
+                        scriptPath: scriptFile,
+                        stdoutTruncated: false,
+                        stderrTruncated: false,
+                        stdoutOriginalLength: 0,
+                        stderrOriginalLength: 0,
+                    };
+                }
                 console.log(`[Dataset ${datasetId}] Script written to: ${scriptFile}`);
                 console.log(`[Dataset ${datasetId}] Executing: python ${scriptFile}`);
                 const result = await runDatasetSandboxCommandStep({

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

@@ -1,59 +1,6 @@
-import { createContext, type ContextReactor } from "@ekairos/events";
-import { FilePreviewContext } from "./filepreview.js";
-export type FileParseContext = {
-    datasetId: string;
-    fileId: string;
-    instructions: string;
-    sandboxConfig: {
-        filePath: string;
-    };
-    analysis: any[];
-    schema: any | null;
-    plan: any | null;
-    executionResult: any | null;
-    errors: string[];
-    iterationCount: number;
-    filePreview?: FilePreviewContext;
-};
-export type FileParseContextParams = {
-    fileId?: string;
-    instructions?: string;
-    sandboxId?: string;
-    datasetId?: string;
-    model?: string;
-    reactor?: ContextReactor<any, any>;
-};
-export type FileParseRunOptions = {
-    prompt?: string;
-    durable?: boolean;
-};
-export type FileParseContextBuilder<Env extends {
-    orgId: string;
-}> = {
-    datasetId: string;
-    context: ReturnType<ReturnType<typeof createContext<Env>>["context"]> extends any ? any : any;
-};
-export type DatasetResult = {
-    id: string;
-    status?: string;
-    title?: string;
-    schema?: any;
-    analysis?: any;
-    calculatedTotalRows?: number;
-    actualGeneratedRowCount?: number;
-    createdAt?: number;
-    updatedAt?: number;
-};
-/**
- * Factory (DX-first):
- *
- * Usage:
- *   const { datasetId } = await createFileParseContext(fileId, { instructions }).parse(runtime)
- *
- * - 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.
- */
+import { type ContextReactor } from "@ekairos/events";
+import type { FileParseRunOptions } from "./file-dataset.types.js";
+export type { DatasetResult, FileParseContext, FileParseContextBuilder, FileParseContextParams, FileParseRunOptions, SandboxState, } from "./file-dataset.types.js";
 export declare function createFileParseContext<Env extends {
     orgId: string;
 }>(fileId: string, opts?: {

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

@@ -1,15 +1,11 @@
-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, didCompleteDatasetSucceed } 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 { createContext, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL, } from "@ekairos/events";
 import { id } from "@instantdb/admin";
-import { getDatasetWorkstation } from "../datasetFiles.js";
-import { readInstantFileStep } from "./steps.js";
+import { createClearDatasetTool } from "../clearDataset.tool.js";
+import { createCompleteDatasetTool, didCompleteDatasetSucceed, getDatasetFatalFailure, } from "../completeDataset.tool.js";
 import { datasetGetByIdStep } from "../dataset/steps.js";
+import { createExecuteCommandTool } from "../executeCommand.tool.js";
+import { createGenerateSchemaTool } from "./generateSchema.tool.js";
+import { buildFileDatasetPromptStep, generateFileParsePreviewStep, initializeFileParseSandboxStep, } from "./file-dataset.steps.js";
 async function awaitContextRun(run) {
     if (!run)
         return;
@@ -19,63 +15,6 @@ async function awaitContextRun(run) {
     }
     await run;
 }
-async function initializeSandbox(runtime, sandboxId, datasetId, fileId, state) {
-    "use step";
-    if (state.initialized) {
-        return state.filePath;
-    }
-    console.log(`[FileParseContext ${datasetId}] Initializing sandbox...`);
-    await ensurePreviewScriptsAvailable(runtime, sandboxId);
-    console.log(`[FileParseContext ${datasetId}] Installing Python dependencies...`);
-    const pipInstall = await runDatasetSandboxCommandStep({
-        runtime,
-        sandboxId,
-        cmd: "python",
-        args: ["-m", "pip", "install", "pandas", "openpyxl", "--quiet", "--upgrade"],
-    });
-    const installStderr = pipInstall.stderr;
-    if (installStderr && (installStderr.includes("ERROR") || installStderr.includes("FAILED"))) {
-        throw new Error(`pip install failed: ${installStderr.substring(0, 300)}`);
-    }
-    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({
-        runtime,
-        sandboxId,
-        cmd: "mkdir",
-        args: ["-p", workstation],
-    });
-    const fileName = file.contentDisposition ?? "";
-    const fileExtension = fileName.includes(".") ? fileName.substring(fileName.lastIndexOf(".")) : "";
-    const sandboxFilePath = `${workstation}/${fileId}${fileExtension}`;
-    await writeDatasetSandboxFilesStep({
-        runtime,
-        sandboxId,
-        files: [
-            {
-                path: sandboxFilePath,
-                contentBase64: file.contentBase64,
-            },
-        ],
-    });
-    console.log(`[FileParseContext ${datasetId}] ✅ Workstation created: ${workstation}`);
-    console.log(`[FileParseContext ${datasetId}] ✅ File saved: ${sandboxFilePath}`);
-    state.filePath = sandboxFilePath;
-    state.initialized = true;
-    return sandboxFilePath;
-}
-/**
- * FileParseContext
- *
- * Uso:
- * - Crear una instancia con `fileId`, `instructions` y un `sandbox`
- * - Llamar `getDataset()` para crear un dataset nuevo (crea un datasetId interno)
- * - Llamar `followUp(datasetId, feedback)` para iterar el mismo dataset con feedback
- *
- * Internamente corre un Context (`createContext("file.parse")`) que itera hasta que se ejecuta el tool `completeDataset`.
- */
 function createFileParseContextDefinition(params) {
     const fallbackDatasetId = params.datasetId;
     const model = params.model ?? "openai/gpt-5";
@@ -96,18 +35,31 @@ function createFileParseContextDefinition(params) {
         if (!sandboxId) {
             throw new Error("dataset_sandbox_required");
         }
-        const sandboxFilePath = await initializeSandbox(runtime, sandboxId, datasetId, fileId, sandboxState);
+        const initialized = await initializeFileParseSandboxStep({
+            runtime,
+            sandboxId,
+            datasetId,
+            fileId,
+            state: sandboxState,
+        });
+        const sandboxFilePath = initialized.filePath;
         let filePreview = undefined;
         try {
-            filePreview = await generateFilePreview(runtime, sandboxId, sandboxFilePath, datasetId);
+            filePreview = await generateFileParsePreviewStep({
+                runtime,
+                sandboxId,
+                sandboxFilePath,
+                datasetId,
+            });
         }
         catch {
-            // optional
+            // Preview is optional; parsing can still proceed from the file path.
         }
         let schema = null;
         const datasetResult = await datasetGetByIdStep({ runtime, datasetId });
-        if (datasetResult.ok && datasetResult.data.schema)
+        if (datasetResult.ok && datasetResult.data.schema) {
             schema = datasetResult.data.schema;
+        }
         const ctx = {
             datasetId,
             fileId,
@@ -127,13 +79,13 @@ function createFileParseContextDefinition(params) {
             fileId,
             instructions,
             sandboxId,
-            sandboxState,
+            sandboxState: initialized.state,
             ctx,
         };
     })
         .narrative(async (stored) => {
         const ctx = stored?.content?.ctx;
-        const base = buildFileDatasetPrompt(ctx);
+        const base = await buildFileDatasetPromptStep({ context: ctx });
         const userInstructions = String(ctx?.instructions ?? "").trim();
         if (!userInstructions)
             return base;
@@ -184,6 +136,10 @@ function createFileParseContextDefinition(params) {
         return actions;
     })
         .shouldContinue(({ reactionEvent }) => {
+        const fatalFailure = getDatasetFatalFailure(reactionEvent);
+        if (fatalFailure) {
+            throw new Error(fatalFailure);
+        }
         return !didCompleteDatasetSucceed(reactionEvent);
     });
     if (params.reactor) {
@@ -195,16 +151,6 @@ function createFileParseContextDefinition(params) {
     const context = contextBuilder.build();
     return { datasetId: fallbackDatasetId ?? "", context };
 }
-/**
- * Factory (DX-first):
- *
- * Usage:
- *   const { datasetId } = await createFileParseContext(fileId, { instructions }).parse(runtime)
- *
- * - 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 createFileParseContext(fileId, opts) {
     const datasetId = opts?.datasetId ?? id();
     const params = {
@@ -225,14 +171,25 @@ export function createFileParseContext(fileId, opts) {
                 channel: WEB_CHANNEL,
                 createdAt: new Date().toISOString(),
                 content: {
-                    parts: [{ type: "text", text: options.prompt ?? "generate a dataset for this file" }],
+                    parts: [
+                        {
+                            type: "text",
+                            text: options.prompt ?? "generate a dataset for this file",
+                        },
+                    ],
                 },
             };
             const shell = await context.react(triggerEvent, {
                 runtime: runtime,
                 context: { key: `dataset:${datasetId}` },
                 durable: options.durable ?? false,
-                options: { silent: true, preventClose: true, sendFinish: false, maxIterations: 20, maxModelSteps: 5 },
+                options: {
+                    silent: true,
+                    preventClose: true,
+                    sendFinish: false,
+                    maxIterations: 20,
+                    maxModelSteps: 5,
+                },
                 __initialContent: {
                     datasetId,
                     fileId,
@@ -244,7 +201,6 @@ export function createFileParseContext(fileId, opts) {
             await awaitContextRun(shell.run);
             return { datasetId };
         },
-        // Optional: expose the built context for advanced callers (not required for parse DX)
         context,
     };
 }

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

@@ -0,0 +1,21 @@
+import type { FileParseContext, SandboxState } from "./file-dataset.types.js";
+import type { FilePreviewContext } from "./filepreview.types.js";
+export declare function initializeFileParseSandboxStep(params: {
+    runtime: any;
+    sandboxId: string;
+    datasetId: string;
+    fileId: string;
+    state: SandboxState;
+}): Promise<{
+    filePath: string;
+    state: SandboxState;
+}>;
+export declare function generateFileParsePreviewStep(params: {
+    runtime: any;
+    sandboxId: string;
+    sandboxFilePath: string;
+    datasetId: string;
+}): Promise<FilePreviewContext>;
+export declare function buildFileDatasetPromptStep(params: {
+    context: FileParseContext;
+}): Promise<string>;

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

@@ -0,0 +1,62 @@
+import { getDatasetWorkstation } from "../datasetFiles.js";
+import { runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep } from "../sandbox/steps.js";
+import { buildFileDatasetPrompt } from "./prompts.js";
+import { generateFilePreview, ensurePreviewScriptsAvailable } from "./filepreview.js";
+import { readInstantFileStep } from "./steps.js";
+export async function initializeFileParseSandboxStep(params) {
+    "use step";
+    if (params.state.initialized) {
+        return { filePath: params.state.filePath, state: params.state };
+    }
+    console.log(`[FileParseContext ${params.datasetId}] Initializing sandbox...`);
+    await ensurePreviewScriptsAvailable(params.runtime, params.sandboxId);
+    console.log(`[FileParseContext ${params.datasetId}] Installing Python dependencies...`);
+    const pipInstall = await runDatasetSandboxCommandStep({
+        runtime: params.runtime,
+        sandboxId: params.sandboxId,
+        cmd: "python",
+        args: ["-m", "pip", "install", "pandas", "openpyxl", "--quiet", "--upgrade"],
+    });
+    const installStderr = pipInstall.stderr;
+    if (installStderr && (installStderr.includes("ERROR") || installStderr.includes("FAILED"))) {
+        throw new Error(`pip install failed: ${installStderr.substring(0, 300)}`);
+    }
+    console.log(`[FileParseContext ${params.datasetId}] Fetching file from InstantDB...`);
+    const file = await readInstantFileStep({ runtime: params.runtime, fileId: params.fileId });
+    console.log(`[FileParseContext ${params.datasetId}] Creating dataset workstation...`);
+    const workstation = getDatasetWorkstation(params.datasetId);
+    await runDatasetSandboxCommandStep({
+        runtime: params.runtime,
+        sandboxId: params.sandboxId,
+        cmd: "mkdir",
+        args: ["-p", workstation],
+    });
+    const fileName = file.contentDisposition ?? "";
+    const fileExtension = fileName.includes(".") ? fileName.substring(fileName.lastIndexOf(".")) : "";
+    const sandboxFilePath = `${workstation}/${params.fileId}${fileExtension}`;
+    await writeDatasetSandboxFilesStep({
+        runtime: params.runtime,
+        sandboxId: params.sandboxId,
+        files: [
+            {
+                path: sandboxFilePath,
+                contentBase64: file.contentBase64,
+            },
+        ],
+    });
+    console.log(`[FileParseContext ${params.datasetId}] Workstation created: ${workstation}`);
+    console.log(`[FileParseContext ${params.datasetId}] File saved: ${sandboxFilePath}`);
+    const state = {
+        initialized: true,
+        filePath: sandboxFilePath,
+    };
+    return { filePath: sandboxFilePath, state };
+}
+export async function generateFileParsePreviewStep(params) {
+    "use step";
+    return await generateFilePreview(params.runtime, params.sandboxId, params.sandboxFilePath, params.datasetId);
+}
+export async function buildFileDatasetPromptStep(params) {
+    "use step";
+    return buildFileDatasetPrompt(params.context);
+}

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

@@ -0,0 +1,50 @@
+import type { ContextReactor } from "@ekairos/events";
+import type { FilePreviewContext } from "./filepreview.types.js";
+export type SandboxState = {
+    initialized: boolean;
+    filePath: string;
+};
+export type FileParseContext = {
+    datasetId: string;
+    fileId: string;
+    instructions: string;
+    sandboxConfig: {
+        filePath: string;
+    };
+    analysis: any[];
+    schema: any | null;
+    plan: any | null;
+    executionResult: any | null;
+    errors: string[];
+    iterationCount: number;
+    filePreview?: FilePreviewContext;
+};
+export type FileParseContextParams = {
+    fileId?: string;
+    instructions?: string;
+    sandboxId?: string;
+    datasetId?: string;
+    model?: string;
+    reactor?: ContextReactor<any, any>;
+};
+export type FileParseRunOptions = {
+    prompt?: string;
+    durable?: boolean;
+};
+export type FileParseContextBuilder<Env extends {
+    orgId: string;
+}> = {
+    datasetId: string;
+    context: any;
+};
+export type DatasetResult = {
+    id: string;
+    status?: string;
+    title?: string;
+    schema?: any;
+    analysis?: any;
+    calculatedTotalRows?: number;
+    actualGeneratedRowCount?: number;
+    createdAt?: number;
+    updatedAt?: number;
+};

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

@@ -0,0 +1 @@
+export {};

package/dist/file/filepreview.d.ts

@@ -1,34 +1,5 @@
-export type FilePreviewContext = {
-    totalRows: number;
-    metadata?: {
-        description: string;
-        script: string;
-        command: string;
-        stdout: string;
-        stderr: string;
-    };
-    head?: {
-        description: string;
-        script: string;
-        command: string;
-        stdout: string;
-        stderr: string;
-    };
-    tail?: {
-        description: string;
-        script: string;
-        command: string;
-        stdout: string;
-        stderr: string;
-    };
-    mid?: {
-        description: string;
-        script: string;
-        command: string;
-        stdout: string;
-        stderr: string;
-    };
-};
+import type { FilePreviewContext } from "./filepreview.types.js";
+export type { FilePreviewContext } from "./filepreview.types.js";
 interface PreviewOptions {
     headLines?: number;
     tailLines?: number;
@@ -36,4 +7,3 @@ interface PreviewOptions {
 }
 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.types.d.ts

@@ -0,0 +1,31 @@
+export type FilePreviewContext = {
+    totalRows: number;
+    metadata?: {
+        description: string;
+        script: string;
+        command: string;
+        stdout: string;
+        stderr: string;
+    };
+    head?: {
+        description: string;
+        script: string;
+        command: string;
+        stdout: string;
+        stderr: string;
+    };
+    tail?: {
+        description: string;
+        script: string;
+        command: string;
+        stdout: string;
+        stderr: string;
+    };
+    mid?: {
+        description: string;
+        script: string;
+        command: string;
+        stdout: string;
+        stderr: string;
+    };
+};

package/dist/file/filepreview.types.js

@@ -0,0 +1 @@
+export {};

package/dist/file/prompts.d.ts

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

package/dist/index.d.ts

@@ -3,3 +3,5 @@ export * from "./domain.js";
 export * from "./materializeDataset.tool.js";
 export * from "./schema.js";
 export * from "./service.js";
+export { registerFileParseContext } from "./file/file-dataset.agent.js";
+export { registerTransformDatasetContext } from "./transform/index.js";

package/dist/index.js

@@ -3,3 +3,5 @@ export * from "./domain.js";
 export * from "./materializeDataset.tool.js";
 export * from "./schema.js";
 export * from "./service.js";
+export { registerFileParseContext } from "./file/file-dataset.agent.js";
+export { registerTransformDatasetContext } from "./transform/index.js";

package/dist/sandbox/steps.d.ts

@@ -27,6 +27,14 @@ export declare function writeDatasetSandboxFilesStep(params: {
         contentBase64: string;
     }>;
 }): Promise<void>;
+export declare function writeDatasetSandboxTextFilesStep(params: {
+    runtime: any;
+    sandboxId: DatasetSandboxId;
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+}): Promise<void>;
 export declare function readDatasetSandboxFileStep(params: {
     runtime: any;
     sandboxId: DatasetSandboxId;
@@ -34,6 +42,13 @@ export declare function readDatasetSandboxFileStep(params: {
 }): Promise<{
     contentBase64: string;
 }>;
+export declare function readDatasetSandboxTextFileStep(params: {
+    runtime: any;
+    sandboxId: DatasetSandboxId;
+    path: string;
+}): Promise<{
+    content: string;
+}>;
 export declare function stopDatasetSandboxStep(params: {
     runtime: any;
     sandboxId: DatasetSandboxId;

package/dist/sandbox/steps.js

@@ -117,6 +117,25 @@ export async function writeDatasetSandboxFilesStep(params) {
     if (!result.ok)
         throw new Error(result.error);
 }
+export async function writeDatasetSandboxTextFilesStep(params) {
+    "use step";
+    if (isLocalDatasetSandboxMode()) {
+        for (const file of params.files) {
+            await fs.mkdir(path.dirname(file.path), { recursive: true });
+            await fs.writeFile(file.path, file.content, "utf-8");
+        }
+        return;
+    }
+    const db = await getRuntimeDb(params.runtime);
+    const service = new SandboxService(db);
+    const files = params.files.map((file) => ({
+        path: file.path,
+        contentBase64: Buffer.from(file.content, "utf-8").toString("base64"),
+    }));
+    const result = await service.writeFiles(params.sandboxId, files);
+    if (!result.ok)
+        throw new Error(result.error);
+}
 export async function readDatasetSandboxFileStep(params) {
     "use step";
     if (isLocalDatasetSandboxMode()) {
@@ -130,6 +149,19 @@ export async function readDatasetSandboxFileStep(params) {
         throw new Error(result.error);
     return result.data;
 }
+export async function readDatasetSandboxTextFileStep(params) {
+    "use step";
+    if (isLocalDatasetSandboxMode()) {
+        const content = await fs.readFile(params.path, "utf-8");
+        return { content };
+    }
+    const db = await getRuntimeDb(params.runtime);
+    const service = new SandboxService(db);
+    const result = await service.readFile(params.sandboxId, params.path);
+    if (!result.ok)
+        throw new Error(result.error);
+    return { content: Buffer.from(result.data.contentBase64, "base64").toString("utf-8") };
+}
 export async function stopDatasetSandboxStep(params) {
     "use step";
     if (isLocalDatasetSandboxMode()) {

package/dist/transform/index.d.ts

@@ -1,2 +1,2 @@
-export { createTransformDatasetContext, type TransformDatasetAgentParams, type TransformDatasetContext, } from "./transform-dataset.agent.js";
+export { createTransformDatasetContext, registerTransformDatasetContext, type TransformDatasetAgentParams, type TransformDatasetContext, type TransformDatasetRunOptions, } from "./transform-dataset.agent.js";
 export { transformDataset, type TransformDatasetInput, type TransformDatasetResult, } from "./transformDataset.js";

package/dist/transform/index.js

@@ -1,2 +1,2 @@
-export { createTransformDatasetContext, } from "./transform-dataset.agent.js";
+export { createTransformDatasetContext, registerTransformDatasetContext, } from "./transform-dataset.agent.js";
 export { transformDataset, } from "./transformDataset.js";

package/dist/transform/prompts.d.ts

@@ -1,34 +1,2 @@
-export type TransformPromptContext = {
-    datasetId: string;
-    sourceDatasetIds: string[];
-    outputSchema: any;
-    sandboxConfig: {
-        sourcePaths: Array<{
-            datasetId: string;
-            path: string;
-        }>;
-        outputPath: string;
-    };
-    sourcePreviews?: Array<{
-        datasetId: string;
-        preview: {
-            totalRows: number;
-            metadata?: {
-                description: string;
-                script: string;
-                command: string;
-                stdout: string;
-                stderr: string;
-            };
-            head?: {
-                description: string;
-                script: string;
-                command: string;
-                stdout: string;
-                stderr: string;
-            };
-        };
-    }>;
-    errors: string[];
-};
+import type { TransformPromptContext } from "./transform-dataset.types.js";
 export declare function buildTransformDatasetPrompt(context: TransformPromptContext): string;

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

@@ -1,48 +1,6 @@
 import { type ContextReactor } from "@ekairos/events";
-import { TransformSourcePreviewContext } from "./filepreview.js";
-export type TransformDatasetContext = {
-    datasetId: string;
-    sourceDatasetIds: string[];
-    outputSchema: any;
-    sandboxConfig: {
-        sourcePaths: Array<{
-            datasetId: string;
-            path: string;
-        }>;
-        outputPath: string;
-    };
-    sourcePreviews?: Array<{
-        datasetId: string;
-        preview: TransformSourcePreviewContext;
-    }>;
-    errors: string[];
-    iterationCount: number;
-    instructions?: string;
-};
-export type TransformDatasetAgentParams = {
-    sourceDatasetIds?: string[];
-    outputSchema?: any;
-    instructions?: string;
-    datasetId?: string;
-    model?: string;
-    sandboxId?: string;
-    reactor?: ContextReactor<any, any>;
-};
-export type TransformDatasetRunOptions = {
-    prompt?: string;
-    durable?: boolean;
-};
-export type TransformDatasetResult = {
-    id: string;
-    status?: string;
-    title?: string;
-    schema?: any;
-    analysis?: any;
-    calculatedTotalRows?: number;
-    actualGeneratedRowCount?: number;
-    createdAt?: number;
-    updatedAt?: number;
-};
+import type { TransformDatasetRunOptions } from "./transform-dataset.types.js";
+export type { TransformDatasetAgentParams, TransformDatasetContext, TransformDatasetResult, TransformDatasetRunOptions, TransformPromptContext, TransformSandboxState, } from "./transform-dataset.types.js";
 export declare function createTransformDatasetContext<Env extends {
     orgId: string;
 }>(params: {

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

@@ -1,13 +1,10 @@
-import { createContext, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL } from "@ekairos/events";
-import { createCompleteDatasetTool, didCompleteDatasetSucceed } from "../completeDataset.tool.js";
-import { createExecuteCommandTool } from "../executeCommand.tool.js";
-import { createClearDatasetTool } from "../clearDataset.tool.js";
-import { buildTransformDatasetPrompt } from "./prompts.js";
-import { getDatasetWorkstation, getDatasetOutputPath } from "../datasetFiles.js";
+import { createContext, INPUT_TEXT_ITEM_TYPE, WEB_CHANNEL, } from "@ekairos/events";
 import { id } from "@instantdb/admin";
-import { generateSourcePreview } from "./filepreview.js";
-import { datasetReadOutputJsonlStep, datasetUpdateSchemaStep } from "../dataset/steps.js";
-import { runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep } from "../sandbox/steps.js";
+import { createClearDatasetTool } from "../clearDataset.tool.js";
+import { createCompleteDatasetTool, didCompleteDatasetSucceed, getDatasetFatalFailure, } from "../completeDataset.tool.js";
+import { datasetUpdateSchemaStep } from "../dataset/steps.js";
+import { createExecuteCommandTool } from "../executeCommand.tool.js";
+import { buildTransformDatasetPromptStep, ensureTransformSourcesInSandboxStep, generateTransformSourcePreviewsStep, } from "./transform-dataset.steps.js";
 async function awaitContextRun(run) {
     if (!run)
         return;
@@ -17,28 +14,6 @@ async function awaitContextRun(run) {
     }
     await run;
 }
-async function ensureSourcesInSandbox(runtime, sandboxId, datasetId, sourceDatasetIds, state) {
-    "use step";
-    if (state.initialized) {
-        return { sourcePaths: state.sourcePaths, outputPath: getDatasetOutputPath(datasetId) };
-    }
-    const workstation = getDatasetWorkstation(datasetId);
-    await runDatasetSandboxCommandStep({ runtime, sandboxId, cmd: "mkdir", args: ["-p", workstation] });
-    const sourcePaths = [];
-    for (const sourceDatasetId of sourceDatasetIds) {
-        const sourcePath = `${workstation}/source_${sourceDatasetId}.jsonl`;
-        const source = await datasetReadOutputJsonlStep({ runtime, datasetId: sourceDatasetId });
-        await writeDatasetSandboxFilesStep({
-            runtime,
-            sandboxId,
-            files: [{ path: sourcePath, contentBase64: source.contentBase64 }],
-        });
-        sourcePaths.push({ datasetId: sourceDatasetId, path: sourcePath });
-    }
-    state.sourcePaths = sourcePaths;
-    state.initialized = true;
-    return { sourcePaths, outputPath: getDatasetOutputPath(datasetId) };
-}
 function createTransformDatasetContextDefinition(params) {
     const fallbackDatasetId = params.datasetId;
     const model = params.model ?? "openai/gpt-5";
@@ -67,18 +42,19 @@ function createTransformDatasetContextDefinition(params) {
         if (!sandboxId) {
             throw new Error("dataset_sandbox_required");
         }
-        const { sourcePaths, outputPath } = await ensureSourcesInSandbox(runtime, sandboxId, datasetId, sourceDatasetIds, sandboxState);
-        const sourcePreviews = [];
-        for (const sp of sourcePaths) {
-            try {
-                const preview = await generateSourcePreview(runtime, sandboxId, sp.path, datasetId);
-                sourcePreviews.push({ datasetId: sp.datasetId, preview });
-            }
-            catch {
-                // optional
-            }
-        }
-        // Persist output schema on the dataset record (so completeDataset validates against it)
+        const initialized = await ensureTransformSourcesInSandboxStep({
+            runtime,
+            sandboxId,
+            datasetId,
+            sourceDatasetIds,
+            state: sandboxState,
+        });
+        const sourcePreviews = await generateTransformSourcePreviewsStep({
+            runtime,
+            sandboxId,
+            datasetId,
+            sourcePaths: initialized.sourcePaths,
+        });
         await datasetUpdateSchemaStep({
             runtime,
             datasetId,
@@ -89,11 +65,16 @@ function createTransformDatasetContextDefinition(params) {
             datasetId,
             sourceDatasetIds,
             outputSchema,
-            sandboxConfig: { sourcePaths, outputPath },
+            sandboxConfig: {
+                sourcePaths: initialized.sourcePaths,
+                outputPath: initialized.outputPath,
+            },
             sourcePreviews: sourcePreviews.length > 0 ? sourcePreviews : undefined,
             errors: [],
         };
-        const basePrompt = buildTransformDatasetPrompt(promptContext);
+        const basePrompt = await buildTransformDatasetPromptStep({
+            context: promptContext,
+        });
         const userInstructions = String(instructions ?? "").trim();
         const system = userInstructions
             ? [
@@ -112,9 +93,12 @@ function createTransformDatasetContextDefinition(params) {
             outputSchema,
             instructions,
             sandboxId,
-            sandboxState,
+            sandboxState: initialized.state,
             system,
-            sandboxConfig: { sourcePaths, outputPath },
+            sandboxConfig: {
+                sourcePaths: initialized.sourcePaths,
+                outputPath: initialized.outputPath,
+            },
         };
     })
         .narrative(async (stored) => {
@@ -146,6 +130,10 @@ function createTransformDatasetContextDefinition(params) {
         };
     })
         .shouldContinue(({ reactionEvent }) => {
+        const fatalFailure = getDatasetFatalFailure(reactionEvent);
+        if (fatalFailure) {
+            throw new Error(fatalFailure);
+        }
         return !didCompleteDatasetSucceed(reactionEvent);
     });
     if (params.reactor) {
@@ -193,7 +181,13 @@ export function createTransformDatasetContext(params) {
                 runtime: runtime,
                 context: { key: `dataset:${datasetId}` },
                 durable: options.durable ?? false,
-                options: { silent: true, preventClose: true, sendFinish: false, maxIterations: 20, maxModelSteps: 5 },
+                options: {
+                    silent: true,
+                    preventClose: true,
+                    sendFinish: false,
+                    maxIterations: 20,
+                    maxModelSteps: 5,
+                },
                 __initialContent: {
                     datasetId,
                     sourceDatasetIds: params.sourceDatasetIds,

package/dist/transform/transform-dataset.steps.d.ts

@@ -0,0 +1,30 @@
+import type { TransformPromptContext, TransformSandboxState, TransformSourcePreviewContext } from "./transform-dataset.types.js";
+export declare function ensureTransformSourcesInSandboxStep(params: {
+    runtime: any;
+    sandboxId: string;
+    datasetId: string;
+    sourceDatasetIds: string[];
+    state: TransformSandboxState;
+}): Promise<{
+    sourcePaths: Array<{
+        datasetId: string;
+        path: string;
+    }>;
+    outputPath: string;
+    state: TransformSandboxState;
+}>;
+export declare function generateTransformSourcePreviewsStep(params: {
+    runtime: any;
+    sandboxId: string;
+    datasetId: string;
+    sourcePaths: Array<{
+        datasetId: string;
+        path: string;
+    }>;
+}): Promise<Array<{
+    datasetId: string;
+    preview: TransformSourcePreviewContext;
+}>>;
+export declare function buildTransformDatasetPromptStep(params: {
+    context: TransformPromptContext;
+}): Promise<string>;

package/dist/transform/transform-dataset.steps.js

@@ -0,0 +1,62 @@
+import { getDatasetOutputPath, getDatasetWorkstation } from "../datasetFiles.js";
+import { datasetReadOutputJsonlStep } from "../dataset/steps.js";
+import { runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep } from "../sandbox/steps.js";
+import { generateSourcePreview } from "./filepreview.js";
+import { buildTransformDatasetPrompt } from "./prompts.js";
+export async function ensureTransformSourcesInSandboxStep(params) {
+    "use step";
+    if (params.state.initialized) {
+        return {
+            sourcePaths: params.state.sourcePaths,
+            outputPath: getDatasetOutputPath(params.datasetId),
+            state: params.state,
+        };
+    }
+    const workstation = getDatasetWorkstation(params.datasetId);
+    await runDatasetSandboxCommandStep({
+        runtime: params.runtime,
+        sandboxId: params.sandboxId,
+        cmd: "mkdir",
+        args: ["-p", workstation],
+    });
+    const sourcePaths = [];
+    for (const sourceDatasetId of params.sourceDatasetIds) {
+        const sourcePath = `${workstation}/source_${sourceDatasetId}.jsonl`;
+        const source = await datasetReadOutputJsonlStep({
+            runtime: params.runtime,
+            datasetId: sourceDatasetId,
+        });
+        await writeDatasetSandboxFilesStep({
+            runtime: params.runtime,
+            sandboxId: params.sandboxId,
+            files: [{ path: sourcePath, contentBase64: source.contentBase64 }],
+        });
+        sourcePaths.push({ datasetId: sourceDatasetId, path: sourcePath });
+    }
+    return {
+        sourcePaths,
+        outputPath: getDatasetOutputPath(params.datasetId),
+        state: {
+            initialized: true,
+            sourcePaths,
+        },
+    };
+}
+export async function generateTransformSourcePreviewsStep(params) {
+    "use step";
+    const sourcePreviews = [];
+    for (const sourcePath of params.sourcePaths) {
+        try {
+            const preview = await generateSourcePreview(params.runtime, params.sandboxId, sourcePath.path, params.datasetId);
+            sourcePreviews.push({ datasetId: sourcePath.datasetId, preview });
+        }
+        catch {
+            // Source preview is optional; transformation can still read the JSONL files.
+        }
+    }
+    return sourcePreviews;
+}
+export async function buildTransformDatasetPromptStep(params) {
+    "use step";
+    return buildTransformDatasetPrompt(params.context);
+}

package/dist/transform/transform-dataset.types.d.ts

@@ -0,0 +1,86 @@
+import type { ContextReactor } from "@ekairos/events";
+import type { TransformSourcePreviewContext } from "./filepreview.js";
+export type { TransformSourcePreviewContext } from "./filepreview.js";
+export type TransformSandboxState = {
+    initialized: boolean;
+    sourcePaths: Array<{
+        datasetId: string;
+        path: string;
+    }>;
+};
+export type TransformDatasetContext = {
+    datasetId: string;
+    sourceDatasetIds: string[];
+    outputSchema: any;
+    sandboxConfig: {
+        sourcePaths: Array<{
+            datasetId: string;
+            path: string;
+        }>;
+        outputPath: string;
+    };
+    sourcePreviews?: Array<{
+        datasetId: string;
+        preview: TransformSourcePreviewContext;
+    }>;
+    errors: string[];
+    iterationCount: number;
+    instructions?: string;
+};
+export type TransformDatasetAgentParams = {
+    sourceDatasetIds?: string[];
+    outputSchema?: any;
+    instructions?: string;
+    datasetId?: string;
+    model?: string;
+    sandboxId?: string;
+    reactor?: ContextReactor<any, any>;
+};
+export type TransformDatasetRunOptions = {
+    prompt?: string;
+    durable?: boolean;
+};
+export type TransformDatasetResult = {
+    id: string;
+    status?: string;
+    title?: string;
+    schema?: any;
+    analysis?: any;
+    calculatedTotalRows?: number;
+    actualGeneratedRowCount?: number;
+    createdAt?: number;
+    updatedAt?: number;
+};
+export type TransformPromptContext = {
+    datasetId: string;
+    sourceDatasetIds: string[];
+    outputSchema: any;
+    sandboxConfig: {
+        sourcePaths: Array<{
+            datasetId: string;
+            path: string;
+        }>;
+        outputPath: string;
+    };
+    sourcePreviews?: Array<{
+        datasetId: string;
+        preview: {
+            totalRows: number;
+            metadata?: {
+                description: string;
+                script: string;
+                command: string;
+                stdout: string;
+                stderr: string;
+            };
+            head?: {
+                description: string;
+                script: string;
+                command: string;
+                stdout: string;
+                stderr: string;
+            };
+        };
+    }>;
+    errors: string[];
+};

package/dist/transform/transform-dataset.types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/dataset",
-  "version": "1.22.55-beta.development.0",
+  "version": "1.22.57-beta.development.0",
   "description": "Pulzar Dataset Tools",
   "type": "module",
   "main": "dist/index.js",
@@ -65,9 +65,9 @@
     "test:ai-sdk:instant": "vitest run -c vitest.codex.config.mts src/tests/materializeDataset.ai-sdk.instant.test.ts"
   },
   "dependencies": {
-    "@ekairos/domain": "^1.22.55-beta.development.0",
-    "@ekairos/events": "^1.22.55-beta.development.0",
-    "@ekairos/sandbox": "^1.22.55-beta.development.0",
+    "@ekairos/domain": "^1.22.57-beta.development.0",
+    "@ekairos/events": "^1.22.57-beta.development.0",
+    "@ekairos/sandbox": "^1.22.57-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "ai": "^5.0.44",