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

package/dist/completeDataset.tool.js

@@ -14,7 +14,7 @@ function getAjv() {
     }
     return ajvInstance;
 }
-export function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
+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.",
         inputSchema: z.object({
@@ -27,23 +27,33 @@ export function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
             console.log(`[Dataset ${datasetId}] ========================================`);
             const outputPath = getDatasetOutputPath(datasetId);
             try {
-                await ensureFileExists(env, sandboxId, outputPath);
+                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({ env, datasetId });
+            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;
@@ -51,7 +61,12 @@ export function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
                 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;
@@ -64,11 +79,16 @@ export function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
                 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({
-                env,
+                runtime,
                 sandboxId,
                 outputPath,
                 validator,
@@ -77,29 +97,40 @@ export function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
             if (!validationResult.success) {
                 return validationResult;
             }
-            const totalValidRows = validationResult.validRowCount;
+            const totalValidRows = validationResult.validRowCount ?? 0;
+            const rowRecordCount = validationResult.rowRecordCount ?? totalValidRows;
             console.log(`[Dataset ${datasetId}] Reading file content for upload`);
-            const fileRead = await readDatasetSandboxFileStep({ env, sandboxId, path: outputPath });
+            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",
                 };
             }
             const fileBuffer = Buffer.from(fileRead.contentBase64, "base64");
             console.log(`[Dataset ${datasetId}] Uploading file to InstantDB storage`);
-            const uploadResult = await datasetUploadOutputFileStep({ env, datasetId, fileBuffer });
+            const uploadResult = await datasetUploadOutputFileStep({ runtime, datasetId, fileBuffer });
             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({
-                env,
+                runtime,
                 datasetId,
                 status: "completed",
                 calculatedTotalRows: totalValidRows,
@@ -109,14 +140,21 @@ export function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
                 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",
@@ -124,9 +162,23 @@ export function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
         },
     });
 }
-async function ensureFileExists(env, sandboxId, path) {
+export function didCompleteDatasetSucceed(event) {
+    const parts = Array.isArray(event?.content?.parts) ? event.content.parts : [];
+    return parts.some((part) => {
+        if (part?.type === "action" && part?.content?.actionName === "completeDataset") {
+            const output = part.content.output;
+            return part.content.status === "completed" && output?.success === true && output?.status === "completed";
+        }
+        if (part?.type === "tool-completeDataset") {
+            const output = part.output ?? part.result;
+            return part.state === "output-available" && output?.success === true && output?.status === "completed";
+        }
+        return false;
+    });
+}
+async function ensureFileExists(runtime, sandboxId, path) {
     const result = await runDatasetSandboxCommandStep({
-        env,
+        runtime,
         sandboxId,
         cmd: "test",
         args: ["-f", path],
@@ -135,14 +187,23 @@ async function ensureFileExists(env, sandboxId, path) {
         throw new Error(`Required file not found: ${path}`);
     }
 }
-async function validateJsonlRows({ env, sandboxId, outputPath, validator, datasetId }) {
+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 readDatasetSandboxFileStep({ env, sandboxId, path: outputPath });
+    const fileRead = await readDatasetSandboxFileStep({ runtime, sandboxId, path: outputPath });
     if (!fileRead.contentBase64) {
         console.log(`[Dataset ${datasetId}] Empty output file`);
-        return { success: true, validation, validRowCount: 0 };
+        return {
+            success: false,
+            status: "empty_output",
+            validation,
+            validRowCount: 0,
+            rowRecordCount: 0,
+            error: "output.jsonl is empty",
+            message: "output.jsonl is empty",
+        };
     }
     const fileContent = Buffer.from(fileRead.contentBase64, "base64").toString();
     const lines = fileContent.split("\n");
@@ -167,8 +228,14 @@ async function validateJsonlRows({ env, sandboxId, outputPath, validator, datase
             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({
@@ -187,6 +254,7 @@ async function validateJsonlRows({ env, sandboxId, outputPath, validator, datase
                 index,
                 valid: false,
                 errors,
+                dataKeys: data && typeof data === "object" && !Array.isArray(data) ? Object.keys(data) : [],
             });
             continue;
         }
@@ -197,9 +265,29 @@ async function validateJsonlRows({ env, sandboxId, outputPath, validator, datase
         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,22 +1,22 @@
-export declare function getDatasetServiceDb(env?: any): Promise<any>;
+export declare function getDatasetServiceDb(runtime: any): Promise<any>;
 export declare function datasetGetByIdStep(params: {
-    env?: any;
+    runtime: any;
     datasetId: string;
 }): Promise<import("../service.js").ServiceResult<any>>;
 export declare function datasetReadOutputJsonlStep(params: {
-    env?: any;
+    runtime: any;
     datasetId: string;
 }): Promise<{
     contentBase64: string;
 }>;
 export declare function datasetUpdateSchemaStep(params: {
-    env?: any;
+    runtime: any;
     datasetId: string;
     schema: any;
     status?: string;
 }): Promise<import("../service.js").ServiceResult<void>>;
 export declare function datasetUploadOutputFileStep(params: {
-    env?: any;
+    runtime: any;
     datasetId: string;
     fileBuffer: Buffer;
 }): Promise<import("../service.js").ServiceResult<{
@@ -24,22 +24,46 @@ export declare function datasetUploadOutputFileStep(params: {
     storagePath: string;
 }>>;
 export declare function datasetUpdateStatusStep(params: {
-    env?: any;
+    runtime: any;
     datasetId: string;
     status: string;
     calculatedTotalRows?: number;
     actualGeneratedRowCount?: number;
 }): Promise<import("../service.js").ServiceResult<void>>;
 export declare function datasetClearStep(params: {
-    env?: any;
+    runtime: any;
     datasetId: string;
 }): Promise<import("../service.js").ServiceResult<{
     deletedCount: number;
 }>>;
 export declare function datasetPreviewRowsStep(params: {
-    env?: any;
+    runtime: any;
     datasetId: string;
     limit?: number;
 }): Promise<{
     rows: any[];
 }>;
+export declare function datasetReadRowsStep(params: {
+    runtime: any;
+    datasetId: string;
+    cursor?: number;
+    limit?: number;
+}): Promise<{
+    rows: any[];
+    cursor: number;
+    done: boolean;
+}>;
+export declare function datasetReadOneStep(params: {
+    runtime: any;
+    datasetId: string;
+}): Promise<{
+    row: any | null;
+}>;
+export declare function datasetInferAndUpdateSchemaStep(params: {
+    runtime: any;
+    datasetId: string;
+    title?: string;
+    description?: string;
+}): Promise<{
+    schema: import("../dataset.js").DatasetSchemaInput;
+}>;

package/dist/dataset/steps.js

@@ -1,22 +1,31 @@
-import { getContextRuntime, getContextEnv } from "@ekairos/events/runtime";
 import { DatasetService } from "../service.js";
-async function resolveEnv(env) {
-    return env ?? (await getContextEnv());
+import { datasetDomain } from "../schema.js";
+import { inferDatasetSchema } from "../builder/schemaInference.js";
+async function getRuntimeDb(runtime) {
+    if (!runtime) {
+        throw new Error("Dataset step requires runtime.");
+    }
+    if (typeof runtime.use === "function") {
+        const scoped = await runtime.use(datasetDomain);
+        const scopedDb = scoped.db;
+        return typeof scopedDb === "function" ? await scopedDb.call(scoped) : scopedDb;
+    }
+    const db = runtime.db;
+    return typeof db === "function" ? await db.call(runtime) : db;
 }
-export async function getDatasetServiceDb(env) {
+export async function getDatasetServiceDb(runtime) {
     "use step";
-    const runtime = (await getContextRuntime(await resolveEnv(env)));
-    return runtime.db;
+    return await getRuntimeDb(runtime);
 }
 export async function datasetGetByIdStep(params) {
     "use step";
-    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const db = await getRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     return await service.getDatasetById(params.datasetId);
 }
 export async function datasetReadOutputJsonlStep(params) {
     "use step";
-    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const db = await getRuntimeDb(params.runtime);
     for (let attempt = 1; attempt <= 20; attempt++) {
         const query = await db.query({
             dataset_datasets: {
@@ -37,7 +46,7 @@ export async function datasetReadOutputJsonlStep(params) {
 }
 export async function datasetUpdateSchemaStep(params) {
     "use step";
-    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const db = await getRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     return await service.updateDatasetSchema({
         datasetId: params.datasetId,
@@ -47,7 +56,7 @@ export async function datasetUpdateSchemaStep(params) {
 }
 export async function datasetUploadOutputFileStep(params) {
     "use step";
-    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const db = await getRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     return await service.uploadDatasetOutputFile({
         datasetId: params.datasetId,
@@ -56,7 +65,7 @@ export async function datasetUploadOutputFileStep(params) {
 }
 export async function datasetUpdateStatusStep(params) {
     "use step";
-    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const db = await getRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     return await service.updateDatasetStatus({
         datasetId: params.datasetId,
@@ -67,13 +76,13 @@ export async function datasetUpdateStatusStep(params) {
 }
 export async function datasetClearStep(params) {
     "use step";
-    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const db = await getRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     return await service.clearDataset(params.datasetId);
 }
 export async function datasetPreviewRowsStep(params) {
     "use step";
-    const db = (await getContextRuntime(await resolveEnv(params.env))).db;
+    const db = await getRuntimeDb(params.runtime);
     const service = new DatasetService(db);
     const rowsResult = await service.previewRows(params.datasetId, params.limit ?? 20);
     if (!rowsResult.ok) {
@@ -81,3 +90,50 @@ export async function datasetPreviewRowsStep(params) {
     }
     return { rows: rowsResult.data };
 }
+export async function datasetReadRowsStep(params) {
+    "use step";
+    const db = await getRuntimeDb(params.runtime);
+    const service = new DatasetService(db);
+    const rowsResult = await service.readRows({
+        datasetId: params.datasetId,
+        cursor: params.cursor,
+        limit: params.limit,
+    });
+    if (!rowsResult.ok) {
+        throw new Error(rowsResult.error);
+    }
+    return rowsResult.data;
+}
+export async function datasetReadOneStep(params) {
+    "use step";
+    const db = await getRuntimeDb(params.runtime);
+    const service = new DatasetService(db);
+    const firstResult = await service.readOne(params.datasetId);
+    if (!firstResult.ok) {
+        throw new Error(firstResult.error);
+    }
+    return { row: firstResult.data };
+}
+export async function datasetInferAndUpdateSchemaStep(params) {
+    "use step";
+    const db = await getRuntimeDb(params.runtime);
+    const service = new DatasetService(db);
+    const readResult = await service.readRows({
+        datasetId: params.datasetId,
+        cursor: 0,
+        limit: 1000,
+    });
+    if (!readResult.ok) {
+        throw new Error(readResult.error);
+    }
+    const inferred = inferDatasetSchema(readResult.data.rows, params.title ?? `${params.datasetId}Row`, params.description ?? "One dataset row");
+    const updateResult = await service.updateDatasetSchema({
+        datasetId: params.datasetId,
+        schema: inferred,
+        status: "completed",
+    });
+    if (!updateResult.ok) {
+        throw new Error(updateResult.error);
+    }
+    return { schema: inferred };
+}

package/dist/dataset.js

@@ -1,6 +1,7 @@
 import { id as newId } from "@instantdb/admin";
 import { buildObjectOutputInstructions } from "./builder/instructions.js";
-import { materializeDerivedDataset, materializeQuerySource, materializeSingleFileLikeSource, } from "./builder/materialize.js";
+import { getDatasetAgentMaterializers } from "./builder/agentMaterializers.js";
+import { materializeQuerySource } from "./builder/materializeQuery.js";
 import { finalizeBuildResult } from "./builder/persistence.js";
 export function dataset(runtime, options = {}) {
     const datasetId = normalizeDatasetId(options.datasetId);
@@ -11,6 +12,7 @@ export function dataset(runtime, options = {}) {
         sources: [],
         output: "rows",
         inferSchema: false,
+        durable: options.durable,
         first: false,
     };
     const api = {
@@ -100,13 +102,17 @@ export function dataset(runtime, options = {}) {
             const targetDatasetId = options?.datasetId
                 ? normalizeDatasetId(options.datasetId)
                 : datasetId;
-            const effectiveState = state.output === "object"
+            const stateWithBuildOptions = {
+                ...state,
+                durable: options?.durable ?? state.durable,
+            };
+            const effectiveState = stateWithBuildOptions.output === "object"
                 ? {
-                    ...state,
+                    ...stateWithBuildOptions,
                     first: true,
-                    instructions: buildObjectOutputInstructions(state.instructions),
+                    instructions: buildObjectOutputInstructions(stateWithBuildOptions.instructions),
                 }
-                : state;
+                : stateWithBuildOptions;
             const onlySource = effectiveState.sources[0];
             const isSingleSource = effectiveState.sources.length === 1;
             const hasInstructions = Boolean(String(effectiveState.instructions ?? "").trim());
@@ -128,7 +134,7 @@ export function dataset(runtime, options = {}) {
                 if (!effectiveState.reactor) {
                     throw new Error("dataset_reactor_required");
                 }
-                await materializeSingleFileLikeSource(effectiveState, onlySource, targetDatasetId);
+                await getDatasetAgentMaterializers().materializeSingleFileLikeSource(effectiveState, onlySource, targetDatasetId);
                 return finalizeOutputResult(await finalizeBuildResult(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
             }
             if (!effectiveState.sandboxId) {
@@ -137,7 +143,7 @@ export function dataset(runtime, options = {}) {
             if (!effectiveState.reactor) {
                 throw new Error("dataset_reactor_required");
             }
-            await materializeDerivedDataset(effectiveState, targetDatasetId);
+            await getDatasetAgentMaterializers().materializeDerivedDataset(effectiveState, targetDatasetId);
             return finalizeOutputResult(await finalizeBuildResult(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
         },
     };

package/dist/executeCommand.tool.d.ts

@@ -1,9 +1,9 @@
 interface ExecuteCommandToolParams {
     datasetId: string;
     sandboxId: string;
-    env?: any;
+    runtime: any;
 }
-export declare function createExecuteCommandTool({ datasetId, sandboxId, env }: ExecuteCommandToolParams): import("ai").Tool<{
+export declare function createExecuteCommandTool({ datasetId, sandboxId, runtime }: ExecuteCommandToolParams): import("ai").Tool<{
     pythonCode: string;
     scriptName: string;
 }, {

package/dist/executeCommand.tool.js

@@ -6,7 +6,7 @@ import { getDatasetWorkstation } from "./datasetFiles.js";
 // The tool's return payload exposes stdout (capped) plus the on-disk script path.
 const MAX_STDOUT_CHARS = 20000;
 const MAX_STDERR_CHARS = 5000;
-export function createExecuteCommandTool({ datasetId, sandboxId, env }) {
+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({
@@ -25,7 +25,7 @@ export function createExecuteCommandTool({ datasetId, sandboxId, env }) {
             console.log(`[Dataset ${datasetId}] ========================================`);
             try {
                 await writeDatasetSandboxFilesStep({
-                    env,
+                    runtime,
                     sandboxId,
                     files: [
                         {
@@ -37,7 +37,7 @@ export function createExecuteCommandTool({ datasetId, sandboxId, env }) {
                 console.log(`[Dataset ${datasetId}] Script written to: ${scriptFile}`);
                 console.log(`[Dataset ${datasetId}] Executing: python ${scriptFile}`);
                 const result = await runDatasetSandboxCommandStep({
-                    env,
+                    runtime,
                     sandboxId,
                     cmd: "python",
                     args: [scriptFile],

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

@@ -1,6 +1,6 @@
 import { createContext, type ContextReactor } from "@ekairos/events";
 import { FilePreviewContext } from "./filepreview.js";
-export type FileParseStoryContext = {
+export type FileParseContext = {
     datasetId: string;
     fileId: string;
     instructions: string;
@@ -15,7 +15,7 @@ export type FileParseStoryContext = {
     iterationCount: number;
     filePreview?: FilePreviewContext;
 };
-export type FileParseStoryParams = {
+export type FileParseContextParams = {
     fileId: string;
     instructions?: string;
     sandboxId?: string;
@@ -23,11 +23,15 @@ export type FileParseStoryParams = {
     model?: string;
     reactor?: ContextReactor<any, any>;
 };
-export type FileParseStoryBuilder<Env extends {
+export type FileParseRunOptions = {
+    prompt?: string;
+    durable?: boolean;
+};
+export type FileParseContextBuilder<Env extends {
     orgId: string;
 }> = {
     datasetId: string;
-    story: ReturnType<ReturnType<typeof createContext<Env>>["context"]> extends any ? any : any;
+    context: ReturnType<ReturnType<typeof createContext<Env>>["context"]> extends any ? any : any;
 };
 export type DatasetResult = {
     id: string;
@@ -44,13 +48,13 @@ export type DatasetResult = {
  * Factory (DX-first):
  *
  * Usage:
- *   const { datasetId } = await createFileParseStory(fileId, { instructions }).parse(env)
+ *   const { datasetId } = await createFileParseContext(fileId, { instructions }).parse(runtime)
  *
- * - No `db` is accepted/stored (workflow-safe).
- * - All I/O happens in `"use step"` functions via Ekairos runtime (`getContextRuntime(env).db`).
- * - `parse()` is the entrypoint; it calls `story.react(...)` internally.
+ * - Uses the caller runtime; no secondary runtime is created.
+ * - All I/O happens in `"use step"` functions via the provided Ekairos runtime.
+ * - `parse()` is the entrypoint; it calls `context.react(...)` internally.
  */
-export declare function createFileParseStory<Env extends {
+export declare function createFileParseContext<Env extends {
     orgId: string;
 }>(fileId: string, opts?: {
     instructions?: string;
@@ -60,8 +64,10 @@ export declare function createFileParseStory<Env extends {
     reactor?: ContextReactor<any, any>;
 }): {
     datasetId: string;
-    parse(env?: Env, prompt?: string): Promise<{
+    parse(runtime: {
+        env: Env;
+    }, options?: FileParseRunOptions): Promise<{
         datasetId: string;
     }>;
-    story: any;
+    context: any;
 };