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

package/dist/builder/agentMaterializers.d.ts

@@ -1,6 +1,6 @@
-import type { AnyDatasetRuntime, DatasetBuilderState, InternalSource } from "./types.js";
+import type { AnyDatasetRuntime, DatasetBuilderState, InternalDatasetResource } from "./types.js";
 export type DatasetAgentMaterializers = {
-    materializeSingleFileLikeSource<Runtime extends AnyDatasetRuntime>(state: DatasetBuilderState<Runtime>, source: Extract<InternalSource, {
+    materializeSingleFileLikeResource<Runtime extends AnyDatasetRuntime>(state: DatasetBuilderState<Runtime>, resource: Extract<InternalDatasetResource, {
         kind: "file" | "text";
     }>, targetDatasetId: string): Promise<string>;
     materializeDerivedDataset<Runtime extends AnyDatasetRuntime>(state: DatasetBuilderState<Runtime>, targetDatasetId: string): Promise<string>;

package/dist/builder/context.d.ts

@@ -0,0 +1,7 @@
+import type { AnyDatasetRuntime, InternalDatasetResource } from "./types.js";
+type DatasetContextResolution = {
+    contextId: string;
+    resources: InternalDatasetResource[];
+};
+export declare function resolveDatasetResourceContext<Runtime extends AnyDatasetRuntime>(runtime: Runtime, datasetId: string, resources: InternalDatasetResource[]): Promise<DatasetContextResolution>;
+export {};

package/dist/builder/context.js

@@ -0,0 +1,192 @@
+import { eventsDomain } from "@ekairos/events";
+import { createDatasetId } from "../id.js";
+import { getDomainDescriptor } from "./rows.js";
+function getContextWhere(context) {
+    return "id" in context ? { id: context.id } : { key: context.key };
+}
+async function getEventsDb(runtime) {
+    const scoped = await runtime.use(eventsDomain);
+    return scoped.db;
+}
+function resourceKey(index, resource) {
+    if (resource.kind === "file")
+        return `file:${index}:${resource.fileId}`;
+    if (resource.kind === "text")
+        return `text:${index}:${resource.name ?? "inline"}`;
+    if (resource.kind === "dataset")
+        return `dataset:${index}:${resource.datasetId}`;
+    if (resource.kind === "query")
+        return `query:${index}:${resource.title ?? "query"}`;
+    return `resource:${index}`;
+}
+function resourceName(index, resource) {
+    if (resource.kind === "file")
+        return resource.filename ?? `File ${index + 1}`;
+    if (resource.kind === "text")
+        return resource.name ?? `Text ${index + 1}`;
+    if (resource.kind === "dataset")
+        return resource.datasetId;
+    if (resource.kind === "query")
+        return resource.title ?? `Query ${index + 1}`;
+    return `Resource ${index + 1}`;
+}
+function resourceDescription(resource) {
+    if ("description" in resource && typeof resource.description === "string" && resource.description.trim()) {
+        return resource.description.trim();
+    }
+    if (resource.kind === "query" && typeof resource.explanation === "string" && resource.explanation.trim()) {
+        return resource.explanation.trim();
+    }
+    return `Dataset ${resource.kind} resource.`;
+}
+function resourceToContextResource(index, resource) {
+    const base = {
+        key: resourceKey(index, resource),
+        type: resource.kind,
+        name: resourceName(index, resource),
+        description: resourceDescription(resource),
+    };
+    if (resource.kind === "file") {
+        return {
+            ...base,
+            fileId: resource.fileId,
+            filename: resource.filename,
+            mediaType: resource.mediaType,
+        };
+    }
+    if (resource.kind === "text") {
+        return {
+            ...base,
+            text: resource.text,
+            mimeType: resource.mimeType,
+        };
+    }
+    if (resource.kind === "dataset") {
+        return {
+            ...base,
+            datasetId: resource.datasetId,
+        };
+    }
+    if (resource.kind === "query") {
+        return {
+            ...base,
+            query: resource.query,
+            title: resource.title,
+            explanation: resource.explanation,
+            ...getDomainDescriptor(resource.domain),
+        };
+    }
+    return base;
+}
+async function createDatasetResourceContextStep(params) {
+    "use step";
+    const db = await getEventsDb(params.runtime);
+    const contextId = createDatasetId();
+    const now = new Date();
+    await db.transact([
+        db.tx.event_contexts[contextId].create({
+            createdAt: now,
+            updatedAt: now,
+            name: `Dataset ${params.datasetId} resource context`,
+            status: "open_idle",
+            content: {
+                datasetId: params.datasetId,
+                resourceCount: params.resources.length,
+            },
+            resources: params.resources,
+            description: `Dataset materialization context for ${params.datasetId}.`,
+            goal: "Materialize the dataset from the resources declared in this context.",
+        }),
+    ]);
+    return {
+        contextId,
+    };
+}
+function contextResourceToDatasetResource(resource) {
+    if (resource.type === "file" && typeof resource.fileId === "string" && resource.fileId.trim()) {
+        return {
+            kind: "file",
+            fileId: resource.fileId.trim(),
+            description: resource.description,
+            filename: typeof resource.filename === "string" ? resource.filename : undefined,
+            mediaType: typeof resource.mediaType === "string" ? resource.mediaType : undefined,
+        };
+    }
+    if (resource.type === "dataset" &&
+        typeof resource.datasetId === "string" &&
+        resource.datasetId.trim()) {
+        return {
+            kind: "dataset",
+            datasetId: resource.datasetId.trim(),
+            description: resource.description,
+        };
+    }
+    if (resource.type === "text" && typeof resource.text === "string") {
+        return {
+            kind: "text",
+            text: String(resource.text),
+            mimeType: typeof resource.mimeType === "string"
+                ? String(resource.mimeType)
+                : "text/plain",
+            name: resource.name,
+            description: resource.description,
+        };
+    }
+    if (resource.type === "query") {
+        throw new Error("dataset_context_query_resource_requires_builder_shortcut");
+    }
+    return {
+        kind: "text",
+        text: JSON.stringify({ resource }, null, 2),
+        mimeType: "application/vnd.ekairos.context-resource+json",
+        name: `${resource.key}.context-resource.json`,
+        description: resource.description,
+    };
+}
+async function readExistingContext(params) {
+    "use step";
+    const db = await getEventsDb(params.runtime);
+    const res = await db.query({
+        event_contexts: {
+            $: {
+                where: getContextWhere(params.context),
+                limit: 1,
+            },
+        },
+    });
+    const row = res?.event_contexts?.[0];
+    if (!row?.id)
+        throw new Error("dataset_context_not_found");
+    const resources = Array.isArray(row.resources)
+        ? row.resources
+        : [];
+    if (resources.length === 0) {
+        throw new Error("dataset_context_resources_required");
+    }
+    return {
+        contextId: String(row.id),
+        resources: resources.map((resource) => contextResourceToDatasetResource(resource)),
+    };
+}
+export async function resolveDatasetResourceContext(runtime, datasetId, resources) {
+    const contextRefs = resources.filter((resource) => resource.kind === "context");
+    if (contextRefs.length > 1) {
+        throw new Error("dataset_context_resource_must_be_unique");
+    }
+    if (contextRefs.length === 1) {
+        if (resources.length > 1) {
+            throw new Error("dataset_context_resource_is_exclusive");
+        }
+        return await readExistingContext({ runtime, context: contextRefs[0] });
+    }
+    const contextResourceRecords = resources.map((resource, index) => resourceToContextResource(index, resource));
+    const created = await createDatasetResourceContextStep({
+        runtime,
+        datasetId,
+        resources: contextResourceRecords,
+    });
+    return {
+        contextId: created.contextId,
+        resources,
+    };
+}

package/dist/builder/instructions.d.ts

@@ -1,5 +1,5 @@
 import type { DatasetSchemaInput } from "./types.js";
-export declare function buildFileDefaultInstructions(schema?: DatasetSchemaInput): "Create a dataset from the source file and ensure each output row matches the provided dataset schema exactly." | "Create a dataset representing the source content as structured rows.";
-export declare function buildRawSourceInstructions(sourceKind: "file" | "text"): "Create a dataset representing the raw text content as structured rows without applying business transformations." | "Create a dataset representing the raw file content as structured rows without applying business transformations.";
-export declare function buildTransformInstructions(sourceCount: number, userInstructions?: string, schema?: DatasetSchemaInput): string;
+export declare function buildFileDefaultInstructions(schema?: DatasetSchemaInput): "Create a dataset from the resource file and ensure each output row matches the provided dataset schema exactly." | "Create a dataset representing the resource content as structured rows.";
+export declare function buildRawResourceInstructions(resourceKind: "file" | "text"): "Create a dataset representing the raw text content as structured rows without applying business transformations." | "Create a dataset representing the raw file content as structured rows without applying business transformations.";
+export declare function buildTransformInstructions(resourceCount: number, userInstructions?: string, schema?: DatasetSchemaInput): string;
 export declare function buildObjectOutputInstructions(userInstructions?: string): string;

package/dist/builder/instructions.js

@@ -1,29 +1,29 @@
 export function buildFileDefaultInstructions(schema) {
     if (schema) {
-        return "Create a dataset from the source file and ensure each output row matches the provided dataset schema exactly.";
+        return "Create a dataset from the resource file and ensure each output row matches the provided dataset schema exactly.";
     }
-    return "Create a dataset representing the source content as structured rows.";
+    return "Create a dataset representing the resource content as structured rows.";
 }
-export function buildRawSourceInstructions(sourceKind) {
-    if (sourceKind === "text") {
+export function buildRawResourceInstructions(resourceKind) {
+    if (resourceKind === "text") {
         return "Create a dataset representing the raw text content as structured rows without applying business transformations.";
     }
     return "Create a dataset representing the raw file content as structured rows without applying business transformations.";
 }
-export function buildTransformInstructions(sourceCount, userInstructions, schema) {
+export function buildTransformInstructions(resourceCount, userInstructions, schema) {
     const explicit = String(userInstructions ?? "").trim();
     if (explicit)
         return explicit;
-    if (sourceCount > 1) {
+    if (resourceCount > 1) {
         if (schema) {
-            return "Combine the source datasets into a new dataset that matches the provided output schema exactly.";
+            return "Combine the input datasets into a new dataset that matches the provided output schema exactly.";
         }
-        return "Combine the source datasets into one coherent dataset.";
+        return "Combine the input datasets into one coherent dataset.";
     }
     if (schema) {
-        return "Transform the source dataset into a new dataset that matches the provided output schema exactly.";
+        return "Transform the input dataset into a new dataset that matches the provided output schema exactly.";
     }
-    return "Transform the source dataset into a new useful dataset.";
+    return "Transform the input dataset into a new useful dataset.";
 }
 export function buildObjectOutputInstructions(userInstructions) {
     const base = String(userInstructions ?? "").trim();

package/dist/builder/materialize.d.ts

@@ -1,7 +1,7 @@
-import type { AnyDatasetRuntime, DatasetBuilderState, DatasetSchemaInput, InternalSource } from "./types.js";
+import type { AnyDatasetRuntime, DatasetBuilderState, DatasetSchemaInput, InternalDatasetResource } from "./types.js";
 import type { SandboxState } from "../file/file-dataset.types.js";
 import type { FilePreviewContext } from "../file/filepreview.types.js";
-import type { TransformSandboxState, TransformSourcePreviewContext } from "../transform/transform-dataset.types.js";
+import type { TransformSandboxState, TransformInputPreviewContext } from "../transform/transform-dataset.types.js";
 export declare function resolveDatasetAgentDurable(requestedDurable?: boolean): Promise<boolean>;
 type PreparedFileDatasetContext = {
     kind: "file";
@@ -18,12 +18,12 @@ type PreparedTransformDatasetContext = {
     kind: "transform";
     datasetId: string;
     sandboxId: string;
-    sourceDatasetIds: string[];
+    inputDatasetIds: string[];
     outputSchema: DatasetSchemaInput;
     sandboxState: TransformSandboxState;
-    sourcePreviews?: Array<{
+    inputPreviews?: Array<{
         datasetId: string;
-        preview: TransformSourcePreviewContext;
+        preview: TransformInputPreviewContext;
     }>;
 };
 type PreparedDatasetContext = PreparedFileDatasetContext | PreparedTransformDatasetContext;
@@ -37,19 +37,18 @@ export declare function initializeDatasetStep<Runtime extends AnyDatasetRuntime>
     sandboxId: string;
     title?: string;
     instructions?: string;
-    sources: any[];
-    sourceKinds: string[];
+    contextId: string;
     schema?: DatasetSchemaInput;
 }): Promise<{
     datasetId: string;
     sandboxId: string;
 }>;
-export declare function prepareDatasetSourcesStep<Runtime extends AnyDatasetRuntime>(params: {
+export declare function prepareDatasetResourcesStep<Runtime extends AnyDatasetRuntime>(params: {
     kind: "file";
     runtime: Runtime;
     datasetId: string;
     sandboxId: string;
-    source: Extract<InternalSource, {
+    resource: Extract<InternalDatasetResource, {
         kind: "file" | "text";
     }>;
     schema?: DatasetSchemaInput;
@@ -58,7 +57,7 @@ export declare function prepareDatasetSourcesStep<Runtime extends AnyDatasetRunt
     runtime: Runtime;
     datasetId: string;
     sandboxId: string;
-    sourceDatasetIds: string[];
+    inputDatasetIds: string[];
     outputSchema: DatasetSchemaInput;
 }): Promise<PreparedDatasetContext>;
 export declare function initializeDatasetContextStep(params: {
@@ -77,7 +76,7 @@ export declare function completeDatasetStep<Runtime extends AnyDatasetRuntime>(p
     previewRows: any[];
     firstRow: any;
 }>;
-export declare function materializeSingleFileLikeSource<Runtime extends AnyDatasetRuntime>(state: DatasetBuilderState<Runtime>, source: Extract<InternalSource, {
+export declare function materializeSingleFileLikeResource<Runtime extends AnyDatasetRuntime>(state: DatasetBuilderState<Runtime>, resource: Extract<InternalDatasetResource, {
     kind: "file" | "text";
 }>, targetDatasetId: string): Promise<string>;
 export declare function materializeDerivedDataset<Runtime extends AnyDatasetRuntime>(state: DatasetBuilderState<Runtime>, targetDatasetId: string): Promise<string>;