@ekairos/dataset 1.22.45-beta.development.0 → 1.22.47-beta.development.0

package/dist/builder/instructions.d.ts

@@ -1,6 +1,5 @@
-import type { DatasetSchemaInput } from "./types";
+import type { DatasetSchemaInput } from "./types.js";
 export declare function buildFileDefaultInstructions(schema?: DatasetSchemaInput): "Create a dataset from the source file and ensure each output row matches the provided dataset schema exactly." | "Create a dataset representing the source content as structured rows.";
 export declare function buildRawSourceInstructions(sourceKind: "file" | "text"): "Create a dataset representing the raw text content as structured rows without applying business transformations." | "Create a dataset representing the raw file content as structured rows without applying business transformations.";
 export declare function buildTransformInstructions(sourceCount: number, userInstructions?: string, schema?: DatasetSchemaInput): string;
 export declare function buildObjectOutputInstructions(userInstructions?: string): string;
-//# sourceMappingURL=instructions.d.ts.map

package/dist/builder/instructions.js

@@ -1,22 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFileDefaultInstructions = buildFileDefaultInstructions;
-exports.buildRawSourceInstructions = buildRawSourceInstructions;
-exports.buildTransformInstructions = buildTransformInstructions;
-exports.buildObjectOutputInstructions = buildObjectOutputInstructions;
-function buildFileDefaultInstructions(schema) {
+export function buildFileDefaultInstructions(schema) {
     if (schema) {
         return "Create a dataset from the source file and ensure each output row matches the provided dataset schema exactly.";
     }
     return "Create a dataset representing the source content as structured rows.";
 }
-function buildRawSourceInstructions(sourceKind) {
+export function buildRawSourceInstructions(sourceKind) {
     if (sourceKind === "text") {
         return "Create a dataset representing the raw text content as structured rows without applying business transformations.";
     }
     return "Create a dataset representing the raw file content as structured rows without applying business transformations.";
 }
-function buildTransformInstructions(sourceCount, userInstructions, schema) {
+export function buildTransformInstructions(sourceCount, userInstructions, schema) {
     const explicit = String(userInstructions ?? "").trim();
     if (explicit)
         return explicit;
@@ -31,7 +25,7 @@ function buildTransformInstructions(sourceCount, userInstructions, schema) {
     }
     return "Transform the source dataset into a new useful dataset.";
 }
-function buildObjectOutputInstructions(userInstructions) {
+export function buildObjectOutputInstructions(userInstructions) {
     const base = String(userInstructions ?? "").trim();
     const objectContract = [
         "Output mode is object.",
@@ -43,4 +37,3 @@ function buildObjectOutputInstructions(userInstructions) {
         return objectContract;
     return [base, "", objectContract].join("\n");
 }
-//# sourceMappingURL=instructions.js.map

package/dist/builder/materialize.d.ts

@@ -1,4 +1,4 @@
-import type { AnyDatasetRuntime, DatasetBuilderState, DatasetSchemaInput, InternalSource } from "./types";
+import type { AnyDatasetRuntime, DatasetBuilderState, DatasetSchemaInput, InternalSource } from "./types.js";
 export declare function materializeQuerySource<Runtime extends AnyDatasetRuntime>(runtime: DatasetBuilderState<Runtime>["runtime"], source: Extract<InternalSource, {
     kind: "query";
 }>, params: {
@@ -13,4 +13,3 @@ export declare function materializeSingleFileLikeSource<Runtime extends AnyDatas
     kind: "file" | "text";
 }>, targetDatasetId: string): Promise<string>;
 export declare function materializeDerivedDataset<Runtime extends AnyDatasetRuntime>(state: DatasetBuilderState<Runtime>, targetDatasetId: string): Promise<string>;
-//# sourceMappingURL=materialize.d.ts.map

package/dist/builder/materialize.js

@@ -1,24 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.materializeQuerySource = materializeQuerySource;
-exports.materializeSingleFileLikeSource = materializeSingleFileLikeSource;
-exports.materializeDerivedDataset = materializeDerivedDataset;
-const file_dataset_agent_1 = require("../file/file-dataset.agent");
-const service_1 = require("../service");
-const transform_dataset_agent_1 = require("../transform/transform-dataset.agent");
-const instructions_1 = require("./instructions");
-const persistence_1 = require("./persistence");
-const schemaInference_1 = require("./schemaInference");
-const sourceRows_1 = require("./sourceRows");
+import { createFileParseStory } from "../file/file-dataset.agent.js";
+import { DatasetService } from "../service.js";
+import { createTransformDatasetStory } from "../transform/transform-dataset.agent.js";
+import { buildFileDefaultInstructions, buildRawSourceInstructions, buildTransformInstructions, } from "./instructions.js";
+import { createOrUpdateDatasetMetadata, getDatasetDb, materializeRowsToDataset, uploadInlineTextSource, } from "./persistence.js";
+import { inferDatasetSchema } from "./schemaInference.js";
+import { getDomainDescriptor, normalizeQueryRows } from "./sourceRows.js";
 function makeIntermediateDatasetId(targetDatasetId, sourceKind, index) {
     return `${targetDatasetId}__${sourceKind}_${index}`;
 }
-async function materializeQuerySource(runtime, source, params) {
+export async function materializeQuerySource(runtime, source, params) {
     const scoped = await runtime.use(source.domain);
     const result = await scoped.db.query(source.query);
-    const rows = (0, sourceRows_1.normalizeQueryRows)(result);
-    const domainDescriptor = (0, sourceRows_1.getDomainDescriptor)(source.domain);
-    return await (0, persistence_1.materializeRowsToDataset)(runtime, {
+    const rows = normalizeQueryRows(result);
+    const domainDescriptor = getDomainDescriptor(source.domain);
+    return await materializeRowsToDataset(runtime, {
         datasetId: params.datasetId,
         sandboxId: params.sandboxId,
         title: params.title ?? source.title,
@@ -44,7 +39,7 @@ async function materializeQuerySource(runtime, source, params) {
         first: params.first,
     });
 }
-async function materializeSingleFileLikeSource(state, source, targetDatasetId) {
+export async function materializeSingleFileLikeSource(state, source, targetDatasetId) {
     if (!state.reactor) {
         throw new Error("dataset_reactor_required");
     }
@@ -53,8 +48,8 @@ async function materializeSingleFileLikeSource(state, source, targetDatasetId) {
     }
     const fileId = source.kind === "file"
         ? source.fileId
-        : await (0, persistence_1.uploadInlineTextSource)(state.runtime, targetDatasetId, source);
-    await (0, persistence_1.createOrUpdateDatasetMetadata)(state.runtime, {
+        : await uploadInlineTextSource(state.runtime, targetDatasetId, source);
+    await createOrUpdateDatasetMetadata(state.runtime, {
         datasetId: targetDatasetId,
         sandboxId: state.sandboxId,
         title: state.title ?? targetDatasetId,
@@ -73,21 +68,21 @@ async function materializeSingleFileLikeSource(state, source, targetDatasetId) {
         schema: state.outputSchema,
         status: "building",
     });
-    const parseStory = (0, file_dataset_agent_1.createFileParseStory)(fileId, {
+    const parseStory = createFileParseStory(fileId, {
         datasetId: targetDatasetId,
-        instructions: state.instructions ?? (0, instructions_1.buildFileDefaultInstructions)(state.outputSchema),
+        instructions: state.instructions ?? buildFileDefaultInstructions(state.outputSchema),
         reactor: state.reactor,
         sandboxId: state.sandboxId,
     });
     await parseStory.parse(state.env);
     if (!state.outputSchema) {
-        const db = await (0, persistence_1.getDatasetDb)(state.runtime);
-        const service = new service_1.DatasetService(db);
+        const db = await getDatasetDb(state.runtime);
+        const service = new DatasetService(db);
         const readResult = await service.readRows({ datasetId: targetDatasetId, cursor: 0, limit: 1000 });
         if (!readResult.ok) {
             throw new Error(readResult.error);
         }
-        const inferred = (0, schemaInference_1.inferDatasetSchema)(readResult.data.rows, `${targetDatasetId}Row`, "One dataset row");
+        const inferred = inferDatasetSchema(readResult.data.rows, `${targetDatasetId}Row`, "One dataset row");
         const updateResult = await service.updateDatasetSchema({
             datasetId: targetDatasetId,
             schema: inferred,
@@ -98,8 +93,8 @@ async function materializeSingleFileLikeSource(state, source, targetDatasetId) {
         }
     }
     if (state.first) {
-        const db = await (0, persistence_1.getDatasetDb)(state.runtime);
-        const service = new service_1.DatasetService(db);
+        const db = await getDatasetDb(state.runtime);
+        const service = new DatasetService(db);
         const firstResult = await service.readOne(targetDatasetId);
         if (!firstResult.ok) {
             throw new Error(firstResult.error);
@@ -125,11 +120,11 @@ async function normalizeSourceToDatasetId(state, source, targetDatasetId, source
         ...state,
         outputSchema: undefined,
         first: false,
-        instructions: (0, instructions_1.buildRawSourceInstructions)(source.kind),
+        instructions: buildRawSourceInstructions(source.kind),
     }, source, intermediateDatasetId);
     return intermediateDatasetId;
 }
-async function materializeDerivedDataset(state, targetDatasetId) {
+export async function materializeDerivedDataset(state, targetDatasetId) {
     if (!state.reactor) {
         throw new Error("dataset_reactor_required");
     }
@@ -150,7 +145,7 @@ async function materializeDerivedDataset(state, targetDatasetId) {
                 properties: {},
             },
         };
-    await (0, persistence_1.createOrUpdateDatasetMetadata)(state.runtime, {
+    await createOrUpdateDatasetMetadata(state.runtime, {
         datasetId: targetDatasetId,
         sandboxId: state.sandboxId,
         title: state.title ?? targetDatasetId,
@@ -161,30 +156,30 @@ async function materializeDerivedDataset(state, targetDatasetId) {
                 query: source.query,
                 title: source.title,
                 explanation: source.explanation,
-                ...(0, sourceRows_1.getDomainDescriptor)(source.domain),
+                ...getDomainDescriptor(source.domain),
             }
             : source),
         sourceKinds: state.sources.map((source) => source.kind),
         schema: transformSchema,
         status: "building",
     });
-    const transformStory = (0, transform_dataset_agent_1.createTransformDatasetStory)({
+    const transformStory = createTransformDatasetStory({
         sourceDatasetIds: normalizedSources,
         outputSchema: transformSchema,
-        instructions: (0, instructions_1.buildTransformInstructions)(normalizedSources.length, state.instructions, state.outputSchema),
+        instructions: buildTransformInstructions(normalizedSources.length, state.instructions, state.outputSchema),
         datasetId: targetDatasetId,
         reactor: state.reactor,
         sandboxId: state.sandboxId,
     });
     await transformStory.transform(state.env);
-    const db = await (0, persistence_1.getDatasetDb)(state.runtime);
-    const service = new service_1.DatasetService(db);
+    const db = await getDatasetDb(state.runtime);
+    const service = new DatasetService(db);
     if (!state.outputSchema) {
         const readResult = await service.readRows({ datasetId: targetDatasetId, cursor: 0, limit: 1000 });
         if (!readResult.ok) {
             throw new Error(readResult.error);
         }
-        const inferred = (0, schemaInference_1.inferDatasetSchema)(readResult.data.rows, `${targetDatasetId}Row`, "One dataset row");
+        const inferred = inferDatasetSchema(readResult.data.rows, `${targetDatasetId}Row`, "One dataset row");
         const updateResult = await service.updateDatasetSchema({
             datasetId: targetDatasetId,
             schema: inferred,
@@ -202,4 +197,3 @@ async function materializeDerivedDataset(state, targetDatasetId) {
     }
     return targetDatasetId;
 }
-//# sourceMappingURL=materialize.js.map

package/dist/builder/persistence.d.ts

@@ -1,4 +1,4 @@
-import type { AnyDatasetRuntime, DatasetBuildResult, DatasetTextSourceInput, MaterializeRowsParams } from "./types";
+import type { AnyDatasetRuntime, DatasetBuildResult, DatasetTextSourceInput, MaterializeRowsParams } from "./types.js";
 export declare function defaultTextSourceName(source: DatasetTextSourceInput): string;
 export declare function getDatasetDb<Runtime extends AnyDatasetRuntime>(runtime: Runtime): Promise<any>;
 export declare function createOrUpdateDatasetMetadata<Runtime extends AnyDatasetRuntime>(runtime: Runtime, params: {
@@ -15,4 +15,3 @@ export declare function createOrUpdateDatasetMetadata<Runtime extends AnyDataset
 export declare function materializeRowsToDataset<Runtime extends AnyDatasetRuntime>(runtime: Runtime, params: MaterializeRowsParams): Promise<string>;
 export declare function uploadInlineTextSource<Runtime extends AnyDatasetRuntime>(runtime: Runtime, datasetId: string, source: DatasetTextSourceInput): Promise<string>;
 export declare function finalizeBuildResult<Runtime extends AnyDatasetRuntime>(runtime: Runtime, datasetId: string, withFirst: boolean): Promise<DatasetBuildResult>;
-//# sourceMappingURL=persistence.d.ts.map

package/dist/builder/persistence.js

@@ -1,16 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultTextSourceName = defaultTextSourceName;
-exports.getDatasetDb = getDatasetDb;
-exports.createOrUpdateDatasetMetadata = createOrUpdateDatasetMetadata;
-exports.materializeRowsToDataset = materializeRowsToDataset;
-exports.uploadInlineTextSource = uploadInlineTextSource;
-exports.finalizeBuildResult = finalizeBuildResult;
-const service_1 = require("../service");
-const schema_1 = require("../schema");
-const schemaInference_1 = require("./schemaInference");
-const sourceRows_1 = require("./sourceRows");
-function defaultTextSourceName(source) {
+import { DatasetService } from "../service.js";
+import { datasetDomain } from "../schema.js";
+import { inferDatasetSchema, validateRows } from "./schemaInference.js";
+import { rowsToJsonl } from "./sourceRows.js";
+export function defaultTextSourceName(source) {
     if (source.name?.trim())
         return source.name.trim();
     const mimeType = String(source.mimeType ?? "").toLowerCase();
@@ -22,13 +14,13 @@ function defaultTextSourceName(source) {
         return "source.yaml";
     return "source.txt";
 }
-async function getDatasetDb(runtime) {
-    const scoped = await runtime.use(schema_1.datasetDomain);
+export async function getDatasetDb(runtime) {
+    const scoped = await runtime.use(datasetDomain);
     return scoped.db;
 }
-async function createOrUpdateDatasetMetadata(runtime, params) {
+export async function createOrUpdateDatasetMetadata(runtime, params) {
     const db = await getDatasetDb(runtime);
-    const service = new service_1.DatasetService(db);
+    const service = new DatasetService(db);
     const result = await service.createDataset({
         id: params.datasetId,
         sandboxId: params.sandboxId,
@@ -45,13 +37,13 @@ async function createOrUpdateDatasetMetadata(runtime, params) {
         throw new Error(result.error);
     }
 }
-async function materializeRowsToDataset(runtime, params) {
+export async function materializeRowsToDataset(runtime, params) {
     if (params.first && params.rows.length > 1) {
         throw new Error("dataset_first_expected_zero_or_one_row");
     }
     const resolvedSchema = params.schema ??
-        (0, schemaInference_1.inferDatasetSchema)(params.rows, params.title ? `${params.title}Row` : "DatasetRow", params.title ? `One row for ${params.title}` : "One dataset row");
-    (0, schemaInference_1.validateRows)(params.rows, resolvedSchema);
+        inferDatasetSchema(params.rows, params.title ? `${params.title}Row` : "DatasetRow", params.title ? `One row for ${params.title}` : "One dataset row");
+    validateRows(params.rows, resolvedSchema);
     await createOrUpdateDatasetMetadata(runtime, {
         datasetId: params.datasetId,
         sandboxId: params.sandboxId,
@@ -64,10 +56,10 @@ async function materializeRowsToDataset(runtime, params) {
         status: "building",
     });
     const db = await getDatasetDb(runtime);
-    const service = new service_1.DatasetService(db);
+    const service = new DatasetService(db);
     const uploadResult = await service.uploadDatasetOutputFile({
         datasetId: params.datasetId,
-        fileBuffer: Buffer.from((0, sourceRows_1.rowsToJsonl)(params.rows), "utf-8"),
+        fileBuffer: Buffer.from(rowsToJsonl(params.rows), "utf-8"),
     });
     if (!uploadResult.ok) {
         throw new Error(uploadResult.error);
@@ -83,7 +75,7 @@ async function materializeRowsToDataset(runtime, params) {
     }
     return params.datasetId;
 }
-async function uploadInlineTextSource(runtime, datasetId, source) {
+export async function uploadInlineTextSource(runtime, datasetId, source) {
     const db = await getDatasetDb(runtime);
     const fileName = defaultTextSourceName(source);
     const storagePath = `/dataset/source/${datasetId}/${Date.now()}-${fileName}`;
@@ -97,9 +89,9 @@ async function uploadInlineTextSource(runtime, datasetId, source) {
     }
     return fileId;
 }
-async function finalizeBuildResult(runtime, datasetId, withFirst) {
+export async function finalizeBuildResult(runtime, datasetId, withFirst) {
     const db = await getDatasetDb(runtime);
-    const service = new service_1.DatasetService(db);
+    const service = new DatasetService(db);
     const datasetResult = await service.getDatasetById(datasetId);
     if (!datasetResult.ok) {
         throw new Error(datasetResult.error);
@@ -144,4 +136,3 @@ async function finalizeBuildResult(runtime, datasetId, withFirst) {
         firstRow: firstResult.data,
     };
 }
-//# sourceMappingURL=persistence.js.map

package/dist/builder/schemaInference.d.ts

@@ -1,4 +1,3 @@
-import type { DatasetSchemaInput } from "./types";
+import type { DatasetSchemaInput } from "./types.js";
 export declare function inferDatasetSchema(rows: any[], title?: string, description?: string): DatasetSchemaInput;
 export declare function validateRows(rows: any[], schema: DatasetSchemaInput): void;
-//# sourceMappingURL=schemaInference.d.ts.map

package/dist/builder/schemaInference.js

@@ -1,12 +1,5 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inferDatasetSchema = inferDatasetSchema;
-exports.validateRows = validateRows;
-const ajv_1 = __importDefault(require("ajv"));
-const ajv = new ajv_1.default({ allErrors: true, strict: false });
+import Ajv from "ajv";
+const ajv = new Ajv({ allErrors: true, strict: false });
 function inferJsonSchemaType(value) {
     if (value === null)
         return { type: "null" };
@@ -23,7 +16,7 @@ function inferJsonSchemaType(value) {
             return { type: "string" };
     }
 }
-function inferDatasetSchema(rows, title = "DatasetRow", description = "One dataset row") {
+export function inferDatasetSchema(rows, title = "DatasetRow", description = "One dataset row") {
     const properties = {};
     const required = [];
     const keys = new Set();
@@ -56,7 +49,7 @@ function inferDatasetSchema(rows, title = "DatasetRow", description = "One datas
         },
     };
 }
-function validateRows(rows, schema) {
+export function validateRows(rows, schema) {
     const validator = ajv.compile(schema.schema);
     for (const row of rows) {
         const valid = validator(row);
@@ -66,4 +59,3 @@ function validateRows(rows, schema) {
         }
     }
 }
-//# sourceMappingURL=schemaInference.js.map

package/dist/builder/sourceRows.d.ts

@@ -5,4 +5,3 @@ export declare function getDomainDescriptor(domain: DomainSchemaResult): {
     domainPackageName?: string | undefined;
     domainName: string;
 };
-//# sourceMappingURL=sourceRows.d.ts.map

package/dist/builder/sourceRows.js

@@ -1,9 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rowsToJsonl = rowsToJsonl;
-exports.normalizeQueryRows = normalizeQueryRows;
-exports.getDomainDescriptor = getDomainDescriptor;
-function rowsToJsonl(rows) {
+export function rowsToJsonl(rows) {
     return rows
         .map((row) => JSON.stringify({
         type: "row",
@@ -12,7 +7,7 @@ function rowsToJsonl(rows) {
         .join("\n")
         .concat(rows.length > 0 ? "\n" : "");
 }
-function normalizeQueryRows(result) {
+export function normalizeQueryRows(result) {
     if (!result || typeof result !== "object")
         return [];
     const entries = Object.entries(result);
@@ -49,7 +44,7 @@ function normalizeQueryRows(result) {
     }
     return rows;
 }
-function getDomainDescriptor(domain) {
+export function getDomainDescriptor(domain) {
     const meta = domain?.meta ?? {};
     const context = typeof domain?.context === "function" ? domain.context() : {};
     const name = String(meta?.name ?? context?.name ?? "domain");
@@ -59,4 +54,3 @@ function getDomainDescriptor(domain) {
         ...(packageName ? { domainPackageName: packageName } : {}),
     };
 }
-//# sourceMappingURL=sourceRows.js.map

package/dist/builder/types.d.ts

@@ -2,7 +2,7 @@ import type { InstaQLParams, ValidQuery } from "@instantdb/core";
 import type { DomainInstantSchema, DomainSchemaResult } from "@ekairos/domain";
 import type { EkairosRuntime, RuntimeForDomain } from "@ekairos/domain/runtime";
 import type { ContextReactor } from "@ekairos/events";
-import { datasetDomain } from "../schema";
+import { datasetDomain } from "../schema.js";
 export type DatasetQuerySourceInput<D extends DomainSchemaResult = DomainSchemaResult> = {
     query: InstaQLParams<DomainInstantSchema<D>>;
     title?: string;
@@ -127,4 +127,3 @@ export type DatasetBuilder<Runtime extends AnyDatasetRuntime> = {
     first(): DatasetBuilder<Runtime>;
     build(options?: DatasetBuildOptions): Promise<DatasetBuildResult>;
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/builder/types.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map
+export {};

package/dist/clearDataset.tool.d.ts

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

package/dist/clearDataset.tool.js

@@ -1,26 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClearDatasetTool = createClearDatasetTool;
-const ai_1 = require("ai");
-const zod_1 = require("zod");
-const steps_1 = require("./sandbox/steps");
-const datasetFiles_1 = require("./datasetFiles");
-const steps_2 = require("./dataset/steps");
-function createClearDatasetTool({ datasetId, sandboxId, env }) {
-    return (0, ai_1.tool)({
+import { tool } from "ai";
+import { z } from "zod";
+import { runDatasetSandboxCommandStep } from "./sandbox/steps.js";
+import { getDatasetOutputPath } from "./datasetFiles.js";
+import { datasetClearStep } from "./dataset/steps.js";
+export function createClearDatasetTool({ datasetId, sandboxId, env }) {
+    return tool({
         description: "Clear all dataset records and output files. This will delete all generated data and reset the dataset to its initial state.",
-        inputSchema: zod_1.z.object({
-            reason: zod_1.z.string().describe("The reason for clearing the dataset"),
+        inputSchema: z.object({
+            reason: z.string().describe("The reason for clearing the dataset"),
         }),
         execute: async ({ reason }) => {
             console.log(`[Dataset ${datasetId}] ========================================`);
             console.log(`[Dataset ${datasetId}] Tool: clearDataset`);
             console.log(`[Dataset ${datasetId}] Reason: ${reason}`);
             console.log(`[Dataset ${datasetId}] ========================================`);
-            const outputPath = (0, datasetFiles_1.getDatasetOutputPath)(datasetId);
+            const outputPath = getDatasetOutputPath(datasetId);
             console.log(`[Dataset ${datasetId}] Step 1: Deleting output file`);
             try {
-                const result = await (0, steps_1.runDatasetSandboxCommandStep)({
+                const result = await runDatasetSandboxCommandStep({
                     env,
                     sandboxId,
                     cmd: "rm",
@@ -38,7 +35,7 @@ function createClearDatasetTool({ datasetId, sandboxId, env }) {
                 console.warn(`[Dataset ${datasetId}] Error deleting output file: ${message}`);
             }
             console.log(`[Dataset ${datasetId}] Step 2: Clearing dataset records`);
-            const clearResult = await (0, steps_2.datasetClearStep)({ env, datasetId });
+            const clearResult = await datasetClearStep({ env, datasetId });
             if (!clearResult.ok) {
                 console.error(`[Dataset ${datasetId}] Failed to clear dataset: ${clearResult.error}`);
                 return {
@@ -58,4 +55,3 @@ function createClearDatasetTool({ datasetId, sandboxId, env }) {
         },
     });
 }
-//# sourceMappingURL=clearDataset.tool.js.map

package/dist/completeDataset.tool.d.ts

@@ -22,4 +22,3 @@ export declare function createCompleteDatasetTool({ datasetId, sandboxId, env }:
     message: string;
 }>;
 export {};
-//# sourceMappingURL=completeDataset.tool.d.ts.map

package/dist/completeDataset.tool.js

@@ -1,37 +1,31 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCompleteDatasetTool = createCompleteDatasetTool;
-const ai_1 = require("ai");
-const zod_1 = require("zod");
-const steps_1 = require("./sandbox/steps");
-const ajv_1 = __importDefault(require("ajv"));
-const datasetFiles_1 = require("./datasetFiles");
-const steps_2 = require("./dataset/steps");
+import { tool } from "ai";
+import { z } from "zod";
+import { readDatasetSandboxFileStep, 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_1.default({
+        ajvInstance = new Ajv({
             allErrors: true,
             strict: false,
         });
     }
     return ajvInstance;
 }
-function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
-    return (0, ai_1.tool)({
+export function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
+    return tool({
         description: "Mark the dataset as completed. Use only when output.jsonl has been successfully generated and is ready for validation.",
-        inputSchema: zod_1.z.object({
-            summary: zod_1.z.string().describe("Summary of the completed dataset including record count and structure"),
+        inputSchema: z.object({
+            summary: z.string().describe("Summary of the completed dataset including record count and structure"),
         }),
         execute: async ({ summary }) => {
             console.log(`[Dataset ${datasetId}] ========================================`);
             console.log(`[Dataset ${datasetId}] Tool: completeDataset`);
             console.log(`[Dataset ${datasetId}] Summary: ${summary}`);
             console.log(`[Dataset ${datasetId}] ========================================`);
-            const outputPath = (0, datasetFiles_1.getDatasetOutputPath)(datasetId);
+            const outputPath = getDatasetOutputPath(datasetId);
             try {
                 await ensureFileExists(env, sandboxId, outputPath);
             }
@@ -44,7 +38,7 @@ function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
                 };
             }
             console.log(`[Dataset ${datasetId}] Validating dataset rows against schema`);
-            const datasetResult = await (0, steps_2.datasetGetByIdStep)({ env, datasetId });
+            const datasetResult = await datasetGetByIdStep({ env, datasetId });
             if (!datasetResult.ok) {
                 console.error(`[Dataset ${datasetId}] ${datasetResult.error}`);
                 return {
@@ -85,7 +79,7 @@ function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
             }
             const totalValidRows = validationResult.validRowCount;
             console.log(`[Dataset ${datasetId}] Reading file content for upload`);
-            const fileRead = await (0, steps_1.readDatasetSandboxFileStep)({ env, sandboxId, path: outputPath });
+            const fileRead = await readDatasetSandboxFileStep({ env, sandboxId, path: outputPath });
             if (!fileRead.contentBase64) {
                 console.error(`[Dataset ${datasetId}] Empty file content`);
                 return {
@@ -95,7 +89,7 @@ function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
             }
             const fileBuffer = Buffer.from(fileRead.contentBase64, "base64");
             console.log(`[Dataset ${datasetId}] Uploading file to InstantDB storage`);
-            const uploadResult = await (0, steps_2.datasetUploadOutputFileStep)({ env, datasetId, fileBuffer });
+            const uploadResult = await datasetUploadOutputFileStep({ env, datasetId, fileBuffer });
             if (!uploadResult.ok) {
                 console.error(`[Dataset ${datasetId}] File upload failed: ${uploadResult.error}`);
                 return {
@@ -104,7 +98,7 @@ function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
                 };
             }
             console.log(`[Dataset ${datasetId}] File uploaded successfully: ${uploadResult.data.fileId}`);
-            const statusResult = await (0, steps_2.datasetUpdateStatusStep)({
+            const statusResult = await datasetUpdateStatusStep({
                 env,
                 datasetId,
                 status: "completed",
@@ -131,7 +125,7 @@ function createCompleteDatasetTool({ datasetId, sandboxId, env }) {
     });
 }
 async function ensureFileExists(env, sandboxId, path) {
-    const result = await (0, steps_1.runDatasetSandboxCommandStep)({
+    const result = await runDatasetSandboxCommandStep({
         env,
         sandboxId,
         cmd: "test",
@@ -145,7 +139,7 @@ async function validateJsonlRows({ env, sandboxId, outputPath, validator, datase
     const validation = [];
     let validRowCount = 0;
     console.log(`[Dataset ${datasetId}] Reading and validating JSONL file from sandbox`);
-    const fileRead = await (0, steps_1.readDatasetSandboxFileStep)({ env, sandboxId, path: outputPath });
+    const fileRead = await readDatasetSandboxFileStep({ env, sandboxId, path: outputPath });
     if (!fileRead.contentBase64) {
         console.log(`[Dataset ${datasetId}] Empty output file`);
         return { success: true, validation, validRowCount: 0 };
@@ -209,4 +203,3 @@ async function validateJsonlRows({ env, sandboxId, outputPath, validator, datase
         validRowCount,
     };
 }
-//# sourceMappingURL=completeDataset.tool.js.map

package/dist/dataset/steps.d.ts

@@ -2,7 +2,7 @@ export declare function getDatasetServiceDb(env?: any): Promise<any>;
 export declare function datasetGetByIdStep(params: {
     env?: any;
     datasetId: string;
-}): Promise<import("../service").ServiceResult<any>>;
+}): Promise<import("../service.js").ServiceResult<any>>;
 export declare function datasetReadOutputJsonlStep(params: {
     env?: any;
     datasetId: string;
@@ -14,12 +14,12 @@ export declare function datasetUpdateSchemaStep(params: {
     datasetId: string;
     schema: any;
     status?: string;
-}): Promise<import("../service").ServiceResult<void>>;
+}): Promise<import("../service.js").ServiceResult<void>>;
 export declare function datasetUploadOutputFileStep(params: {
     env?: any;
     datasetId: string;
     fileBuffer: Buffer;
-}): Promise<import("../service").ServiceResult<{
+}): Promise<import("../service.js").ServiceResult<{
     fileId: string;
     storagePath: string;
 }>>;
@@ -29,11 +29,11 @@ export declare function datasetUpdateStatusStep(params: {
     status: string;
     calculatedTotalRows?: number;
     actualGeneratedRowCount?: number;
-}): Promise<import("../service").ServiceResult<void>>;
+}): Promise<import("../service.js").ServiceResult<void>>;
 export declare function datasetClearStep(params: {
     env?: any;
     datasetId: string;
-}): Promise<import("../service").ServiceResult<{
+}): Promise<import("../service.js").ServiceResult<{
     deletedCount: number;
 }>>;
 export declare function datasetPreviewRowsStep(params: {
@@ -43,4 +43,3 @@ export declare function datasetPreviewRowsStep(params: {
 }): Promise<{
     rows: any[];
 }>;
-//# sourceMappingURL=steps.d.ts.map