@treeseed/sdk 0.13.0-rc.11 → 0.13.0-rc.111

package/dist/deployment/ai/storage.d.ts

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+/** Public selection contains references only; the API resolves current service custody. */
+export declare const aiStorageBindingSchema: z.ZodObject<{
+    connectionId: z.ZodString;
+    bucket: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    connectionId: string;
+    bucket: string;
+}, {
+    connectionId: string;
+    bucket: string;
+}>;
+export declare const aiStorageProofSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.ai-storage-proof/v1">;
+    teamId: z.ZodString;
+    projectId: z.ZodString;
+    nodeId: z.ZodString;
+    service: z.ZodEnum<["inference", "training", "lab"]>;
+    storeId: z.ZodEnum<["managed-inference", "managed-training", "managed-lab"]>;
+    action: z.ZodEnum<["read", "write", "list", "delete"]>;
+    key: z.ZodEffects<z.ZodString, string, string>;
+    issuedAt: z.ZodNumber;
+    nonce: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    service: "inference" | "training" | "lab";
+    nonce: string;
+    schemaVersion: "treeseed.ai-storage-proof/v1";
+    key: string;
+    action: "read" | "write" | "list" | "delete";
+    projectId: string;
+    teamId: string;
+    issuedAt: number;
+    nodeId: string;
+    storeId: "managed-inference" | "managed-training" | "managed-lab";
+}, {
+    service: "inference" | "training" | "lab";
+    nonce: string;
+    schemaVersion: "treeseed.ai-storage-proof/v1";
+    key: string;
+    action: "read" | "write" | "list" | "delete";
+    projectId: string;
+    teamId: string;
+    issuedAt: number;
+    nodeId: string;
+    storeId: "managed-inference" | "managed-training" | "managed-lab";
+}>, {
+    service: "inference" | "training" | "lab";
+    nonce: string;
+    schemaVersion: "treeseed.ai-storage-proof/v1";
+    key: string;
+    action: "read" | "write" | "list" | "delete";
+    projectId: string;
+    teamId: string;
+    issuedAt: number;
+    nodeId: string;
+    storeId: "managed-inference" | "managed-training" | "managed-lab";
+}, {
+    service: "inference" | "training" | "lab";
+    nonce: string;
+    schemaVersion: "treeseed.ai-storage-proof/v1";
+    key: string;
+    action: "read" | "write" | "list" | "delete";
+    projectId: string;
+    teamId: string;
+    issuedAt: number;
+    nodeId: string;
+    storeId: "managed-inference" | "managed-training" | "managed-lab";
+}>;
+export type AiStorageProof = z.infer<typeof aiStorageProofSchema>;
+export declare const aiStorageRequestSchema: z.ZodObject<{
+    proof: z.ZodEffects<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"treeseed.ai-storage-proof/v1">;
+        teamId: z.ZodString;
+        projectId: z.ZodString;
+        nodeId: z.ZodString;
+        service: z.ZodEnum<["inference", "training", "lab"]>;
+        storeId: z.ZodEnum<["managed-inference", "managed-training", "managed-lab"]>;
+        action: z.ZodEnum<["read", "write", "list", "delete"]>;
+        key: z.ZodEffects<z.ZodString, string, string>;
+        issuedAt: z.ZodNumber;
+        nonce: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        service: "inference" | "training" | "lab";
+        nonce: string;
+        schemaVersion: "treeseed.ai-storage-proof/v1";
+        key: string;
+        action: "read" | "write" | "list" | "delete";
+        projectId: string;
+        teamId: string;
+        issuedAt: number;
+        nodeId: string;
+        storeId: "managed-inference" | "managed-training" | "managed-lab";
+    }, {
+        service: "inference" | "training" | "lab";
+        nonce: string;
+        schemaVersion: "treeseed.ai-storage-proof/v1";
+        key: string;
+        action: "read" | "write" | "list" | "delete";
+        projectId: string;
+        teamId: string;
+        issuedAt: number;
+        nodeId: string;
+        storeId: "managed-inference" | "managed-training" | "managed-lab";
+    }>, {
+        service: "inference" | "training" | "lab";
+        nonce: string;
+        schemaVersion: "treeseed.ai-storage-proof/v1";
+        key: string;
+        action: "read" | "write" | "list" | "delete";
+        projectId: string;
+        teamId: string;
+        issuedAt: number;
+        nodeId: string;
+        storeId: "managed-inference" | "managed-training" | "managed-lab";
+    }, {
+        service: "inference" | "training" | "lab";
+        nonce: string;
+        schemaVersion: "treeseed.ai-storage-proof/v1";
+        key: string;
+        action: "read" | "write" | "list" | "delete";
+        projectId: string;
+        teamId: string;
+        issuedAt: number;
+        nodeId: string;
+        storeId: "managed-inference" | "managed-training" | "managed-lab";
+    }>;
+    signature: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    proof: {
+        service: "inference" | "training" | "lab";
+        nonce: string;
+        schemaVersion: "treeseed.ai-storage-proof/v1";
+        key: string;
+        action: "read" | "write" | "list" | "delete";
+        projectId: string;
+        teamId: string;
+        issuedAt: number;
+        nodeId: string;
+        storeId: "managed-inference" | "managed-training" | "managed-lab";
+    };
+    signature: string;
+}, {
+    proof: {
+        service: "inference" | "training" | "lab";
+        nonce: string;
+        schemaVersion: "treeseed.ai-storage-proof/v1";
+        key: string;
+        action: "read" | "write" | "list" | "delete";
+        projectId: string;
+        teamId: string;
+        issuedAt: number;
+        nodeId: string;
+        storeId: "managed-inference" | "managed-training" | "managed-lab";
+    };
+    signature: string;
+}>;
+/** Domain-separated, deterministic bytes signed by a Deployment-owned Ed25519 identity. */
+export declare function aiStorageProofMessage(input: AiStorageProof): string;

package/dist/deployment/ai/storage.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+const aiStorageBindingSchema = z.object({
+  connectionId: z.string().uuid(),
+  bucket: z.string().regex(/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/u)
+}).strict();
+const aiStorageProofSchema = z.object({
+  schemaVersion: z.literal("treeseed.ai-storage-proof/v1"),
+  teamId: z.string().uuid(),
+  projectId: z.string().uuid(),
+  nodeId: z.string().uuid(),
+  service: z.enum(["inference", "training", "lab"]),
+  storeId: z.enum(["managed-inference", "managed-training", "managed-lab"]),
+  action: z.enum(["read", "write", "list", "delete"]),
+  key: z.string().max(1024).refine((value) => !/[\\\x00-\x1f\x7f%?#]/u.test(value) && (!value || !value.split("/").some((part) => !part || part === "." || part === "..")), "Use a relative artifact key."),
+  issuedAt: z.number().int().positive(),
+  nonce: z.string().uuid()
+}).strict().refine((value) => value.action === "list" || value.key.length > 0, "An object key is required.");
+const aiStorageRequestSchema = z.object({
+  proof: aiStorageProofSchema,
+  signature: z.string().regex(/^[A-Za-z0-9_-]{86}$/u)
+}).strict();
+function aiStorageProofMessage(input) {
+  const proof = aiStorageProofSchema.parse(input);
+  return `treeseed.ai-storage-proof/v1
+${JSON.stringify(Object.fromEntries(Object.entries(proof).sort(([a], [b]) => a.localeCompare(b))))}`;
+}
+export {
+  aiStorageBindingSchema,
+  aiStorageProofMessage,
+  aiStorageProofSchema,
+  aiStorageRequestSchema
+};

package/dist/deployment/ai-hosting.d.ts

@@ -0,0 +1,297 @@
+import { z } from 'zod';
+/** Public intent only: credentials are resolved at execution, never serialized here. */
+export declare const aiHostingScheduleSchema: z.ZodEffects<z.ZodObject<{
+    timeZone: z.ZodEffects<z.ZodString, string, string>;
+    weekdays: z.ZodArray<z.ZodNumber, "many">;
+    start: z.ZodString;
+    end: z.ZodString;
+    startupLeadMinutes: z.ZodNumber;
+    idleAction: z.ZodLiteral<"hibernate">;
+    activeWorkPolicy: z.ZodLiteral<"drain-and-checkpoint">;
+}, "strict", z.ZodTypeAny, {
+    start: string;
+    activeWorkPolicy: "drain-and-checkpoint";
+    timeZone: string;
+    weekdays: number[];
+    end: string;
+    startupLeadMinutes: number;
+    idleAction: "hibernate";
+}, {
+    start: string;
+    activeWorkPolicy: "drain-and-checkpoint";
+    timeZone: string;
+    weekdays: number[];
+    end: string;
+    startupLeadMinutes: number;
+    idleAction: "hibernate";
+}>, {
+    start: string;
+    activeWorkPolicy: "drain-and-checkpoint";
+    timeZone: string;
+    weekdays: number[];
+    end: string;
+    startupLeadMinutes: number;
+    idleAction: "hibernate";
+}, {
+    start: string;
+    activeWorkPolicy: "drain-and-checkpoint";
+    timeZone: string;
+    weekdays: number[];
+    end: string;
+    startupLeadMinutes: number;
+    idleAction: "hibernate";
+}>;
+export declare const aiHostingDeploymentSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.ai-hosting-deployment/v1">;
+    teamId: z.ZodString;
+    projectId: z.ZodString;
+    deploymentId: z.ZodString;
+    environment: z.ZodEnum<["staging", "production"]>;
+    provider: z.ZodLiteral<"hyperstack">;
+    hostingBindingId: z.ZodString;
+    components: z.ZodArray<z.ZodObject<{
+        componentId: z.ZodEnum<["ai-inference", "ai-training"]>;
+        releaseDigest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        componentId: "ai-inference" | "ai-training";
+        releaseDigest: string;
+    }, {
+        componentId: "ai-inference" | "ai-training";
+        releaseDigest: string;
+    }>, "many">;
+    machine: z.ZodObject<{
+        name: z.ZodString;
+        environmentName: z.ZodString;
+        flavorName: z.ZodString;
+        imageName: z.ZodString;
+        keypairName: z.ZodString;
+        volumeName: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        environmentName: string;
+        flavorName: string;
+        imageName: string;
+        keypairName: string;
+        volumeName: string;
+    }, {
+        name: string;
+        environmentName: string;
+        flavorName: string;
+        imageName: string;
+        keypairName: string;
+        volumeName: string;
+    }>;
+    gpuAdmission: z.ZodLiteral<"exclusive-engine">;
+    storage: z.ZodArray<z.ZodObject<{
+        bindingId: z.ZodString;
+        purpose: z.ZodEnum<["datasets", "models", "checkpoints", "artifacts"]>;
+        access: z.ZodEnum<["read", "write"]>;
+    }, "strict", z.ZodTypeAny, {
+        purpose: "artifacts" | "datasets" | "models" | "checkpoints";
+        bindingId: string;
+        access: "read" | "write";
+    }, {
+        purpose: "artifacts" | "datasets" | "models" | "checkpoints";
+        bindingId: string;
+        access: "read" | "write";
+    }>, "many">;
+    schedule: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        timeZone: z.ZodEffects<z.ZodString, string, string>;
+        weekdays: z.ZodArray<z.ZodNumber, "many">;
+        start: z.ZodString;
+        end: z.ZodString;
+        startupLeadMinutes: z.ZodNumber;
+        idleAction: z.ZodLiteral<"hibernate">;
+        activeWorkPolicy: z.ZodLiteral<"drain-and-checkpoint">;
+    }, "strict", z.ZodTypeAny, {
+        start: string;
+        activeWorkPolicy: "drain-and-checkpoint";
+        timeZone: string;
+        weekdays: number[];
+        end: string;
+        startupLeadMinutes: number;
+        idleAction: "hibernate";
+    }, {
+        start: string;
+        activeWorkPolicy: "drain-and-checkpoint";
+        timeZone: string;
+        weekdays: number[];
+        end: string;
+        startupLeadMinutes: number;
+        idleAction: "hibernate";
+    }>, {
+        start: string;
+        activeWorkPolicy: "drain-and-checkpoint";
+        timeZone: string;
+        weekdays: number[];
+        end: string;
+        startupLeadMinutes: number;
+        idleAction: "hibernate";
+    }, {
+        start: string;
+        activeWorkPolicy: "drain-and-checkpoint";
+        timeZone: string;
+        weekdays: number[];
+        end: string;
+        startupLeadMinutes: number;
+        idleAction: "hibernate";
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    provider: "hyperstack";
+    schemaVersion: "treeseed.ai-hosting-deployment/v1";
+    components: {
+        componentId: "ai-inference" | "ai-training";
+        releaseDigest: string;
+    }[];
+    projectId: string;
+    teamId: string;
+    environment: "production" | "staging";
+    deploymentId: string;
+    hostingBindingId: string;
+    machine: {
+        name: string;
+        environmentName: string;
+        flavorName: string;
+        imageName: string;
+        keypairName: string;
+        volumeName: string;
+    };
+    gpuAdmission: "exclusive-engine";
+    storage: {
+        purpose: "artifacts" | "datasets" | "models" | "checkpoints";
+        bindingId: string;
+        access: "read" | "write";
+    }[];
+    schedule?: {
+        start: string;
+        activeWorkPolicy: "drain-and-checkpoint";
+        timeZone: string;
+        weekdays: number[];
+        end: string;
+        startupLeadMinutes: number;
+        idleAction: "hibernate";
+    } | undefined;
+}, {
+    provider: "hyperstack";
+    schemaVersion: "treeseed.ai-hosting-deployment/v1";
+    components: {
+        componentId: "ai-inference" | "ai-training";
+        releaseDigest: string;
+    }[];
+    projectId: string;
+    teamId: string;
+    environment: "production" | "staging";
+    deploymentId: string;
+    hostingBindingId: string;
+    machine: {
+        name: string;
+        environmentName: string;
+        flavorName: string;
+        imageName: string;
+        keypairName: string;
+        volumeName: string;
+    };
+    gpuAdmission: "exclusive-engine";
+    storage: {
+        purpose: "artifacts" | "datasets" | "models" | "checkpoints";
+        bindingId: string;
+        access: "read" | "write";
+    }[];
+    schedule?: {
+        start: string;
+        activeWorkPolicy: "drain-and-checkpoint";
+        timeZone: string;
+        weekdays: number[];
+        end: string;
+        startupLeadMinutes: number;
+        idleAction: "hibernate";
+    } | undefined;
+}>, {
+    provider: "hyperstack";
+    schemaVersion: "treeseed.ai-hosting-deployment/v1";
+    components: {
+        componentId: "ai-inference" | "ai-training";
+        releaseDigest: string;
+    }[];
+    projectId: string;
+    teamId: string;
+    environment: "production" | "staging";
+    deploymentId: string;
+    hostingBindingId: string;
+    machine: {
+        name: string;
+        environmentName: string;
+        flavorName: string;
+        imageName: string;
+        keypairName: string;
+        volumeName: string;
+    };
+    gpuAdmission: "exclusive-engine";
+    storage: {
+        purpose: "artifacts" | "datasets" | "models" | "checkpoints";
+        bindingId: string;
+        access: "read" | "write";
+    }[];
+    schedule?: {
+        start: string;
+        activeWorkPolicy: "drain-and-checkpoint";
+        timeZone: string;
+        weekdays: number[];
+        end: string;
+        startupLeadMinutes: number;
+        idleAction: "hibernate";
+    } | undefined;
+}, {
+    provider: "hyperstack";
+    schemaVersion: "treeseed.ai-hosting-deployment/v1";
+    components: {
+        componentId: "ai-inference" | "ai-training";
+        releaseDigest: string;
+    }[];
+    projectId: string;
+    teamId: string;
+    environment: "production" | "staging";
+    deploymentId: string;
+    hostingBindingId: string;
+    machine: {
+        name: string;
+        environmentName: string;
+        flavorName: string;
+        imageName: string;
+        keypairName: string;
+        volumeName: string;
+    };
+    gpuAdmission: "exclusive-engine";
+    storage: {
+        purpose: "artifacts" | "datasets" | "models" | "checkpoints";
+        bindingId: string;
+        access: "read" | "write";
+    }[];
+    schedule?: {
+        start: string;
+        activeWorkPolicy: "drain-and-checkpoint";
+        timeZone: string;
+        weekdays: number[];
+        end: string;
+        startupLeadMinutes: number;
+        idleAction: "hibernate";
+    } | undefined;
+}>;
+export type AiHostingDeployment = z.infer<typeof aiHostingDeploymentSchema>;
+export type AiHostingSchedule = z.infer<typeof aiHostingScheduleSchema>;
+/** Engine selection is independent from the infrastructure provider or credentials. */
+export declare const AI_HOSTING_TARGETS: readonly [{
+    readonly id: "ai-inference";
+    readonly project: "ai";
+    readonly engine: "vllm";
+    readonly capability: "ai-inference-hosting";
+    readonly runtimeOwner: "ai";
+    readonly infrastructureOwner: "deployment";
+}, {
+    readonly id: "ai-training";
+    readonly project: "ai";
+    readonly engine: "axolotl";
+    readonly capability: "ai-training-hosting";
+    readonly runtimeOwner: "ai";
+    readonly infrastructureOwner: "deployment";
+}];

package/dist/deployment/ai-hosting.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+const id = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u);
+const name = z.string().trim().min(1).max(128);
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const time = z.string().regex(/^(?:[01][0-9]|2[0-3]):[0-5][0-9]$/u);
+const aiHostingScheduleSchema = z.object({
+  timeZone: z.string().refine((value) => {
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: value });
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Use an IANA time zone."),
+  weekdays: z.array(z.number().int().min(1).max(7)).min(1).max(7),
+  start: time,
+  end: time,
+  startupLeadMinutes: z.number().int().min(0).max(120),
+  idleAction: z.literal("hibernate"),
+  activeWorkPolicy: z.literal("drain-and-checkpoint")
+}).strict().superRefine((value, context) => {
+  if (new Set(value.weekdays).size !== value.weekdays.length) context.addIssue({ code: "custom", path: ["weekdays"], message: "Choose each weekday once." });
+  if (value.start >= value.end) context.addIssue({ code: "custom", path: ["end"], message: "End must follow start on the same local day." });
+});
+const storage = z.object({
+  bindingId: id,
+  purpose: z.enum(["datasets", "models", "checkpoints", "artifacts"]),
+  access: z.enum(["read", "write"])
+}).strict();
+const component = z.object({ componentId: z.enum(["ai-inference", "ai-training"]), releaseDigest: digest }).strict();
+const aiHostingDeploymentSchema = z.object({
+  schemaVersion: z.literal("treeseed.ai-hosting-deployment/v1"),
+  teamId: id,
+  projectId: id,
+  deploymentId: id,
+  environment: z.enum(["staging", "production"]),
+  provider: z.literal("hyperstack"),
+  hostingBindingId: id,
+  components: z.array(component).min(1).max(2),
+  machine: z.object({ name, environmentName: name, flavorName: name, imageName: name, keypairName: name, volumeName: name }).strict(),
+  gpuAdmission: z.literal("exclusive-engine"),
+  storage: z.array(storage).min(1).max(16),
+  schedule: aiHostingScheduleSchema.optional()
+}).strict().superRefine((value, context) => {
+  if (new Set(value.components.map((item) => item.componentId)).size !== value.components.length)
+    context.addIssue({ code: "custom", path: ["components"], message: "Each engine can be selected once." });
+  if (!value.storage.some((item) => item.purpose === "models" && item.access === "read"))
+    context.addIssue({ code: "custom", path: ["storage"], message: "An authorized model read binding is required." });
+  if (value.components.some((item) => item.componentId === "ai-training")) {
+    for (const [purpose, access] of [["datasets", "read"], ["checkpoints", "write"]])
+      if (!value.storage.some((item) => item.purpose === purpose && item.access === access))
+        context.addIssue({ code: "custom", path: ["storage"], message: `Training requires ${purpose} ${access} access.` });
+  }
+});
+const AI_HOSTING_TARGETS = [
+  { id: "ai-inference", project: "ai", engine: "vllm", capability: "ai-inference-hosting", runtimeOwner: "ai", infrastructureOwner: "deployment" },
+  { id: "ai-training", project: "ai", engine: "axolotl", capability: "ai-training-hosting", runtimeOwner: "ai", infrastructureOwner: "deployment" }
+];
+export {
+  AI_HOSTING_TARGETS,
+  aiHostingDeploymentSchema,
+  aiHostingScheduleSchema
+};

package/dist/deployment/ai-instance.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+export declare const aiInstanceDraftSchema: z.ZodEffects<z.ZodObject<{
+    name: z.ZodString;
+    projectId: z.ZodString;
+    purpose: z.ZodEnum<["inference", "training", "both"]>;
+    hostingConnectionId: z.ZodString;
+    storageConnectionId: z.ZodNullable<z.ZodString>;
+    model: z.ZodString;
+    schedule: z.ZodEnum<["always", "weekdays"]>;
+    timeZone: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    projectId: string;
+    purpose: "inference" | "training" | "both";
+    timeZone: string;
+    schedule: "weekdays" | "always";
+    hostingConnectionId: string;
+    storageConnectionId: string | null;
+    model: string;
+}, {
+    name: string;
+    projectId: string;
+    purpose: "inference" | "training" | "both";
+    timeZone: string;
+    schedule: "weekdays" | "always";
+    hostingConnectionId: string;
+    storageConnectionId: string | null;
+    model: string;
+}>, {
+    name: string;
+    projectId: string;
+    purpose: "inference" | "training" | "both";
+    timeZone: string;
+    schedule: "weekdays" | "always";
+    hostingConnectionId: string;
+    storageConnectionId: string | null;
+    model: string;
+}, {
+    name: string;
+    projectId: string;
+    purpose: "inference" | "training" | "both";
+    timeZone: string;
+    schedule: "weekdays" | "always";
+    hostingConnectionId: string;
+    storageConnectionId: string | null;
+    model: string;
+}>;
+export type AiInstanceDraft = z.infer<typeof aiInstanceDraftSchema>;
+/** Registration adopts an already managed local runtime; it never provisions a cloud machine. */
+export declare const aiNodeRegistrationSchema: z.ZodObject<{
+    name: z.ZodString;
+    projectId: z.ZodString;
+    purpose: z.ZodEnum<["inference", "training", "both"]>;
+    model: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    projectId: string;
+    purpose: "inference" | "training" | "both";
+    model: string;
+}, {
+    name: string;
+    projectId: string;
+    purpose: "inference" | "training" | "both";
+    model: string;
+}>;

package/dist/deployment/ai-instance.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+const aiInstanceDraftSchema = z.object({
+  name: z.string().trim().min(1).max(128),
+  projectId: z.string().min(1).max(128),
+  purpose: z.enum(["inference", "training", "both"]),
+  hostingConnectionId: z.string().min(1).max(128),
+  storageConnectionId: z.string().min(1).max(128).nullable(),
+  model: z.string().trim().min(1).max(512),
+  schedule: z.enum(["always", "weekdays"]),
+  timeZone: z.string().refine((value) => {
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: value });
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Use an IANA time zone.")
+}).strict().superRefine((value, context) => {
+  if (value.purpose !== "inference" && !value.storageConnectionId) context.addIssue({ code: "custom", path: ["storageConnectionId"], message: "Training requires a storage connection." });
+});
+const aiNodeRegistrationSchema = z.object({
+  name: z.string().trim().min(1).max(128),
+  projectId: z.string().uuid(),
+  purpose: z.enum(["inference", "training", "both"]),
+  model: z.string().trim().min(1).max(512)
+}).strict();
+export {
+  aiInstanceDraftSchema,
+  aiNodeRegistrationSchema
+};