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

package/dist/materializeDataset.tool.d.ts

@@ -7,26 +7,30 @@ 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">;
-        fileId: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"text">;
-        text: z.ZodString;
-        mimeType: z.ZodOptional<z.ZodString>;
+        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>;
+        text: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"dataset">;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, 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";
@@ -52,29 +56,33 @@ export declare function createMaterializeDatasetTool<Runtime extends AnyMaterial
     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;

package/dist/materializeDataset.tool.js

@@ -1,29 +1,33 @@
 import { tool } from "ai";
 import { z } from "zod";
 import { dataset } from "./dataset.js";
-const fileSourceSchema = z.object({
+const fileResourceSchema = z.object({
     kind: z.literal("file"),
     fileId: z.string(),
     description: z.string().optional(),
 });
-const textSourceSchema = z.object({
+const textResourceSchema = z.object({
     kind: z.literal("text"),
     text: z.string(),
     mimeType: z.string().optional(),
     name: z.string().optional(),
     description: z.string().optional(),
 });
-const datasetSourceSchema = z.object({
+const datasetResourceSchema = z.object({
     kind: z.literal("dataset"),
     datasetId: z.string(),
     description: z.string().optional(),
 });
-const querySourceSchema = z.object({
+const queryResourceSchema = z.object({
     kind: z.literal("query"),
     query: z.record(z.string(), z.any()),
     title: z.string().optional(),
     explanation: z.string().optional(),
 });
+const contextInputSchema = z.union([
+    z.object({ id: z.string() }),
+    z.object({ key: z.string() }),
+]);
 const datasetSchemaSchema = z.object({
     title: z.string().optional(),
     description: z.string().optional(),
@@ -33,14 +37,11 @@ const materializeDatasetToolInputSchema = z.object({
     datasetId: z.string().optional(),
     sandboxId: z.string().optional(),
     title: z.string().optional(),
-    sources: z
-        .array(z.discriminatedUnion("kind", [
-        fileSourceSchema,
-        textSourceSchema,
-        datasetSourceSchema,
-        querySourceSchema,
-    ]))
-        .min(1),
+    context: contextInputSchema.optional(),
+    files: z.array(fileResourceSchema.omit({ kind: true })).optional(),
+    texts: z.array(textResourceSchema.omit({ kind: true })).optional(),
+    datasets: z.array(datasetResourceSchema.omit({ kind: true })).optional(),
+    queries: z.array(queryResourceSchema.omit({ kind: true })).optional(),
     instructions: z.string().optional(),
     mode: z.enum(["auto", "schema"]).optional(),
     output: z.enum(["rows", "object"]).optional(),
@@ -49,7 +50,7 @@ const materializeDatasetToolInputSchema = z.object({
 });
 export function createMaterializeDatasetTool(params) {
     return tool({
-        description: "Materialize a dataset from declarative sources. Returns only the target datasetId. Query sources use the preconfigured runtime domain.",
+        description: "Materialize a dataset from declarative resources. Returns only the target datasetId. Query resources use the preconfigured runtime domain.",
         inputSchema: materializeDatasetToolInputSchema,
         execute: async (input) => {
             let builder = dataset(params.runtime);
@@ -59,23 +60,33 @@ export function createMaterializeDatasetTool(params) {
             if (input.sandboxId?.trim()) {
                 builder = builder.sandbox({ sandboxId: input.sandboxId });
             }
-            for (const source of input.sources) {
-                if (source.kind === "file") {
-                    builder = builder.fromFile(source);
-                    continue;
-                }
-                if (source.kind === "text") {
-                    builder = builder.fromText(source);
-                    continue;
-                }
-                if (source.kind === "dataset") {
-                    builder = builder.fromDataset(source);
-                    continue;
-                }
+            const materialCount = (input.files?.length ?? 0) +
+                (input.texts?.length ?? 0) +
+                (input.datasets?.length ?? 0) +
+                (input.queries?.length ?? 0);
+            if (input.context && materialCount > 0) {
+                throw new Error("dataset_context_resource_is_exclusive");
+            }
+            if (!input.context && materialCount === 0) {
+                throw new Error("dataset_context_or_material_required");
+            }
+            if (input.context) {
+                builder = builder.fromContext(input.context);
+            }
+            for (const resource of input.files ?? []) {
+                builder = builder.fromFile(resource);
+            }
+            for (const resource of input.texts ?? []) {
+                builder = builder.fromText(resource);
+            }
+            for (const resource of input.datasets ?? []) {
+                builder = builder.fromDataset(resource);
+            }
+            for (const resource of input.queries ?? []) {
                 builder = builder.fromQuery(params.queryDomain, {
-                    query: source.query,
-                    title: source.title,
-                    explanation: source.explanation,
+                    query: resource.query,
+                    title: resource.title,
+                    explanation: resource.explanation,
                 });
             }
             if (input.output === "object") {

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;
@@ -64,6 +63,7 @@ export declare class DatasetService {
     uploadDatasetOutputFile(params: {
         datasetId: string;
         fileBuffer: Buffer;
+        storagePath?: string;
     }): Promise<ServiceResult<{
         fileId: string;
         storagePath: 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 } };
         }
@@ -308,7 +311,7 @@ export class DatasetService {
     }
     async uploadDatasetOutputFile(params) {
         try {
-            const storagePath = `/dataset/${params.datasetId}/output.jsonl`;
+            const storagePath = params.storagePath ?? `/dataset/${params.datasetId}/output.jsonl`;
             const uploadResult = await this.db.storage.uploadFile(storagePath, params.fileBuffer, {
                 contentType: "application/x-ndjson",
                 contentDisposition: "output.jsonl",

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);