@ekairos/dataset 1.22.83-beta.development.0 → 1.22.84-beta.development.0

package/dist/schema.d.ts

@@ -8,8 +8,6 @@ declare const entities: {
         updatedAt: import("@instantdb/core").DataAttrDef<number, false, false, false>;
         organizationId: import("@instantdb/core").DataAttrDef<string, false, true, false>;
         title: import("@instantdb/core").DataAttrDef<string, false, false, false>;
-        sources: import("@instantdb/core").DataAttrDef<any, false, false, false>;
-        sourceKinds: import("@instantdb/core").DataAttrDef<any, false, false, false>;
         instructions: import("@instantdb/core").DataAttrDef<string, false, false, false>;
         analysis: import("@instantdb/core").DataAttrDef<any, false, false, false>;
         schema: import("@instantdb/core").DataAttrDef<any, false, false, false>;
@@ -47,6 +45,18 @@ declare const links: {
             readonly label: "datasets";
         };
     };
+    readonly dataset_datasetsContext: {
+        readonly forward: {
+            readonly on: "dataset_datasets";
+            readonly has: "one";
+            readonly label: "context";
+        };
+        readonly reverse: {
+            readonly on: "event_contexts";
+            readonly has: "many";
+            readonly label: "datasets";
+        };
+    };
 };
 declare const rooms: {};
 export declare const datasetDomain: DomainSchemaResult<typeof entities, typeof links, typeof rooms, {}, "dataset", "dataset">;

package/dist/schema.js

@@ -1,5 +1,6 @@
 import { i } from "@instantdb/core";
 import { domain } from "@ekairos/domain";
+import { eventsDomain } from "@ekairos/events";
 const entities = {
     dataset_datasets: i.entity({
         datasetId: i.string().unique().indexed(),
@@ -9,8 +10,6 @@ const entities = {
         updatedAt: i.number().optional(),
         organizationId: i.string().optional().indexed(),
         title: i.string().optional(),
-        sources: i.json().optional(),
-        sourceKinds: i.json().optional(),
         instructions: i.string().optional(),
         analysis: i.json().optional(),
         schema: i.json().optional(),
@@ -32,9 +31,13 @@ const links = {
         forward: { on: "dataset_datasets", has: "one", label: "dataFile" },
         reverse: { on: "$files", has: "many", label: "datasets" },
     },
+    dataset_datasetsContext: {
+        forward: { on: "dataset_datasets", has: "one", label: "context" },
+        reverse: { on: "event_contexts", has: "many", label: "datasets" },
+    },
 };
 const rooms = {};
-export const datasetDomain = domain("dataset").withSchema({
+export const datasetDomain = domain("dataset").includes(eventsDomain).withSchema({
     entities,
     links,
     rooms,

package/dist/service.d.ts

@@ -15,8 +15,7 @@ export declare class DatasetService {
     private resolveDatasetEntityId;
     createDataset(params: {
         id?: string;
-        sources?: any;
-        sourceKinds?: any;
+        contextId?: string;
         instructions?: string;
         status?: string;
         organizationId?: string;

package/dist/service.js

@@ -28,18 +28,21 @@ export class DatasetService {
     async createDataset(params) {
         try {
             const datasetId = params.id ?? createDatasetId();
+            const { id: _id, contextId, ...attrs } = params;
             const existing = await this.resolveDatasetEntityId(datasetId);
             const entityId = existing.ok ? existing.data : createDatasetId();
             const mutations = [];
             mutations.push(this.db.tx.dataset_datasets[entityId].update({
                 datasetId,
-                sources: params.sources ?? "",
                 instructions: params.instructions ?? "",
                 status: params.status ?? "created",
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
-                ...params,
+                ...attrs,
             }));
+            if (contextId) {
+                mutations.push(this.db.tx.dataset_datasets[entityId].link({ context: contextId }));
+            }
             await this.db.transact(mutations);
             return { ok: true, data: { datasetId } };
         }

package/dist/transform/filepreview.d.ts

@@ -1,4 +1,4 @@
-export type TransformSourcePreviewContext = {
+export type TransformInputPreviewContext = {
     totalRows: number;
     metadata?: {
         description: string;
@@ -18,5 +18,5 @@ export type TransformSourcePreviewContext = {
 interface PreviewOptions {
     headLines?: number;
 }
-export declare function generateSourcePreview(runtime: any, sandboxId: string, sourcePath: string, datasetId: string, options?: PreviewOptions): Promise<TransformSourcePreviewContext>;
+export declare function generateInputPreview(runtime: any, sandboxId: string, inputPath: string, datasetId: string, options?: PreviewOptions): Promise<TransformInputPreviewContext>;
 export {};

package/dist/transform/filepreview.js

@@ -17,7 +17,7 @@ async function runPythonSnippet(runtime, sandboxId, datasetId, scriptName, code,
         stderr,
     };
 }
-export async function generateSourcePreview(runtime, sandboxId, sourcePath, datasetId, options = {}) {
+export async function generateInputPreview(runtime, sandboxId, inputPath, datasetId, options = {}) {
     const context = {
         totalRows: 0,
     };
@@ -41,7 +41,7 @@ try:
 except Exception as e:
     print(str(e))
 `;
-    const meta = await runPythonSnippet(runtime, sandboxId, datasetId, "jsonl_count", countScript, [sourcePath], "Counts number of JSONL records with type='row'");
+    const meta = await runPythonSnippet(runtime, sandboxId, datasetId, "jsonl_count", countScript, [inputPath], "Counts number of JSONL records with type='row'");
     context.metadata = meta;
     try {
         if (meta.stdout) {
@@ -76,7 +76,7 @@ try:
 except Exception as e:
     print(str(e))
 `;
-    const head = await runPythonSnippet(runtime, sandboxId, datasetId, "jsonl_head", headScript, [sourcePath, String(headLines)], `Reads the first ${headLines} JSONL row records`);
+    const head = await runPythonSnippet(runtime, sandboxId, datasetId, "jsonl_head", headScript, [inputPath, String(headLines)], `Reads the first ${headLines} JSONL row records`);
     context.head = head;
     return context;
 }

package/dist/transform/prompts.js

@@ -9,7 +9,7 @@ function buildRole() {
 function buildGoal() {
     let xml = create()
         .ele("Goal")
-        .txt("Transform the source dataset(s) (JSONL with {type:'row', data:{...}} per line) into a new dataset strictly matching the output schema. Save to output.jsonl in the dataset workstation. Each line must remain a single JSON object representing one record. You may need to combine, filter, or reshape data from multiple source datasets.")
+        .txt("Transform the input dataset(s) (JSONL with {type:'row', data:{...}} per line) into a new dataset strictly matching the output schema. Save to output.jsonl in the dataset workstation. Each line must remain a single JSON object representing one record. You may need to combine, filter, or reshape data from multiple input datasets.")
         .up();
     return xml.end({ prettyPrint: true, headless: true });
 }
@@ -17,26 +17,26 @@ function buildContextSection(context) {
     let xml = create()
         .ele("Context")
         .ele("DatasetId").txt(context.datasetId).up();
-    let sourcesXml = create().ele("SourceDatasets");
-    for (const sourceId of context.sourceDatasetIds) {
-        sourcesXml = sourcesXml.ele("SourceDatasetId").txt(sourceId).up();
+    let inputsXml = create().ele("InputDatasets");
+    for (const sourceId of context.inputDatasetIds) {
+        inputsXml = inputsXml.ele("InputDatasetId").txt(sourceId).up();
     }
-    xml = xml.import(sourcesXml.first());
+    xml = xml.import(inputsXml.first());
     let sandboxXml = create().ele("Sandbox");
-    for (const sourcePathInfo of context.sandboxConfig.sourcePaths) {
-        sandboxXml = sandboxXml.ele("SourceFile")
-            .ele("DatasetId").txt(sourcePathInfo.datasetId).up()
-            .ele("Path").txt(sourcePathInfo.path).up()
+    for (const inputPathInfo of context.sandboxConfig.inputPaths) {
+        sandboxXml = sandboxXml.ele("InputFile")
+            .ele("DatasetId").txt(inputPathInfo.datasetId).up()
+            .ele("Path").txt(inputPathInfo.path).up()
             .up();
     }
     sandboxXml = sandboxXml.ele("OutputPath").txt(context.sandboxConfig.outputPath).up();
     xml = xml.import(sandboxXml.first());
-    if (context.sourcePreviews && context.sourcePreviews.length > 0) {
-        let previewsXml = create().ele("SourcePreviews");
-        for (const sourcePreviewInfo of context.sourcePreviews) {
-            const sp = sourcePreviewInfo.preview;
-            let px = create().ele("SourcePreview")
-                .ele("DatasetId").txt(sourcePreviewInfo.datasetId).up()
+    if (context.inputPreviews && context.inputPreviews.length > 0) {
+        let previewsXml = create().ele("InputPreviews");
+        for (const inputPreviewInfo of context.inputPreviews) {
+            const sp = inputPreviewInfo.preview;
+            let px = create().ele("InputPreview")
+                .ele("DatasetId").txt(inputPreviewInfo.datasetId).up()
                 .ele("TotalRows").txt(String(sp.totalRows)).up();
             if (sp.metadata) {
                 const m = sp.metadata;
@@ -86,21 +86,21 @@ function buildOutputSchemaSection(context) {
 }
 function buildInstructions(context) {
     const outputPath = context.sandboxConfig.outputPath;
-    const multipleSourcesNote = context.sourceDatasetIds.length > 1
-        ? "You have multiple source datasets available. You may need to read, join, filter, or combine data from them to produce the output."
+    const multipleInputsNote = context.inputDatasetIds.length > 1
+        ? "You have multiple input datasets available. You may need to read, join, filter, or combine data from them to produce the output."
         : "";
     let xml = create()
         .ele("Instructions")
         .ele("Workflow")
-        .ele("Step", { number: "1", name: "Inspect Source" })
-        .ele("Action").txt(`Review SourcePreviews to understand current record structures (data fields, shapes, edge cases). ${multipleSourcesNote}`).up()
+        .ele("Step", { number: "1", name: "Inspect Inputs" })
+        .ele("Action").txt(`Review InputPreviews to understand current record structures (data fields, shapes, edge cases). ${multipleInputsNote}`).up()
         .up()
         .ele("Step", { number: "2", name: "Plan Mapping" })
-        .ele("Action").txt("Plan a deterministic mapping from source data fields to the output schema fields (normalize names, types, and formats).").up()
-        .ele("Note").txt("If fields are missing, set defaults; if types differ, coerce consistently. When working with multiple sources, decide how to combine or relate them. Output field names must remain exactly as declared by the output schema.").up()
+        .ele("Action").txt("Plan a deterministic mapping from input data fields to the output schema fields (normalize names, types, and formats).").up()
+        .ele("Note").txt("If fields are missing, set defaults; if types differ, coerce consistently. When working with multiple inputs, decide how to combine or relate them. Output field names must remain exactly as declared by the output schema.").up()
         .up()
         .ele("Step", { number: "3", name: "Transform" })
-        .ele("Action").txt("Use executeCommand to run a Python script that reads source JSONL file(s) and writes transformed records to output.jsonl. Keep line-per-record JSON objects with { 'type': 'row', 'data': { ... } }.").up()
+        .ele("Action").txt("Use executeCommand to run a Python script that reads input JSONL file(s) and writes transformed records to output.jsonl. Keep line-per-record JSON objects with { 'type': 'row', 'data': { ... } }.").up()
         .ele("Requirement").txt(`Write file to: ${outputPath}`).up()
         .ele("Requirement").txt("Every data object MUST use the exact property names from OutputSchema required/properties keys. Do not translate, localize, rename, or infer alternative field names.").up()
         .ele("Requirement").txt("Do not print large data to stdout; only progress and summaries.").up()
@@ -112,12 +112,12 @@ function buildInstructions(context) {
         .up()
         .ele("Rules")
         .ele("Rule").txt("Output must strictly match the output schema for each record in data.").up()
-        .ele("Rule").txt("OutputSchema property names are authoritative. Field names are a technical contract; only field values may preserve source language.").up()
+        .ele("Rule").txt("OutputSchema property names are authoritative. Field names are a technical contract; only field values may preserve input language.").up()
         .ele("Rule").txt("Each line in output.jsonl must be a standalone JSON object with {type:'row', data:{...}}.").up()
         .ele("Rule").txt("Do not include headers, summaries, or metadata as records.").up()
-        .ele("Rule").txt("Be robust to malformed lines in source: skip or sanitize, but do not crash.").up()
+        .ele("Rule").txt("Be robust to malformed lines in input: skip or sanitize, but do not crash.").up()
         .up()
-        .ele("CurrentTask").txt("Transform source dataset(s) to match OutputSchema and write output.jsonl, then complete.").up()
+        .ele("CurrentTask").txt("Transform input dataset(s) to match OutputSchema and write output.jsonl, then complete.").up()
         .up();
     return xml.end({ prettyPrint: true, headless: true });
 }

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

@@ -1,10 +1,10 @@
 import { type ContextReactor } from "@ekairos/events";
-import type { TransformDatasetRunOptions, TransformSandboxState, TransformSourcePreviewContext } from "./transform-dataset.types.js";
+import type { TransformDatasetRunOptions, TransformSandboxState, TransformInputPreviewContext } from "./transform-dataset.types.js";
 export type { TransformDatasetAgentParams, TransformDatasetContext, TransformDatasetResult, TransformDatasetRunOptions, TransformPromptContext, TransformSandboxState, } from "./transform-dataset.types.js";
 export declare function createTransformDatasetContext<Env extends {
     orgId: string;
 }>(params: {
-    sourceDatasetIds: string[];
+    inputDatasetIds: string[];
     outputSchema: any;
     instructions?: string;
     datasetId?: string;
@@ -12,9 +12,9 @@ export declare function createTransformDatasetContext<Env extends {
     sandboxId?: string;
     reactor?: ContextReactor<any, any>;
     sandboxState?: TransformSandboxState;
-    sourcePreviews?: Array<{
+    inputPreviews?: Array<{
         datasetId: string;
-        preview: TransformSourcePreviewContext;
+        preview: TransformInputPreviewContext;
     }>;
 }): {
     datasetId: string;

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

@@ -4,7 +4,7 @@ import { createCompleteDatasetTool, didCompleteDatasetSucceed, getDatasetFatalFa
 import { datasetUpdateSchemaStep } from "../dataset/steps.js";
 import { getDatasetOutputPath } from "../datasetFiles.js";
 import { createExecuteCommandTool } from "../executeCommand.tool.js";
-import { buildTransformDatasetPromptStep, ensureTransformSourcesInSandboxStep, generateTransformSourcePreviewsStep, } from "./transform-dataset.steps.js";
+import { buildTransformDatasetPromptStep, ensureTransformInputsInSandboxStep, generateTransformInputPreviewsStep, } from "./transform-dataset.steps.js";
 import { createDatasetId } from "../id.js";
 async function awaitContextRun(run) {
     if (!run)
@@ -22,12 +22,12 @@ function createTransformDatasetContextDefinition(params) {
         .context(async (stored, _env, runtime) => {
         const previous = stored?.content ?? {};
         const sandboxState = previous?.sandboxState ??
-            params.sandboxState ?? { initialized: false, sourcePaths: [] };
+            params.sandboxState ?? { initialized: false, inputPaths: [] };
         const datasetId = previous?.datasetId ?? fallbackDatasetId ?? "";
-        const sourceDatasetIds = Array.isArray(previous?.sourceDatasetIds)
-            ? previous.sourceDatasetIds
-            : Array.isArray(params.sourceDatasetIds)
-                ? params.sourceDatasetIds
+        const inputDatasetIds = Array.isArray(previous?.inputDatasetIds)
+            ? previous.inputDatasetIds
+            : Array.isArray(params.inputDatasetIds)
+                ? params.inputDatasetIds
                 : [];
         const outputSchema = previous?.outputSchema ?? params.outputSchema;
         const instructions = previous?.instructions ?? params.instructions;
@@ -35,8 +35,8 @@ function createTransformDatasetContextDefinition(params) {
         if (!datasetId) {
             throw new Error("dataset_id_required");
         }
-        if (sourceDatasetIds.length === 0) {
-            throw new Error("dataset_transform_sources_required");
+        if (inputDatasetIds.length === 0) {
+            throw new Error("dataset_transform_inputs_required");
         }
         if (!outputSchema) {
             throw new Error("dataset_transform_schema_required");
@@ -44,26 +44,26 @@ function createTransformDatasetContextDefinition(params) {
         if (!sandboxId) {
             throw new Error("dataset_sandbox_required");
         }
-        const initialized = sandboxState.initialized && Array.isArray(sandboxState.sourcePaths)
+        const initialized = sandboxState.initialized && Array.isArray(sandboxState.inputPaths)
             ? {
-                sourcePaths: sandboxState.sourcePaths,
+                inputPaths: sandboxState.inputPaths,
                 outputPath: previous?.sandboxConfig?.outputPath ?? getDatasetOutputPath(datasetId),
                 state: sandboxState,
             }
-            : await ensureTransformSourcesInSandboxStep({
+            : await ensureTransformInputsInSandboxStep({
                 runtime,
                 sandboxId,
                 datasetId,
-                sourceDatasetIds,
+                inputDatasetIds,
                 state: sandboxState,
             });
-        let sourcePreviews = previous?.sourcePreviews ?? params.sourcePreviews ?? undefined;
-        if (!sourcePreviews) {
-            sourcePreviews = await generateTransformSourcePreviewsStep({
+        let inputPreviews = previous?.inputPreviews ?? params.inputPreviews ?? undefined;
+        if (!inputPreviews) {
+            inputPreviews = await generateTransformInputPreviewsStep({
                 runtime,
                 sandboxId,
                 datasetId,
-                sourcePaths: initialized.sourcePaths,
+                inputPaths: initialized.inputPaths,
             });
         }
         await datasetUpdateSchemaStep({
@@ -74,13 +74,13 @@ function createTransformDatasetContextDefinition(params) {
         });
         const promptContext = {
             datasetId,
-            sourceDatasetIds,
+            inputDatasetIds,
             outputSchema,
             sandboxConfig: {
-                sourcePaths: initialized.sourcePaths,
+                inputPaths: initialized.inputPaths,
                 outputPath: initialized.outputPath,
             },
-            sourcePreviews: sourcePreviews.length > 0 ? sourcePreviews : undefined,
+            inputPreviews: inputPreviews.length > 0 ? inputPreviews : undefined,
             errors: [],
         };
         const basePrompt = await buildTransformDatasetPromptStep({
@@ -100,14 +100,14 @@ function createTransformDatasetContextDefinition(params) {
         return {
             ...previous,
             datasetId,
-            sourceDatasetIds,
+            inputDatasetIds,
             outputSchema,
             instructions,
             sandboxId,
             sandboxState: initialized.state,
             system,
             sandboxConfig: {
-                sourcePaths: initialized.sourcePaths,
+                inputPaths: initialized.inputPaths,
                 outputPath: initialized.outputPath,
             },
         };
@@ -159,7 +159,7 @@ function createTransformDatasetContextDefinition(params) {
 export function createTransformDatasetContext(params) {
     const datasetId = params.datasetId ?? createDatasetId();
     const { context } = createTransformDatasetContextDefinition({
-        sourceDatasetIds: params.sourceDatasetIds,
+        inputDatasetIds: params.inputDatasetIds,
         outputSchema: params.outputSchema,
         instructions: params.instructions,
         datasetId,
@@ -167,14 +167,14 @@ export function createTransformDatasetContext(params) {
         sandboxId: params.sandboxId,
         reactor: params.reactor,
         sandboxState: params.sandboxState,
-        sourcePreviews: params.sourcePreviews,
+        inputPreviews: params.inputPreviews,
     });
     return {
         datasetId,
         async transform(runtime, options = {}) {
-            const datasetCountText = params.sourceDatasetIds.length === 1
-                ? "the source dataset"
-                : `${params.sourceDatasetIds.length} source datasets`;
+            const datasetCountText = params.inputDatasetIds.length === 1
+                ? "the input dataset"
+                : `${params.inputDatasetIds.length} input datasets`;
             const triggerEvent = {
                 id: createDatasetId(),
                 type: INPUT_TEXT_ITEM_TYPE,
@@ -195,7 +195,6 @@ export function createTransformDatasetContext(params) {
                 context: { key: `dataset:${datasetId}` },
                 durable: options.durable ?? false,
                 options: {
-                    silent: true,
                     preventClose: true,
                     sendFinish: false,
                     maxIterations: 20,
@@ -204,12 +203,12 @@ export function createTransformDatasetContext(params) {
                 __initialContent: {
                     ...(options.initialContent ?? {}),
                     datasetId,
-                    sourceDatasetIds: params.sourceDatasetIds,
+                    inputDatasetIds: params.inputDatasetIds,
                     outputSchema: params.outputSchema,
                     instructions: params.instructions,
                     sandboxId: params.sandboxId ?? "",
-                    sandboxState: params.sandboxState ?? { initialized: false, sourcePaths: [] },
-                    sourcePreviews: params.sourcePreviews,
+                    sandboxState: params.sandboxState ?? { initialized: false, inputPaths: [] },
+                    inputPreviews: params.inputPreviews,
                 },
             });
             await awaitContextRun(shell.run);

package/dist/transform/transform-dataset.steps.d.ts

@@ -1,29 +1,29 @@
-import type { TransformPromptContext, TransformSandboxState, TransformSourcePreviewContext } from "./transform-dataset.types.js";
-export declare function ensureTransformSourcesInSandboxStep(params: {
+import type { TransformPromptContext, TransformSandboxState, TransformInputPreviewContext } from "./transform-dataset.types.js";
+export declare function ensureTransformInputsInSandboxStep(params: {
     runtime: any;
     sandboxId: string;
     datasetId: string;
-    sourceDatasetIds: string[];
+    inputDatasetIds: string[];
     state: TransformSandboxState;
 }): Promise<{
-    sourcePaths: Array<{
+    inputPaths: Array<{
         datasetId: string;
         path: string;
     }>;
     outputPath: string;
     state: TransformSandboxState;
 }>;
-export declare function generateTransformSourcePreviewsStep(params: {
+export declare function generateTransformInputPreviewsStep(params: {
     runtime: any;
     sandboxId: string;
     datasetId: string;
-    sourcePaths: Array<{
+    inputPaths: Array<{
         datasetId: string;
         path: string;
     }>;
 }): Promise<Array<{
     datasetId: string;
-    preview: TransformSourcePreviewContext;
+    preview: TransformInputPreviewContext;
 }>>;
 export declare function buildTransformDatasetPromptStep(params: {
     context: TransformPromptContext;

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

@@ -1,13 +1,13 @@
-import { getDatasetOutputPath, getDatasetSourcesDir, getDatasetStandardDirs, } from "../datasetFiles.js";
+import { getDatasetOutputPath, getDatasetResourcesDir, getDatasetStandardDirs, } from "../datasetFiles.js";
 import { datasetReadOutputJsonlStep } from "../dataset/steps.js";
 import { runDatasetSandboxCommandStep, writeDatasetSandboxFilesStep } from "../sandbox/steps.js";
-import { generateSourcePreview } from "./filepreview.js";
+import { generateInputPreview } from "./filepreview.js";
 import { buildTransformDatasetPrompt } from "./prompts.js";
-export async function ensureTransformSourcesInSandboxStep(params) {
+export async function ensureTransformInputsInSandboxStep(params) {
     "use step";
     if (params.state.initialized) {
         return {
-            sourcePaths: params.state.sourcePaths,
+            inputPaths: params.state.inputPaths,
             outputPath: getDatasetOutputPath(params.datasetId),
             state: params.state,
         };
@@ -18,42 +18,42 @@ export async function ensureTransformSourcesInSandboxStep(params) {
         cmd: "mkdir",
         args: ["-p", ...getDatasetStandardDirs(params.datasetId)],
     });
-    const sourcePaths = [];
-    for (const sourceDatasetId of params.sourceDatasetIds) {
-        const sourcePath = `${getDatasetSourcesDir(params.datasetId)}/source_${sourceDatasetId}.jsonl`;
-        const source = await datasetReadOutputJsonlStep({
+    const inputPaths = [];
+    for (const inputDatasetId of params.inputDatasetIds) {
+        const inputPath = `${getDatasetResourcesDir(params.datasetId)}/resource_${inputDatasetId}.jsonl`;
+        const input = await datasetReadOutputJsonlStep({
             runtime: params.runtime,
-            datasetId: sourceDatasetId,
+            datasetId: inputDatasetId,
         });
         await writeDatasetSandboxFilesStep({
             runtime: params.runtime,
             sandboxId: params.sandboxId,
-            files: [{ path: sourcePath, contentBase64: source.contentBase64 }],
+            files: [{ path: inputPath, contentBase64: input.contentBase64 }],
         });
-        sourcePaths.push({ datasetId: sourceDatasetId, path: sourcePath });
+        inputPaths.push({ datasetId: inputDatasetId, path: inputPath });
     }
     return {
-        sourcePaths,
+        inputPaths,
         outputPath: getDatasetOutputPath(params.datasetId),
         state: {
             initialized: true,
-            sourcePaths,
+            inputPaths,
         },
     };
 }
-export async function generateTransformSourcePreviewsStep(params) {
+export async function generateTransformInputPreviewsStep(params) {
     "use step";
-    const sourcePreviews = [];
-    for (const sourcePath of params.sourcePaths) {
+    const inputPreviews = [];
+    for (const inputPath of params.inputPaths) {
         try {
-            const preview = await generateSourcePreview(params.runtime, params.sandboxId, sourcePath.path, params.datasetId);
-            sourcePreviews.push({ datasetId: sourcePath.datasetId, preview });
+            const preview = await generateInputPreview(params.runtime, params.sandboxId, inputPath.path, params.datasetId);
+            inputPreviews.push({ datasetId: inputPath.datasetId, preview });
         }
         catch {
-            // Source preview is optional; transformation can still read the JSONL files.
+            // Input preview is optional; transformation can still read the JSONL files.
         }
     }
-    return sourcePreviews;
+    return inputPreviews;
 }
 export async function buildTransformDatasetPromptStep(params) {
     "use step";

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

@@ -1,34 +1,34 @@
 import type { ContextReactor } from "@ekairos/events";
-import type { TransformSourcePreviewContext } from "./filepreview.js";
-export type { TransformSourcePreviewContext } from "./filepreview.js";
+import type { TransformInputPreviewContext } from "./filepreview.js";
+export type { TransformInputPreviewContext } from "./filepreview.js";
 export type TransformSandboxState = {
     initialized: boolean;
-    sourcePaths: Array<{
+    inputPaths: Array<{
         datasetId: string;
         path: string;
     }>;
 };
 export type TransformDatasetContext = {
     datasetId: string;
-    sourceDatasetIds: string[];
+    inputDatasetIds: string[];
     outputSchema: any;
     sandboxConfig: {
-        sourcePaths: Array<{
+        inputPaths: Array<{
             datasetId: string;
             path: string;
         }>;
         outputPath: string;
     };
-    sourcePreviews?: Array<{
+    inputPreviews?: Array<{
         datasetId: string;
-        preview: TransformSourcePreviewContext;
+        preview: TransformInputPreviewContext;
     }>;
     errors: string[];
     iterationCount: number;
     instructions?: string;
 };
 export type TransformDatasetAgentParams = {
-    sourceDatasetIds?: string[];
+    inputDatasetIds?: string[];
     outputSchema?: any;
     instructions?: string;
     datasetId?: string;
@@ -36,9 +36,9 @@ export type TransformDatasetAgentParams = {
     sandboxId?: string;
     reactor?: ContextReactor<any, any>;
     sandboxState?: TransformSandboxState;
-    sourcePreviews?: Array<{
+    inputPreviews?: Array<{
         datasetId: string;
-        preview: TransformSourcePreviewContext;
+        preview: TransformInputPreviewContext;
     }>;
 };
 export type TransformDatasetRunOptions = {
@@ -59,16 +59,16 @@ export type TransformDatasetResult = {
 };
 export type TransformPromptContext = {
     datasetId: string;
-    sourceDatasetIds: string[];
+    inputDatasetIds: string[];
     outputSchema: any;
     sandboxConfig: {
-        sourcePaths: Array<{
+        inputPaths: Array<{
             datasetId: string;
             path: string;
         }>;
         outputPath: string;
     };
-    sourcePreviews?: Array<{
+    inputPreviews?: Array<{
         datasetId: string;
         preview: {
             totalRows: number;

package/dist/transform/transformDataset.js

@@ -1,7 +1,7 @@
 import { datasetPreviewRowsStep } from "../dataset/steps.js";
 import { createTransformDatasetContext } from "./transform-dataset.agent.js";
 function buildInstructions(input) {
-    const sources = input.datasets
+    const inputs = input.datasets
         .map((d, idx) => {
         const name = d.description ? ` - ${d.description}` : "";
         return `${idx + 1}. ${d.id}${name}`;
@@ -12,8 +12,8 @@ function buildInstructions(input) {
         "Use pandas when helpful. Output must be JSONL with {type:'row', data:{...}} lines.",
         "Respect the provided output schema exactly.",
         "",
-        "## Source Datasets",
-        sources || "- (none)",
+        "## Input Datasets",
+        inputs || "- (none)",
         "",
         "## Transformation Description (LaTeX + sets)",
         String(input.description ?? "").trim(),
@@ -25,7 +25,7 @@ function buildInstructions(input) {
  */
 export async function transformDataset(runtime, input) {
     const transformContext = createTransformDatasetContext({
-        sourceDatasetIds: input.datasets.map((d) => d.id),
+        inputDatasetIds: input.datasets.map((d) => d.id),
         outputSchema: input.outputSchema,
         instructions: buildInstructions(input),
         datasetId: input.datasetId,