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

package/dist/file/prompts.js

@@ -1,26 +1,23 @@
-"use strict";
 // Plain build API using template literals and XML
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFileDatasetPrompt = buildFileDatasetPrompt;
-const xmlbuilder2_1 = require("xmlbuilder2");
-const datasetFiles_1 = require("../datasetFiles");
+import { create } from "xmlbuilder2";
+import { getDatasetWorkstation, getDatasetOutputPath } from "../datasetFiles.js";
 function buildRole() {
-    let xml = (0, xmlbuilder2_1.create)()
+    let xml = create()
         .ele("Role")
         .txt("You are a dataset creator for a SINGLE file. Your goal is to convert the file content into a validated JSONL dataset where each line represents one record.")
         .up();
     return xml.end({ prettyPrint: true, headless: true });
 }
 function buildGoal() {
-    let xml = (0, xmlbuilder2_1.create)()
+    let xml = create()
         .ele("Goal")
-        .txt("Convert the source file into a validated JSONL dataset (output.jsonl) where each line is a JSON object conforming to a generated schema. The schema describes ONE data record structure. Extract ONLY data records; exclude any header sections, metadata, or summary information from the file.")
+        .txt("Convert the input file into a validated JSONL dataset (output.jsonl) where each line is a JSON object conforming to a generated schema. The schema describes ONE data record structure. Extract ONLY data records; exclude any header sections, metadata, or summary information from the file.")
         .up();
     return xml.end({ prettyPrint: true, headless: true });
 }
-function buildSourceInfo(context) {
-    let xml = (0, xmlbuilder2_1.create)()
-        .ele("Source")
+function buildResourceInfo(context) {
+    let xml = create()
+        .ele("FileResource")
         .ele("Type").txt("file").up()
         .ele("FileId").txt(context.fileId).up()
         .ele("DatasetId").txt(context.datasetId).up()
@@ -29,7 +26,7 @@ function buildSourceInfo(context) {
     return xml;
 }
 function buildFilePreviewSection(preview) {
-    let xml = (0, xmlbuilder2_1.create)()
+    let xml = create()
         .ele("FilePreview")
         .ele("TotalRows").txt(String(preview.totalRows)).up();
     if (preview.metadata) {
@@ -91,8 +88,9 @@ function buildErrorsSection(errors) {
     if (errors.length === 0) {
         return null;
     }
-    let xml = (0, xmlbuilder2_1.create)()
-        .ele("PreviousErrors");
+    let xml = create()
+        .ele("PreviousErrors")
+        .ele("Instruction").txt("Treat these as repair feedback from the previous validation attempt. Rewrite output.jsonl from the schema contract; do not patch input column names into schema keys piecemeal.").up();
     for (const error of errors) {
         xml = xml.ele("Error").txt(error).up();
     }
@@ -100,10 +98,10 @@ function buildErrorsSection(errors) {
     return xml;
 }
 function buildContextSection(context) {
-    let xml = (0, xmlbuilder2_1.create)()
+    let xml = create()
         .ele("Context");
-    const sourceXml = buildSourceInfo(context);
-    xml = xml.import(sourceXml.first());
+    const resourceXml = buildResourceInfo(context);
+    xml = xml.import(resourceXml.first());
     if (context.filePreview) {
         const previewXml = buildFilePreviewSection(context.filePreview);
         xml = xml.import(previewXml.first());
@@ -117,46 +115,159 @@ function buildContextSection(context) {
     xml = xml.up();
     return xml.end({ prettyPrint: true, headless: true });
 }
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function getSchemaObject(context) {
+    return asRecord(context.schema?.schema);
+}
+function joinSchemaPath(basePath, key) {
+    return basePath === "$" ? `$.${key}` : `${basePath}.${key}`;
+}
+function collectSchemaContract(schema, path = "$", contract = {
+    requiredPaths: [],
+    propertyPaths: [],
+    enumConstraints: [],
+    closedObjectPaths: [],
+}) {
+    const record = asRecord(schema);
+    if (!record) {
+        return contract;
+    }
+    if (Array.isArray(record.enum)) {
+        contract.enumConstraints.push({
+            path,
+            values: record.enum.map((value) => JSON.stringify(value)),
+        });
+    }
+    const properties = asRecord(record.properties);
+    if (properties) {
+        if (record.additionalProperties === false) {
+            contract.closedObjectPaths.push(path);
+        }
+        const required = Array.isArray(record.required)
+            ? record.required.filter((value) => typeof value === "string")
+            : [];
+        for (const key of required) {
+            contract.requiredPaths.push(joinSchemaPath(path, key));
+        }
+        for (const [key, childSchema] of Object.entries(properties)) {
+            const childPath = joinSchemaPath(path, key);
+            contract.propertyPaths.push(childPath);
+            collectSchemaContract(childSchema, childPath, contract);
+        }
+    }
+    if (record.items) {
+        collectSchemaContract(record.items, `${path}[]`, contract);
+    }
+    for (const keyword of ["oneOf", "anyOf", "allOf"]) {
+        if (Array.isArray(record[keyword])) {
+            for (const childSchema of record[keyword]) {
+                collectSchemaContract(childSchema, path, contract);
+            }
+        }
+    }
+    return contract;
+}
+function appendLimitedList(xml, elementName, itemName, values, maxItems) {
+    let node = xml.ele(elementName);
+    for (const value of values.slice(0, maxItems)) {
+        node = node.ele(itemName).txt(value).up();
+    }
+    if (values.length > maxItems) {
+        node = node.ele("Truncated").txt(String(values.length - maxItems)).up();
+    }
+    return node.up();
+}
 function buildSchemaSection(context) {
-    if (!context.schema) {
+    const schema = getSchemaObject(context);
+    if (!context.schema || !schema) {
         return "";
     }
-    let xml = (0, xmlbuilder2_1.create)()
+    const contract = collectSchemaContract(schema);
+    let xml = create()
         .com("Schema section: This defines the structure of ONE RECORD (row). Each line in the JSONL output must conform to this schema.")
         .ele("Schema")
         .ele("Title").txt(context.schema.title || "").up()
-        .ele("Description").txt(context.schema.description || "").up()
-        .ele("JsonSchema").txt(JSON.stringify(context.schema.schema, null, 2)).up()
+        .ele("Description").txt(context.schema.description || "").up();
+    xml = xml
+        .ele("SchemaContract")
+        .ele("Purpose").txt("Compact output contract derived from JSON Schema. Use this before writing output.jsonl.").up()
+        .ele("Rule").txt("Use only schema property keys in data objects. Input headers are input labels, not output keys.").up()
+        .ele("Rule").txt("Required paths are required everywhere, including nested objects and array items.").up()
+        .ele("Rule").txt("Enum fields must use exactly one of the listed literal values. Normalize input labels to the closest valid enum literal; never emit a value outside the enum.").up();
+    xml = appendLimitedList(xml, "RequiredPaths", "Path", contract.requiredPaths, 120);
+    xml = appendLimitedList(xml, "PropertyPaths", "Path", contract.propertyPaths, 160);
+    let enumsXml = xml.ele("EnumConstraints");
+    for (const constraint of contract.enumConstraints.slice(0, 80)) {
+        let enumXml = enumsXml.ele("Enum", { path: constraint.path });
+        for (const value of constraint.values.slice(0, 80)) {
+            enumXml = enumXml.ele("Value").txt(value).up();
+        }
+        if (constraint.values.length > 80) {
+            enumXml = enumXml.ele("Truncated").txt(String(constraint.values.length - 80)).up();
+        }
+        enumsXml = enumXml.up();
+    }
+    if (contract.enumConstraints.length > 80) {
+        enumsXml = enumsXml.ele("Truncated").txt(String(contract.enumConstraints.length - 80)).up();
+    }
+    xml = enumsXml.up();
+    xml = appendLimitedList(xml, "ClosedObjectPaths", "Path", contract.closedObjectPaths, 80);
+    xml = xml
+        .up()
+        .ele("JsonSchema").txt(JSON.stringify(schema, null, 2)).up()
         .up();
     return xml.end({ prettyPrint: true, headless: true });
 }
 function buildInstructions(context) {
-    const datasetWorkstation = (0, datasetFiles_1.getDatasetWorkstation)(context.datasetId);
-    const outputPath = (0, datasetFiles_1.getDatasetOutputPath)(context.datasetId);
+    const datasetWorkstation = context.sandboxConfig.scriptsDir
+        ? context.sandboxConfig.scriptsDir.replace(/\/scripts$/, "")
+        : getDatasetWorkstation(context.datasetId);
+    const outputPath = context.sandboxConfig.outputPath ?? getDatasetOutputPath(context.datasetId);
     const hasProvidedSchema = Boolean(context.schema?.schema);
     const currentTask = hasProvidedSchema
         ? "Review FilePreview section, use the provided schema as the output contract, then parse the file and generate the dataset"
         : "Review FilePreview section to understand file structure, then generate JSON Schema for a SINGLE RECORD, then parse the file and generate the dataset";
-    let xml = (0, xmlbuilder2_1.create)()
+    let xml = create()
         .ele("Instructions")
         .ele("Workflow")
         .ele("Step", { number: "1", name: "Inspect File" })
         .ele("Action").txt("Review the FilePreview section in Context to understand the file structure").up()
         .ele("Note").txt("FilePreview contains: TotalRows (total data rows), Metadata (file properties with JSON output), Head (first N raw file lines), Tail (last N lines if present), Mid (middle sample for large files). Each section shows Description, Script (full Python code), Command, Stdout (raw content), Stderr. This allows you to understand the exact file format.").up()
         .up();
+    xml = xml
+        .ele("Step", { number: "2", name: "Define the Dataset (PLAN FIRST)" })
+        .ele("Action").txt("Call defineNotation with the INITIAL formal definition of the dataset as a set, derived from the file preview: D = { r | r ∈ File ∧ <constraints> } in LaTeX, the symbols it binds (sets, variables, functions) and the predicates the set satisfies").up()
+        .ele("Requirements")
+        .ele("Requirement").txt("The definition and the materialization (schema + parsing code + rows) are TWO CO-EQUAL FACES of the dataset. The definition is the dataset stated intensionally — author it FIRST; it is your PLAN and the code is built to realize it").up()
+        .ele("Requirement").txt("Use set-builder notation, quantifiers and arithmetic in LaTeX (e.g. D = \\{(c, q, p) \\mid q \\in \\mathbb{Z}^{+},\\; p \\in \\mathbb{R}_{\\geq 0}\\})").up()
+        .ele("Requirement").txt("Declare every discovered set and variable as a symbol with a one-line meaning").up()
+        .ele("Requirement").txt("Predicates are formal claims we trust; they may be semantic (e.g. 'x es una frase relevante'). Only for the few that are purely arithmetic (row counts, field types, ranges, uniqueness, aggregates) you MAY add a checkJson for optional advisory evidence — leave every other claim without checkJson").up()
+        .ele("Requirement").txt("REFINE: every time the analysis discovers a new set, variable, constraint or correction (new columns, unexpected types, excluded sections), call defineNotation again with the updated definition and the reason. The definition is not fixed up front — discovery is the point").up()
+        .ele("Requirement").txt("Before calling completeDataset, call defineNotation one last time with final=true so the definition becomes the RESULT — it describes EXACTLY the dataset you produced; any arithmetic predicates get optional advisory evidence afterwards (never a pass/fail verdict — the dataset's validity is trusted)").up()
+        .up()
+        .up();
     if (hasProvidedSchema) {
         xml = xml
-            .ele("Step", { number: "2", name: "Use Provided Schema" })
+            .ele("Step", { number: "3", name: "Use Provided Schema" })
             .ele("Action").txt("Use the provided schema as the output contract for every row in output.jsonl").up()
             .ele("Requirements")
             .ele("Requirement").txt("Every output row must conform exactly to the provided schema").up()
+            .ele("Requirement").txt("Every data object MUST use the exact property names from the provided JSON Schema required/properties keys").up()
+            .ele("Requirement").txt("Build a schema-first mapping from input columns to schema fields before writing output.jsonl. Do not use raw input headers as JSON keys unless they are exactly schema keys").up()
+            .ele("Requirement").txt("For nested required fields, populate the required child keys inside each nested object or array item; top-level validity is not enough").up()
+            .ele("Requirement").txt("For enum fields, emit exactly one allowed enum literal from SchemaContract; normalize labels or abbreviations into allowed literals").up()
+            .ele("Requirement").txt("Do not translate, localize, rename, camelize differently, or infer alternative field names. Field names are a technical contract; only field values may preserve the input language").up()
             .ele("Requirement").txt("Do not call generateSchema when a schema is already provided").up()
             .up()
             .up();
     }
     else {
         xml = xml
-            .ele("Step", { number: "2", name: "Generate JSON Schema" })
+            .ele("Step", { number: "3", name: "Generate JSON Schema" })
             .ele("Action").txt("Call generateSchema to create a JSON Schema for a SINGLE DATA RECORD (one row of data)").up()
             .ele("Requirements")
             .ele("Requirement").txt("Schema describes ONE DATA RECORD structure only (type: object, not array)").up()
@@ -168,23 +279,28 @@ function buildInstructions(context) {
             .up();
     }
     xml = xml
-        .ele("Step", { number: "3", name: "Generate Dataset JSONL" })
+        .ele("Step", { number: "4", name: "Generate Dataset JSONL" })
         .ele("Action").txt(`Use executeCommand to parse the file and generate output.jsonl in the dataset workstation`).up()
         .ele("Requirements")
         .ele("Requirement").txt("Parse ALL data rows/records from the file (exclude header sections and metadata)").up()
         .ele("Requirement").txt("Output JSONL format: each line is {\"type\": \"row\", \"data\": {...record...}}").up()
+        .ele("Requirement").txt("When a schema is provided, each data object must contain the exact required schema keys and must not use translated or synonymous keys").up()
+        .ele("Requirement").txt("When validation returns zero valid rows, treat the previous output as structurally wrong and rewrite output.jsonl from the SchemaContract, not by applying small patches").up()
         .ele("Requirement").txt("Extract ONLY data records; skip any header lines, summary sections, or file metadata").up()
         .ele("Requirement").txt(`Save output to: ${outputPath}`).up()
         .ele("Requirement").txt("Use descriptive scriptName in snake_case (e.g., 'parse_csv_to_jsonl')").up()
         .up()
         .up()
-        .ele("Step", { number: "4", name: "Complete and Validate" })
-        .ele("Action").txt("Call completeDataset to validate the dataset").up()
-        .ele("Behavior").txt("Validates that output.jsonl exists and all records conform to the schema stored in database. Returns error details if validation fails.").up()
+        .ele("Step", { number: "5", name: "Complete and Validate" })
+        .ele("Action").txt("Call defineNotation with final=true (the definition as RESULT, matching the produced rows), then call completeDataset to validate the dataset").up()
+        .ele("Behavior").txt("Validates that output.jsonl exists and all records conform to the schema stored in database. Returns success:false with validation details if validation fails. If validation fails, inspect validation errors, rewrite output.jsonl, and call completeDataset again. Do not stop until completeDataset returns success:true.").up()
         .up()
         .up()
         .ele("Rules")
+        .ele("Rule").txt("The formal definition (defineNotation) and the materialization (schema + code + rows) are co-equal faces of the dataset: author the definition first as the PLAN, refine it on every discovery, finalize it as the RESULT before completion").up()
         .ele("Rule").txt("Schema defines ONE DATA RECORD structure (not array, not header)").up()
+        .ele("Rule").txt("Schema property names are authoritative. Never translate or rename keys such as itemName, quantity, or unit into the input language").up()
+        .ele("Rule").txt("Original/input language applies to extracted values only, not to JSON object keys").up()
         .ele("Rule").txt("Datasets contain ONLY data records; exclude all header sections and file metadata").up()
         .ele("Rule").txt("JSONL format: each line = separate JSON object representing one data record").up()
         .ele("Rule").txt("FilePreview shows raw file content - use Script to understand data extraction").up()
@@ -197,7 +313,7 @@ function buildInstructions(context) {
         .up();
     return xml.end({ prettyPrint: true, headless: true });
 }
-function buildFileDatasetPrompt(context) {
+export function buildFileDatasetPrompt(context) {
     const sections = [];
     sections.push(buildRole());
     sections.push("");
@@ -205,7 +321,11 @@ function buildFileDatasetPrompt(context) {
     sections.push("");
     sections.push(buildContextSection(context));
     sections.push("");
+    const schemaSection = buildSchemaSection(context);
+    if (schemaSection) {
+        sections.push(schemaSection);
+        sections.push("");
+    }
     sections.push(buildInstructions(context));
     return sections.join("\n");
 }
-//# sourceMappingURL=prompts.js.map

package/dist/file/scripts.generated.d.ts

@@ -0,0 +1 @@
+export declare const PYTHON_SCRIPT_BASE64_BY_NAME: Readonly<Record<string, string>>;

package/dist/file/scripts.generated.js

@@ -0,0 +1,11 @@
+// Generated by packages/dataset/scripts/generate-python-scripts-module.js.
+// Do not edit by hand.
+export const PYTHON_SCRIPT_BASE64_BY_NAME = Object.freeze({
+    "file_metadata.py": "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",
+    "preview_head_csv.py": "aW1wb3J0IHN5cwppbXBvcnQgY3N2CmltcG9ydCB4bWwuZXRyZWUuRWxlbWVudFRyZWUgYXMgRVQKCmZpbGVfcGF0aCA9IHN5cy5hcmd2WzFdCm5fcm93cyA9IGludChzeXMuYXJndlsyXSkgaWYgbGVuKHN5cy5hcmd2KSA+IDIgZWxzZSAxMAoKcm9vdCA9IEVULkVsZW1lbnQoInJvd3MiKQoKd2l0aCBvcGVuKGZpbGVfcGF0aCwgInIiLCBlbmNvZGluZz0idXRmLTgiLCBlcnJvcnM9Imlnbm9yZSIpIGFzIGZoOgogICAgcmVhZGVyID0gY3N2LnJlYWRlcihmaCkKICAgIGZvciByb3dfaWR4LCByb3dfZGF0YSBpbiBlbnVtZXJhdGUocmVhZGVyKToKICAgICAgICBpZiByb3dfaWR4ID49IG5fcm93czoKICAgICAgICAgICAgYnJlYWsKICAgICAgICByb3dfZWxlbSA9IEVULlN1YkVsZW1lbnQocm9vdCwgInJvdyIsIGluZGV4PXN0cihyb3dfaWR4KSkKICAgICAgICBmb3IgY29sX2lkeCwgY2VsbF92YWx1ZSBpbiBlbnVtZXJhdGUocm93X2RhdGEpOgogICAgICAgICAgICBjZWxsX2VsZW0gPSBFVC5TdWJFbGVtZW50KHJvd19lbGVtLCAiY2VsbCIsIGNvbHVtbj1zdHIoY29sX2lkeCkpCiAgICAgICAgICAgIGNlbGxfZWxlbS50ZXh0ID0gY2VsbF92YWx1ZSBpZiBjZWxsX3ZhbHVlIGVsc2UgIiIKCnRyZWUgPSBFVC5FbGVtZW50VHJlZShyb290KQpFVC5pbmRlbnQodHJlZSwgc3BhY2U9IiAgIikKcHJpbnQoJzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+JykKcHJpbnQoRVQudG9zdHJpbmcocm9vdCwgZW5jb2Rpbmc9InVuaWNvZGUiKSkKCg==",
+    "preview_head_excel.py": "aW1wb3J0IHN5cwppbXBvcnQgb3BlbnB5eGwKaW1wb3J0IHhtbC5ldHJlZS5FbGVtZW50VHJlZSBhcyBFVAoKZmlsZV9wYXRoID0gc3lzLmFyZ3ZbMV0Kbl9yb3dzID0gaW50KHN5cy5hcmd2WzJdKSBpZiBsZW4oc3lzLmFyZ3YpID4gMiBlbHNlIDEwCgp3YiA9IG9wZW5weXhsLmxvYWRfd29ya2Jvb2soZmlsZV9wYXRoLCByZWFkX29ubHk9VHJ1ZSwgZGF0YV9vbmx5PVRydWUpCndzID0gd2Iud29ya3NoZWV0c1swXQoKcm9vdCA9IEVULkVsZW1lbnQoInJvd3MiKQoKcm93c19wcmludGVkID0gMApmb3Igcm93X2lkeCwgcm93IGluIGVudW1lcmF0ZSh3cy5pdGVyX3Jvd3MoKSk6CiAgICBpZiByb3dzX3ByaW50ZWQgPj0gbl9yb3dzOgogICAgICAgIGJyZWFrCiAgICByb3dfZWxlbSA9IEVULlN1YkVsZW1lbnQocm9vdCwgInJvdyIsIGluZGV4PXN0cihyb3dfaWR4KSkKICAgIAogICAgZm9yIGNvbF9pZHgsIGNlbGwgaW4gZW51bWVyYXRlKHJvdyk6CiAgICAgICAgY2VsbF9lbGVtID0gRVQuU3ViRWxlbWVudChyb3dfZWxlbSwgImNlbGwiLCBjb2x1bW49c3RyKGNvbF9pZHgpKQogICAgICAgIGNlbGxfdmFsdWUgPSBjZWxsLnZhbHVlCiAgICAgICAgY2VsbF9lbGVtLnRleHQgPSBzdHIoY2VsbF92YWx1ZSkgaWYgY2VsbF92YWx1ZSBpcyBub3QgTm9uZSBlbHNlICIiCiAgICAKICAgIHJvd3NfcHJpbnRlZCArPSAxCgp0cmVlID0gRVQuRWxlbWVudFRyZWUocm9vdCkKRVQuaW5kZW50KHRyZWUsIHNwYWNlPSIgICIpCnByaW50KCc8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PicpCnByaW50KEVULnRvc3RyaW5nKHJvb3QsIGVuY29kaW5nPSJ1bmljb2RlIikpCgo=",
+    "preview_mid_csv.py": "aW1wb3J0IHN5cwppbXBvcnQgY3N2CmltcG9ydCByYW5kb20KaW1wb3J0IHhtbC5ldHJlZS5FbGVtZW50VHJlZSBhcyBFVAoKZmlsZV9wYXRoID0gc3lzLmFyZ3ZbMV0Kc3RhcnRfcm93ID0gaW50KHN5cy5hcmd2WzJdKQplbmRfcm93ID0gaW50KHN5cy5hcmd2WzNdKQpuX3NhbXBsZXMgPSBpbnQoc3lzLmFyZ3ZbNF0pIGlmIGxlbihzeXMuYXJndikgPiA0IGVsc2UgMTAKCnJvb3QgPSBFVC5FbGVtZW50KCJyb3dzIikKCndpdGggb3BlbihmaWxlX3BhdGgsICJyIiwgZW5jb2Rpbmc9InV0Zi04IiwgZXJyb3JzPSJpZ25vcmUiKSBhcyBmaDoKICAgIHJlYWRlciA9IGNzdi5yZWFkZXIoZmgpCiAgICBhbGxfcm93cyA9IGxpc3QocmVhZGVyKQoKbWlkX3NlY3Rpb24gPSBhbGxfcm93c1tzdGFydF9yb3c6ZW5kX3Jvd10KCmlmIGxlbihtaWRfc2VjdGlvbikgPD0gbl9zYW1wbGVzOgogICAgc2FtcGxlZF93aXRoX2lkeCA9IFsoaSwgcm93KSBmb3IgaSwgcm93IGluIGVudW1lcmF0ZShtaWRfc2VjdGlvbildCmVsc2U6CiAgICByYW5kb20uc2VlZCg0MikKICAgIHNhbXBsZWRfd2l0aF9pZHggPSBzb3J0ZWQocmFuZG9tLnNhbXBsZShsaXN0KGVudW1lcmF0ZShtaWRfc2VjdGlvbikpLCBuX3NhbXBsZXMpLCBrZXk9bGFtYmRhIHg6IHhbMF0pCgpmb3IgcmVsYXRpdmVfaWR4LCByb3dfZGF0YSBpbiBzYW1wbGVkX3dpdGhfaWR4OgogICAgYWN0dWFsX2lkeCA9IHN0YXJ0X3JvdyArIHJlbGF0aXZlX2lkeAogICAgcm93X2VsZW0gPSBFVC5TdWJFbGVtZW50KHJvb3QsICJyb3ciLCBpbmRleD1zdHIoYWN0dWFsX2lkeCkpCiAgICBmb3IgY29sX2lkeCwgY2VsbF92YWx1ZSBpbiBlbnVtZXJhdGUocm93X2RhdGEpOgogICAgICAgIGNlbGxfZWxlbSA9IEVULlN1YkVsZW1lbnQocm93X2VsZW0sICJjZWxsIiwgY29sdW1uPXN0cihjb2xfaWR4KSkKICAgICAgICBjZWxsX2VsZW0udGV4dCA9IGNlbGxfdmFsdWUgaWYgY2VsbF92YWx1ZSBlbHNlICIiCgp0cmVlID0gRVQuRWxlbWVudFRyZWUocm9vdCkKRVQuaW5kZW50KHRyZWUsIHNwYWNlPSIgICIpCnByaW50KCc8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PicpCnByaW50KEVULnRvc3RyaW5nKHJvb3QsIGVuY29kaW5nPSJ1bmljb2RlIikpCgo=",
+    "preview_mid_excel.py": "aW1wb3J0IHN5cwppbXBvcnQgcmFuZG9tCmltcG9ydCBvcGVucHl4bAppbXBvcnQgeG1sLmV0cmVlLkVsZW1lbnRUcmVlIGFzIEVUCgpmaWxlX3BhdGggPSBzeXMuYXJndlsxXQpzdGFydF9yb3cgPSBpbnQoc3lzLmFyZ3ZbMl0pCmVuZF9yb3cgPSBpbnQoc3lzLmFyZ3ZbM10pCm5fc2FtcGxlcyA9IGludChzeXMuYXJndls0XSkgaWYgbGVuKHN5cy5hcmd2KSA+IDQgZWxzZSAxMAoKd2IgPSBvcGVucHl4bC5sb2FkX3dvcmtib29rKGZpbGVfcGF0aCwgcmVhZF9vbmx5PVRydWUsIGRhdGFfb25seT1UcnVlKQp3cyA9IHdiLndvcmtzaGVldHNbMF0KCnJvb3QgPSBFVC5FbGVtZW50KCJyb3dzIikKCmFsbF9yb3dzID0gbGlzdCh3cy5pdGVyX3Jvd3MoKSkKbWlkX3NlY3Rpb24gPSBhbGxfcm93c1tzdGFydF9yb3c6ZW5kX3Jvd10KCmlmIGxlbihtaWRfc2VjdGlvbikgPD0gbl9zYW1wbGVzOgogICAgc2FtcGxlZF93aXRoX2lkeCA9IFsoaSwgcm93KSBmb3IgaSwgcm93IGluIGVudW1lcmF0ZShtaWRfc2VjdGlvbildCmVsc2U6CiAgICByYW5kb20uc2VlZCg0MikKICAgIGluZGljZXMgPSBzb3J0ZWQocmFuZG9tLnNhbXBsZShyYW5nZShsZW4obWlkX3NlY3Rpb24pKSwgbl9zYW1wbGVzKSkKICAgIHNhbXBsZWRfd2l0aF9pZHggPSBbKGksIG1pZF9zZWN0aW9uW2ldKSBmb3IgaSBpbiBpbmRpY2VzXQoKZm9yIHJlbGF0aXZlX2lkeCwgcm93IGluIHNhbXBsZWRfd2l0aF9pZHg6CiAgICBhY3R1YWxfaWR4ID0gc3RhcnRfcm93ICsgcmVsYXRpdmVfaWR4CiAgICByb3dfZWxlbSA9IEVULlN1YkVsZW1lbnQocm9vdCwgInJvdyIsIGluZGV4PXN0cihhY3R1YWxfaWR4KSkKICAgIAogICAgZm9yIGNvbF9pZHgsIGNlbGwgaW4gZW51bWVyYXRlKHJvdyk6CiAgICAgICAgY2VsbF9lbGVtID0gRVQuU3ViRWxlbWVudChyb3dfZWxlbSwgImNlbGwiLCBjb2x1bW49c3RyKGNvbF9pZHgpKQogICAgICAgIGNlbGxfdmFsdWUgPSBjZWxsLnZhbHVlCiAgICAgICAgY2VsbF9lbGVtLnRleHQgPSBzdHIoY2VsbF92YWx1ZSkgaWYgY2VsbF92YWx1ZSBpcyBub3QgTm9uZSBlbHNlICIiCgp0cmVlID0gRVQuRWxlbWVudFRyZWUocm9vdCkKRVQuaW5kZW50KHRyZWUsIHNwYWNlPSIgICIpCnByaW50KCc8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PicpCnByaW50KEVULnRvc3RyaW5nKHJvb3QsIGVuY29kaW5nPSJ1bmljb2RlIikpCgo=",
+    "preview_tail_csv.py": "aW1wb3J0IHN5cwppbXBvcnQgY3N2CmltcG9ydCB4bWwuZXRyZWUuRWxlbWVudFRyZWUgYXMgRVQKZnJvbSBjb2xsZWN0aW9ucyBpbXBvcnQgZGVxdWUKCmZpbGVfcGF0aCA9IHN5cy5hcmd2WzFdCm5fcm93cyA9IGludChzeXMuYXJndlsyXSkgaWYgbGVuKHN5cy5hcmd2KSA+IDIgZWxzZSAxMAoKcm9vdCA9IEVULkVsZW1lbnQoInJvd3MiKQoKd2l0aCBvcGVuKGZpbGVfcGF0aCwgInIiLCBlbmNvZGluZz0idXRmLTgiLCBlcnJvcnM9Imlnbm9yZSIpIGFzIGZoOgogICAgcmVhZGVyID0gY3N2LnJlYWRlcihmaCkKICAgIGFsbF9yb3dzID0gbGlzdChyZWFkZXIpCiAgICB0YWlsX3Jvd3MgPSBhbGxfcm93c1stbl9yb3dzOl0gaWYgbGVuKGFsbF9yb3dzKSA+IG5fcm93cyBlbHNlIGFsbF9yb3dzCiAgICBzdGFydF9pbmRleCA9IGxlbihhbGxfcm93cykgLSBsZW4odGFpbF9yb3dzKQogICAgCiAgICBmb3IgaWR4LCByb3dfZGF0YSBpbiBlbnVtZXJhdGUodGFpbF9yb3dzKToKICAgICAgICByb3dfZWxlbSA9IEVULlN1YkVsZW1lbnQocm9vdCwgInJvdyIsIGluZGV4PXN0cihzdGFydF9pbmRleCArIGlkeCkpCiAgICAgICAgZm9yIGNvbF9pZHgsIGNlbGxfdmFsdWUgaW4gZW51bWVyYXRlKHJvd19kYXRhKToKICAgICAgICAgICAgY2VsbF9lbGVtID0gRVQuU3ViRWxlbWVudChyb3dfZWxlbSwgImNlbGwiLCBjb2x1bW49c3RyKGNvbF9pZHgpKQogICAgICAgICAgICBjZWxsX2VsZW0udGV4dCA9IGNlbGxfdmFsdWUgaWYgY2VsbF92YWx1ZSBlbHNlICIiCgp0cmVlID0gRVQuRWxlbWVudFRyZWUocm9vdCkKRVQuaW5kZW50KHRyZWUsIHNwYWNlPSIgICIpCnByaW50KCc8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PicpCnByaW50KEVULnRvc3RyaW5nKHJvb3QsIGVuY29kaW5nPSJ1bmljb2RlIikpCgo=",
+    "preview_tail_excel.py": "aW1wb3J0IHN5cwppbXBvcnQgb3BlbnB5eGwKaW1wb3J0IHhtbC5ldHJlZS5FbGVtZW50VHJlZSBhcyBFVAoKZmlsZV9wYXRoID0gc3lzLmFyZ3ZbMV0Kbl9yb3dzID0gaW50KHN5cy5hcmd2WzJdKSBpZiBsZW4oc3lzLmFyZ3YpID4gMiBlbHNlIDEwCgp3YiA9IG9wZW5weXhsLmxvYWRfd29ya2Jvb2soZmlsZV9wYXRoLCByZWFkX29ubHk9VHJ1ZSwgZGF0YV9vbmx5PVRydWUpCndzID0gd2Iud29ya3NoZWV0c1swXQoKcm9vdCA9IEVULkVsZW1lbnQoInJvd3MiKQoKYWxsX3Jvd3MgPSBsaXN0KHdzLml0ZXJfcm93cygpKQp0YWlsX3Jvd3MgPSBhbGxfcm93c1stbl9yb3dzOl0gaWYgbGVuKGFsbF9yb3dzKSA+IG5fcm93cyBlbHNlIGFsbF9yb3dzCnN0YXJ0X2luZGV4ID0gbGVuKGFsbF9yb3dzKSAtIGxlbih0YWlsX3Jvd3MpCgpmb3IgaWR4LCByb3cgaW4gZW51bWVyYXRlKHRhaWxfcm93cyk6CiAgICByb3dfZWxlbSA9IEVULlN1YkVsZW1lbnQocm9vdCwgInJvdyIsIGluZGV4PXN0cihzdGFydF9pbmRleCArIGlkeCkpCiAgICAKICAgIGZvciBjb2xfaWR4LCBjZWxsIGluIGVudW1lcmF0ZShyb3cpOgogICAgICAgIGNlbGxfZWxlbSA9IEVULlN1YkVsZW1lbnQocm93X2VsZW0sICJjZWxsIiwgY29sdW1uPXN0cihjb2xfaWR4KSkKICAgICAgICBjZWxsX3ZhbHVlID0gY2VsbC52YWx1ZQogICAgICAgIGNlbGxfZWxlbS50ZXh0ID0gc3RyKGNlbGxfdmFsdWUpIGlmIGNlbGxfdmFsdWUgaXMgbm90IE5vbmUgZWxzZSAiIgoKdHJlZSA9IEVULkVsZW1lbnRUcmVlKHJvb3QpCkVULmluZGVudCh0cmVlLCBzcGFjZT0iICAiKQpwcmludCgnPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4nKQpwcmludChFVC50b3N0cmluZyhyb290LCBlbmNvZGluZz0idW5pY29kZSIpKQoK"
+});

package/dist/file/steps.d.ts

@@ -1,9 +1,8 @@
 export declare function readInstantFileStep(params: {
-    env: any;
+    runtime: any;
     fileId: string;
 }): Promise<{
     url: string;
     contentDisposition?: string;
     contentBase64: string;
 }>;
-//# sourceMappingURL=steps.d.ts.map

package/dist/file/steps.js

@@ -1,10 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readInstantFileStep = readInstantFileStep;
-const runtime_1 = require("@ekairos/events/runtime");
-async function readInstantFileStep(params) {
+async function getRuntimeDb(runtime) {
+    if (!runtime) {
+        throw new Error("Dataset file step requires runtime.");
+    }
+    const db = runtime.db;
+    return typeof db === "function" ? await db.call(runtime) : db;
+}
+export async function readInstantFileStep(params) {
     "use step";
-    const db = (await (0, runtime_1.getContextRuntime)(params.env)).db;
+    const db = await getRuntimeDb(params.runtime);
     const fileQuery = await db.query({
         $files: { $: { where: { id: params.fileId }, limit: 1 } },
     });
@@ -20,4 +23,3 @@ async function readInstantFileStep(params) {
         contentBase64: Buffer.from(fileBuffer).toString("base64"),
     };
 }
-//# sourceMappingURL=steps.js.map

package/dist/id.d.ts

@@ -0,0 +1 @@
+export declare function createDatasetId(): string;

package/dist/id.js

@@ -0,0 +1,10 @@
+export function createDatasetId() {
+    const uuid = globalThis.crypto?.randomUUID?.();
+    if (typeof uuid === "string" && uuid.length > 0)
+        return uuid;
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-export * from "./dataset";
-export * from "./domain";
-export * from "./materializeDataset.tool";
-export * from "./schema";
-export * from "./service";
-export * from "./skill";
-//# sourceMappingURL=index.d.ts.map
+export * from "./dataset.js";
+export * from "./contextWorkspace.js";
+export * from "./domain.js";
+export * from "./materializeDataset.tool.js";
+export * from "./notation.js";
+export * from "./schema.js";
+export * from "./service.js";
+export { registerFileParseContext } from "./file/file-dataset.agent.js";
+export { registerTransformDatasetContext } from "./transform/index.js";

package/dist/index.js

@@ -1,23 +1,9 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./dataset"), exports);
-__exportStar(require("./domain"), exports);
-__exportStar(require("./materializeDataset.tool"), exports);
-__exportStar(require("./schema"), exports);
-__exportStar(require("./service"), exports);
-__exportStar(require("./skill"), exports);
-//# sourceMappingURL=index.js.map
+export * from "./dataset.js";
+export * from "./contextWorkspace.js";
+export * from "./domain.js";
+export * from "./materializeDataset.tool.js";
+export * from "./notation.js";
+export * from "./schema.js";
+export * from "./service.js";
+export { registerFileParseContext } from "./file/file-dataset.agent.js";
+export { registerTransformDatasetContext } from "./transform/index.js";

package/dist/materializeDataset.tool.d.ts

@@ -1,31 +1,45 @@
 import { z } from "zod";
 import type { DomainSchemaResult } from "@ekairos/domain";
+import type { EkairosRuntime, RuntimeForDomain } from "@ekairos/domain/runtime";
 import type { ContextReactor } from "@ekairos/events";
+import { datasetDomain } from "./schema.js";
 declare const materializeDatasetToolInputSchema: z.ZodObject<{
     datasetId: z.ZodOptional<z.ZodString>;
     sandboxId: z.ZodOptional<z.ZodString>;
     title: z.ZodOptional<z.ZodString>;
-    sources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"file">;
+    context: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$strip>]>>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
         fileId: z.ZodString;
+    }, z.core.$strip>>>;
+    texts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"text">;
         text: z.ZodString;
         mimeType: z.ZodOptional<z.ZodString>;
-        name: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"dataset">;
+    }, z.core.$strip>>>;
+    datasets: z.ZodOptional<z.ZodArray<z.ZodObject<{
         datasetId: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"query">;
-        query: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, z.core.$strip>>>;
+    queries: z.ZodOptional<z.ZodArray<z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
+        query: z.ZodRecord<z.ZodString, z.ZodAny>;
         explanation: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>>>;
     instructions: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        schema: "schema";
+        auto: "auto";
+    }>>;
+    output: z.ZodOptional<z.ZodEnum<{
+        object: "object";
+        rows: "rows";
+    }>>;
     schema: z.ZodOptional<z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
@@ -33,38 +47,45 @@ declare const materializeDatasetToolInputSchema: z.ZodObject<{
     }, z.core.$strip>>;
     first: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-export declare function createMaterializeDatasetTool<Env extends {
-    orgId: string;
-}>(params: {
-    env: Env;
+type AnyMaterializeDatasetRuntime = EkairosRuntime<any, any, any>;
+type MaterializeDatasetRuntimeHandle<Runtime extends AnyMaterializeDatasetRuntime> = RuntimeForDomain<Runtime, typeof datasetDomain>;
+type CompatibleToolQueryDomain<Runtime extends AnyMaterializeDatasetRuntime, QueryDomain extends DomainSchemaResult> = RuntimeForDomain<Runtime, QueryDomain> extends never ? never : QueryDomain;
+export declare function createMaterializeDatasetTool<Runtime extends AnyMaterializeDatasetRuntime, QueryDomain extends DomainSchemaResult>(params: {
+    runtime: Runtime & MaterializeDatasetRuntimeHandle<Runtime>;
     reactor?: ContextReactor<any, any>;
-    queryDomain: DomainSchemaResult;
+    queryDomain: QueryDomain & CompatibleToolQueryDomain<Runtime, QueryDomain>;
     toolName?: string;
 }): import("ai").Tool<{
-    sources: ({
-        kind: "file";
+    datasetId?: string | undefined;
+    sandboxId?: string | undefined;
+    title?: string | undefined;
+    context?: {
+        id: string;
+    } | {
+        key: string;
+    } | undefined;
+    files?: {
         fileId: string;
         description?: string | undefined;
-    } | {
-        kind: "text";
+    }[] | undefined;
+    texts?: {
         text: string;
-        mimeType?: string | undefined;
         name?: string | undefined;
         description?: string | undefined;
-    } | {
-        kind: "dataset";
+        mimeType?: string | undefined;
+    }[] | undefined;
+    datasets?: {
         datasetId: string;
         description?: string | undefined;
-    } | {
-        kind: "query";
+    }[] | undefined;
+    queries?: {
         query: Record<string, any>;
         title?: string | undefined;
         explanation?: string | undefined;
-    })[];
-    datasetId?: string | undefined;
-    sandboxId?: string | undefined;
-    title?: string | undefined;
+    }[] | undefined;
     instructions?: string | undefined;
+    mode?: "schema" | "auto" | undefined;
+    output?: "object" | "rows" | undefined;
     schema?: {
         schema: any;
         title?: string | undefined;
@@ -75,4 +96,3 @@ export declare function createMaterializeDatasetTool<Env extends {
     datasetId: string;
 }>;
 export { materializeDatasetToolInputSchema };
-//# sourceMappingURL=materializeDataset.tool.d.ts.map