dataiku-sdk 3.6.1 → 3.8.0

package/dist/src/cli/helpers/flow-zone.js

@@ -1,4 +1,5 @@
 import { readFileSync, } from "node:fs";
+import { ClientValidationError, } from "../../errors.js";
 import { asRecord, } from "../../utils/records.js";
 import { compareStrings, } from "../../utils/stable-hash.js";
 import { finiteNumberField, jsonInput, optionalStringField, parseJsonObject, requiredStringArray, splitCsvFlag, } from "../coerce.js";
@@ -319,6 +320,16 @@ export function flowZonePruneItems(existing, plannedItemKeys) {
         return [];
     return flowZoneExplicitItems(existing).filter((item) => !plannedItemKeys.has(flowZoneItemKey(item)));
 }
+/**
+ * The position an existing zone must move to, if the plan changes it. DSS
+ * honors a zone position only on creation, so a move means recreating the zone.
+ */
+export function flowZoneRepositionTarget(plan, existing) {
+    return plan.position !== undefined
+        && !flowZoneSamePosition(flowZoneCurrentPosition(existing), plan.position)
+        ? plan.position
+        : undefined;
+}
 export function flowZoneOrganizeStep(plan, existing, sync, plannedItemKeys) {
     ensureFlowZonePlanTarget(plan, existing);
     const update = {};
@@ -326,10 +337,8 @@ export function flowZoneOrganizeStep(plan, existing, sync, plannedItemKeys) {
         update.name = plan.name;
     if (existing && plan.color && plan.color !== existing.color)
         update.color = plan.color;
-    if (existing && plan.position !== undefined
-        && !flowZoneSamePosition(flowZoneCurrentPosition(existing), plan.position)) {
-        update.position = plan.position;
-    }
+    const recreatePosition = existing ? flowZoneRepositionTarget(plan, existing) : undefined;
+    const recreate = recreatePosition ? { position: recreatePosition, } : undefined;
     const pruneItems = sync ? flowZonePruneItems(existing, plannedItemKeys) : [];
     const moveItems = flowZoneMoveDelta(existing, plan.items);
     return {
@@ -341,10 +350,141 @@ export function flowZoneOrganizeStep(plan, existing, sync, plannedItemKeys) {
         },
         ...(existing ? { existing: flowZoneSummary(existing), } : { create: true, }),
         ...(Object.keys(update).length > 0 ? { update, } : {}),
+        ...(recreate ? { recreate, } : {}),
         moveItems,
+        ...(plan.impliedItems && plan.impliedItems.length > 0
+            ? { impliedItems: plan.impliedItems, }
+            : {}),
         ...(pruneItems.length > 0 ? { pruneItems, } : {}),
     };
 }
+function flowNodeObjectType(node, knownTypes) {
+    switch (node.kind) {
+        case "recipe":
+            return "RECIPE";
+        case "dataset":
+            return "DATASET";
+        case "folder":
+            return "MANAGED_FOLDER";
+        default:
+            return knownTypes.get(node.id);
+    }
+}
+/**
+ * DSS keeps a recipe and its outputs in one zone: moving either drags the
+ * others. Each unit is keyed by its recipe id and lists the recipe plus every
+ * object the recipe writes.
+ */
+function flowZoneUnits(graph) {
+    const kindById = new Map(graph.nodes.map((node) => [node.id, node.kind,]));
+    const units = new Map();
+    for (const node of graph.nodes) {
+        if (node.kind === "recipe")
+            units.set(node.id, [node.id,]);
+    }
+    for (const edge of graph.edges) {
+        if (kindById.get(edge.from) !== "recipe" || kindById.get(edge.to) === "recipe")
+            continue;
+        units.get(edge.from)?.push(edge.to);
+    }
+    return units;
+}
+function explicitTypesById(zones) {
+    const types = new Map();
+    for (const zone of zones) {
+        for (const item of flowZoneItems(zone)) {
+            if (!item.projectKey)
+                types.set(item.objectId, item.objectType);
+        }
+    }
+    return types;
+}
+/**
+ * Enforce the DSS recipe/output zone invariant on a plan. Rejects plans that
+ * place members of one unit in different zones (they would never converge),
+ * and adds the unlisted members of each planned unit to that zone as
+ * `impliedItems`, so moves, `--sync` pruning, and reruns all agree with what
+ * DSS actually does.
+ */
+export function applyFlowZoneUnits(plan, graph, zones, projectKey) {
+    const zoneIndexById = new Map();
+    plan.zones.forEach((zonePlan, index) => {
+        for (const item of zonePlan.items) {
+            // Shared objects from other projects never move with a local recipe.
+            if (!item.projectKey || item.projectKey === projectKey)
+                zoneIndexById.set(item.objectId, index);
+        }
+    });
+    const nodeById = new Map(graph.nodes.map((node) => [node.id, node,]));
+    const knownTypes = explicitTypesById(zones);
+    const conflicts = [];
+    const implied = plan.zones.map(() => []);
+    for (const [recipe, members,] of flowZoneUnits(graph)) {
+        const planned = members.filter((member) => zoneIndexById.has(member));
+        if (planned.length === 0)
+            continue;
+        const indexes = new Set(planned.map((member) => zoneIndexById.get(member)));
+        if (indexes.size > 1) {
+            const byZone = {};
+            for (const member of planned) {
+                const label = flowZonePlanLabel(plan.zones[zoneIndexById.get(member)]);
+                (byZone[label] ??= []).push(member);
+            }
+            conflicts.push({ recipe, zones: byZone, });
+            continue;
+        }
+        const [index,] = indexes;
+        for (const member of members) {
+            if (zoneIndexById.has(member))
+                continue;
+            const node = nodeById.get(member);
+            const objectType = node ? flowNodeObjectType(node, knownTypes) : undefined;
+            if (objectType)
+                implied[index].push({ objectType, objectId: member, });
+        }
+    }
+    if (conflicts.length > 0) {
+        throw new ClientValidationError(`Flow zone plan splits ${conflicts.length} recipe(s) from their outputs across zones; DSS keeps a recipe and its outputs in one zone.`, "validation_failed", "Assign each recipe to one zone (its outputs follow automatically), or list the recipe and all its outputs in the same zone.", { conflicts, });
+    }
+    return {
+        ...plan,
+        zones: plan.zones.map((zonePlan, index) => implied[index].length === 0
+            ? zonePlan
+            : {
+                ...zonePlan,
+                items: [...zonePlan.items, ...implied[index],],
+                impliedItems: implied[index],
+            }),
+    };
+}
+/**
+ * Default-zone objects an organization plan has to place: recipes (their
+ * outputs follow) and objects no recipe produces, such as uploaded sources.
+ */
+export function flowZoneUnassignedItems(graph, zones) {
+    const assigned = new Set();
+    for (const zone of zones) {
+        if (zone.id === "default")
+            continue;
+        for (const item of flowZoneExplicitItems(zone))
+            assigned.add(item.objectId);
+    }
+    const produced = new Set();
+    for (const members of flowZoneUnits(graph).values()) {
+        for (const member of members.slice(1))
+            produced.add(member);
+    }
+    const knownTypes = explicitTypesById(zones);
+    const items = [];
+    for (const node of graph.nodes) {
+        if (assigned.has(node.id) || produced.has(node.id))
+            continue;
+        const objectType = flowNodeObjectType(node, knownTypes);
+        if (objectType)
+            items.push({ objectType, objectId: node.id, });
+    }
+    return items.sort((a, b) => compareStrings(flowZoneItemKey(a), flowZoneItemKey(b)));
+}
 export function flowZoneValidationBucket(index, objectType) {
     switch (objectType) {
         case "DATASET":

package/dist/src/cli/helpers/trained-model.d.ts

@@ -0,0 +1,26 @@
+import type { DataikuClient } from "../../client.js";
+import { type ComputedModelDiagnostic, type ModelDiagnostic, type ModelDiagnosticsComputation, type TrainedModel } from "../../resources/trained-model.js";
+import type { CommandDefinition } from "../types.js";
+type Flags = Record<string, string | boolean>;
+export declare function diagnosticKindFromFlags(flags: Flags): ModelDiagnostic;
+/** `compute-diagnostics` flags → kind, features, and computation settings (shared with --plan). */
+export declare function diagnosticsComputationFromFlags(flags: Flags): {
+    kind: ComputedModelDiagnostic;
+    features: string[];
+    computation: ModelDiagnosticsComputation;
+};
+export interface TrainedModelCommandSpec {
+    resource: "ml-task" | "saved-model";
+    /** Positional ids in examples, e.g. `ANALYSIS_ID TASK_ID MODEL_ID`. */
+    ids: string;
+    /** What one model is called in descriptions: "lab model" or "saved-model version". */
+    noun: string;
+    model: (client: DataikuClient, args: string[], projectKey: string | undefined) => TrainedModel;
+    downloadDocumentation: (client: DataikuClient, exportId: string, projectKey: string | undefined) => Promise<Response>;
+}
+/**
+ * The actions lab models and saved-model versions share, over one
+ * {@link TrainedModel}: user meta, scoring exports, diagnostics, documentation.
+ */
+export declare function trainedModelCommands(spec: TrainedModelCommandSpec): Record<string, CommandDefinition>;
+export {};

package/dist/src/cli/helpers/trained-model.js

@@ -0,0 +1,144 @@
+import { unexpectedResponseError, } from "../../errors.js";
+import { COMPUTED_MODEL_DIAGNOSTICS, MODEL_DIAGNOSTICS, } from "../../resources/trained-model.js";
+import { writeResponseToFile, } from "../../utils/response-file.js";
+import { num, parseBooleanOption, requiredJsonInput, splitCsvFlag, } from "../coerce.js";
+import { executionMode, } from "../flags.js";
+import { commandUsage, } from "../syntax.js";
+import { requireArgs, UsageError, } from "../usage.js";
+import { documentationTemplateFromFlags, runDocumentationCommand, taskWaitOptions, } from "./documentation.js";
+export function diagnosticKindFromFlags(flags) {
+    const kind = flags["kind"];
+    if (typeof kind !== "string" || MODEL_DIAGNOSTICS[kind] !== true) {
+        throw new UsageError(`--kind must be one of ${Object.keys(MODEL_DIAGNOSTICS).join(", ")}.`, "invalid_enum");
+    }
+    return kind;
+}
+/** `compute-diagnostics` flags → kind, features, and computation settings (shared with --plan). */
+export function diagnosticsComputationFromFlags(flags) {
+    const kind = flags["kind"];
+    if (typeof kind !== "string" || COMPUTED_MODEL_DIAGNOSTICS[kind] !== true) {
+        throw new UsageError(`--kind must be one of ${Object.keys(COMPUTED_MODEL_DIAGNOSTICS).join(", ")}.`, "invalid_enum");
+    }
+    const sampleSize = num(flags["sample-size"], "--sample-size");
+    const randomState = num(flags["random-state"], "--random-state");
+    const nJobs = num(flags["n-jobs"], "--n-jobs");
+    return {
+        kind: kind,
+        features: splitCsvFlag(flags["features"]),
+        computation: {
+            ...(sampleSize !== undefined ? { sampleSize, } : {}),
+            ...(randomState !== undefined ? { randomState, } : {}),
+            ...(nJobs !== undefined ? { nJobs, } : {}),
+        },
+    };
+}
+/** Write a binary export to `--output`; DSS answering without a body is an unexpected response. */
+async function writeExport(res, out, operation) {
+    if (!res.body)
+        throw unexpectedResponseError(`${operation} response did not include a body`);
+    return { path: out, bytes: await writeResponseToFile(out, res), };
+}
+function requiredOutput(flags) {
+    const out = flags["output"];
+    if (typeof out !== "string") {
+        throw new UsageError("--output PATH is required.", "missing_required_flag");
+    }
+    return out;
+}
+/**
+ * The actions lab models and saved-model versions share, over one
+ * {@link TrainedModel}: user meta, scoring exports, diagnostics, documentation.
+ */
+export function trainedModelCommands(spec) {
+    const { resource, ids, noun, } = spec;
+    const argCount = ids.split(" ").length;
+    const model = (c, a, f, action) => {
+        requireArgs(a, argCount, commandUsage(resource, action));
+        return spec.model(c, a, f["project-key"]);
+    };
+    return {
+        "set-user-meta": {
+            handler: async (c, a, f) => {
+                const target = model(c, a, f, "set-user-meta");
+                const userMeta = requiredJsonInput(f, "User-meta JSON is required via --data, --data-file, or --stdin.");
+                if (executionMode(f).dryRun) {
+                    return {
+                        dryRun: true,
+                        action: "set-user-meta",
+                        resource,
+                        ids: a.slice(0, argCount),
+                        payload: userMeta,
+                    };
+                }
+                await target.setUserMeta(userMeta);
+                return { updated: a[argCount - 1], resource, };
+            },
+            description: `Update the user metadata (name, description, labels, ...) of a ${noun}. Send only the "userMeta" field of its details, edited.`,
+            examples: [
+                `dss ${resource} set-user-meta ${ids} --data '{"name":"Churn model","description":"v2"}'`,
+            ],
+        },
+        "download-scoring-jar": {
+            handler: async (c, a, f) => {
+                const target = model(c, a, f, "download-scoring-jar");
+                const out = requiredOutput(f);
+                const fullClassName = f["full-class-name"];
+                const res = await target.downloadScoringJar({
+                    ...(typeof fullClassName === "string" ? { fullClassName, } : {}),
+                    ...(f["include-libs"] !== undefined
+                        ? { includeLibs: parseBooleanOption(f["include-libs"], "--include-libs"), }
+                        : {}),
+                });
+                return writeExport(res, out, "Scoring JAR download");
+            },
+            description: `Download the optimized scoring JAR of a ${noun} (license-gated server side). --full-class-name sets the Java class; --include-libs toggles bundling the scoring libraries.`,
+            examples: [`dss ${resource} download-scoring-jar ${ids} --output ./scoring.jar`,],
+        },
+        "download-scoring-pmml": {
+            handler: async (c, a, f) => {
+                const target = model(c, a, f, "download-scoring-pmml");
+                const out = requiredOutput(f);
+                return writeExport(await target.downloadScoringPmml(), out, "Scoring PMML download");
+            },
+            description: `Download the PMML scoring file of a ${noun} (license-gated server side).`,
+            examples: [`dss ${resource} download-scoring-pmml ${ids} --output ./model.pmml`,],
+        },
+        diagnostics: {
+            handler: (c, a, f) => model(c, a, f, "diagnostics").get(diagnosticKindFromFlags(f)),
+            description: `Read computed diagnostics of a ${noun}: subpopulation-analyses, partial-dependencies, timeseries-residuals, or (forecasting) per-timeseries-metrics / per-timeseries-evaluation-forecasts.`,
+            examples: [`dss ${resource} diagnostics ${ids} --kind partial-dependencies`,],
+        },
+        "compute-diagnostics": {
+            handler: async (c, a, f) => {
+                const target = model(c, a, f, "compute-diagnostics");
+                const { kind, features, computation, } = diagnosticsComputationFromFlags(f);
+                const task = await target.compute(kind, features, computation);
+                return f["wait"] === true ? c.futures.waitTask(task, taskWaitOptions(f)) : task;
+            },
+            description: `Compute subpopulation-analyses or partial-dependencies over --features COLS (--sample-size N, default 10000), or timeseries-residuals, for a ${noun}. Returns the DSS future; --wait waits and returns the result.`,
+            examples: [
+                `dss ${resource} compute-diagnostics ${ids} --kind partial-dependencies --features age,income --wait`,
+            ],
+        },
+        "generate-documentation": {
+            handler: async (c, a, f) => {
+                const target = model(c, a, f, "generate-documentation");
+                const pk = f["project-key"];
+                const task = await target.generateDocumentation(documentationTemplateFromFlags(f));
+                return runDocumentationCommand(c, f, task, (exportId) => spec.downloadDocumentation(c, exportId, pk));
+            },
+            description: `Generate the model documentation (Word docx) of a ${noun} from the DSS default template, an uploaded --template-file, or a template in a managed folder (--folder FOLDER_ID --path PATH). Returns the DSS future; --wait waits; --output PATH waits and downloads.`,
+            examples: [`dss ${resource} generate-documentation ${ids} --output model.docx`,],
+        },
+        "download-documentation": {
+            handler: async (c, a, f) => {
+                requireArgs(a, 1, commandUsage(resource, "download-documentation"));
+                const out = requiredOutput(f);
+                const res = await spec.downloadDocumentation(c, a[0], f["project-key"]);
+                return writeExport(res, out, "Model documentation download");
+            },
+            description: "Download a generated model documentation by the exportId from a finished generate-documentation future.",
+            examples: [`dss ${resource} download-documentation EXPORT_ID --output model.docx`,],
+        },
+    };
+}

package/dist/src/cli/list-output.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shape a `*.list` result for agents: `--contains` filters on identifier
+ * fields, `--limit` caps the count (a `list_truncated` warning reports the
+ * total), and large DSS objects compact to their decision fields unless
+ * `--full` or `--fields` asks for the DSS objects.
+ */
+export declare function shapeListResult(resource: string, result: unknown, flags: Record<string, string | boolean>): unknown;

package/dist/src/cli/list-output.js

@@ -0,0 +1,77 @@
+import { num, } from "./coerce.js";
+import { COMPACT_LIST_FIELDS, } from "./list-shapes.js";
+import { enqueueCliWarning, } from "./output.js";
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function compactValue(item, spec) {
+    let value = item;
+    for (const key of spec.path.split("."))
+        value = record(value)[key];
+    if (spec.roleRefs !== true)
+        return value;
+    // Dataset refs across every role of recipe inputs/outputs (`{main:{items:[{ref}]}}`).
+    return Object.values(record(value)).flatMap((role) => {
+        const items = record(role).items;
+        return Array.isArray(items)
+            ? items.flatMap((entry) => {
+                const ref = record(entry).ref;
+                return typeof ref === "string" ? [ref,] : [];
+            })
+            : [];
+    });
+}
+/** Identifier fields `--contains` matches; string items match themselves. */
+const IDENTIFIER_FIELDS = [
+    "id",
+    "name",
+    "projectKey",
+    "envName",
+    "login",
+    "displayName",
+    "label",
+    "runnableType",
+];
+/** `job list` filters by --contains/--limit itself (job name, state, outputs). */
+const LISTS_WITH_OWN_FILTERS = { job: true, };
+function itemMatches(item, needle) {
+    if (typeof item === "string")
+        return item.toLowerCase().includes(needle);
+    const fields = record(item);
+    return IDENTIFIER_FIELDS.some((field) => {
+        const value = fields[field];
+        return typeof value === "string" && value.toLowerCase().includes(needle);
+    });
+}
+/**
+ * Shape a `*.list` result for agents: `--contains` filters on identifier
+ * fields, `--limit` caps the count (a `list_truncated` warning reports the
+ * total), and large DSS objects compact to their decision fields unless
+ * `--full` or `--fields` asks for the DSS objects.
+ */
+export function shapeListResult(resource, result, flags) {
+    if (!Array.isArray(result))
+        return result;
+    let items = result;
+    if (LISTS_WITH_OWN_FILTERS[resource] !== true) {
+        const contains = flags["contains"];
+        if (typeof contains === "string" && contains.length > 0) {
+            const needle = contains.toLowerCase();
+            items = items.filter((item) => itemMatches(item, needle));
+        }
+        const limit = num(flags["limit"], "--limit");
+        if (limit !== undefined && items.length > limit) {
+            enqueueCliWarning({
+                code: "list_truncated",
+                shown: limit,
+                total: items.length,
+                hint: "Raise --limit or narrow with --contains.",
+            });
+            items = items.slice(0, Math.max(0, limit));
+        }
+    }
+    const fields = COMPACT_LIST_FIELDS[resource];
+    if (!fields || flags["full"] === true || typeof flags["fields"] === "string")
+        return items;
+    return items.map((item) => Object.fromEntries(Object.entries(fields).map(([name, spec,]) => [name, compactValue(record(item), spec),])));
+}

package/dist/src/cli/list-shapes.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Compact `RESOURCE.list` item shapes, as plain data shared by the runtime
+ * mapper (src/cli/list-output.ts) and the discovery output schemas
+ * (src/cli/output-schemas.ts), so the advertised schema is the emitted shape.
+ */
+/** Where a compact field comes from in the DSS object, and its JSON Schema. */
+export interface CompactListField {
+    /** Dotted path into the DSS list item. */
+    path: string;
+    /** Flatten recipe roles (`{main:{items:[{ref}]}}`) to the dataset refs. */
+    roleRefs?: true;
+    schema: Record<string, unknown>;
+}
+/**
+ * Lists whose DSS objects are large: the identifier the follow-up get/build
+ * commands take, the kind, and the one or two attributes that decide what to
+ * call next. Lists not named here keep the DSS objects.
+ */
+export declare const COMPACT_LIST_FIELDS: Record<string, Record<string, CompactListField>>;
+/** Discovery output schemas of the compact `RESOURCE.list` defaults. */
+export declare function compactListOutputSchemas(): Record<string, Record<string, unknown>>;

package/dist/src/cli/list-shapes.js

@@ -0,0 +1,111 @@
+/**
+ * Compact `RESOURCE.list` item shapes, as plain data shared by the runtime
+ * mapper (src/cli/list-output.ts) and the discovery output schemas
+ * (src/cli/output-schemas.ts), so the advertised schema is the emitted shape.
+ */
+const STRING = { type: ["string", "null",], };
+const BOOLEAN = { type: ["boolean", "null",], };
+const NUMBER = { type: ["number", "null",], };
+const STRINGS = { type: "array", items: { type: "string", }, };
+const field = (path, schema) => ({
+    path,
+    schema,
+});
+/**
+ * Lists whose DSS objects are large: the identifier the follow-up get/build
+ * commands take, the kind, and the one or two attributes that decide what to
+ * call next. Lists not named here keep the DSS objects.
+ */
+export const COMPACT_LIST_FIELDS = {
+    project: {
+        projectKey: field("projectKey", STRING),
+        name: field("name", STRING),
+        ownerLogin: field("ownerLogin", STRING),
+    },
+    dataset: {
+        name: field("name", STRING),
+        type: field("type", STRING),
+        managed: field("managed", BOOLEAN),
+        connection: field("params.connection", STRING),
+    },
+    recipe: {
+        name: field("name", STRING),
+        type: field("type", STRING),
+        inputs: { path: "inputs", roleRefs: true, schema: STRINGS, },
+        outputs: { path: "outputs", roleRefs: true, schema: STRINGS, },
+    },
+    scenario: {
+        id: field("id", STRING),
+        name: field("name", STRING),
+        type: field("type", STRING),
+        active: field("active", BOOLEAN),
+        running: field("running", BOOLEAN),
+    },
+    folder: {
+        id: field("id", STRING),
+        name: field("name", STRING),
+        type: field("type", STRING),
+        connection: field("params.connection", STRING),
+    },
+    job: {
+        id: field("def.id", STRING),
+        name: field("def.name", STRING),
+        type: field("def.type", STRING),
+        state: field("state", STRING),
+        startTime: field("startTime", NUMBER),
+        endTime: field("endTime", NUMBER),
+    },
+    "code-env": {
+        envName: field("envName", STRING),
+        envLang: field("envLang", STRING),
+        deploymentMode: field("deploymentMode", STRING),
+    },
+    future: {
+        jobId: field("jobId", STRING),
+        owner: field("owner", STRING),
+        alive: field("alive", BOOLEAN),
+        hasResult: field("hasResult", BOOLEAN),
+        runningTime: field("runningTime", NUMBER),
+    },
+    user: {
+        login: field("login", STRING),
+        displayName: field("displayName", STRING),
+        userProfile: field("userProfile", STRING),
+        groups: field("groups", STRINGS),
+        enabled: field("enabled", BOOLEAN),
+    },
+    group: {
+        name: field("name", STRING),
+        description: field("description", STRING),
+        admin: field("admin", BOOLEAN),
+    },
+    plugin: {
+        id: field("id", STRING),
+        version: field("version", STRING),
+        label: field("meta.label", STRING),
+    },
+    macro: {
+        runnableType: field("runnableType", STRING),
+        ownerPluginId: field("ownerPluginId", STRING),
+        label: field("meta.label", STRING),
+    },
+    meaning: {
+        id: field("id", STRING),
+        label: field("label", STRING),
+        type: field("type", STRING),
+    },
+};
+/** Discovery output schemas of the compact `RESOURCE.list` defaults. */
+export function compactListOutputSchemas() {
+    return Object.fromEntries(Object.entries(COMPACT_LIST_FIELDS).map(([resource, fields,]) => [
+        `${resource}.list`,
+        {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: Object.fromEntries(Object.entries(fields).map(([name, spec,]) => [name, spec.schema,])),
+            },
+        },
+    ]));
+}

package/dist/src/cli/output-schemas.d.ts

@@ -1,17 +1,3 @@
-/**
- * Canonical discovery output schemas, keyed by `resource.action`.
- *
- * TypeBox definitions from `packages/types` plus the inline literal schemas
- * that exist only on the CLI side (code-env log envelope, code.run outcome,
- * project-library payloads, notebook saves, sql.query handoff envelope).
- * `scripts/generate-action-output-schemas.mjs` serializes this map into
- * `src/generated/action-output-schemas.json`; discovery (src/cli/contract.ts)
- * reads that generated JSON as plain data, so the TypeBox schema graph never
- * loads on the discovery path. SDK validation keeps using the TypeBox schema
- * objects from `packages/types` directly.
- *
- * Imported by the generator and the discovery parity test only.
- */
 /**
  * Canonical TypeBox-derived output schemas, keyed by `resource.action`. This is
  * the single source of truth for `src/generated/action-output-schemas.json`,

package/dist/src/cli/output-schemas.js

@@ -12,6 +12,7 @@
  *
  * Imported by the generator and the discovery parity test only.
  */
+import { compactListOutputSchemas, } from "./list-shapes.js";
 const PROJECT_LIBRARY_ITEM_OUTPUT_SCHEMA = {
     type: "object",
     additionalProperties: false,
@@ -62,9 +63,8 @@ let commandOutputSchemas;
 export function typeBoxCommandOutputSchemas() {
     if (commandOutputSchemas)
         return commandOutputSchemas;
-    const { CodeEnvDetailsSchema, CodeEnvLogSummaryArraySchema, CodeEnvSummaryArraySchema, CodeEnvUsageArraySchema, CodeEnvVersionForProjectSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, FlowZoneArraySchema, FlowZoneSchema, JobSummaryArraySchema, JobWaitResultSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, NotebookSessionArraySchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, RecipeSummaryArraySchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, SqlNotebookContentSchema, SqlNotebookHistorySchema, SqlNotebookSummaryArraySchema, SqlQueryResponseSchema, } = require("../schemas.js");
+    const { CodeEnvDetailsSchema, CodeEnvLogSummaryArraySchema, CodeEnvUsageArraySchema, CodeEnvVersionForProjectSchema, DatasetDetailsSchema, DatasetSchemaSchema, FlowZoneArraySchema, FlowZoneSchema, JobWaitResultSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, NotebookSessionArraySchema, ProjectDetailsSchema, ProjectMetadataSchema, ScenarioDetailsSchema, ScenarioStatusSchema, SqlNotebookContentSchema, SqlNotebookHistorySchema, SqlNotebookSummaryArraySchema, SqlQueryResponseSchema, } = require("../schemas.js");
     return commandOutputSchemas = {
-        "code-env.list": CodeEnvSummaryArraySchema,
         "code-env.get": CodeEnvDetailsSchema,
         "code-env.list-logs": CodeEnvLogSummaryArraySchema,
         "code-env.get-log": {
@@ -196,17 +196,12 @@ export function typeBoxCommandOutputSchemas() {
                 maxLines: { type: "integer", minimum: 0, },
             },
         },
-        "project.list": ProjectSummaryArraySchema,
         "project.get": ProjectDetailsSchema,
         "project.metadata": ProjectMetadataSchema,
-        "dataset.list": DatasetSummaryArraySchema,
         "dataset.get": DatasetDetailsSchema,
         "dataset.schema": DatasetSchemaSchema,
-        "recipe.list": RecipeSummaryArraySchema,
-        "job.list": JobSummaryArraySchema,
         "job.wait": JobWaitResultSchema,
         "job.monitor": JobWaitResultSchema,
-        "scenario.list": ScenarioSummaryArraySchema,
         "scenario.get": ScenarioDetailsSchema,
         "scenario.status": ScenarioStatusSchema,
         "flow-zone.list": FlowZoneArraySchema,
@@ -229,5 +224,7 @@ export function typeBoxCommandOutputSchemas() {
                 },
             ],
         },
+        // `*.list` defaults to compact items; `--full` returns the DSS objects.
+        ...compactListOutputSchemas(),
     };
 }

package/dist/src/cli/output.d.ts

@@ -12,7 +12,6 @@ export declare function pickResultFields(item: unknown, fields: string[]): unkno
  */
 export declare function projectResultFields(result: unknown, fields: string[], availableFieldNames?: () => string[]): unknown;
 export declare function writeCommandResult(result: unknown): void;
-export declare function transientBodyWithTargetContext(body: string, target: string, elapsedMs: number): string;
 export declare function addTransientTargetContext(error: unknown, target: string, elapsedMs: number): never;
 export declare function isFailedWaitResult(result: unknown): boolean;
 export declare function isAssertionFailureResult(result: unknown): boolean;