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

package/dist/builder/types.d.ts

@@ -1,40 +1,44 @@
 import type { InstaQLParams, ValidQuery } from "@instantdb/core";
 import type { DomainInstantSchema, DomainSchemaResult } from "@ekairos/domain";
 import type { EkairosRuntime, RuntimeForDomain } from "@ekairos/domain/runtime";
-import type { ContextReactor } from "@ekairos/events";
+import type { ContextIdentifier, ContextReactor } from "@ekairos/events";
 import { datasetDomain } from "../schema.js";
-export type DatasetQuerySourceInput<D extends DomainSchemaResult = DomainSchemaResult> = {
+export type DatasetQueryResourceInput<D extends DomainSchemaResult = DomainSchemaResult> = {
     query: InstaQLParams<DomainInstantSchema<D>>;
     title?: string;
     explanation?: string;
     domain: D;
 };
-export type DatasetFileSourceInput = {
+export type DatasetFileResourceInput = {
     fileId: string;
     description?: string;
     filename?: string;
     mediaType?: string;
 };
-export type DatasetTextSourceInput = {
+export type DatasetTextResourceInput = {
     text: string;
     mimeType?: string;
     name?: string;
     description?: string;
 };
-export type DatasetExistingSourceInput = {
+export type DatasetExistingResourceInput = {
     datasetId: string;
     description?: string;
 };
-export type DatasetFileSource = {
+export type DatasetContextResourceInput = ContextIdentifier;
+export type DatasetFileResource = {
     kind: "file";
-} & DatasetFileSourceInput;
-export type DatasetTextSource = {
+} & DatasetFileResourceInput;
+export type DatasetTextResource = {
     kind: "text";
-} & DatasetTextSourceInput;
-export type DatasetExistingSource = {
+} & DatasetTextResourceInput;
+export type DatasetExistingResource = {
     kind: "dataset";
-} & DatasetExistingSourceInput;
-export type DatasetSourceInput = DatasetFileSourceInput | DatasetTextSourceInput | DatasetExistingSourceInput | DatasetFileSource | DatasetTextSource | DatasetExistingSource;
+} & DatasetExistingResourceInput;
+export type DatasetContextResource = {
+    kind: "context";
+} & DatasetContextResourceInput;
+export type DatasetResourceInput = DatasetFileResourceInput | DatasetTextResourceInput | DatasetExistingResourceInput | DatasetContextResourceInput | DatasetFileResource | DatasetTextResource | DatasetExistingResource | DatasetContextResource;
 export type DatasetSchemaInput = {
     title?: string;
     description?: string;
@@ -50,9 +54,9 @@ export type DatasetBuildOptions = {
     datasetId?: string;
     durable?: boolean;
 };
-export type InternalSource = DatasetFileSource | DatasetTextSource | DatasetExistingSource | ({
+export type InternalDatasetResource = DatasetFileResource | DatasetTextResource | DatasetExistingResource | DatasetContextResource | ({
     kind: "query";
-} & DatasetQuerySourceInput);
+} & DatasetQueryResourceInput);
 export type DatasetReaderResult = {
     rows: any[];
     cursor: number;
@@ -78,8 +82,8 @@ export type DatasetRuntimeEnv = {
 };
 export type AnyDatasetRuntime = EkairosRuntime<any, any, any>;
 export type DatasetRuntimeHandle<Runtime extends AnyDatasetRuntime> = RuntimeForDomain<Runtime, typeof datasetDomain>;
-export type CompatibleSourceDomain<Runtime extends AnyDatasetRuntime, D extends DomainSchemaResult> = RuntimeForDomain<Runtime, D> extends never ? never : D;
-export type DatasetQuerySourceOptions<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>> = {
+export type CompatibleQueryDomain<Runtime extends AnyDatasetRuntime, D extends DomainSchemaResult> = RuntimeForDomain<Runtime, D> extends never ? never : D;
+export type DatasetQueryResourceOptions<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>> = {
     query: Q;
     title?: string;
     explanation?: string;
@@ -87,9 +91,10 @@ export type DatasetQuerySourceOptions<D extends DomainSchemaResult, Q extends Va
 export type DatasetBuilderState<Runtime extends AnyDatasetRuntime> = {
     runtime: Runtime;
     env: Runtime["env"] & DatasetRuntimeEnv;
-    sources: InternalSource[];
+    resources: InternalDatasetResource[];
     title?: string;
     sandboxId?: string;
+    contextId?: string;
     outputSchema?: DatasetSchemaInput;
     output: DatasetOutput;
     inferSchema: boolean;
@@ -103,8 +108,7 @@ export type MaterializeRowsParams = {
     sandboxId?: string;
     title?: string;
     instructions?: string;
-    sources: any[];
-    sourceKinds: string[];
+    contextId: string;
     analysis?: any;
     rows: any[];
     schema?: DatasetSchemaInput;
@@ -113,11 +117,12 @@ export type MaterializeRowsParams = {
 };
 export type DatasetBuilder<Runtime extends AnyDatasetRuntime> = {
     readonly datasetId: string;
-    fromFile(source: DatasetFileSourceInput): DatasetBuilder<Runtime>;
-    fromText(source: DatasetTextSourceInput): DatasetBuilder<Runtime>;
-    fromDataset(source: DatasetExistingSourceInput): DatasetBuilder<Runtime>;
-    from(...sources: DatasetSourceInput[]): DatasetBuilder<Runtime>;
-    fromQuery<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>>(domain: D & CompatibleSourceDomain<Runtime, D>, source: DatasetQuerySourceOptions<D, Q>): DatasetBuilder<Runtime>;
+    fromFile(resource: DatasetFileResourceInput): DatasetBuilder<Runtime>;
+    fromText(resource: DatasetTextResourceInput): DatasetBuilder<Runtime>;
+    fromDataset(resource: DatasetExistingResourceInput): DatasetBuilder<Runtime>;
+    fromContext(context: DatasetContextResourceInput): DatasetBuilder<Runtime>;
+    from(...resources: DatasetResourceInput[]): DatasetBuilder<Runtime>;
+    fromQuery<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>>(domain: D & CompatibleQueryDomain<Runtime, D>, resource: DatasetQueryResourceOptions<D, Q>): DatasetBuilder<Runtime>;
     title(title: string): DatasetBuilder<Runtime>;
     sandbox(input: {
         sandboxId: string;

package/dist/completeDataset.steps.js

@@ -313,7 +313,7 @@ function buildValidationFailureSummary(params) {
 }
 function buildRepairInstructions(summary) {
     const instructions = [
-        "Rewrite output.jsonl using the schema as the source of truth. Do not use source file headers as JSON keys unless they exactly match schema property names.",
+        "Rewrite output.jsonl using the schema as the authority. Do not use input file headers as JSON keys unless they exactly match schema property names.",
         "Each non-empty line must be a JSON object shaped as {\"type\":\"row\",\"data\":{...}}.",
         "Populate every required top-level and nested required path from failureSummary.requiredPaths.",
         "For enum fields, emit exactly one allowed literal from failureSummary.enumConstraints or failureSummary.enumFailures.",

package/dist/dataset.d.ts

@@ -1,3 +1,3 @@
 import type { AnyDatasetRuntime, DatasetBuilder, DatasetBuilderOptions, DatasetRuntimeHandle } from "./builder/types.js";
-export type { AnyDatasetRuntime, CompatibleSourceDomain, DatasetBuilder, DatasetBuilderOptions, DatasetBuildOptions, DatasetBuildResult, DatasetExistingSource, DatasetExistingSourceInput, DatasetFileSource, DatasetFileSourceInput, DatasetMode, DatasetOutput, DatasetQuerySourceInput, DatasetReader, DatasetReaderResult, DatasetRuntimeEnv, DatasetRuntimeHandle, DatasetSchemaInput, DatasetTextSource, DatasetSourceInput, DatasetTextSourceInput, } from "./builder/types.js";
+export type { AnyDatasetRuntime, CompatibleQueryDomain, DatasetBuilder, DatasetBuilderOptions, DatasetBuildOptions, DatasetBuildResult, DatasetExistingResource, DatasetExistingResourceInput, DatasetFileResource, DatasetFileResourceInput, DatasetMode, DatasetOutput, DatasetQueryResourceInput, DatasetReader, DatasetReaderResult, DatasetRuntimeEnv, DatasetRuntimeHandle, DatasetSchemaInput, DatasetTextResource, DatasetResourceInput, DatasetTextResourceInput, } from "./builder/types.js";
 export declare function dataset<Runtime extends AnyDatasetRuntime>(runtime: Runtime & DatasetRuntimeHandle<Runtime>, options?: DatasetBuilderOptions): DatasetBuilder<Runtime>;

package/dist/dataset.js

@@ -1,7 +1,8 @@
 import { buildObjectOutputInstructions } from "./builder/instructions.js";
+import { resolveDatasetResourceContext } from "./builder/context.js";
 import { createDatasetId } from "./id.js";
-import { completeDatasetStep, materializeDerivedDataset, materializeSingleFileLikeSource, } from "./builder/materialize.js";
-import { materializeQuerySource } from "./builder/materializeQuery.js";
+import { completeDatasetStep, materializeDerivedDataset, materializeSingleFileLikeResource, } from "./builder/materialize.js";
+import { materializeQueryResource } from "./builder/materializeQuery.js";
 import { createDatasetBuildResult, finalizeBuildResult, } from "./builder/persistence.js";
 export function dataset(runtime, options = {}) {
     const datasetId = normalizeDatasetId(options.datasetId);
@@ -9,7 +10,7 @@ export function dataset(runtime, options = {}) {
     const state = {
         runtime: typedRuntime,
         env: typedRuntime.env,
-        sources: [],
+        resources: [],
         output: "rows",
         inferSchema: false,
         durable: options.durable,
@@ -17,38 +18,46 @@ export function dataset(runtime, options = {}) {
     };
     const api = {
         datasetId,
-        fromFile(source) {
-            state.sources.push({ kind: "file", ...source });
+        fromFile(resource) {
+            state.resources.push({ kind: "file", ...resource });
             return api;
         },
-        fromText(source) {
-            state.sources.push({ kind: "text", ...source });
+        fromText(resource) {
+            state.resources.push({ kind: "text", ...resource });
             return api;
         },
-        fromDataset(source) {
-            state.sources.push({ kind: "dataset", ...source });
+        fromDataset(resource) {
+            state.resources.push({ kind: "dataset", ...resource });
             return api;
         },
-        from(...sources) {
-            for (const source of sources) {
-                if ("kind" in source) {
-                    state.sources.push(source);
+        fromContext(context) {
+            state.resources.push({ kind: "context", ...context });
+            return api;
+        },
+        from(...resources) {
+            for (const resource of resources) {
+                if ("kind" in resource) {
+                    state.resources.push(resource);
+                    continue;
+                }
+                if ("fileId" in resource) {
+                    state.resources.push({ kind: "file", ...resource });
                     continue;
                 }
-                if ("fileId" in source) {
-                    state.sources.push({ kind: "file", ...source });
+                if ("datasetId" in resource) {
+                    state.resources.push({ kind: "dataset", ...resource });
                     continue;
                 }
-                if ("datasetId" in source) {
-                    state.sources.push({ kind: "dataset", ...source });
+                if ("id" in resource || "key" in resource) {
+                    state.resources.push({ kind: "context", ...resource });
                     continue;
                 }
-                state.sources.push({ kind: "text", ...source });
+                state.resources.push({ kind: "text", ...resource });
             }
             return api;
         },
-        fromQuery(domain, source) {
-            state.sources.push({ kind: "query", domain, ...source });
+        fromQuery(domain, resource) {
+            state.resources.push({ kind: "query", domain, ...resource });
             return api;
         },
         title(title) {
@@ -96,8 +105,8 @@ export function dataset(runtime, options = {}) {
             return api;
         },
         async build(options) {
-            if (state.sources.length === 0) {
-                throw new Error("dataset_sources_required");
+            if (state.resources.length === 0) {
+                throw new Error("dataset_resources_required");
             }
             const targetDatasetId = options?.datasetId
                 ? normalizeDatasetId(options.datasetId)
@@ -106,6 +115,9 @@ export function dataset(runtime, options = {}) {
                 ...state,
                 durable: options?.durable ?? state.durable,
             };
+            const context = await resolveDatasetResourceContext(typedRuntime, targetDatasetId, stateWithBuildOptions.resources);
+            stateWithBuildOptions.resources = context.resources;
+            stateWithBuildOptions.contextId = context.contextId;
             const effectiveState = stateWithBuildOptions.output === "object"
                 ? {
                     ...stateWithBuildOptions,
@@ -113,25 +125,26 @@ export function dataset(runtime, options = {}) {
                     instructions: buildObjectOutputInstructions(stateWithBuildOptions.instructions),
                 }
                 : stateWithBuildOptions;
-            const onlySource = effectiveState.sources[0];
-            const isSingleSource = effectiveState.sources.length === 1;
+            const onlyResource = effectiveState.resources[0];
+            const isSingleResource = effectiveState.resources.length === 1;
             const hasInstructions = Boolean(String(effectiveState.instructions ?? "").trim());
-            if (isSingleSource && onlySource.kind === "query" && !hasInstructions) {
-                await materializeQuerySource(effectiveState.runtime, onlySource, {
+            if (isSingleResource && onlyResource.kind === "query" && !hasInstructions) {
+                await materializeQueryResource(effectiveState.runtime, onlyResource, {
                     datasetId: targetDatasetId,
                     sandboxId: effectiveState.sandboxId,
                     schema: effectiveState.outputSchema,
-                    title: effectiveState.title ?? onlySource.title,
+                    title: effectiveState.title ?? onlyResource.title,
                     instructions: effectiveState.instructions,
                     first: effectiveState.first,
+                    contextId: effectiveState.contextId ?? "",
                 });
                 return finalizeOutputResult(await finalizeBuildResult(effectiveState.runtime, targetDatasetId, effectiveState.first), effectiveState.output);
             }
-            if (isSingleSource && (onlySource.kind === "file" || onlySource.kind === "text")) {
+            if (isSingleResource && (onlyResource.kind === "file" || onlyResource.kind === "text")) {
                 if (!effectiveState.reactor) {
                     throw new Error("dataset_reactor_required");
                 }
-                await materializeSingleFileLikeSource(effectiveState, onlySource, targetDatasetId);
+                await materializeSingleFileLikeResource(effectiveState, onlyResource, targetDatasetId);
                 const completed = await completeDatasetStep({
                     runtime: effectiveState.runtime,
                     datasetId: targetDatasetId,

package/dist/datasetFiles.d.ts

@@ -1,7 +1,7 @@
 export declare const DATASET_OUTPUT_FILE_NAME = "output.jsonl";
 export declare function getDatasetWorkdirBase(): string;
 export declare function getDatasetWorkstation(datasetId: string): string;
-export declare function getDatasetSourcesDir(datasetId: string): string;
+export declare function getDatasetResourcesDir(datasetId: string): string;
 export declare function getDatasetScriptsDir(datasetId: string): string;
 export declare function getDatasetArtifactsDir(datasetId: string): string;
 export declare function getDatasetLogsDir(datasetId: string): string;

package/dist/datasetFiles.js

@@ -9,8 +9,8 @@ export function getDatasetWorkdirBase() {
 export function getDatasetWorkstation(datasetId) {
     return `${getDatasetWorkdirBase()}/${datasetId}`;
 }
-export function getDatasetSourcesDir(datasetId) {
-    return `${getDatasetWorkstation(datasetId)}/sources`;
+export function getDatasetResourcesDir(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/resources`;
 }
 export function getDatasetScriptsDir(datasetId) {
     return `${getDatasetWorkstation(datasetId)}/scripts`;
@@ -24,7 +24,7 @@ export function getDatasetLogsDir(datasetId) {
 export function getDatasetStandardDirs(datasetId) {
     return [
         getDatasetWorkstation(datasetId),
-        getDatasetSourcesDir(datasetId),
+        getDatasetResourcesDir(datasetId),
         getDatasetScriptsDir(datasetId),
         getDatasetArtifactsDir(datasetId),
         getDatasetLogsDir(datasetId),

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

@@ -210,7 +210,7 @@ export function createFileParseContext(fileId, opts) {
                         {
                             type: "file",
                             fileId,
-                            filename: opts?.filename ?? "source-file",
+                            filename: opts?.filename ?? "resource-file",
                             mediaType: opts?.mediaType ?? "application/octet-stream",
                         },
                     ],
@@ -218,14 +218,13 @@ export function createFileParseContext(fileId, opts) {
             };
             params.sourceEventId = triggerEvent.id;
             params.sourcePartIndex = 1;
-            params.filename = opts?.filename ?? "source-file";
+            params.filename = opts?.filename ?? "resource-file";
             params.mediaType = opts?.mediaType ?? "application/octet-stream";
             const shell = await context.react(triggerEvent, {
                 runtime: runtime,
                 context: { key: `dataset:${datasetId}` },
                 durable: options.durable ?? false,
                 options: {
-                    silent: true,
                     preventClose: true,
                     sendFinish: false,
                     maxIterations: 20,
@@ -237,7 +236,7 @@ export function createFileParseContext(fileId, opts) {
                     fileId,
                     sourceEventId: triggerEvent.id,
                     sourcePartIndex: 1,
-                    filename: opts?.filename ?? "source-file",
+                    filename: opts?.filename ?? "resource-file",
                     mediaType: opts?.mediaType ?? "application/octet-stream",
                     instructions: opts?.instructions ?? "",
                     sandboxId: opts?.sandboxId ?? "",

package/dist/file/prompts.js

@@ -11,13 +11,13 @@ function buildRole() {
 function buildGoal() {
     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) {
+function buildResourceInfo(context) {
     let xml = create()
-        .ele("Source")
+        .ele("FileResource")
         .ele("Type").txt("file").up()
         .ele("FileId").txt(context.fileId).up()
         .ele("DatasetId").txt(context.datasetId).up()
@@ -90,7 +90,7 @@ function buildErrorsSection(errors) {
     }
     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 source column names into schema keys piecemeal.").up();
+        .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,8 +100,8 @@ function buildErrorsSection(errors) {
 function buildContextSection(context) {
     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());
@@ -195,9 +195,9 @@ function buildSchemaSection(context) {
     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. Source headers are input labels, not output keys.").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 source labels to the closest valid enum literal; never emit a value outside the enum.").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");
@@ -245,10 +245,10 @@ function buildInstructions(context) {
             .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 source columns to schema fields before writing output.jsonl. Do not use raw source headers as JSON keys unless they are exactly schema 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 source language").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();
@@ -286,8 +286,8 @@ function buildInstructions(context) {
         .up()
         .ele("Rules")
         .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 source language").up()
-        .ele("Rule").txt("Original/source language applies to extracted values only, not to JSON object keys").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()

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") {