@ekairos/dataset 1.22.78-beta.development.0 → 1.22.80-beta.development.0

package/dist/completeDataset.tool.js

@@ -1,19 +1,6 @@
 import { tool } from "ai";
 import { z } from "zod";
-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";
-let ajvInstance = null;
-function getAjv() {
-    if (!ajvInstance) {
-        ajvInstance = new Ajv({
-            allErrors: true,
-            strict: false,
-        });
-    }
-    return ajvInstance;
-}
+import { persistDatasetStep } from "./completeDataset.steps.js";
 export function createCompleteDatasetTool({ datasetId, sandboxId, runtime }) {
     return tool({
         description: "Mark the dataset as completed. Use only when output.jsonl has been successfully generated and is ready for validation.",
@@ -25,143 +12,12 @@ export function createCompleteDatasetTool({ datasetId, sandboxId, runtime }) {
             console.log(`[Dataset ${datasetId}] Tool: completeDataset`);
             console.log(`[Dataset ${datasetId}] Summary: ${summary}`);
             console.log(`[Dataset ${datasetId}] ========================================`);
-            const outputPath = getDatasetOutputPath(datasetId);
-            try {
-                await ensureFileExists(runtime, sandboxId, outputPath);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                console.error(`[Dataset ${datasetId}] Missing output file:`, message);
-                return {
-                    success: false,
-                    status: "missing_output",
-                    validRows: 0,
-                    rowRecordCount: 0,
-                    validation: [],
-                    error: message,
-                    message,
-                };
-            }
-            console.log(`[Dataset ${datasetId}] Validating dataset rows against schema`);
-            const datasetResult = await datasetGetByIdStep({ runtime, datasetId });
-            if (!datasetResult.ok) {
-                console.error(`[Dataset ${datasetId}] ${datasetResult.error}`);
-                return {
-                    success: false,
-                    status: "dataset_not_found",
-                    validRows: 0,
-                    rowRecordCount: 0,
-                    validation: [],
-                    error: datasetResult.error,
-                    message: datasetResult.error,
-                };
-            }
-            const datasetRecord = datasetResult.data;
-            if (!datasetRecord.schema) {
-                console.error(`[Dataset ${datasetId}] Schema not found in database`);
-                return {
-                    success: false,
-                    status: "schema_missing",
-                    validRows: 0,
-                    rowRecordCount: 0,
-                    validation: [],
-                    error: "Schema not found in database. Please generate schema first.",
-                    message: "Schema not found in database. Please generate schema first.",
-                };
-            }
-            const schemaJson = datasetRecord.schema.schema;
-            let validator;
-            try {
-                validator = getAjv().compile(schemaJson);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                console.error(`[Dataset ${datasetId}] Failed to compile schema:`, message);
-                return {
-                    success: false,
-                    status: "schema_invalid",
-                    validRows: 0,
-                    rowRecordCount: 0,
-                    validation: [],
-                    error: `Failed to compile schema: ${message}`,
-                    message: `Failed to compile schema: ${message}`,
-                };
-            }
-            const validationResult = await validateJsonlRows({
-                runtime,
-                sandboxId,
-                outputPath,
-                validator,
-                datasetId,
-            });
-            if (!validationResult.success) {
-                return validationResult;
-            }
-            const totalValidRows = validationResult.validRowCount ?? 0;
-            const rowRecordCount = validationResult.rowRecordCount ?? totalValidRows;
-            console.log(`[Dataset ${datasetId}] Reading file content for upload`);
-            const fileRead = await readDatasetSandboxFileStep({ runtime, sandboxId, path: outputPath });
-            if (!fileRead.contentBase64) {
-                console.error(`[Dataset ${datasetId}] Empty file content`);
-                return {
-                    success: false,
-                    status: "empty_output",
-                    validRows: 0,
-                    rowRecordCount: 0,
-                    validation: [],
-                    error: "Empty file content",
-                    message: "Empty file content",
-                };
-            }
-            console.log(`[Dataset ${datasetId}] Uploading file to InstantDB storage`);
-            const uploadResult = await datasetUploadOutputFileStep({
-                runtime,
-                datasetId,
-                contentBase64: fileRead.contentBase64,
-            });
-            if (!uploadResult.ok) {
-                console.error(`[Dataset ${datasetId}] File upload failed: ${uploadResult.error}`);
-                return {
-                    success: false,
-                    status: "upload_failed",
-                    validRows: totalValidRows,
-                    rowRecordCount,
-                    validation: validationResult.validation,
-                    error: uploadResult.error,
-                    message: uploadResult.error,
-                };
-            }
-            console.log(`[Dataset ${datasetId}] File uploaded successfully: ${uploadResult.data.fileId}`);
-            const statusResult = await datasetUpdateStatusStep({
+            return await persistDatasetStep({
                 runtime,
                 datasetId,
-                status: "completed",
-                calculatedTotalRows: totalValidRows,
-                actualGeneratedRowCount: totalValidRows,
+                sandboxId,
+                summary,
             });
-            if (!statusResult.ok) {
-                console.error(`[Dataset ${datasetId}] Failed to update status: ${statusResult.error}`);
-                return {
-                    success: false,
-                    status: "status_update_failed",
-                    validRows: totalValidRows,
-                    rowRecordCount,
-                    validation: validationResult.validation,
-                    error: statusResult.error,
-                    message: statusResult.error,
-                };
-            }
-            console.log(`[Dataset ${datasetId}] Dataset marked as COMPLETED (${totalValidRows} valid rows)`);
-            console.log(`[Dataset ${datasetId}] ========================================`);
-            return {
-                success: true,
-                status: "completed",
-                validRows: totalValidRows,
-                rowRecordCount,
-                fileId: uploadResult.data.fileId,
-                storagePath: uploadResult.data.storagePath,
-                message: "Dataset creation completed and uploaded to storage",
-            };
         },
     });
 }
@@ -204,117 +60,3 @@ export function getDatasetFatalFailure(event) {
     }
     return null;
 }
-async function ensureFileExists(runtime, sandboxId, path) {
-    const result = await runDatasetSandboxCommandStep({
-        runtime,
-        sandboxId,
-        cmd: "test",
-        args: ["-f", path],
-    });
-    if (result.exitCode !== 0) {
-        throw new Error(`Required file not found: ${path}`);
-    }
-}
-async function validateJsonlRows({ runtime, sandboxId, outputPath, validator, datasetId }) {
-    const validation = [];
-    let validRowCount = 0;
-    let rowRecordCount = 0;
-    console.log(`[Dataset ${datasetId}] Reading and validating JSONL file from sandbox`);
-    const fileRead = await readDatasetSandboxTextFileStep({ runtime, sandboxId, path: outputPath });
-    if (!fileRead.content) {
-        console.log(`[Dataset ${datasetId}] Empty output file`);
-        return {
-            success: false,
-            status: "empty_output",
-            validation,
-            validRowCount: 0,
-            rowRecordCount: 0,
-            error: "output.jsonl is empty",
-            message: "output.jsonl is empty",
-        };
-    }
-    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];
-        const trimmed = line.trim();
-        if (trimmed.length === 0) {
-            continue;
-        }
-        let record;
-        try {
-            record = JSON.parse(trimmed);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            validation.push({
-                index,
-                valid: false,
-                errors: [`Invalid JSON: ${message}`],
-            });
-            continue;
-        }
-        if (record.type !== "row") {
-            validation.push({
-                index,
-                valid: false,
-                errors: ["Every non-empty output line must be a JSON object with type 'row'"],
-            });
-            continue;
-        }
-        rowRecordCount++;
-        const data = record.data;
-        if (data === undefined || data === null) {
-            validation.push({
-                index,
-                valid: false,
-                errors: ["Missing 'data' field"],
-            });
-            continue;
-        }
-        const valid = validator(data);
-        if (!valid) {
-            const errors = Array.isArray(validator.errors)
-                ? validator.errors.map((err) => err.message || "Unknown validation error")
-                : ["Unknown validation error"];
-            validation.push({
-                index,
-                valid: false,
-                errors,
-                dataKeys: data && typeof data === "object" && !Array.isArray(data) ? Object.keys(data) : [],
-            });
-            continue;
-        }
-        validation.push({
-            index,
-            valid: true,
-        });
-        validRowCount++;
-    }
-    console.log(`[Dataset ${datasetId}] Validation completed: ${validRowCount} valid rows`);
-    const invalidRows = validation.filter((entry) => !entry.valid);
-    if (rowRecordCount === 0 || validRowCount === 0 || invalidRows.length > 0) {
-        const message = rowRecordCount === 0
-            ? "output.jsonl does not contain any type='row' records"
-            : validRowCount === 0
-                ? "No dataset rows matched the stored schema"
-                : `${invalidRows.length} dataset row(s) failed schema validation`;
-        console.error(`[Dataset ${datasetId}] Validation failed: ${message}`);
-        return {
-            success: false,
-            status: "validation_failed",
-            validation,
-            validRowCount,
-            rowRecordCount,
-            error: message,
-            message,
-        };
-    }
-    return {
-        success: true,
-        status: "completed",
-        validation,
-        validRowCount,
-        rowRecordCount,
-    };
-}

package/dist/dataset/steps.d.ts

@@ -1,3 +1,4 @@
+export declare function getDatasetRuntimeDb(runtime: any): Promise<any>;
 export declare function getDatasetServiceDb(runtime: any): Promise<any>;
 export declare function datasetGetByIdStep(params: {
     runtime: any;

package/dist/dataset/steps.js

@@ -1,7 +1,7 @@
 import { DatasetService } from "../service.js";
 import { datasetDomain } from "../schema.js";
 import { inferDatasetSchema } from "../builder/schemaInference.js";
-async function getRuntimeDb(runtime) {
+export async function getDatasetRuntimeDb(runtime) {
     if (!runtime) {
         throw new Error("Dataset step requires runtime.");
     }
@@ -15,17 +15,17 @@ async function getRuntimeDb(runtime) {
 }
 export async function getDatasetServiceDb(runtime) {
     "use step";
-    return await getRuntimeDb(runtime);
+    return await getDatasetRuntimeDb(runtime);
 }
 export async function datasetGetByIdStep(params) {
     "use step";
-    const db = await getRuntimeDb(params.runtime);
+    const db = await getDatasetRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     return await service.getDatasetById(params.datasetId);
 }
 export async function datasetReadOutputJsonlStep(params) {
     "use step";
-    const db = await getRuntimeDb(params.runtime);
+    const db = await getDatasetRuntimeDb(params.runtime);
     for (let attempt = 1; attempt <= 20; attempt++) {
         const query = await db.query({
             dataset_datasets: {
@@ -46,7 +46,7 @@ export async function datasetReadOutputJsonlStep(params) {
 }
 export async function datasetUpdateSchemaStep(params) {
     "use step";
-    const db = await getRuntimeDb(params.runtime);
+    const db = await getDatasetRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     return await service.updateDatasetSchema({
         datasetId: params.datasetId,
@@ -56,7 +56,7 @@ export async function datasetUpdateSchemaStep(params) {
 }
 export async function datasetUploadOutputFileStep(params) {
     "use step";
-    const db = await getRuntimeDb(params.runtime);
+    const db = await getDatasetRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     return await service.uploadDatasetOutputFile({
         datasetId: params.datasetId,
@@ -65,7 +65,7 @@ export async function datasetUploadOutputFileStep(params) {
 }
 export async function datasetUpdateStatusStep(params) {
     "use step";
-    const db = await getRuntimeDb(params.runtime);
+    const db = await getDatasetRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     return await service.updateDatasetStatus({
         datasetId: params.datasetId,
@@ -76,13 +76,13 @@ export async function datasetUpdateStatusStep(params) {
 }
 export async function datasetClearStep(params) {
     "use step";
-    const db = await getRuntimeDb(params.runtime);
+    const db = await getDatasetRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     return await service.clearDataset(params.datasetId);
 }
 export async function datasetPreviewRowsStep(params) {
     "use step";
-    const db = await getRuntimeDb(params.runtime);
+    const db = await getDatasetRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     const rowsResult = await service.previewRows(params.datasetId, params.limit ?? 20);
     if (!rowsResult.ok) {
@@ -92,7 +92,7 @@ export async function datasetPreviewRowsStep(params) {
 }
 export async function datasetReadRowsStep(params) {
     "use step";
-    const db = await getRuntimeDb(params.runtime);
+    const db = await getDatasetRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     const rowsResult = await service.readRows({
         datasetId: params.datasetId,
@@ -106,7 +106,7 @@ export async function datasetReadRowsStep(params) {
 }
 export async function datasetReadOneStep(params) {
     "use step";
-    const db = await getRuntimeDb(params.runtime);
+    const db = await getDatasetRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     const firstResult = await service.readOne(params.datasetId);
     if (!firstResult.ok) {
@@ -116,7 +116,7 @@ export async function datasetReadOneStep(params) {
 }
 export async function datasetInferAndUpdateSchemaStep(params) {
     "use step";
-    const db = await getRuntimeDb(params.runtime);
+    const db = await getDatasetRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     const readResult = await service.readRows({
         datasetId: params.datasetId,

package/dist/dataset.js

@@ -1,8 +1,8 @@
 import { buildObjectOutputInstructions } from "./builder/instructions.js";
 import { createDatasetId } from "./id.js";
-import { materializeDerivedDataset, materializeSingleFileLikeSource, } from "./builder/materialize.js";
+import { completeDatasetStep, materializeDerivedDataset, materializeSingleFileLikeSource, } from "./builder/materialize.js";
 import { materializeQuerySource } from "./builder/materializeQuery.js";
-import { finalizeBuildResult } from "./builder/persistence.js";
+import { createDatasetBuildResult, finalizeBuildResult, } from "./builder/persistence.js";
 export function dataset(runtime, options = {}) {
     const datasetId = normalizeDatasetId(options.datasetId);
     const typedRuntime = runtime;
@@ -132,13 +132,25 @@ export function dataset(runtime, options = {}) {
                     throw new Error("dataset_reactor_required");
                 }
                 await materializeSingleFileLikeSource(effectiveState, onlySource, targetDatasetId);
-                return finalizeOutputResult(await finalizeBuildResult(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
+                const completed = await completeDatasetStep({
+                    runtime: effectiveState.runtime,
+                    datasetId: targetDatasetId,
+                    schema: effectiveState.outputSchema,
+                    first: effectiveState.first,
+                });
+                return finalizeOutputResult(createDatasetBuildResult(effectiveState.runtime, completed), effectiveState.output);
             }
             if (!effectiveState.reactor) {
                 throw new Error("dataset_reactor_required");
             }
             await materializeDerivedDataset(effectiveState, targetDatasetId);
-            return finalizeOutputResult(await finalizeBuildResult(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
+            const completed = await completeDatasetStep({
+                runtime: effectiveState.runtime,
+                datasetId: targetDatasetId,
+                schema: effectiveState.outputSchema,
+                first: effectiveState.first,
+            });
+            return finalizeOutputResult(createDatasetBuildResult(effectiveState.runtime, completed), effectiveState.output);
         },
     };
     return api;

package/dist/datasetFiles.d.ts

@@ -1,4 +1,9 @@
 export declare const DATASET_OUTPUT_FILE_NAME = "output.jsonl";
 export declare function getDatasetWorkdirBase(): string;
 export declare function getDatasetWorkstation(datasetId: string): string;
+export declare function getDatasetSourcesDir(datasetId: string): string;
+export declare function getDatasetScriptsDir(datasetId: string): string;
+export declare function getDatasetArtifactsDir(datasetId: string): string;
+export declare function getDatasetLogsDir(datasetId: string): string;
+export declare function getDatasetStandardDirs(datasetId: string): string[];
 export declare function getDatasetOutputPath(datasetId: string): string;

package/dist/datasetFiles.js

@@ -21,6 +21,27 @@ export function getDatasetWorkdirBase() {
 export function getDatasetWorkstation(datasetId) {
     return `${getDatasetWorkdirBase()}/${datasetId}`;
 }
+export function getDatasetSourcesDir(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/sources`;
+}
+export function getDatasetScriptsDir(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/scripts`;
+}
+export function getDatasetArtifactsDir(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/artifacts`;
+}
+export function getDatasetLogsDir(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/logs`;
+}
+export function getDatasetStandardDirs(datasetId) {
+    return [
+        getDatasetWorkstation(datasetId),
+        getDatasetSourcesDir(datasetId),
+        getDatasetScriptsDir(datasetId),
+        getDatasetArtifactsDir(datasetId),
+        getDatasetLogsDir(datasetId),
+    ];
+}
 export function getDatasetOutputPath(datasetId) {
     return `${getDatasetWorkstation(datasetId)}/${DATASET_OUTPUT_FILE_NAME}`;
 }

package/dist/executeCommand.tool.js

@@ -1,7 +1,7 @@
 import { tool } from "ai";
 import { z } from "zod";
 import { runDatasetSandboxCommandStep, writeDatasetSandboxTextFilesStep } from "./sandbox/steps.js";
-import { getDatasetWorkstation } from "./datasetFiles.js";
+import { getDatasetScriptsDir } 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;
@@ -30,10 +30,9 @@ export function createExecuteCommandTool({ datasetId, sandboxId, runtime }) {
             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 workstation = getDatasetWorkstation(datasetId);
             const normalizedScriptName = normalizeScriptName(scriptName);
             const scriptHash = stableScriptHash(`${normalizedScriptName}\0${pythonCode}`);
-            const scriptFile = `${workstation}/${normalizedScriptName}-${scriptHash}.py`;
+            const scriptFile = `${getDatasetScriptsDir(datasetId)}/${normalizedScriptName}-${scriptHash}.py`;
             console.log(`[Dataset ${datasetId}] ========================================`);
             console.log(`[Dataset ${datasetId}] Tool: executeCommand`);
             console.log(`[Dataset ${datasetId}] Script: ${normalizedScriptName}`);

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

@@ -1,5 +1,5 @@
 import { type ContextReactor } from "@ekairos/events";
-import type { FileParseRunOptions } from "./file-dataset.types.js";
+import type { FileParseContext, FileParseRunOptions, SandboxState } 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;
@@ -9,6 +9,9 @@ export declare function createFileParseContext<Env extends {
     datasetId?: string;
     model?: string;
     reactor?: ContextReactor<any, any>;
+    sandboxState?: SandboxState;
+    filePreview?: FileParseContext["filePreview"];
+    schema?: any | null;
 }): {
     datasetId: string;
     parse(runtime: {

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

@@ -21,7 +21,8 @@ function createFileParseContextDefinition(params) {
     let contextBuilder = createContext("file.parse")
         .context(async (stored, _env, runtime) => {
         const previous = stored?.content ?? {};
-        const sandboxState = previous?.sandboxState ?? { initialized: false, filePath: "" };
+        const sandboxState = previous?.sandboxState ??
+            params.sandboxState ?? { initialized: false, filePath: "" };
         const datasetId = previous?.datasetId ?? fallbackDatasetId ?? "";
         const fileId = previous?.fileId ?? params.fileId ?? "";
         const instructions = previous?.instructions ?? params.instructions ?? "";
@@ -35,27 +36,31 @@ function createFileParseContextDefinition(params) {
         if (!sandboxId) {
             throw new Error("dataset_sandbox_required");
         }
-        const initialized = await initializeFileParseSandboxStep({
-            runtime,
-            sandboxId,
-            datasetId,
-            fileId,
-            state: sandboxState,
-        });
-        const sandboxFilePath = initialized.filePath;
-        let filePreview = undefined;
-        try {
-            filePreview = await generateFileParsePreviewStep({
+        const initialized = sandboxState.initialized && sandboxState.filePath
+            ? { filePath: sandboxState.filePath, state: sandboxState }
+            : await initializeFileParseSandboxStep({
                 runtime,
                 sandboxId,
-                sandboxFilePath,
                 datasetId,
+                fileId,
+                state: sandboxState,
             });
+        const sandboxFilePath = initialized.filePath;
+        let filePreview = previous?.filePreview ?? previous?.ctx?.filePreview ?? params.filePreview;
+        if (!filePreview) {
+            try {
+                filePreview = await generateFileParsePreviewStep({
+                    runtime,
+                    sandboxId,
+                    sandboxFilePath,
+                    datasetId,
+                });
+            }
+            catch {
+                // Preview is optional; parsing can still proceed from the file path.
+            }
         }
-        catch {
-            // Preview is optional; parsing can still proceed from the file path.
-        }
-        let schema = null;
+        let schema = previous?.ctx?.schema ?? previous?.schema ?? params.schema ?? null;
         const datasetResult = await datasetGetByIdStep({ runtime, datasetId });
         if (datasetResult.ok && datasetResult.data.schema) {
             schema = datasetResult.data.schema;
@@ -80,6 +85,7 @@ function createFileParseContextDefinition(params) {
             instructions,
             sandboxId,
             sandboxState: initialized.state,
+            filePreview,
             ctx,
         };
     })
@@ -160,6 +166,9 @@ export function createFileParseContext(fileId, opts) {
         datasetId,
         model: opts?.model,
         reactor: opts?.reactor,
+        sandboxState: opts?.sandboxState,
+        filePreview: opts?.filePreview,
+        schema: opts?.schema,
     };
     const { context } = createFileParseContextDefinition(params);
     return {
@@ -191,11 +200,14 @@ export function createFileParseContext(fileId, opts) {
                     maxModelSteps: 5,
                 },
                 __initialContent: {
+                    ...(options.initialContent ?? {}),
                     datasetId,
                     fileId,
                     instructions: opts?.instructions ?? "",
                     sandboxId: opts?.sandboxId ?? "",
-                    sandboxState: { initialized: false, filePath: "" },
+                    sandboxState: opts?.sandboxState ?? { initialized: false, filePath: "" },
+                    filePreview: opts?.filePreview,
+                    schema: opts?.schema,
                 },
             });
             await awaitContextRun(shell.run);

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

@@ -1,4 +1,4 @@
-import { getDatasetWorkstation } from "../datasetFiles.js";
+import { getDatasetSourcesDir, getDatasetStandardDirs, getDatasetWorkstation, } from "../datasetFiles.js";
 import { runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep } from "../sandbox/steps.js";
 import { buildFileDatasetPrompt } from "./prompts.js";
 import { generateFilePreview, ensurePreviewScriptsAvailable } from "./filepreview.js";
@@ -29,11 +29,11 @@ export async function initializeFileParseSandboxStep(params) {
         runtime: params.runtime,
         sandboxId: params.sandboxId,
         cmd: "mkdir",
-        args: ["-p", workstation],
+        args: ["-p", ...getDatasetStandardDirs(params.datasetId)],
     });
     const fileName = file.contentDisposition ?? "";
     const fileExtension = fileName.includes(".") ? fileName.substring(fileName.lastIndexOf(".")) : "";
-    const sandboxFilePath = `${workstation}/${params.fileId}${fileExtension}`;
+    const sandboxFilePath = `${getDatasetSourcesDir(params.datasetId)}/${params.fileId}${fileExtension}`;
     await writeDatasetSandboxFilesStep({
         runtime: params.runtime,
         sandboxId: params.sandboxId,

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

@@ -26,10 +26,14 @@ export type FileParseContextParams = {
     datasetId?: string;
     model?: string;
     reactor?: ContextReactor<any, any>;
+    sandboxState?: SandboxState;
+    filePreview?: FilePreviewContext;
+    schema?: any | null;
 };
 export type FileParseRunOptions = {
     prompt?: string;
     durable?: boolean;
+    initialContent?: Record<string, any>;
 };
 export type FileParseContextBuilder<Env extends {
     orgId: string;