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

package/dist/datasetFiles.d.ts

@@ -1,5 +1,9 @@
 export declare const DATASET_OUTPUT_FILE_NAME = "output.jsonl";
 export declare function getDatasetWorkdirBase(): string;
 export declare function getDatasetWorkstation(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;
+export declare function getDatasetStandardDirs(datasetId: string): string[];
 export declare function getDatasetOutputPath(datasetId: string): string;
-//# sourceMappingURL=datasetFiles.d.ts.map

package/dist/datasetFiles.js

@@ -1,33 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DATASET_OUTPUT_FILE_NAME = void 0;
-exports.getDatasetWorkdirBase = getDatasetWorkdirBase;
-exports.getDatasetWorkstation = getDatasetWorkstation;
-exports.getDatasetOutputPath = getDatasetOutputPath;
-exports.DATASET_OUTPUT_FILE_NAME = "output.jsonl";
-const DEFAULT_VERCEL_WORKDIR_BASE = "/vercel/sandbox/datasets";
-const DEFAULT_DAYTONA_WORKDIR_BASE = "/home/daytona/.ekairos/datasets";
-const DEFAULT_SPRITES_WORKDIR_BASE = "/workspace/.ekairos/datasets";
+export const DATASET_OUTPUT_FILE_NAME = "output.jsonl";
+const DATASET_WORKDIR_BASE = "/tmp/ekairos/dataset";
 function trimTrailingSlash(value) {
     return value.endsWith("/") ? value.slice(0, -1) : value;
 }
-function getDatasetWorkdirBase() {
-    const explicit = String(process.env.DATASET_SANDBOX_WORKDIR_BASE ?? "").trim();
-    if (explicit)
-        return trimTrailingSlash(explicit);
-    const provider = String(process.env.SANDBOX_PROVIDER ?? "").trim().toLowerCase();
-    if (provider === "daytona")
-        return DEFAULT_DAYTONA_WORKDIR_BASE;
-    if (provider === "vercel")
-        return DEFAULT_VERCEL_WORKDIR_BASE;
-    if (provider === "sprites")
-        return DEFAULT_SPRITES_WORKDIR_BASE;
-    return DEFAULT_VERCEL_WORKDIR_BASE;
-}
-function getDatasetWorkstation(datasetId) {
+export function getDatasetWorkdirBase() {
+    return trimTrailingSlash(DATASET_WORKDIR_BASE);
+}
+export function getDatasetWorkstation(datasetId) {
     return `${getDatasetWorkdirBase()}/${datasetId}`;
 }
-function getDatasetOutputPath(datasetId) {
-    return `${getDatasetWorkstation(datasetId)}/${exports.DATASET_OUTPUT_FILE_NAME}`;
+export function getDatasetResourcesDir(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/resources`;
+}
+export function getDatasetScriptsDir(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/scripts`;
+}
+export function getDatasetArtifactsDir(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/artifacts`;
+}
+export function getDatasetLogsDir(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/logs`;
+}
+export function getDatasetStandardDirs(datasetId) {
+    return [
+        getDatasetWorkstation(datasetId),
+        getDatasetResourcesDir(datasetId),
+        getDatasetScriptsDir(datasetId),
+        getDatasetArtifactsDir(datasetId),
+        getDatasetLogsDir(datasetId),
+    ];
+}
+export function getDatasetOutputPath(datasetId) {
+    return `${getDatasetWorkstation(datasetId)}/${DATASET_OUTPUT_FILE_NAME}`;
 }
-//# sourceMappingURL=datasetFiles.js.map

package/dist/defineNotation.tool.d.ts

@@ -0,0 +1,49 @@
+interface DefineNotationToolParams {
+    datasetId: string;
+    runtime: any;
+}
+/**
+ * defineNotation — author or REFINE the formal DEFINITION of the dataset.
+ *
+ * A dataset has two co-equal faces: its formal definition (the notation —
+ * the proposition that defines the set, in LaTeX) and its materialization
+ * (the rows + the code that produces them). They sit at the SAME level: the
+ * definition is not a side note about the data, it IS the dataset stated
+ * intensionally. The same notation is the PLAN (you state it first and the
+ * materialization realizes it) and, finalized, the RESULT (it describes what
+ * you produced).
+ *
+ * Call it FIRST with the initial definition derived from the resources, and
+ * AGAIN whenever the analysis discovers new sets, variables, constraints or
+ * corrections — every call keeps the prior version in history. Mark the last
+ * call with final=true so the definition describes the produced dataset.
+ * Predicates may be formal/semantic (trusted); the few that are arithmetic
+ * MAY carry optional advisory evidence.
+ */
+export declare function createDefineNotationTool({ datasetId, runtime }: DefineNotationToolParams): import("ai").Tool<{
+    latex: string;
+    symbols: {
+        name: string;
+        kind: "function" | "set" | "variable" | "constant" | "predicate";
+        description: string;
+        latex?: string | undefined;
+    }[];
+    predicates: {
+        id: string;
+        description: string;
+        latex: string;
+        checkJson?: string | undefined;
+    }[];
+    reason: string;
+    final?: boolean | undefined;
+}, {
+    success: boolean;
+    error: string;
+} | {
+    warning?: string | undefined;
+    success: boolean;
+    version: number;
+    status: import("./notation.js").DatasetNotationStatus;
+    error?: undefined;
+}>;
+export {};

package/dist/defineNotation.tool.js

@@ -0,0 +1,154 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { DatasetService } from "./service.js";
+import { datasetDomain } from "./schema.js";
+import { reviseDatasetNotation, } from "./notation.js";
+const symbolSchema = z.object({
+    name: z.string().describe("Plain identifier, e.g. 'D', 'Orders', 'w'"),
+    latex: z
+        .string()
+        .optional()
+        .describe("LaTeX for the symbol, e.g. '\\\\mathcal{D}' (defaults to the name)"),
+    kind: z.enum(["set", "variable", "function", "constant", "predicate"]),
+    description: z.string().describe("What this symbol denotes in the data"),
+});
+const predicateSchema = z.object({
+    id: z.string().describe("Stable id, e.g. 'p1', 'cardinality'"),
+    description: z.string().describe("The claim in plain language"),
+    latex: z
+        .string()
+        .describe("The claim in LaTeX, e.g. '\\\\forall r \\\\in D: r.amount > 0'"),
+    checkJson: z
+        .string()
+        .optional()
+        .describe([
+        "OPTIONAL arithmetic form of the claim as a JSON string, used only for",
+        "advisory evidence over the produced rows (not a verdict). Shapes:",
+        '{"kind":"row_count","op":"=","value":124}',
+        '{"kind":"field_type","field":"amount","type":"number","allowNull":true}',
+        '{"kind":"field_range","field":"amount","min":0}',
+        '{"kind":"field_in","field":"status","values":["paid","void"]}',
+        '{"kind":"field_nonnull","field":"orderId"}',
+        '{"kind":"field_matches","field":"sku","pattern":"^[A-Z0-9-]+$"}',
+        '{"kind":"unique","fields":["orderId"]}',
+        '{"kind":"aggregate","fn":"sum","field":"amount","op":">=","value":0}',
+        'Propositional composition: {"kind":"and"|"or","checks":[...]},',
+        '{"kind":"not","check":...}, {"kind":"implies","if":...,"then":...}.',
+        "Fields support dot-paths into nested records (company.taxId).",
+        "Omit for formal/semantic claims (the normal case) — they are trusted.",
+    ].join(" ")),
+});
+async function getDatasetService(runtime) {
+    const scoped = await runtime.use(datasetDomain);
+    return new DatasetService(scoped.db);
+}
+/**
+ * defineNotation — author or REFINE the formal DEFINITION of the dataset.
+ *
+ * A dataset has two co-equal faces: its formal definition (the notation —
+ * the proposition that defines the set, in LaTeX) and its materialization
+ * (the rows + the code that produces them). They sit at the SAME level: the
+ * definition is not a side note about the data, it IS the dataset stated
+ * intensionally. The same notation is the PLAN (you state it first and the
+ * materialization realizes it) and, finalized, the RESULT (it describes what
+ * you produced).
+ *
+ * Call it FIRST with the initial definition derived from the resources, and
+ * AGAIN whenever the analysis discovers new sets, variables, constraints or
+ * corrections — every call keeps the prior version in history. Mark the last
+ * call with final=true so the definition describes the produced dataset.
+ * Predicates may be formal/semantic (trusted); the few that are arithmetic
+ * MAY carry optional advisory evidence.
+ */
+export function createDefineNotationTool({ datasetId, runtime }) {
+    return tool({
+        description: [
+            "Author or refine the formal DEFINITION of the dataset: the dataset as a",
+            "set in LaTeX (set-builder, relational algebra, quantified or even",
+            "semantic predicates) plus the symbols it binds. This definition and the",
+            "materialization (rows + code) are TWO CO-EQUAL FACES of the dataset —",
+            "the definition is the dataset stated intensionally, not a comment on it.",
+            "It is your PLAN (state it before writing any code; the materialization",
+            "realizes it) and, once final, the RESULT (it describes what you",
+            "produced). The definition is a logical proposition, possibly derived —",
+            "it need not be mechanically provable; we trust the formality. State it",
+            "first, refine it on every discovery, and set final=true on the last",
+            "call. For the few predicates that are arithmetic you MAY attach a",
+            "checkJson for optional advisory evidence (non-blocking, never a verdict).",
+        ].join(" "),
+        inputSchema: z.object({
+            latex: z
+                .string()
+                .describe("Main definition of the dataset as a set, in LaTeX. Example: 'D = \\\\{(w,r,t) \\\\mid t = \\\\sum_{o \\\\in Orders} o.amount,\\\\; o.status = paid\\\\}'"),
+            symbols: z.array(symbolSchema).describe("Symbols bound by the definition"),
+            predicates: z
+                .array(predicateSchema)
+                .describe("Claims the set satisfies; attach a checkJson only when arithmetic"),
+            reason: z
+                .string()
+                .describe("What this revision states or what discovery triggered it (or 'initial definition')"),
+            final: z
+                .boolean()
+                .optional()
+                .describe("true when this definition describes the dataset you are about to complete (the RESULT)"),
+        }),
+        execute: async ({ latex, symbols, predicates, reason, final }) => {
+            try {
+                const service = await getDatasetService(runtime);
+                const existing = await service.getDatasetById(datasetId);
+                const previous = (existing.ok ? existing.data?.notation : null);
+                const parsedPredicates = [];
+                const checkErrors = [];
+                for (const predicate of predicates) {
+                    let check;
+                    if (predicate.checkJson) {
+                        try {
+                            check = JSON.parse(predicate.checkJson);
+                            if (!check || typeof check !== "object" || !("kind" in check)) {
+                                throw new Error("check must be an object with a 'kind'");
+                            }
+                        }
+                        catch (error) {
+                            checkErrors.push(`predicate ${predicate.id}: invalid checkJson (${String(error).slice(0, 80)})`);
+                            check = undefined;
+                        }
+                    }
+                    parsedPredicates.push({
+                        id: predicate.id,
+                        description: predicate.description,
+                        latex: predicate.latex,
+                        ...(check ? { check } : {}),
+                    });
+                }
+                const notation = reviseDatasetNotation(previous, {
+                    latex,
+                    symbols: symbols,
+                    predicates: parsedPredicates,
+                    reason,
+                    final,
+                });
+                const update = await service.updateDatasetNotation({ datasetId, notation });
+                if (!update.ok) {
+                    return { success: false, error: update.error };
+                }
+                console.log(`[Dataset ${datasetId}] definition v${notation.version} (${notation.status}): ${reason}`);
+                return {
+                    success: true,
+                    version: notation.version,
+                    status: notation.status,
+                    ...(checkErrors.length
+                        ? {
+                            warning: `some checks were dropped: ${checkErrors.join("; ")}`,
+                        }
+                        : {}),
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        },
+    });
+}

package/dist/domain.d.ts

@@ -1,2 +1 @@
-export { datasetDomain } from "./schema";
-//# sourceMappingURL=domain.d.ts.map
+export { datasetDomain } from "./schema.js";

package/dist/domain.js

@@ -1,6 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.datasetDomain = void 0;
-var schema_1 = require("./schema");
-Object.defineProperty(exports, "datasetDomain", { enumerable: true, get: function () { return schema_1.datasetDomain; } });
-//# sourceMappingURL=domain.js.map
+export { datasetDomain } from "./schema.js";

package/dist/executeCommand.tool.d.ts

@@ -1,35 +1,7 @@
 interface ExecuteCommandToolParams {
     datasetId: string;
     sandboxId: string;
-    env?: any;
+    runtime: any;
 }
-export declare function createExecuteCommandTool({ datasetId, sandboxId, env }: ExecuteCommandToolParams): import("ai").Tool<{
-    pythonCode: string;
-    scriptName: string;
-}, {
-    success: boolean;
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-    scriptPath: string;
-    error: string;
-    stdoutTruncated: boolean;
-    stderrTruncated: boolean;
-    stdoutOriginalLength: number;
-    stderrOriginalLength: number;
-    message?: undefined;
-} | {
-    success: boolean;
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-    scriptPath: string;
-    message: string;
-    stdoutTruncated: boolean;
-    stderrTruncated: boolean;
-    stdoutOriginalLength: number;
-    stderrOriginalLength: number;
-    error?: undefined;
-}>;
+export declare function createExecuteCommandTool({ datasetId, sandboxId, runtime }: ExecuteCommandToolParams): any;
 export {};
-//# sourceMappingURL=executeCommand.tool.d.ts.map

package/dist/executeCommand.tool.js

@@ -1,49 +1,164 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExecuteCommandTool = createExecuteCommandTool;
-const ai_1 = require("ai");
-const zod_1 = require("zod");
-const steps_1 = require("./sandbox/steps");
-const datasetFiles_1 = require("./datasetFiles");
-// To keep responses predictable for big data scenarios, we cap stdout/stderr.
-// The tool's return payload exposes stdout (capped) plus the on-disk script path.
+import { defineAction } from "@ekairos/events";
+import { z } from "zod";
+import { materializeContextResourcesStep } from "./contextResources.js";
+import { getDatasetScriptsDir, getDatasetStandardDirs } from "./datasetFiles.js";
+import { getContextExecutionWorkspaceDirs } from "./contextWorkspace.js";
+import { runDatasetSandboxCommandStep, writeDatasetSandboxTextFilesStep, } from "./sandbox/steps.js";
 const MAX_STDOUT_CHARS = 20000;
 const MAX_STDERR_CHARS = 5000;
-function createExecuteCommandTool({ datasetId, sandboxId, env }) {
-    return (0, ai_1.tool)({
-        description: "Execute Python scripts in the sandbox. Always saves script to a file before executing. The tool's output is EXACTLY the script's stdout and includes the script file path for traceability. CRITICAL: Print concise, human-readable summaries only; do NOT print raw large data. For big results, write artifacts to files in the workstation and print their file paths. Always include progress/result prints (e.g., 'Processing file X...', 'Found Y records', 'Generated output.csv').",
-        inputSchema: zod_1.z.object({
-            pythonCode: zod_1.z.string().describe("Python code to execute. Saved to a file before running. MANDATORY: Use print() to report progress and final results. Keep prints concise; avoid dumping rows/JSON. For large outputs, write to files in the workstation directory and print only file paths and brief summaries."),
-            scriptName: zod_1.z.string().describe("Name for the script file in snake_case (e.g., 'inspect_file', 'parse_csv', 'generate_dataset'). A UUID will be appended automatically."),
-        }),
-        execute: async ({ pythonCode, scriptName }) => {
-            const uuid = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-            const workstation = (0, datasetFiles_1.getDatasetWorkstation)(datasetId);
-            const scriptFile = `${workstation}/${scriptName}-${uuid}.py`;
+function normalizeScriptName(scriptName) {
+    const normalized = String(scriptName ?? "")
+        .trim()
+        .replace(/[^a-zA-Z0-9_.-]/g, "_")
+        .replace(/_+/g, "_")
+        .slice(0, 80);
+    return normalized || "script";
+}
+function stableScriptHash(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index++) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+}
+const executeCommandInputSchema = z.object({
+    commandDescription: z
+        .string()
+        .min(1)
+        .describe("Required pre-execution description of the command. Describe the inputs/resources it will use, the operation it will perform, the expected output, and why a command is the right tool instead of direct completion. Invalid descriptions include rereading resources whose descriptor/preview already contains the needed evidence, merely formatting JSON, constructing the final object, writing output.jsonl, or making completion easier."),
+    pythonCode: z
+        .string()
+        .describe("Python code to execute. Saved to a file before running. MANDATORY: Use print() to report progress and final results. Keep prints concise; avoid dumping rows/JSON. If context resources are materialized, read os.environ['EKAIROS_CONTEXT_RESOURCES_MANIFEST'] to discover files and metadata. Do not install packages, download dependencies, use pip/npm/apt/curl/wget, or access the network. For large outputs, write to files in the workstation directory and print only file paths and brief summaries."),
+    scriptName: z
+        .string()
+        .describe("Name for the script file in snake_case (e.g., 'inspect_file', 'parse_csv', 'generate_dataset'). A deterministic suffix will be appended automatically."),
+    resourceKeys: z
+        .array(z.string())
+        .optional()
+        .describe("Optional context resource keys to materialize before running the script. Omit to materialize every context resource."),
+});
+const materializedResourceSchema = z.object({
+    key: z.string(),
+    type: z.string(),
+    status: z.string(),
+    dir: z.string(),
+    files: z.array(z.object({
+        path: z.string(),
+        role: z.string(),
+        mediaType: z.string().optional(),
+    })),
+    reason: z.string().optional(),
+});
+const executeCommandOutputSchema = z
+    .object({
+    success: z.boolean(),
+    fatal: z.boolean().optional(),
+    status: z.string().optional(),
+    exitCode: z.number().optional(),
+    stdout: z.string(),
+    stderr: z.string(),
+    scriptPath: z.string(),
+    message: z.string().optional(),
+    error: z.string().optional(),
+    resourcesDir: z.string().optional(),
+    resourcesManifestPath: z.string().optional(),
+    materializedResources: z.array(materializedResourceSchema).optional(),
+    stdoutTruncated: z.boolean(),
+    stderrTruncated: z.boolean(),
+    stdoutOriginalLength: z.number(),
+    stderrOriginalLength: z.number(),
+})
+    .passthrough();
+export function createExecuteCommandTool({ datasetId, sandboxId, runtime }) {
+    return defineAction({
+        description: "Execute Python scripts in the sandbox only when command execution is necessary to inspect, parse, aggregate, join, or compute over context resources that are not sufficiently represented in the visible context, resource descriptors, or previews. This is a high-cost computation tool, not a completion tool. Do not use it merely to reread resources whose descriptor/preview already contains the needed evidence, format JSON, build the final object, write output.jsonl, or make completion easier when completeObject or replaceRows can return the result directly. Before the script runs, requested context resources are materialized into /tmp/ekairos/contexts/{contextId}/resources and a manifest.json is written there. The Python process receives EKAIROS_CONTEXT_RESOURCES_DIR and EKAIROS_CONTEXT_RESOURCES_MANIFEST environment variables when resources are available; manifest entries expose files as resources[].files[].path. Do not install packages, download dependencies, use pip/npm/apt/curl/wget, or access the network; use only the available runtime and standard library unless a dependency is already present. Print concise progress and results only; do not dump large data.",
+        input: executeCommandInputSchema,
+        output: executeCommandOutputSchema,
+        execute: async ({ input, context, contextId, executionId, }) => {
+            const { commandDescription, pythonCode, resourceKeys, scriptName } = input;
+            const normalizedScriptName = normalizeScriptName(scriptName);
+            const scriptHash = stableScriptHash(`${normalizedScriptName}\0${pythonCode}`);
+            const scriptsDir = contextId && executionId
+                ? getContextExecutionWorkspaceDirs({ contextId, executionId }).scriptsDir
+                : getDatasetScriptsDir(datasetId);
+            const scriptFile = `${scriptsDir}/${normalizedScriptName}-${scriptHash}.py`;
+            let resourcesManifest = null;
             console.log(`[Dataset ${datasetId}] ========================================`);
-            console.log(`[Dataset ${datasetId}] Tool: executeCommand`);
-            console.log(`[Dataset ${datasetId}] Script: ${scriptName}`);
+            console.log(`[Dataset ${datasetId}] Action: executeCommand`);
+            console.log(`[Dataset ${datasetId}] Description: ${commandDescription}`);
+            console.log(`[Dataset ${datasetId}] Script: ${normalizedScriptName}`);
             console.log(`[Dataset ${datasetId}] File: ${scriptFile}`);
             console.log(`[Dataset ${datasetId}] Code length: ${pythonCode.length} chars`);
             console.log(`[Dataset ${datasetId}] ========================================`);
             try {
-                await (0, steps_1.writeDatasetSandboxFilesStep)({
-                    env,
+                if (contextId && Array.isArray(context?.resources) && context.resources.length > 0) {
+                    resourcesManifest = await materializeContextResourcesStep({
+                        runtime,
+                        sandboxId,
+                        contextId,
+                        resources: context.resources,
+                        resourceKeys,
+                    });
+                    console.log(`[Dataset ${datasetId}] Resources manifest: ${resourcesManifest.manifestPath}`);
+                }
+                await runDatasetSandboxCommandStep({
+                    runtime,
+                    sandboxId,
+                    cmd: "mkdir",
+                    args: ["-p", ...getDatasetStandardDirs(datasetId), scriptsDir],
+                });
+                await writeDatasetSandboxTextFilesStep({
+                    runtime,
+                    sandboxId,
+                    files: [{ path: scriptFile, content: pythonCode }],
+                });
+                const written = await runDatasetSandboxCommandStep({
+                    runtime,
                     sandboxId,
-                    files: [
-                        {
-                            path: scriptFile,
-                            contentBase64: Buffer.from(pythonCode, "utf-8").toString("base64"),
-                        },
-                    ],
+                    cmd: "test",
+                    args: ["-f", scriptFile],
                 });
+                if (written.exitCode !== 0) {
+                    const error = `Script write verification failed: ${scriptFile}`;
+                    console.error(`[Dataset ${datasetId}] ${error}`);
+                    console.error(`[Dataset ${datasetId}] ========================================`);
+                    return {
+                        success: false,
+                        fatal: true,
+                        status: "script_write_failed",
+                        error,
+                        stdout: written.stdout || "",
+                        stderr: written.stderr || "",
+                        exitCode: written.exitCode,
+                        scriptPath: scriptFile,
+                        resourcesDir: resourcesManifest?.resourcesDir,
+                        resourcesManifestPath: resourcesManifest?.manifestPath,
+                        materializedResources: resourcesManifest?.resources,
+                        stdoutTruncated: false,
+                        stderrTruncated: false,
+                        stdoutOriginalLength: 0,
+                        stderrOriginalLength: 0,
+                    };
+                }
+                const pythonArgs = resourcesManifest
+                    ? [
+                        "-c",
+                        [
+                            "import os, runpy",
+                            `os.environ["EKAIROS_CONTEXT_RESOURCES_DIR"] = ${JSON.stringify(resourcesManifest.resourcesDir)}`,
+                            `os.environ["EKAIROS_CONTEXT_RESOURCES_MANIFEST"] = ${JSON.stringify(resourcesManifest.manifestPath)}`,
+                            `runpy.run_path(${JSON.stringify(scriptFile)}, run_name="__main__")`,
+                        ].join("; "),
+                    ]
+                    : [scriptFile];
                 console.log(`[Dataset ${datasetId}] Script written to: ${scriptFile}`);
-                console.log(`[Dataset ${datasetId}] Executing: python ${scriptFile}`);
-                const result = await (0, steps_1.runDatasetSandboxCommandStep)({
-                    env,
+                console.log(`[Dataset ${datasetId}] Executing: python ${resourcesManifest ? "<with context resources env>" : scriptFile}`);
+                const result = await runDatasetSandboxCommandStep({
+                    runtime,
                     sandboxId,
                     cmd: "python",
-                    args: [scriptFile],
+                    args: pythonArgs,
                 });
                 const stdout = result.stdout || "";
                 const stderr = result.stderr || "";
@@ -53,7 +168,7 @@ function createExecuteCommandTool({ datasetId, sandboxId, env }) {
                 const stdoutCapped = isStdoutTruncated ? stdout.slice(0, MAX_STDOUT_CHARS) : stdout;
                 const stderrCapped = isStderrTruncated ? stderr.slice(0, MAX_STDERR_CHARS) : stderr;
                 if (exitCode !== 0) {
-                    console.error(`[Dataset ${datasetId}] ❌ Command failed with exit code ${exitCode}`);
+                    console.error(`[Dataset ${datasetId}] Command failed with exit code ${exitCode}`);
                     console.error(`[Dataset ${datasetId}] Stderr:`, stderrCapped.substring(0, 500));
                     console.error(`[Dataset ${datasetId}] ========================================`);
                     return {
@@ -63,6 +178,9 @@ function createExecuteCommandTool({ datasetId, sandboxId, env }) {
                         stderr: stderrCapped,
                         scriptPath: scriptFile,
                         error: `Command failed with exit code ${exitCode}`,
+                        resourcesDir: resourcesManifest?.resourcesDir,
+                        resourcesManifestPath: resourcesManifest?.manifestPath,
+                        materializedResources: resourcesManifest?.resources,
                         stdoutTruncated: isStdoutTruncated,
                         stderrTruncated: isStderrTruncated,
                         stdoutOriginalLength: stdout.length,
@@ -70,7 +188,7 @@ function createExecuteCommandTool({ datasetId, sandboxId, env }) {
                     };
                 }
                 if (stderr && (stderr.includes("Traceback") || stderr.toLowerCase().includes("error"))) {
-                    console.error(`[Dataset ${datasetId}] ❌ Python error detected`);
+                    console.error(`[Dataset ${datasetId}] Python error detected`);
                     console.error(`[Dataset ${datasetId}] Stderr:`, stderrCapped.substring(0, 500));
                     console.error(`[Dataset ${datasetId}] ========================================`);
                     return {
@@ -80,17 +198,20 @@ function createExecuteCommandTool({ datasetId, sandboxId, env }) {
                         stderr: stderrCapped,
                         scriptPath: scriptFile,
                         error: "Python error detected in stderr",
+                        resourcesDir: resourcesManifest?.resourcesDir,
+                        resourcesManifestPath: resourcesManifest?.manifestPath,
+                        materializedResources: resourcesManifest?.resources,
                         stdoutTruncated: isStdoutTruncated,
                         stderrTruncated: isStderrTruncated,
                         stdoutOriginalLength: stdout.length,
                         stderrOriginalLength: stderr.length,
                     };
                 }
-                console.log(`[Dataset ${datasetId}] ✅ Command executed successfully`);
+                console.log(`[Dataset ${datasetId}] Command executed successfully`);
                 if (stdout) {
                     console.log(`[Dataset ${datasetId}] Output length: ${stdout.length} chars`);
                     if (isStdoutTruncated) {
-                        console.log(`[Dataset ${datasetId}] ⚠️  Stdout truncated to ${MAX_STDOUT_CHARS} chars`);
+                        console.log(`[Dataset ${datasetId}] Stdout truncated to ${MAX_STDOUT_CHARS} chars`);
                     }
                 }
                 console.log(`[Dataset ${datasetId}] ========================================`);
@@ -101,6 +222,9 @@ function createExecuteCommandTool({ datasetId, sandboxId, env }) {
                     stderr: stderrCapped,
                     scriptPath: scriptFile,
                     message: "Command executed successfully",
+                    resourcesDir: resourcesManifest?.resourcesDir,
+                    resourcesManifestPath: resourcesManifest?.manifestPath,
+                    materializedResources: resourcesManifest?.resources,
                     stdoutTruncated: isStdoutTruncated,
                     stderrTruncated: isStderrTruncated,
                     stdoutOriginalLength: stdout.length,
@@ -118,6 +242,9 @@ function createExecuteCommandTool({ datasetId, sandboxId, env }) {
                     stderr: "",
                     exitCode: -1,
                     scriptPath: scriptFile,
+                    resourcesDir: resourcesManifest?.resourcesDir,
+                    resourcesManifestPath: resourcesManifest?.manifestPath,
+                    materializedResources: resourcesManifest?.resources,
                     stdoutTruncated: false,
                     stderrTruncated: false,
                     stdoutOriginalLength: 0,
@@ -127,4 +254,3 @@ function createExecuteCommandTool({ datasetId, sandboxId, env }) {
         },
     });
 }
-//# sourceMappingURL=executeCommand.tool.js.map