@ekairos/dataset 1.22.40-beta.development.0 → 1.22.40

package/dist/builder/materializeQuery.d.ts

@@ -0,0 +1,12 @@
+import type { AnyDatasetRuntime, DatasetBuilderState, DatasetSchemaInput, InternalDatasetResource } from "./types.js";
+export declare function materializeQueryResource<Runtime extends AnyDatasetRuntime>(runtime: DatasetBuilderState<Runtime>["runtime"], resource: Extract<InternalDatasetResource, {
+    kind: "query";
+}>, params: {
+    datasetId: string;
+    sandboxId?: string;
+    schema?: DatasetSchemaInput;
+    title?: string;
+    instructions?: string;
+    first?: boolean;
+    contextId: string;
+}): Promise<string>;

package/dist/builder/materializeQuery.js

@@ -0,0 +1,31 @@
+import { materializeRowsToDataset } from "./persistence.js";
+import { getDomainDescriptor, normalizeQueryRows } from "./rows.js";
+async function readQueryResourceRowsStep(params) {
+    "use step";
+    const db = await params.runtime.db();
+    const result = await db.query(params.query);
+    return { rows: normalizeQueryRows(result) };
+}
+export async function materializeQueryResource(runtime, resource, params) {
+    const { rows } = await readQueryResourceRowsStep({
+        runtime,
+        query: resource.query,
+    });
+    const domainDescriptor = getDomainDescriptor(resource.domain);
+    return await materializeRowsToDataset(runtime, {
+        datasetId: params.datasetId,
+        sandboxId: params.sandboxId,
+        title: params.title ?? resource.title,
+        instructions: params.instructions,
+        contextId: params.contextId,
+        analysis: {
+            query: resource.query,
+            explanation: resource.explanation,
+            ...domainDescriptor,
+        },
+        rows,
+        schema: params.schema,
+        inferSchema: !params.schema,
+        first: params.first,
+    });
+}

package/dist/builder/persistence.d.ts

@@ -1,18 +1,22 @@
-import type { AnyDatasetRuntime, DatasetBuildResult, DatasetTextSourceInput, MaterializeRowsParams } from "./types";
-export declare function defaultTextSourceName(source: DatasetTextSourceInput): string;
+import type { AnyDatasetRuntime, DatasetBuildResult, DatasetTextResourceInput, MaterializeRowsParams } from "./types.js";
+export declare function defaultTextResourceName(resource: DatasetTextResourceInput): string;
 export declare function getDatasetDb<Runtime extends AnyDatasetRuntime>(runtime: Runtime): Promise<any>;
 export declare function createOrUpdateDatasetMetadata<Runtime extends AnyDatasetRuntime>(runtime: Runtime, params: {
     datasetId: string;
     sandboxId?: string;
     title?: string;
     instructions?: string;
-    sources: any[];
-    sourceKinds: string[];
+    contextId: string;
     analysis?: any;
     schema?: any;
     status?: string;
 }): Promise<void>;
 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 uploadInlineTextResource<Runtime extends AnyDatasetRuntime>(runtime: Runtime, datasetId: string, resource: DatasetTextResourceInput): Promise<string>;
 export declare function finalizeBuildResult<Runtime extends AnyDatasetRuntime>(runtime: Runtime, datasetId: string, withFirst: boolean): Promise<DatasetBuildResult>;
-//# sourceMappingURL=persistence.d.ts.map
+export declare function createDatasetBuildResult<Runtime extends AnyDatasetRuntime>(runtime: Runtime, params: {
+    datasetId: string;
+    dataset: any;
+    previewRows: any[];
+    firstRow?: any | null;
+}): DatasetBuildResult;

package/dist/builder/persistence.js

@@ -1,41 +1,38 @@
-"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) {
-    if (source.name?.trim())
-        return source.name.trim();
-    const mimeType = String(source.mimeType ?? "").toLowerCase();
+import { DatasetService } from "../service.js";
+import { datasetDomain } from "../schema.js";
+import { annotateNotationEvidence, inferQueryNotation, } from "../notation.js";
+import { datasetGetByIdStep, datasetPreviewRowsStep, datasetReadOneStep, datasetReadRowsStep, } from "../dataset/steps.js";
+import { inferDatasetSchema, validateRows } from "./schemaInference.js";
+import { rowsToJsonl } from "./rows.js";
+export function defaultTextResourceName(resource) {
+    if (resource.name?.trim())
+        return resource.name.trim();
+    const mimeType = String(resource.mimeType ?? "").toLowerCase();
     if (mimeType.includes("csv"))
-        return "source.csv";
+        return "resource.csv";
     if (mimeType.includes("json"))
-        return "source.json";
+        return "resource.json";
     if (mimeType.includes("yaml") || mimeType.includes("yml"))
-        return "source.yaml";
-    return "source.txt";
+        return "resource.yaml";
+    return "resource.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) {
+    "use step";
+    if (!params.contextId.trim()) {
+        throw new Error("dataset_context_required");
+    }
     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,
         title: params.title ?? params.datasetId,
         instructions: params.instructions ?? "",
-        sources: params.sources,
-        sourceKinds: params.sourceKinds,
+        contextId: params.contextId,
         analysis: params.analysis,
         schema: params.schema,
         status: params.status ?? "building",
@@ -45,29 +42,29 @@ async function createOrUpdateDatasetMetadata(runtime, params) {
         throw new Error(result.error);
     }
 }
-async function materializeRowsToDataset(runtime, params) {
+export async function materializeRowsToDataset(runtime, params) {
+    "use step";
     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,
         title: params.title,
         instructions: params.instructions,
-        sources: params.sources,
-        sourceKinds: params.sourceKinds,
+        contextId: params.contextId,
         analysis: params.analysis,
         schema: resolvedSchema,
         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);
@@ -81,67 +78,115 @@ async function materializeRowsToDataset(runtime, params) {
     if (!statusResult.ok) {
         throw new Error(statusResult.error);
     }
+    // Formal notation, informative only (never blocks the build): a notation
+    // proposed during the build (agent iterations) gets advisory evidence
+    // against the materialized rows; query-backed builds with no proposed
+    // notation get the deterministic one derived from query + schema + rows.
+    try {
+        const existing = await service.getDatasetById(params.datasetId);
+        const previous = (existing.ok ? existing.data?.notation : null);
+        const analysis = (params.analysis ?? {});
+        const queryNotation = analysis.query && typeof analysis.query === "object"
+            ? inferQueryNotation({
+                entityNames: Object.keys(analysis.query),
+                rowCount: params.rows.length,
+                schema: resolvedSchema,
+                explanation: typeof analysis.explanation === "string" ? analysis.explanation : undefined,
+            })
+            : null;
+        // Query-backed builds are deterministic, so a freshly inferred notation
+        // always wins (a prior run's notation would be stale). Only agent-built
+        // datasets (no query) keep the notation the agent proposed during the
+        // build, which by now is the latest `previous`.
+        const candidate = queryNotation ??
+            (previous && Array.isArray(previous.predicates) && previous.predicates.length > 0
+                ? previous
+                : null);
+        if (candidate) {
+            await service.updateDatasetNotation({
+                datasetId: params.datasetId,
+                notation: annotateNotationEvidence(candidate, params.rows),
+            });
+        }
+    }
+    catch {
+        // notation must never affect the build result
+    }
     return params.datasetId;
 }
-async function uploadInlineTextSource(runtime, datasetId, source) {
+export async function uploadInlineTextResource(runtime, datasetId, resource) {
+    "use step";
     const db = await getDatasetDb(runtime);
-    const fileName = defaultTextSourceName(source);
-    const storagePath = `/dataset/source/${datasetId}/${Date.now()}-${fileName}`;
-    const uploadResult = await db.storage.uploadFile(storagePath, Buffer.from(source.text, "utf-8"), {
-        contentType: source.mimeType ?? "text/plain",
+    const fileName = defaultTextResourceName(resource);
+    const storagePath = `/dataset/resource/${datasetId}/${Date.now()}-${fileName}`;
+    const uploadResult = await db.storage.uploadFile(storagePath, Buffer.from(resource.text, "utf-8"), {
+        contentType: resource.mimeType ?? "text/plain",
         contentDisposition: fileName,
     });
     const fileId = uploadResult?.data?.id;
     if (!fileId) {
-        throw new Error("dataset_text_source_upload_failed");
+        throw new Error("dataset_text_resource_upload_failed");
     }
     return fileId;
 }
-async function finalizeBuildResult(runtime, datasetId, withFirst) {
-    const db = await getDatasetDb(runtime);
-    const service = new service_1.DatasetService(db);
-    const datasetResult = await service.getDatasetById(datasetId);
-    if (!datasetResult.ok) {
+export async function finalizeBuildResult(runtime, datasetId, withFirst) {
+    const datasetResult = await datasetGetByIdStep({ runtime, datasetId });
+    if (!datasetResult.ok)
         throw new Error(datasetResult.error);
-    }
-    const previewResult = await service.previewRows(datasetId, 20);
-    if (!previewResult.ok) {
-        throw new Error(previewResult.error);
-    }
+    const previewResult = await datasetPreviewRowsStep({ runtime, datasetId, limit: 20 });
     const reader = {
         async read(cursorOrParams, limit) {
             const params = typeof cursorOrParams === "object" && cursorOrParams !== null
                 ? cursorOrParams
                 : { cursor: cursorOrParams, limit };
-            const rowsResult = await service.readRows({
+            return await datasetReadRowsStep({
+                runtime,
                 datasetId,
                 cursor: params.cursor,
                 limit: params.limit,
             });
-            if (!rowsResult.ok) {
-                throw new Error(rowsResult.error);
-            }
-            return rowsResult.data;
         },
     };
+    const notation = (datasetResult.data?.notation ?? null);
     if (!withFirst) {
         return {
             datasetId,
             dataset: datasetResult.data,
-            previewRows: previewResult.data,
+            notation,
+            previewRows: previewResult.rows,
             reader,
         };
     }
-    const firstResult = await service.readOne(datasetId);
-    if (!firstResult.ok) {
-        throw new Error(firstResult.error);
-    }
+    const firstResult = await datasetReadOneStep({ runtime, datasetId });
     return {
         datasetId,
         dataset: datasetResult.data,
-        previewRows: previewResult.data,
+        notation,
+        previewRows: previewResult.rows,
+        reader,
+        firstRow: firstResult.row,
+    };
+}
+export function createDatasetBuildResult(runtime, params) {
+    const reader = {
+        async read(cursorOrParams, limit) {
+            const readParams = typeof cursorOrParams === "object" && cursorOrParams !== null
+                ? cursorOrParams
+                : { cursor: cursorOrParams, limit };
+            return await datasetReadRowsStep({
+                runtime,
+                datasetId: params.datasetId,
+                cursor: readParams.cursor,
+                limit: readParams.limit,
+            });
+        },
+    };
+    return {
+        datasetId: params.datasetId,
+        dataset: params.dataset,
+        notation: (params.dataset?.notation ?? null),
+        previewRows: params.previewRows,
         reader,
-        firstRow: firstResult.data,
+        ...(params.firstRow !== undefined ? { firstRow: params.firstRow } : {}),
     };
 }
-//# sourceMappingURL=persistence.js.map

package/dist/builder/{sourceRows.d.ts → rows.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 → rows.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/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/types.d.ts

@@ -1,38 +1,46 @@
 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";
-export type DatasetQuerySourceInput<D extends DomainSchemaResult = DomainSchemaResult> = {
+import type { ContextIdentifier, StoredContextResource } from "@ekairos/events";
+import type { ContextReactor } from "@ekairos/reactor/context";
+import { datasetDomain } from "../schema.js";
+import type { DatasetNotation } from "../notation.js";
+export type DatasetQueryResourceInput<D extends DomainSchemaResult = DomainSchemaResult> = {
     query: InstaQLParams<DomainInstantSchema<D>>;
     title?: string;
     explanation?: string;
     domain: D;
 };
-export type DatasetFileSourceInput = {
+export type DatasetFileResourceInput = {
     fileId: string;
     description?: string;
+    filename?: string;
+    mediaType?: string;
 };
-export type DatasetTextSourceInput = {
+export type DatasetTextResourceInput = {
     text: string;
     mimeType?: string;
     name?: string;
     description?: string;
 };
-export type DatasetExistingSourceInput = {
+export type DatasetExistingResourceInput = {
     datasetId: string;
     description?: string;
 };
-export type DatasetFileSource = {
+export type DatasetContextResourceInput = ContextIdentifier;
+export type DatasetFileResource = {
     kind: "file";
-} & DatasetFileSourceInput;
-export type DatasetTextSource = {
+} & DatasetFileResourceInput;
+export type DatasetTextResource = {
     kind: "text";
-} & DatasetTextSourceInput;
-export type DatasetExistingSource = {
+} & DatasetTextResourceInput;
+export type DatasetExistingResource = {
     kind: "dataset";
-} & DatasetExistingSourceInput;
-export type DatasetSourceInput = DatasetFileSourceInput | DatasetTextSourceInput | DatasetExistingSourceInput | DatasetFileSource | DatasetTextSource | DatasetExistingSource;
+} & DatasetExistingResourceInput;
+export type DatasetContextResource = {
+    kind: "context";
+} & DatasetContextResourceInput;
+export type DatasetResourceInput = DatasetFileResourceInput | DatasetTextResourceInput | DatasetExistingResourceInput | DatasetContextResourceInput | DatasetFileResource | DatasetTextResource | DatasetExistingResource | DatasetContextResource;
 export type DatasetSchemaInput = {
     title?: string;
     description?: string;
@@ -42,13 +50,15 @@ export type DatasetOutput = "rows" | "object";
 export type DatasetMode = "auto" | "schema";
 export type DatasetBuilderOptions = {
     datasetId?: string;
+    durable?: boolean;
 };
 export type DatasetBuildOptions = {
     datasetId?: string;
+    durable?: boolean;
 };
-export type InternalSource = DatasetFileSource | DatasetTextSource | DatasetExistingSource | ({
+export type InternalDatasetResource = DatasetFileResource | DatasetTextResource | DatasetExistingResource | DatasetContextResource | ({
     kind: "query";
-} & DatasetQuerySourceInput);
+} & DatasetQueryResourceInput);
 export type DatasetReaderResult = {
     rows: any[];
     cursor: number;
@@ -64,6 +74,9 @@ export type DatasetReader = {
 export type DatasetBuildResult = {
     datasetId: string;
     dataset: any;
+    /** the formal definition (intensional face), co-equal with the rows */
+    notation: DatasetNotation | null;
+    /** preview of the materialization (extensional face) */
     previewRows: any[];
     reader: DatasetReader;
     object?: any | null;
@@ -74,8 +87,8 @@ export type DatasetRuntimeEnv = {
 };
 export type AnyDatasetRuntime = EkairosRuntime<any, any, any>;
 export type DatasetRuntimeHandle<Runtime extends AnyDatasetRuntime> = RuntimeForDomain<Runtime, typeof datasetDomain>;
-export type CompatibleSourceDomain<Runtime extends AnyDatasetRuntime, D extends DomainSchemaResult> = RuntimeForDomain<Runtime, D> extends never ? never : D;
-export type DatasetQuerySourceOptions<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>> = {
+export type CompatibleQueryDomain<Runtime extends AnyDatasetRuntime, D extends DomainSchemaResult> = RuntimeForDomain<Runtime, D> extends never ? never : D;
+export type DatasetQueryResourceOptions<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>> = {
     query: Q;
     title?: string;
     explanation?: string;
@@ -83,14 +96,17 @@ export type DatasetQuerySourceOptions<D extends DomainSchemaResult, Q extends Va
 export type DatasetBuilderState<Runtime extends AnyDatasetRuntime> = {
     runtime: Runtime;
     env: Runtime["env"] & DatasetRuntimeEnv;
-    sources: InternalSource[];
+    resources: InternalDatasetResource[];
+    contextResources?: StoredContextResource[];
     title?: string;
     sandboxId?: string;
+    contextId?: string;
     outputSchema?: DatasetSchemaInput;
     output: DatasetOutput;
     inferSchema: boolean;
     instructions?: string;
     reactor?: ContextReactor<any, any>;
+    durable?: boolean;
     first: boolean;
 };
 export type MaterializeRowsParams = {
@@ -98,8 +114,7 @@ export type MaterializeRowsParams = {
     sandboxId?: string;
     title?: string;
     instructions?: string;
-    sources: any[];
-    sourceKinds: string[];
+    contextId: string;
     analysis?: any;
     rows: any[];
     schema?: DatasetSchemaInput;
@@ -108,11 +123,12 @@ export type MaterializeRowsParams = {
 };
 export type DatasetBuilder<Runtime extends AnyDatasetRuntime> = {
     readonly datasetId: string;
-    fromFile(source: DatasetFileSourceInput): DatasetBuilder<Runtime>;
-    fromText(source: DatasetTextSourceInput): DatasetBuilder<Runtime>;
-    fromDataset(source: DatasetExistingSourceInput): DatasetBuilder<Runtime>;
-    from(...sources: DatasetSourceInput[]): DatasetBuilder<Runtime>;
-    fromQuery<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>>(domain: D & CompatibleSourceDomain<Runtime, D>, source: DatasetQuerySourceOptions<D, Q>): DatasetBuilder<Runtime>;
+    fromFile(resource: DatasetFileResourceInput): DatasetBuilder<Runtime>;
+    fromText(resource: DatasetTextResourceInput): DatasetBuilder<Runtime>;
+    fromDataset(resource: DatasetExistingResourceInput): DatasetBuilder<Runtime>;
+    fromContext(context: DatasetContextResourceInput): DatasetBuilder<Runtime>;
+    from(...resources: DatasetResourceInput[]): DatasetBuilder<Runtime>;
+    fromQuery<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>>(domain: D & CompatibleQueryDomain<Runtime, D>, resource: DatasetQueryResourceOptions<D, Q>): DatasetBuilder<Runtime>;
     title(title: string): DatasetBuilder<Runtime>;
     sandbox(input: {
         sandboxId: string;
@@ -127,4 +143,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

@@ -1,9 +1,9 @@
 interface ClearDatasetToolParams {
     datasetId: string;
     sandboxId: string;
-    env?: any;
+    runtime: any;
 }
-export declare function createClearDatasetTool({ datasetId, sandboxId, env }: ClearDatasetToolParams): import("ai").Tool<{
+export declare function createClearDatasetTool({ datasetId, sandboxId, runtime }: ClearDatasetToolParams): import("ai").Tool<{
     reason: string;
 }, {
     success: boolean;
@@ -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,27 +1,24 @@
-"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, runtime }) {
+    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)({
-                    env,
+                const result = await runDatasetSandboxCommandStep({
+                    runtime,
                     sandboxId,
                     cmd: "rm",
                     args: ["-f", outputPath],
@@ -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({ runtime, 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