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

package/dist/sandbox/steps.d.ts

@@ -1,13 +1,7 @@
+import { type SandboxConfig } from "@ekairos/sandbox";
 export type DatasetSandboxId = string;
-export type CreateDatasetSandboxParams = {
-    runtime?: string;
-    timeoutMs?: number;
-    ports?: number[];
-    resources?: {
-        vcpus?: number;
-    };
-    purpose?: string;
-    params?: Record<string, any>;
+export type CreateDatasetSandboxParams = Pick<SandboxConfig, "provider" | "timeoutMs" | "ports" | "resources" | "purpose" | "params" | "env" | "domain" | "dataset" | "vercel"> & {
+    sandboxRuntime?: string;
 };
 export type DatasetSandboxRunCommandResult = {
     exitCode: number;
@@ -15,33 +9,47 @@ export type DatasetSandboxRunCommandResult = {
     stderr: string;
 };
 export declare function createDatasetSandboxStep(params: {
-    env: any;
+    runtime: any;
 } & CreateDatasetSandboxParams): Promise<{
     sandboxId: DatasetSandboxId;
 }>;
 export declare function runDatasetSandboxCommandStep(params: {
-    env: any;
+    runtime: any;
     sandboxId: DatasetSandboxId;
     cmd: string;
     args?: string[];
 }): Promise<DatasetSandboxRunCommandResult>;
 export declare function writeDatasetSandboxFilesStep(params: {
-    env: any;
+    runtime: any;
     sandboxId: DatasetSandboxId;
     files: Array<{
         path: string;
         contentBase64: string;
     }>;
 }): Promise<void>;
+export declare function writeDatasetSandboxTextFilesStep(params: {
+    runtime: any;
+    sandboxId: DatasetSandboxId;
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+}): Promise<void>;
 export declare function readDatasetSandboxFileStep(params: {
-    env: any;
+    runtime: any;
     sandboxId: DatasetSandboxId;
     path: string;
 }): Promise<{
     contentBase64: string;
 }>;
+export declare function readDatasetSandboxTextFileStep(params: {
+    runtime: any;
+    sandboxId: DatasetSandboxId;
+    path: string;
+}): Promise<{
+    content: string;
+}>;
 export declare function stopDatasetSandboxStep(params: {
-    env: any;
+    runtime: any;
     sandboxId: DatasetSandboxId;
 }): Promise<void>;
-//# sourceMappingURL=steps.d.ts.map

package/dist/sandbox/steps.js

@@ -1,63 +1,27 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDatasetSandboxStep = createDatasetSandboxStep;
-exports.runDatasetSandboxCommandStep = runDatasetSandboxCommandStep;
-exports.writeDatasetSandboxFilesStep = writeDatasetSandboxFilesStep;
-exports.readDatasetSandboxFileStep = readDatasetSandboxFileStep;
-exports.stopDatasetSandboxStep = stopDatasetSandboxStep;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const node_util_1 = require("node:util");
-const runtime_1 = require("@ekairos/events/runtime");
-const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+import { execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import { SandboxService } from "@ekairos/sandbox";
+const execFileAsync = promisify(execFile);
 const localSandboxRoots = new Map();
 function isLocalDatasetSandboxMode() {
     return String(process.env.DATASET_TEST_LOCAL_SANDBOX ?? "").trim() === "1";
 }
+async function getRuntimeDb(runtime) {
+    if (!runtime) {
+        throw new Error("Dataset sandbox step requires runtime.");
+    }
+    const db = runtime.db;
+    return typeof db === "function" ? await db.call(runtime) : db;
+}
 function getLocalSandboxRoot(sandboxId) {
     return (localSandboxRoots.get(sandboxId) ||
-        node_path_1.default.resolve(process.cwd(), "test-results", "dataset-sandboxes", sandboxId));
+        path.resolve(process.cwd(), "test-results", "dataset-sandboxes", sandboxId));
 }
 async function ensureLocalSandboxRoot(sandboxId) {
     const root = getLocalSandboxRoot(sandboxId);
-    await node_fs_1.promises.mkdir(root, { recursive: true });
+    await fs.mkdir(root, { recursive: true });
     localSandboxRoots.set(sandboxId, root);
     return root;
 }
@@ -66,18 +30,20 @@ async function runLocalSandboxCommand(params) {
     const cmd = String(params.cmd ?? "").trim();
     const args = params.args ?? [];
     if (cmd === "mkdir") {
-        const target = args[args.length - 1];
-        await node_fs_1.promises.mkdir(String(target ?? ""), { recursive: true });
+        const targets = args.filter((arg) => !String(arg).startsWith("-"));
+        for (const target of targets) {
+            await fs.mkdir(String(target ?? ""), { recursive: true });
+        }
         return { exitCode: 0, stdout: "", stderr: "" };
     }
     if (cmd === "rm") {
         const target = args[args.length - 1];
-        await node_fs_1.promises.rm(String(target ?? ""), { force: true, recursive: false });
+        await fs.rm(String(target ?? ""), { force: true, recursive: false });
         return { exitCode: 0, stdout: "", stderr: "" };
     }
     if (cmd === "test" && args[0] === "-f") {
         try {
-            await node_fs_1.promises.access(String(args[1] ?? ""));
+            await fs.access(String(args[1] ?? ""));
             return { exitCode: 0, stdout: "", stderr: "" };
         }
         catch {
@@ -99,22 +65,26 @@ async function runLocalSandboxCommand(params) {
         stderr: String(result.stderr ?? ""),
     };
 }
-async function createDatasetSandboxStep(params) {
+export async function createDatasetSandboxStep(params) {
     "use step";
     if (isLocalDatasetSandboxMode()) {
         const sandboxId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
         await ensureLocalSandboxRoot(sandboxId);
         return { sandboxId };
     }
-    const db = (await (0, runtime_1.getContextRuntime)(params.env)).db;
-    const { SandboxService } = (await Promise.resolve().then(() => __importStar(require("@ekairos/sandbox"))));
+    const db = await getRuntimeDb(params.runtime);
     const service = new SandboxService(db);
-    const created = await service.createSandbox(params);
+    const sandboxParams = {
+        ...params,
+        ...(params.sandboxRuntime ? { runtime: params.sandboxRuntime } : {}),
+    };
+    delete sandboxParams.sandboxRuntime;
+    const created = await service.createSandbox(sandboxParams);
     if (!created.ok)
         throw new Error(created.error);
     return { sandboxId: created.data.sandboxId };
 }
-async function runDatasetSandboxCommandStep(params) {
+export async function runDatasetSandboxCommandStep(params) {
     "use step";
     if (isLocalDatasetSandboxMode()) {
         return await runLocalSandboxCommand({
@@ -123,8 +93,7 @@ async function runDatasetSandboxCommandStep(params) {
             args: params.args,
         });
     }
-    const db = (await (0, runtime_1.getContextRuntime)(params.env)).db;
-    const { SandboxService } = (await Promise.resolve().then(() => __importStar(require("@ekairos/sandbox"))));
+    const db = await getRuntimeDb(params.runtime);
     const service = new SandboxService(db);
     const result = await service.runCommand(params.sandboxId, params.cmd, params.args ?? []);
     if (!result.ok)
@@ -135,49 +104,77 @@ async function runDatasetSandboxCommandStep(params) {
         stderr: result.data.error ?? "",
     };
 }
-async function writeDatasetSandboxFilesStep(params) {
+export async function writeDatasetSandboxFilesStep(params) {
     "use step";
     if (isLocalDatasetSandboxMode()) {
         for (const file of params.files) {
-            await node_fs_1.promises.mkdir(node_path_1.default.dirname(file.path), { recursive: true });
-            await node_fs_1.promises.writeFile(file.path, Buffer.from(file.contentBase64, "base64"));
+            await fs.mkdir(path.dirname(file.path), { recursive: true });
+            await fs.writeFile(file.path, Buffer.from(file.contentBase64, "base64"));
         }
         return;
     }
-    const db = (await (0, runtime_1.getContextRuntime)(params.env)).db;
-    const { SandboxService } = (await Promise.resolve().then(() => __importStar(require("@ekairos/sandbox"))));
+    const db = await getRuntimeDb(params.runtime);
     const service = new SandboxService(db);
     const result = await service.writeFiles(params.sandboxId, params.files);
     if (!result.ok)
         throw new Error(result.error);
 }
-async function readDatasetSandboxFileStep(params) {
+export async function writeDatasetSandboxTextFilesStep(params) {
     "use step";
     if (isLocalDatasetSandboxMode()) {
-        const content = await node_fs_1.promises.readFile(params.path);
+        for (const file of params.files) {
+            await fs.mkdir(path.dirname(file.path), { recursive: true });
+            await fs.writeFile(file.path, file.content, "utf-8");
+        }
+        return;
+    }
+    const db = await getRuntimeDb(params.runtime);
+    const service = new SandboxService(db);
+    const files = params.files.map((file) => ({
+        path: file.path,
+        contentBase64: Buffer.from(file.content, "utf-8").toString("base64"),
+    }));
+    const result = await service.writeFiles(params.sandboxId, files);
+    if (!result.ok)
+        throw new Error(result.error);
+}
+export async function readDatasetSandboxFileStep(params) {
+    "use step";
+    if (isLocalDatasetSandboxMode()) {
+        const content = await fs.readFile(params.path);
         return { contentBase64: Buffer.from(content).toString("base64") };
     }
-    const db = (await (0, runtime_1.getContextRuntime)(params.env)).db;
-    const { SandboxService } = (await Promise.resolve().then(() => __importStar(require("@ekairos/sandbox"))));
+    const db = await getRuntimeDb(params.runtime);
     const service = new SandboxService(db);
     const result = await service.readFile(params.sandboxId, params.path);
     if (!result.ok)
         throw new Error(result.error);
     return result.data;
 }
-async function stopDatasetSandboxStep(params) {
+export async function readDatasetSandboxTextFileStep(params) {
+    "use step";
+    if (isLocalDatasetSandboxMode()) {
+        const content = await fs.readFile(params.path, "utf-8");
+        return { content };
+    }
+    const db = await getRuntimeDb(params.runtime);
+    const service = new SandboxService(db);
+    const result = await service.readFile(params.sandboxId, params.path);
+    if (!result.ok)
+        throw new Error(result.error);
+    return { content: Buffer.from(result.data.contentBase64, "base64").toString("utf-8") };
+}
+export async function stopDatasetSandboxStep(params) {
     "use step";
     if (isLocalDatasetSandboxMode()) {
         const root = getLocalSandboxRoot(params.sandboxId);
-        await node_fs_1.promises.rm(root, { recursive: true, force: true });
+        await fs.rm(root, { recursive: true, force: true });
         localSandboxRoots.delete(params.sandboxId);
         return;
     }
-    const db = (await (0, runtime_1.getContextRuntime)(params.env)).db;
-    const { SandboxService } = (await Promise.resolve().then(() => __importStar(require("@ekairos/sandbox"))));
+    const db = await getRuntimeDb(params.runtime);
     const service = new SandboxService(db);
     const result = await service.stopSandbox(params.sandboxId);
     if (!result.ok)
         throw new Error(result.error);
 }
-//# sourceMappingURL=steps.js.map

package/dist/sandbox.steps.d.ts

@@ -1,2 +1 @@
-export * from "./sandbox/steps";
-//# sourceMappingURL=sandbox.steps.d.ts.map
+export * from "./sandbox/steps.js";

package/dist/sandbox.steps.js

@@ -1,18 +1 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./sandbox/steps"), exports);
-//# sourceMappingURL=sandbox.steps.js.map
+export * from "./sandbox/steps.js";

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>;
@@ -21,15 +19,6 @@ declare const entities: {
         order: import("@instantdb/core").DataAttrDef<number, true, true, false>;
         createdAt: import("@instantdb/core").DataAttrDef<number, true, false, false>;
     }, {}, void>;
-    readonly $files: import("@instantdb/core").EntityDef<{
-        path: import("@instantdb/core").DataAttrDef<string, false, true, false>;
-        url: import("@instantdb/core").DataAttrDef<string, false, false, false>;
-        name: import("@instantdb/core").DataAttrDef<string, false, false, false>;
-        contentType: import("@instantdb/core").DataAttrDef<string, false, false, false>;
-        size: import("@instantdb/core").DataAttrDef<number, false, false, false>;
-        createdAt: import("@instantdb/core").DataAttrDef<number, false, true, false>;
-        updatedAt: import("@instantdb/core").DataAttrDef<number, false, true, false>;
-    }, {}, void>;
 };
 declare const links: {
     readonly dataset_datasetsRecords: {
@@ -56,8 +45,19 @@ 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>;
+export declare const datasetDomain: DomainSchemaResult<typeof entities, typeof links, typeof rooms, {}, "dataset", "dataset">;
 export {};
-//# sourceMappingURL=schema.d.ts.map

package/dist/schema.js

@@ -1,40 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.datasetDomain = void 0;
-const core_1 = require("@instantdb/core");
-const domain_1 = require("@ekairos/domain");
+import { i } from "@instantdb/core";
+import { domain } from "@ekairos/domain";
+import { eventsDomain } from "@ekairos/events";
 const entities = {
-    dataset_datasets: core_1.i.entity({
-        datasetId: core_1.i.string().unique().indexed(),
-        sandboxId: core_1.i.string().optional().indexed(),
-        status: core_1.i.string().optional().indexed(),
-        createdAt: core_1.i.number().optional().indexed(),
-        updatedAt: core_1.i.number().optional(),
-        organizationId: core_1.i.string().optional().indexed(),
-        title: core_1.i.string().optional(),
-        sources: core_1.i.json().optional(),
-        sourceKinds: core_1.i.json().optional(),
-        instructions: core_1.i.string().optional(),
-        analysis: core_1.i.json().optional(),
-        schema: core_1.i.json().optional(),
-        calculatedTotalRows: core_1.i.number().optional(),
-        actualGeneratedRowCount: core_1.i.number().optional(),
+    dataset_datasets: i.entity({
+        datasetId: i.string().unique().indexed(),
+        sandboxId: i.string().optional().indexed(),
+        status: i.string().optional().indexed(),
+        createdAt: i.number().optional().indexed(),
+        updatedAt: i.number().optional(),
+        organizationId: i.string().optional().indexed(),
+        title: i.string().optional(),
+        instructions: i.string().optional(),
+        analysis: i.json().optional(),
+        schema: i.json().optional(),
+        calculatedTotalRows: i.number().optional(),
+        actualGeneratedRowCount: i.number().optional(),
     }),
-    dataset_records: core_1.i.entity({
-        rowContent: core_1.i.json(),
-        order: core_1.i.number().indexed(),
-        createdAt: core_1.i.number(),
-    }),
-    // Keep $files compatible with Instant's base file fields used by dataset agents/tools.
-    // (path/url are required by file download + dataset output linking)
-    $files: core_1.i.entity({
-        path: core_1.i.string().optional().indexed(),
-        url: core_1.i.string().optional(),
-        name: core_1.i.string().optional(),
-        contentType: core_1.i.string().optional(),
-        size: core_1.i.number().optional(),
-        createdAt: core_1.i.number().optional().indexed(),
-        updatedAt: core_1.i.number().optional().indexed(),
+    dataset_records: i.entity({
+        rowContent: i.json(),
+        order: i.number().indexed(),
+        createdAt: i.number(),
     }),
 };
 const links = {
@@ -46,11 +31,14 @@ 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 = {};
-exports.datasetDomain = (0, domain_1.domain)("dataset").schema({
+export const datasetDomain = domain("dataset").includes(eventsDomain).withSchema({
     entities,
     links,
     rooms,
 });
-//# sourceMappingURL=schema.js.map

package/dist/service.d.ts

@@ -1,6 +1,6 @@
-import { InstantAdminDatabase } from "@instantdb/admin";
+import type { InstantAdminDatabase } from "@instantdb/admin";
 import { SchemaOf } from "@ekairos/domain";
-import { datasetDomain } from "./schema";
+import { datasetDomain } from "./schema.js";
 export type ServiceResult<T = any> = {
     ok: true;
     data: T;
@@ -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;
@@ -74,6 +74,10 @@ export declare class DatasetService {
         storagePath: string;
     }): Promise<ServiceResult<void>>;
     readRecordsFromFile(datasetId: string): Promise<ServiceResult<AsyncGenerator<any, void, unknown>>>;
+    readLinkedRecords(datasetId: string): Promise<ServiceResult<Array<{
+        rowContent: any;
+        order: number;
+    }>>>;
     previewRows(datasetId: string, limit?: number): Promise<ServiceResult<any[]>>;
     readRows(params: {
         datasetId: string;
@@ -87,4 +91,3 @@ export declare class DatasetService {
     readOne(datasetId: string): Promise<ServiceResult<any | null>>;
 }
 export {};
-//# sourceMappingURL=service.d.ts.map

package/dist/service.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatasetService = void 0;
-const admin_1 = require("@instantdb/admin");
-class DatasetService {
+import { createDatasetId } from "./id.js";
+export class DatasetService {
     constructor(db) {
         this.db = db;
     }
@@ -30,19 +27,22 @@ class DatasetService {
     }
     async createDataset(params) {
         try {
-            const datasetId = params.id ?? (0, admin_1.id)();
+            const datasetId = params.id ?? createDatasetId();
+            const { id: _id, contextId, ...attrs } = params;
             const existing = await this.resolveDatasetEntityId(datasetId);
-            const entityId = existing.ok ? existing.data : (0, admin_1.id)();
+            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 } };
         }
@@ -76,7 +76,7 @@ class DatasetService {
                 return resolved;
             const mutations = [];
             for (const record of params.records) {
-                const recordId = (0, admin_1.id)();
+                const recordId = createDatasetId();
                 mutations.push(this.db.tx.dataset_records[recordId].update({
                     rowContent: record.rowContent,
                     order: record.order,
@@ -311,7 +311,7 @@ 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",
@@ -432,8 +432,51 @@ class DatasetService {
             return { ok: false, error: message };
         }
     }
+    async readLinkedRecords(datasetId) {
+        try {
+            const query = await this.db.query({
+                dataset_datasets: {
+                    $: {
+                        where: { datasetId },
+                        limit: 1,
+                    },
+                    records: {},
+                },
+            });
+            const datasetRecord = query.dataset_datasets?.[0];
+            if (!datasetRecord) {
+                return { ok: false, error: `Dataset not found with id: ${datasetId}` };
+            }
+            const linkedRecords = Array.isArray(datasetRecord?.records)
+                ? datasetRecord.records
+                : [];
+            return {
+                ok: true,
+                data: linkedRecords
+                    .slice()
+                    .sort((a, b) => Number(a?.order ?? 0) - Number(b?.order ?? 0))
+                    .map((record) => ({
+                    rowContent: record?.rowContent,
+                    order: Number(record?.order ?? 0),
+                })),
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
     async previewRows(datasetId, limit = 20) {
         try {
+            const linkedRecords = await this.readLinkedRecords(datasetId);
+            if (linkedRecords.ok && linkedRecords.data.length > 0) {
+                return {
+                    ok: true,
+                    data: linkedRecords.data
+                        .slice(0, Math.max(0, Number(limit ?? 20)))
+                        .map((record) => record.rowContent),
+                };
+            }
             const readResult = await this.readRecordsFromFile(datasetId);
             if (!readResult.ok) {
                 return readResult;
@@ -454,12 +497,26 @@ class DatasetService {
     }
     async readRows(params) {
         try {
+            const start = Math.max(0, Number(params.cursor ?? 0));
+            const limit = Math.max(1, Number(params.limit ?? 200));
+            const linkedRecords = await this.readLinkedRecords(params.datasetId);
+            if (linkedRecords.ok && linkedRecords.data.length > 0) {
+                const rows = linkedRecords.data
+                    .slice(start, start + limit)
+                    .map((record) => record.rowContent);
+                return {
+                    ok: true,
+                    data: {
+                        rows,
+                        cursor: start + rows.length,
+                        done: start + rows.length >= linkedRecords.data.length,
+                    },
+                };
+            }
             const readResult = await this.readRecordsFromFile(params.datasetId);
             if (!readResult.ok) {
                 return readResult;
             }
-            const start = Math.max(0, Number(params.cursor ?? 0));
-            const limit = Math.max(1, Number(params.limit ?? 200));
             const rows = [];
             let index = 0;
             let hasMore = false;
@@ -507,5 +564,3 @@ class DatasetService {
         }
     }
 }
-exports.DatasetService = DatasetService;
-//# sourceMappingURL=service.js.map

package/dist/skill.d.ts

@@ -8,4 +8,3 @@ export type DatasetSkillPackage = {
     files: DatasetSkillPackageFile[];
 };
 export declare function buildDatasetSkillPackage(): DatasetSkillPackage;
-//# sourceMappingURL=skill.d.ts.map