@ekairos/dataset 1.22.54-beta.development.0 → 1.22.56-beta.development.0

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?: {
@@ -71,3 +18,9 @@ export declare function createFileParseContext<Env extends {
     }>;
     context: any;
 };
+export declare function registerFileParseContext<Env extends {
+    orgId: string;
+}>(opts?: {
+    model?: string;
+    reactor?: ContextReactor<any, any>;
+}): void;

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, } 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,89 +15,55 @@ async function awaitContextRun(run) {
     }
     await run;
 }
-async function initializeSandbox(runtime, sandboxId, datasetId, fileId, state) {
-    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 datasetId = params.datasetId ?? id();
+    const fallbackDatasetId = params.datasetId;
     const model = params.model ?? "openai/gpt-5";
     let contextBuilder = createContext("file.parse")
         .context(async (stored, _env, runtime) => {
         const previous = stored?.content ?? {};
         const sandboxState = previous?.sandboxState ?? { initialized: false, filePath: "" };
+        const datasetId = previous?.datasetId ?? fallbackDatasetId ?? "";
+        const fileId = previous?.fileId ?? params.fileId ?? "";
+        const instructions = previous?.instructions ?? params.instructions ?? "";
         const sandboxId = previous?.sandboxId ?? params.sandboxId ?? "";
+        if (!datasetId) {
+            throw new Error("dataset_id_required");
+        }
+        if (!fileId) {
+            throw new Error("dataset_file_id_required");
+        }
         if (!sandboxId) {
             throw new Error("dataset_sandbox_required");
         }
-        const sandboxFilePath = await initializeSandbox(runtime, sandboxId, datasetId, params.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: params.fileId,
-            instructions: params.instructions ?? "",
+            fileId,
+            instructions,
             sandboxConfig: { filePath: sandboxFilePath },
             analysis: [],
             schema,
@@ -114,16 +76,16 @@ function createFileParseContextDefinition(params) {
         return {
             ...previous,
             datasetId,
-            fileId: params.fileId,
-            instructions: params.instructions ?? "",
+            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;
@@ -138,27 +100,36 @@ function createFileParseContextDefinition(params) {
     })
         .actions(async (_stored, _env, runtime) => {
         const existingSchema = _stored?.content?.ctx?.schema?.schema;
+        const datasetId = _stored?.content?.datasetId ?? fallbackDatasetId ?? "";
+        const fileId = _stored?.content?.fileId ?? params.fileId ?? "";
+        const sandboxId = _stored?.content?.sandboxId ?? params.sandboxId ?? "";
+        if (!datasetId)
+            throw new Error("dataset_id_required");
+        if (!fileId)
+            throw new Error("dataset_file_id_required");
+        if (!sandboxId)
+            throw new Error("dataset_sandbox_required");
         const actions = {
             executeCommand: createExecuteCommandTool({
                 datasetId,
-                sandboxId: _stored?.content?.sandboxId ?? params.sandboxId ?? "",
+                sandboxId,
                 runtime,
             }),
             completeDataset: createCompleteDatasetTool({
                 datasetId,
-                sandboxId: _stored?.content?.sandboxId ?? params.sandboxId ?? "",
+                sandboxId,
                 runtime,
             }),
             clearDataset: createClearDatasetTool({
                 datasetId,
-                sandboxId: _stored?.content?.sandboxId ?? params.sandboxId ?? "",
+                sandboxId,
                 runtime,
             }),
         };
         if (!existingSchema) {
             actions.generateSchema = createGenerateSchemaTool({
                 datasetId,
-                fileId: params.fileId,
+                fileId,
                 runtime,
             });
         }
@@ -174,28 +145,19 @@ function createFileParseContextDefinition(params) {
         contextBuilder = contextBuilder.model(model);
     }
     const context = contextBuilder.build();
-    return { datasetId, context };
+    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 = {
         fileId,
         instructions: opts?.instructions,
         sandboxId: opts?.sandboxId,
-        datasetId: opts?.datasetId,
+        datasetId,
         model: opts?.model,
         reactor: opts?.reactor,
     };
-    const { datasetId, context } = createFileParseContextDefinition(params);
+    const { context } = createFileParseContextDefinition(params);
     return {
         datasetId,
         async parse(runtime, options = {}) {
@@ -205,19 +167,43 @@ 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,
+                    instructions: opts?.instructions ?? "",
+                    sandboxId: opts?.sandboxId ?? "",
+                    sandboxState: { initialized: false, filePath: "" },
+                },
             });
             await awaitContextRun(shell.run);
             return { datasetId };
         },
-        // Optional: expose the built context for advanced callers (not required for parse DX)
         context,
     };
 }
+export function registerFileParseContext(opts) {
+    createFileParseContextDefinition({
+        model: opts?.model,
+        reactor: opts?.reactor,
+    }).context;
+}
+registerFileParseContext();

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

@@ -1,3 +1,4 @@
+import "./builder/materialize.js";
 export * from "./dataset.js";
 export * from "./domain.js";
 export * from "./materializeDataset.tool.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+import "./builder/materialize.js";
 export * from "./dataset.js";
 export * from "./domain.js";
 export * from "./materializeDataset.tool.js";

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: {
@@ -62,3 +20,9 @@ export declare function createTransformDatasetContext<Env extends {
     }>;
     context: any;
 };
+export declare function registerTransformDatasetContext<Env extends {
+    orgId: string;
+}>(opts?: {
+    model?: string;
+    reactor?: ContextReactor<any, any>;
+}): void;

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, } 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,66 +14,68 @@ async function awaitContextRun(run) {
     }
     await run;
 }
-async function ensureSourcesInSandbox(runtime, sandboxId, datasetId, sourceDatasetIds, state) {
-    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 datasetId = params.datasetId ?? id();
+    const fallbackDatasetId = params.datasetId;
     const model = params.model ?? "openai/gpt-5";
     let contextBuilder = createContext("dataset.transform")
         .context(async (stored, _env, runtime) => {
         const previous = stored?.content ?? {};
         const sandboxState = previous?.sandboxState ?? { initialized: false, sourcePaths: [] };
+        const datasetId = previous?.datasetId ?? fallbackDatasetId ?? "";
+        const sourceDatasetIds = Array.isArray(previous?.sourceDatasetIds)
+            ? previous.sourceDatasetIds
+            : Array.isArray(params.sourceDatasetIds)
+                ? params.sourceDatasetIds
+                : [];
+        const outputSchema = previous?.outputSchema ?? params.outputSchema;
+        const instructions = previous?.instructions ?? params.instructions;
         const sandboxId = previous?.sandboxId ?? params.sandboxId ?? "";
+        if (!datasetId) {
+            throw new Error("dataset_id_required");
+        }
+        if (sourceDatasetIds.length === 0) {
+            throw new Error("dataset_transform_sources_required");
+        }
+        if (!outputSchema) {
+            throw new Error("dataset_transform_schema_required");
+        }
         if (!sandboxId) {
             throw new Error("dataset_sandbox_required");
         }
-        const { sourcePaths, outputPath } = await ensureSourcesInSandbox(runtime, sandboxId, datasetId, params.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,
-            schema: params.outputSchema,
+            schema: outputSchema,
             status: "schema_complete",
         });
         const promptContext = {
             datasetId,
-            sourceDatasetIds: params.sourceDatasetIds,
-            outputSchema: params.outputSchema,
-            sandboxConfig: { sourcePaths, outputPath },
+            sourceDatasetIds,
+            outputSchema,
+            sandboxConfig: {
+                sourcePaths: initialized.sourcePaths,
+                outputPath: initialized.outputPath,
+            },
             sourcePreviews: sourcePreviews.length > 0 ? sourcePreviews : undefined,
             errors: [],
         };
-        const basePrompt = buildTransformDatasetPrompt(promptContext);
-        const userInstructions = String(params.instructions ?? "").trim();
+        const basePrompt = await buildTransformDatasetPromptStep({
+            context: promptContext,
+        });
+        const userInstructions = String(instructions ?? "").trim();
         const system = userInstructions
             ? [
                 "## USER INSTRUCTIONS",
@@ -90,17 +89,28 @@ function createTransformDatasetContextDefinition(params) {
         return {
             ...previous,
             datasetId,
+            sourceDatasetIds,
+            outputSchema,
+            instructions,
             sandboxId,
-            sandboxState,
+            sandboxState: initialized.state,
             system,
-            sandboxConfig: { sourcePaths, outputPath },
+            sandboxConfig: {
+                sourcePaths: initialized.sourcePaths,
+                outputPath: initialized.outputPath,
+            },
         };
     })
         .narrative(async (stored) => {
         return String(stored?.content?.system ?? "");
     })
         .actions(async (stored, _env, runtime) => {
+        const datasetId = stored?.content?.datasetId ?? fallbackDatasetId ?? "";
         const sandboxId = stored?.content?.sandboxId ?? params.sandboxId ?? "";
+        if (!datasetId)
+            throw new Error("dataset_id_required");
+        if (!sandboxId)
+            throw new Error("dataset_sandbox_required");
         return {
             executeCommand: createExecuteCommandTool({
                 datasetId,
@@ -129,14 +139,15 @@ function createTransformDatasetContextDefinition(params) {
         contextBuilder = contextBuilder.model(model);
     }
     const context = contextBuilder.build();
-    return { datasetId, context };
+    return { datasetId: fallbackDatasetId ?? "", context };
 }
 export function createTransformDatasetContext(params) {
-    const { datasetId, context } = createTransformDatasetContextDefinition({
+    const datasetId = params.datasetId ?? id();
+    const { context } = createTransformDatasetContextDefinition({
         sourceDatasetIds: params.sourceDatasetIds,
         outputSchema: params.outputSchema,
         instructions: params.instructions,
-        datasetId: params.datasetId,
+        datasetId,
         model: params.model,
         sandboxId: params.sandboxId,
         reactor: params.reactor,
@@ -166,7 +177,21 @@ 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,
+                    outputSchema: params.outputSchema,
+                    instructions: params.instructions,
+                    sandboxId: params.sandboxId ?? "",
+                    sandboxState: { initialized: false, sourcePaths: [] },
+                },
             });
             await awaitContextRun(shell.run);
             return { datasetId };
@@ -174,3 +199,10 @@ export function createTransformDatasetContext(params) {
         context,
     };
 }
+export function registerTransformDatasetContext(opts) {
+    createTransformDatasetContextDefinition({
+        model: opts?.model,
+        reactor: opts?.reactor,
+    }).context;
+}
+registerTransformDatasetContext();

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.54-beta.development.0",
+  "version": "1.22.56-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.54-beta.development.0",
-    "@ekairos/events": "^1.22.54-beta.development.0",
-    "@ekairos/sandbox": "^1.22.54-beta.development.0",
+    "@ekairos/domain": "^1.22.56-beta.development.0",
+    "@ekairos/events": "^1.22.56-beta.development.0",
+    "@ekairos/sandbox": "^1.22.56-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "ai": "^5.0.44",