@aexol/spectral 0.9.254 → 0.9.255

package/dist/extensions/dataset-uploader/upload.js

@@ -0,0 +1,274 @@
+/**
+ * Chunked dataset upload to the team dataset vault (Dataset-uploader.md §3.2 —
+ * the `dataset_upload` tool's core).
+ *
+ * Loads a (cleaned) sharegpt JSONL, validates each line, groups it into
+ * batches of `batchSize` and calls the backend MCP tool
+ * `upload_dataset_samples` (JSON-RPC tools/call, Bearer auth) per batch,
+ * then sums the per-batch `DatasetUploadResult` ({accepted, duplicates,
+ * rejected}).
+ *
+ * Auth/URL resolution mirrors `aexol-mcp.ts`: `~/.spectral/config.json`
+ * (`readConfig()`), token = `teamApiKey || userJwt`, URL via `getApiUrl()`,
+ * and a single `ensureAuthenticated()` OAuth retry on 401/403.
+ *
+ * projectId: the Studio binding (`.aexol/aexol.jsonc`) supplies a single
+ * batch-level projectId for ALL batches — the exporter does not persist
+ * per-sample project provenance in the JSONL, so per-project grouping is not
+ * possible without exporter rework (documented in the result notes).
+ *
+ * Testability: the backend call lives behind `callBackendTool`, overridable
+ * per-call (`options.callBackendTool`) or via `setCallBackendToolForTesting`
+ * (module-level), so tests can stub the network entirely.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { getApiUrl, readConfig } from "../../config.js";
+import { AexolMcpClient, AexolMcpError } from "../../mcp-client.js";
+import { ensureAuthenticated } from "../../auth-helper.js";
+import { readStudioBinding } from "../../studio-binding.js";
+import { renderContentToString } from "../aexol-backend-client.js";
+import { loadJsonl } from "./analyzer.js";
+import { scrub } from "./scrubber.js";
+export const DEFAULT_BATCH_SIZE = 50;
+/** Backend MCP tool that ingests one batch of samples. */
+export const BACKEND_UPLOAD_TOOL = "upload_dataset_samples";
+/** Backend MCP tool returning vault stats (best-effort, post-upload). */
+export const BACKEND_VAULT_STATS_TOOL = "dataset_vault_stats";
+export const DATASET_FORMAT = "sharegpt";
+// ---------------------------------------------------------------------------
+// Default backend call (real network path)
+// ---------------------------------------------------------------------------
+let testOverride = null;
+/**
+ * Test hook: override the backend call for the whole module. Pass null to
+ * restore the real implementation. Prefer `options.callBackendTool` for
+ * per-call injection; this exists so tests that drive code through other
+ * entry points (e.g. the extension index) can stub the network too.
+ */
+export function setCallBackendToolForTesting(fn) {
+    testOverride = fn;
+}
+function resolveCallBackendTool(options) {
+    return options.callBackendTool ?? testOverride ?? defaultCallBackendTool;
+}
+function firstJsonContent(content) {
+    if (content.length === 0)
+        return null;
+    const first = content[0];
+    if (first.json !== undefined)
+        return first.json;
+    if (typeof first.text === "string") {
+        try {
+            return JSON.parse(first.text);
+        }
+        catch {
+            return first.text;
+        }
+    }
+    return null;
+}
+/**
+ * Real backend call: config → token → AexolMcpClient.tools/call, with a
+ * single OAuth re-auth retry on 401/403 (same flow as aexol-mcp.ts).
+ */
+async function defaultCallBackendTool(tool, args) {
+    const cfg = await readConfig();
+    if (!cfg) {
+        throw new Error("No Spectral config found — run `spectral login` before uploading. No data was sent.");
+    }
+    const apiUrl = getApiUrl(cfg.apiUrl);
+    let token = cfg.teamApiKey || cfg.userJwt || "";
+    if (!token) {
+        throw new Error("No auth token in Spectral config — run `spectral login` before uploading. No data was sent.");
+    }
+    let client = new AexolMcpClient(apiUrl, token);
+    try {
+        const res = await client.callTool(tool, args);
+        if (res.isError === true) {
+            throw new Error(`Backend tool "${tool}" reported an error: ${renderContentToString(res.content)}`);
+        }
+        return firstJsonContent(res.content);
+    }
+    catch (err) {
+        if (err instanceof AexolMcpError && (err.status === 401 || err.status === 403)) {
+            const auth = await ensureAuthenticated();
+            if (auth.ok && auth.config) {
+                const newToken = auth.config.teamApiKey || auth.config.userJwt || "";
+                if (newToken && newToken !== token) {
+                    client = new AexolMcpClient(apiUrl, newToken);
+                    const res = await client.callTool(tool, args);
+                    if (res.isError === true) {
+                        throw new Error(`Backend tool "${tool}" reported an error after re-auth: ${renderContentToString(res.content)}`);
+                    }
+                    return firstJsonContent(res.content);
+                }
+            }
+            throw new Error(`Authentication failed (HTTP ${err.status}) and re-authentication did not produce a working token. ` +
+                `Run \`spectral login\`. Original error: ${err.message}`);
+        }
+        throw err;
+    }
+}
+// ---------------------------------------------------------------------------
+// Upload
+// ---------------------------------------------------------------------------
+function toInt(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : fallback;
+}
+/**
+ * Upload a dataset JSONL to the team vault in chunks.
+ *
+ * dryRun: parse + validate only — no backend call, `wouldUpload` carries the
+ * count, totals stay zero.
+ */
+export async function uploadDataset(options) {
+    if (!existsSync(options.inputPath)) {
+        throw new Error(`Dataset file not found: ${options.inputPath}`);
+    }
+    const batchSize = typeof options.batchSize === "number" && options.batchSize > 0
+        ? Math.trunc(options.batchSize)
+        : DEFAULT_BATCH_SIZE;
+    const { samples, malformedLines } = loadJsonl(options.inputPath);
+    const notes = [];
+    // ---- team / project resolution (single projectId for all batches) ------
+    const cwd = options.cwd ?? process.cwd();
+    let binding = null;
+    try {
+        binding = await readStudioBinding(cwd);
+    }
+    catch {
+        binding = null;
+    }
+    const teamId = options.teamId ?? binding?.teamId ?? null;
+    const projectId = binding?.projectId ?? null;
+    if (projectId) {
+        notes.push(`All batches use Studio binding projectId ${projectId} (batch-level provenance).`);
+    }
+    else {
+        notes.push("No Studio binding found — batches are sent without projectId (sessions without a bound project).");
+    }
+    notes.push("Per-project batching is not supported by the exporter JSONL (no per-sample project provenance); " +
+        "a single projectId from the binding is used for all batches.");
+    const validSamples = samples.map((s) => JSON.stringify(s));
+    const invalidLines = malformedLines;
+    // ---- pre-upload residue warning (pattern-only dry-run scrub) ------------
+    // Runs in BOTH dry-run and real uploads, before the first network batch.
+    // Pattern rules only (no extraValues) — counts only, never values.
+    let residueWarning = null;
+    try {
+        const rawContent = readFileSync(options.inputPath, "utf8");
+        const scrubResult = scrub(rawContent);
+        const totalRedactions = scrubResult.redactions.reduce((sum, r) => sum + r.count, 0);
+        if (totalRedactions > 0) {
+            residueWarning = {
+                totalRedactions,
+                kinds: scrubResult.redactions.map((r) => r.kind),
+            };
+        }
+    }
+    catch {
+        // Non-fatal — the warning is advisory.
+    }
+    const chunkCount = Math.ceil(validSamples.length / batchSize);
+    const batches = [];
+    const totals = { accepted: 0, duplicates: 0, rejected: 0 };
+    let vaultStats;
+    if (options.dryRun === true) {
+        for (let i = 0; i < chunkCount; i++) {
+            const chunk = validSamples.slice(i * batchSize, (i + 1) * batchSize);
+            batches.push({ projectId, sent: chunk.length, accepted: 0, duplicates: 0, rejected: 0 });
+        }
+    }
+    else {
+        const call = resolveCallBackendTool(options);
+        for (let i = 0; i < chunkCount; i++) {
+            const chunk = validSamples.slice(i * batchSize, (i + 1) * batchSize);
+            const args = {
+                format: DATASET_FORMAT,
+                samples: chunk,
+            };
+            if (teamId)
+                args.teamId = teamId;
+            if (projectId)
+                args.projectId = projectId;
+            const payload = await call(BACKEND_UPLOAD_TOOL, args);
+            const result = (payload && typeof payload === "object" ? payload : {});
+            const accepted = toInt(result.accepted, 0);
+            const duplicates = toInt(result.duplicates, 0);
+            const rejected = toInt(result.rejected, 0);
+            batches.push({ projectId, sent: chunk.length, accepted, duplicates, rejected });
+            totals.accepted += accepted;
+            totals.duplicates += duplicates;
+            totals.rejected += rejected;
+        }
+        // Best-effort vault stats — a failure here never fails the upload.
+        try {
+            const statsArgs = {};
+            if (teamId)
+                statsArgs.teamId = teamId;
+            vaultStats = await call(BACKEND_VAULT_STATS_TOOL, statsArgs);
+        }
+        catch {
+            vaultStats = undefined;
+            notes.push("Vault stats could not be fetched (non-fatal).");
+        }
+    }
+    return {
+        inputPath: options.inputPath,
+        dryRun: options.dryRun === true,
+        totalLines: validSamples.length + invalidLines,
+        validSamples: validSamples.length,
+        invalidLines,
+        batchSize,
+        teamId,
+        projectId,
+        batches,
+        totals,
+        wouldUpload: validSamples.length,
+        ...(vaultStats !== undefined ? { vaultStats } : {}),
+        ...(residueWarning !== null ? { residueWarning } : {}),
+        notes,
+    };
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering
+// ---------------------------------------------------------------------------
+/** Render an upload result as a markdown summary for the agent. */
+export function renderUploadMarkdown(result) {
+    const lines = [];
+    lines.push(`# Dataset upload ${result.dryRun ? "(dry run)" : ""} — ${result.inputPath}`);
+    if (result.residueWarning) {
+        lines.push("");
+        lines.push(`⚠️ residue detected (${result.residueWarning.totalRedactions} redactions across kinds: ${result.residueWarning.kinds.join(", ")}) — run dataset_clean before uploading`);
+    }
+    lines.push("");
+    lines.push(`- Samples: **${result.validSamples}** valid` +
+        (result.invalidLines > 0 ? ` (${result.invalidLines} invalid line(s) skipped)` : "") +
+        `, batch size ${result.batchSize}`);
+    lines.push(`- Scope: team ${result.teamId ?? "(resolved by backend)"} / project ${result.projectId ?? "none"}`);
+    if (result.dryRun) {
+        lines.push(`- Dry run: **${result.wouldUpload} sample(s) would be uploaded in ${result.batches.length} batch(es)** — no data was sent.`);
+    }
+    else {
+        lines.push(`- Totals: accepted **${result.totals.accepted}**, duplicates **${result.totals.duplicates}**, rejected **${result.totals.rejected}**`);
+        lines.push("");
+        lines.push("| Batch | Sent | Accepted | Duplicates | Rejected |");
+        lines.push("| ---: | ---: | ---: | ---: | ---: |");
+        result.batches.forEach((b, i) => {
+            lines.push(`| ${i + 1} | ${b.sent} | ${b.accepted} | ${b.duplicates} | ${b.rejected} |`);
+        });
+    }
+    if (result.vaultStats !== undefined) {
+        lines.push("");
+        lines.push("## Vault stats");
+        lines.push("");
+        lines.push("```json");
+        lines.push(JSON.stringify(result.vaultStats, null, 2));
+        lines.push("```");
+    }
+    lines.push("");
+    lines.push("## Notes");
+    for (const note of result.notes)
+        lines.push(`- ${note}`);
+    return lines.join("\n");
+}

package/dist/generated/zeus/const.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../src/generated/zeus/const.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CAy6B5C,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CA+1C1C,CAAA;AAED,eAAO,MAAM,GAAG;;;;CAIf,CAAA"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../src/generated/zeus/const.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CAw7B5C,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CAw3C1C,CAAA;AAED,eAAO,MAAM,GAAG;;;;CAIf,CAAA"}

package/dist/generated/zeus/const.js

@@ -207,6 +207,8 @@ export const AllTypesProps = {
         syntheticDataset: {},
         fineTuneJobs: {},
         fineTuneJob: {},
+        datasetSamples: {},
+        datasetVaultStats: {},
         dedicatedUsage: {},
         seoSearchAnalytics: {
             input: "SeoSearchAnalyticsInput"
@@ -480,6 +482,10 @@ export const AllTypesProps = {
         cancelFineTuneJob: {},
         deleteFineTuneJob: {},
         deleteSyntheticDataset: {},
+        uploadDatasetSamples: {
+            input: "UploadDatasetSamplesInput"
+        },
+        deleteDatasetSample: {},
         deployDedicated: {
             input: "DeployDedicatedInput"
         },
@@ -538,6 +544,7 @@ export const AllTypesProps = {
     GenerateSyntheticDatasetInput: {},
     ImportSyntheticDatasetInput: {},
     StartFineTuneJobInput: {},
+    UploadDatasetSamplesInput: {},
     AdminCreateBillingPlanInput: {},
     AdminUpdateBillingPlanInput: {},
     AdminCreateCreditPackInput: {},
@@ -1108,6 +1115,8 @@ export const ReturnTypes = {
         syntheticDataset: "SyntheticDataset",
         fineTuneJobs: "FineTuneJob",
         fineTuneJob: "FineTuneJob",
+        datasetSamples: "DatasetSample",
+        datasetVaultStats: "DatasetVaultStats",
         dedicatedHardwareOptions: "DedicatedHardware",
         dedicatedUsage: "DedicatedUsageSummary",
         latestSpectralRelease: "SpectralRelease",
@@ -1271,6 +1280,8 @@ export const ReturnTypes = {
         cancelFineTuneJob: "Boolean",
         deleteFineTuneJob: "Boolean",
         deleteSyntheticDataset: "Boolean",
+        uploadDatasetSamples: "DatasetUploadResult",
+        deleteDatasetSample: "Boolean",
         deployDedicated: "UserModel",
         updateDedicated: "UserModel",
         destroyDedicated: "UserModel",
@@ -1470,6 +1481,27 @@ export const ReturnTypes = {
         message: "String",
         outputModelName: "String"
     },
+    DatasetSample: {
+        id: "ID",
+        teamId: "ID",
+        projectId: "ID",
+        contentHash: "String",
+        format: "String",
+        sampleCount: "Int",
+        sourceSessionId: "String",
+        createdAt: "DateTime"
+    },
+    DatasetUploadResult: {
+        accepted: "Int",
+        duplicates: "Int",
+        rejected: "Int",
+        sampleIds: "ID"
+    },
+    DatasetVaultStats: {
+        count: "Int",
+        totalBytes: "Int",
+        topTools: "String"
+    },
     DedicatedHardware: {
         id: "String",
         name: "String",

package/dist/generated/zeus/index.d.ts

@@ -1390,6 +1390,14 @@ export type ValueTypes = {
             id: ValueTypes["ID"] | Variable<any, string>;
             teamId: ValueTypes["ID"] | Variable<any, string>;
         }, ValueTypes["FineTuneJob"]];
+        datasetSamples?: [{
+            teamId?: ValueTypes["ID"] | undefined | null | Variable<any, string>;
+            limit?: number | undefined | null | Variable<any, string>;
+            offset?: number | undefined | null | Variable<any, string>;
+        }, ValueTypes["DatasetSample"]];
+        datasetVaultStats?: [{
+            teamId?: ValueTypes["ID"] | undefined | null | Variable<any, string>;
+        }, ValueTypes["DatasetVaultStats"]];
         dedicatedHardwareOptions?: ValueTypes["DedicatedHardware"];
         dedicatedUsage?: [{
             userModelId: string | Variable<any, string>;
@@ -1917,6 +1925,13 @@ export type ValueTypes = {
             id: ValueTypes["ID"] | Variable<any, string>;
             teamId: ValueTypes["ID"] | Variable<any, string>;
         }, boolean | `@${string}`];
+        uploadDatasetSamples?: [{
+            input: ValueTypes["UploadDatasetSamplesInput"] | Variable<any, string>;
+        }, ValueTypes["DatasetUploadResult"]];
+        deleteDatasetSample?: [{
+            id: ValueTypes["ID"] | Variable<any, string>;
+            teamId: ValueTypes["ID"] | Variable<any, string>;
+        }, boolean | `@${string}`];
         deployDedicated?: [{
             input: ValueTypes["DeployDedicatedInput"] | Variable<any, string>;
         }, ValueTypes["UserModel"]];
@@ -2291,6 +2306,33 @@ export type ValueTypes = {
         __typename?: boolean | `@${string}`;
         ['...on FineTuneJobEvent']?: Omit<ValueTypes["FineTuneJobEvent"], "...on FineTuneJobEvent">;
     }>;
+    ["DatasetSample"]: AliasType<{
+        id?: boolean | `@${string}`;
+        teamId?: boolean | `@${string}`;
+        projectId?: boolean | `@${string}`;
+        contentHash?: boolean | `@${string}`;
+        format?: boolean | `@${string}`;
+        sampleCount?: boolean | `@${string}`;
+        sourceSessionId?: boolean | `@${string}`;
+        createdAt?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+        ['...on DatasetSample']?: Omit<ValueTypes["DatasetSample"], "...on DatasetSample">;
+    }>;
+    ["DatasetUploadResult"]: AliasType<{
+        accepted?: boolean | `@${string}`;
+        duplicates?: boolean | `@${string}`;
+        rejected?: boolean | `@${string}`;
+        sampleIds?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+        ['...on DatasetUploadResult']?: Omit<ValueTypes["DatasetUploadResult"], "...on DatasetUploadResult">;
+    }>;
+    ["DatasetVaultStats"]: AliasType<{
+        count?: boolean | `@${string}`;
+        totalBytes?: boolean | `@${string}`;
+        topTools?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+        ['...on DatasetVaultStats']?: Omit<ValueTypes["DatasetVaultStats"], "...on DatasetVaultStats">;
+    }>;
     ["DedicatedHardware"]: AliasType<{
         id?: boolean | `@${string}`;
         name?: boolean | `@${string}`;
@@ -2353,6 +2395,13 @@ export type ValueTypes = {
         loraAlpha?: number | undefined | null | Variable<any, string>;
         autoCreateUserModel?: boolean | undefined | null | Variable<any, string>;
     };
+    ["UploadDatasetSamplesInput"]: {
+        teamId?: ValueTypes["ID"] | undefined | null | Variable<any, string>;
+        projectId?: ValueTypes["ID"] | undefined | null | Variable<any, string>;
+        format?: string | undefined | null | Variable<any, string>;
+        samples: Array<string> | Variable<any, string>;
+        sourceSessionId?: string | undefined | null | Variable<any, string>;
+    };
     ["AdminBillingPlan"]: AliasType<{
         id?: boolean | `@${string}`;
         planId?: boolean | `@${string}`;
@@ -4127,6 +4176,14 @@ export type ResolverInputTypes = {
             id: ResolverInputTypes["ID"];
             teamId: ResolverInputTypes["ID"];
         }, ResolverInputTypes["FineTuneJob"]];
+        datasetSamples?: [{
+            teamId?: ResolverInputTypes["ID"] | undefined | null;
+            limit?: number | undefined | null;
+            offset?: number | undefined | null;
+        }, ResolverInputTypes["DatasetSample"]];
+        datasetVaultStats?: [{
+            teamId?: ResolverInputTypes["ID"] | undefined | null;
+        }, ResolverInputTypes["DatasetVaultStats"]];
         dedicatedHardwareOptions?: ResolverInputTypes["DedicatedHardware"];
         dedicatedUsage?: [{
             userModelId: string;
@@ -4653,6 +4710,13 @@ export type ResolverInputTypes = {
             id: ResolverInputTypes["ID"];
             teamId: ResolverInputTypes["ID"];
         }, boolean | `@${string}`];
+        uploadDatasetSamples?: [{
+            input: ResolverInputTypes["UploadDatasetSamplesInput"];
+        }, ResolverInputTypes["DatasetUploadResult"]];
+        deleteDatasetSample?: [{
+            id: ResolverInputTypes["ID"];
+            teamId: ResolverInputTypes["ID"];
+        }, boolean | `@${string}`];
         deployDedicated?: [{
             input: ResolverInputTypes["DeployDedicatedInput"];
         }, ResolverInputTypes["UserModel"]];
@@ -5012,6 +5076,30 @@ export type ResolverInputTypes = {
         outputModelName?: boolean | `@${string}`;
         __typename?: boolean | `@${string}`;
     }>;
+    ["DatasetSample"]: AliasType<{
+        id?: boolean | `@${string}`;
+        teamId?: boolean | `@${string}`;
+        projectId?: boolean | `@${string}`;
+        contentHash?: boolean | `@${string}`;
+        format?: boolean | `@${string}`;
+        sampleCount?: boolean | `@${string}`;
+        sourceSessionId?: boolean | `@${string}`;
+        createdAt?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
+    ["DatasetUploadResult"]: AliasType<{
+        accepted?: boolean | `@${string}`;
+        duplicates?: boolean | `@${string}`;
+        rejected?: boolean | `@${string}`;
+        sampleIds?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
+    ["DatasetVaultStats"]: AliasType<{
+        count?: boolean | `@${string}`;
+        totalBytes?: boolean | `@${string}`;
+        topTools?: boolean | `@${string}`;
+        __typename?: boolean | `@${string}`;
+    }>;
     ["DedicatedHardware"]: AliasType<{
         id?: boolean | `@${string}`;
         name?: boolean | `@${string}`;
@@ -5071,6 +5159,13 @@ export type ResolverInputTypes = {
         loraAlpha?: number | undefined | null;
         autoCreateUserModel?: boolean | undefined | null;
     };
+    ["UploadDatasetSamplesInput"]: {
+        teamId?: ResolverInputTypes["ID"] | undefined | null;
+        projectId?: ResolverInputTypes["ID"] | undefined | null;
+        format?: string | undefined | null;
+        samples: Array<string>;
+        sourceSessionId?: string | undefined | null;
+    };
     ["AdminBillingPlan"]: AliasType<{
         id?: boolean | `@${string}`;
         planId?: boolean | `@${string}`;
@@ -6556,6 +6651,8 @@ export type ModelTypes = {
         syntheticDataset?: ModelTypes["SyntheticDataset"] | undefined | null;
         fineTuneJobs: Array<ModelTypes["FineTuneJob"]>;
         fineTuneJob?: ModelTypes["FineTuneJob"] | undefined | null;
+        datasetSamples: Array<ModelTypes["DatasetSample"]>;
+        datasetVaultStats: ModelTypes["DatasetVaultStats"];
         dedicatedHardwareOptions: Array<ModelTypes["DedicatedHardware"]>;
         dedicatedUsage: ModelTypes["DedicatedUsageSummary"];
         latestSpectralRelease?: ModelTypes["SpectralRelease"] | undefined | null;
@@ -6719,6 +6816,8 @@ export type ModelTypes = {
         cancelFineTuneJob: boolean;
         deleteFineTuneJob: boolean;
         deleteSyntheticDataset: boolean;
+        uploadDatasetSamples: ModelTypes["DatasetUploadResult"];
+        deleteDatasetSample: boolean;
         deployDedicated: ModelTypes["UserModel"];
         updateDedicated: ModelTypes["UserModel"];
         destroyDedicated: ModelTypes["UserModel"];
@@ -6993,6 +7092,27 @@ export type ModelTypes = {
         message?: string | undefined | null;
         outputModelName?: string | undefined | null;
     };
+    ["DatasetSample"]: {
+        id: ModelTypes["ID"];
+        teamId: ModelTypes["ID"];
+        projectId?: ModelTypes["ID"] | undefined | null;
+        contentHash: string;
+        format: string;
+        sampleCount: number;
+        sourceSessionId?: string | undefined | null;
+        createdAt: ModelTypes["DateTime"];
+    };
+    ["DatasetUploadResult"]: {
+        accepted: number;
+        duplicates: number;
+        rejected: number;
+        sampleIds: Array<ModelTypes["ID"]>;
+    };
+    ["DatasetVaultStats"]: {
+        count: number;
+        totalBytes: number;
+        topTools: Array<string>;
+    };
     ["DedicatedHardware"]: {
         id: string;
         name: string;
@@ -7049,6 +7169,13 @@ export type ModelTypes = {
         loraAlpha?: number | undefined | null;
         autoCreateUserModel?: boolean | undefined | null;
     };
+    ["UploadDatasetSamplesInput"]: {
+        teamId?: ModelTypes["ID"] | undefined | null;
+        projectId?: ModelTypes["ID"] | undefined | null;
+        format?: string | undefined | null;
+        samples: Array<string>;
+        sourceSessionId?: string | undefined | null;
+    };
     ["AdminBillingPlan"]: {
         id: string;
         planId: string;
@@ -8602,6 +8729,8 @@ export type GraphQLTypes = {
         syntheticDataset?: GraphQLTypes["SyntheticDataset"] | undefined | null;
         fineTuneJobs: Array<GraphQLTypes["FineTuneJob"]>;
         fineTuneJob?: GraphQLTypes["FineTuneJob"] | undefined | null;
+        datasetSamples: Array<GraphQLTypes["DatasetSample"]>;
+        datasetVaultStats: GraphQLTypes["DatasetVaultStats"];
         dedicatedHardwareOptions: Array<GraphQLTypes["DedicatedHardware"]>;
         dedicatedUsage: GraphQLTypes["DedicatedUsageSummary"];
         latestSpectralRelease?: GraphQLTypes["SpectralRelease"] | undefined | null;
@@ -8767,6 +8896,8 @@ export type GraphQLTypes = {
         cancelFineTuneJob: boolean;
         deleteFineTuneJob: boolean;
         deleteSyntheticDataset: boolean;
+        uploadDatasetSamples: GraphQLTypes["DatasetUploadResult"];
+        deleteDatasetSample: boolean;
         deployDedicated: GraphQLTypes["UserModel"];
         updateDedicated: GraphQLTypes["UserModel"];
         destroyDedicated: GraphQLTypes["UserModel"];
@@ -9076,6 +9207,33 @@ export type GraphQLTypes = {
         outputModelName?: string | undefined | null;
         ['...on FineTuneJobEvent']: Omit<GraphQLTypes["FineTuneJobEvent"], "...on FineTuneJobEvent">;
     };
+    ["DatasetSample"]: {
+        __typename: "DatasetSample";
+        id: GraphQLTypes["ID"];
+        teamId: GraphQLTypes["ID"];
+        projectId?: GraphQLTypes["ID"] | undefined | null;
+        contentHash: string;
+        format: string;
+        sampleCount: number;
+        sourceSessionId?: string | undefined | null;
+        createdAt: GraphQLTypes["DateTime"];
+        ['...on DatasetSample']: Omit<GraphQLTypes["DatasetSample"], "...on DatasetSample">;
+    };
+    ["DatasetUploadResult"]: {
+        __typename: "DatasetUploadResult";
+        accepted: number;
+        duplicates: number;
+        rejected: number;
+        sampleIds: Array<GraphQLTypes["ID"]>;
+        ['...on DatasetUploadResult']: Omit<GraphQLTypes["DatasetUploadResult"], "...on DatasetUploadResult">;
+    };
+    ["DatasetVaultStats"]: {
+        __typename: "DatasetVaultStats";
+        count: number;
+        totalBytes: number;
+        topTools: Array<string>;
+        ['...on DatasetVaultStats']: Omit<GraphQLTypes["DatasetVaultStats"], "...on DatasetVaultStats">;
+    };
     ["DedicatedHardware"]: {
         __typename: "DedicatedHardware";
         id: string;
@@ -9138,6 +9296,13 @@ export type GraphQLTypes = {
         loraAlpha?: number | undefined | null;
         autoCreateUserModel?: boolean | undefined | null;
     };
+    ["UploadDatasetSamplesInput"]: {
+        teamId?: GraphQLTypes["ID"] | undefined | null;
+        projectId?: GraphQLTypes["ID"] | undefined | null;
+        format?: string | undefined | null;
+        samples: Array<string>;
+        sourceSessionId?: string | undefined | null;
+    };
     ["AdminBillingPlan"]: {
         __typename: "AdminBillingPlan";
         id: string;
@@ -10076,6 +10241,7 @@ type ZEUS_VARIABLES = {
     ["GenerateSyntheticDatasetInput"]: ValueTypes["GenerateSyntheticDatasetInput"];
     ["ImportSyntheticDatasetInput"]: ValueTypes["ImportSyntheticDatasetInput"];
     ["StartFineTuneJobInput"]: ValueTypes["StartFineTuneJobInput"];
+    ["UploadDatasetSamplesInput"]: ValueTypes["UploadDatasetSamplesInput"];
     ["AdminCreateBillingPlanInput"]: ValueTypes["AdminCreateBillingPlanInput"];
     ["AdminUpdateBillingPlanInput"]: ValueTypes["AdminUpdateBillingPlanInput"];
     ["AdminCreateCreditPackInput"]: ValueTypes["AdminCreateCreditPackInput"];