@treeseed/sdk 0.13.0-rc.90 → 0.13.0-rc.92

package/dist/content/validation/portable-content-data.d.ts

@@ -297,14 +297,14 @@ export declare function validatePortableContentData(model: string, value: unknow
                 commit?: {
                     allowed: boolean;
                 } | undefined;
-                network?: {
-                    allowWeb?: boolean | undefined;
-                    allowedDomains?: string[] | undefined;
-                } | undefined;
                 content?: Record<string, {
                     operations: string[];
                     filters?: Record<string, unknown> | undefined;
                 }> | undefined;
+                network?: {
+                    allowWeb?: boolean | undefined;
+                    allowedDomains?: string[] | undefined;
+                } | undefined;
                 shell?: {
                     allowCommands?: boolean | undefined;
                     allowedCommands?: string[] | undefined;
@@ -319,14 +319,14 @@ export declare function validatePortableContentData(model: string, value: unknow
                 commit?: {
                     allowed: boolean;
                 } | undefined;
-                network?: {
-                    allowWeb?: boolean | undefined;
-                    allowedDomains?: string[] | undefined;
-                } | undefined;
                 content?: Record<string, {
                     operations: string[];
                     filters?: Record<string, unknown> | undefined;
                 }> | undefined;
+                network?: {
+                    allowWeb?: boolean | undefined;
+                    allowedDomains?: string[] | undefined;
+                } | undefined;
                 shell?: {
                     allowCommands?: boolean | undefined;
                     allowedCommands?: string[] | undefined;
@@ -921,14 +921,14 @@ export declare function validatePortableContentData(model: string, value: unknow
                 commit?: {
                     allowed: boolean;
                 } | undefined;
-                network?: {
-                    allowWeb?: boolean | undefined;
-                    allowedDomains?: string[] | undefined;
-                } | undefined;
                 content?: Record<string, {
                     operations: string[];
                     filters?: Record<string, unknown> | undefined;
                 }> | undefined;
+                network?: {
+                    allowWeb?: boolean | undefined;
+                    allowedDomains?: string[] | undefined;
+                } | undefined;
                 shell?: {
                     allowCommands?: boolean | undefined;
                     allowedCommands?: string[] | undefined;
@@ -1093,14 +1093,14 @@ export declare function validatePortableContentData(model: string, value: unknow
                 commit?: {
                     allowed: boolean;
                 } | undefined;
-                network?: {
-                    allowWeb?: boolean | undefined;
-                    allowedDomains?: string[] | undefined;
-                } | undefined;
                 content?: Record<string, {
                     operations: string[];
                     filters?: Record<string, unknown> | undefined;
                 }> | undefined;
+                network?: {
+                    allowWeb?: boolean | undefined;
+                    allowedDomains?: string[] | undefined;
+                } | undefined;
                 shell?: {
                     allowCommands?: boolean | undefined;
                     allowedCommands?: string[] | undefined;
@@ -1265,14 +1265,14 @@ export declare function validatePortableContentData(model: string, value: unknow
                 commit?: {
                     allowed: boolean;
                 } | undefined;
-                network?: {
-                    allowWeb?: boolean | undefined;
-                    allowedDomains?: string[] | undefined;
-                } | undefined;
                 content?: Record<string, {
                     operations: string[];
                     filters?: Record<string, unknown> | undefined;
                 }> | undefined;
+                network?: {
+                    allowWeb?: boolean | undefined;
+                    allowedDomains?: string[] | undefined;
+                } | undefined;
                 shell?: {
                     allowCommands?: boolean | undefined;
                     allowedCommands?: string[] | undefined;
@@ -1437,14 +1437,14 @@ export declare function validatePortableContentData(model: string, value: unknow
                 commit?: {
                     allowed: boolean;
                 } | undefined;
-                network?: {
-                    allowWeb?: boolean | undefined;
-                    allowedDomains?: string[] | undefined;
-                } | undefined;
                 content?: Record<string, {
                     operations: string[];
                     filters?: Record<string, unknown> | undefined;
                 }> | undefined;
+                network?: {
+                    allowWeb?: boolean | undefined;
+                    allowedDomains?: string[] | undefined;
+                } | undefined;
                 shell?: {
                     allowCommands?: boolean | undefined;
                     allowedCommands?: string[] | undefined;
@@ -1628,8 +1628,8 @@ export declare function validatePortableContentData(model: string, value: unknow
                 directory: string;
                 integrity?: string | undefined;
             } | {
-                version: string;
                 kind: "r2";
+                version: string;
                 objectKey: string;
                 integrity?: string | undefined;
                 bucket?: string | undefined;
@@ -1649,8 +1649,8 @@ export declare function validatePortableContentData(model: string, value: unknow
         teamId?: string | undefined;
         sourceRef?: string | undefined;
     } | {
-        id: string;
         kind: "workday" | "api" | "handler" | "spec" | "message_chain" | "manager_worker" | "ui" | "context-query" | "context-query-set";
+        id: string;
         trigger: Record<string, unknown>;
         agent: string;
         contextQueryRefs: string[];
@@ -1710,8 +1710,8 @@ export declare function validatePortableContentData(model: string, value: unknow
         purpose: string;
         target: {
             kind: "code" | "content" | "graph" | "mixed";
-            paths?: string[] | undefined;
             models?: string[] | undefined;
+            paths?: string[] | undefined;
         };
         description: string;
         revision: number;
@@ -1746,9 +1746,9 @@ export declare function validatePortableContentData(model: string, value: unknow
         }[];
         mergePolicy: "replace" | "append";
     } | {
+        kind: "status" | "message" | "summary" | "plan";
         id: string;
         variables: string[];
-        kind: "status" | "message" | "summary" | "plan";
         description: string;
         revision: number;
         title: string;

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, {
+    schemaVersion: "treeseed.ai-hosting-deployment/v1";
+    components: {
+        componentId: "ai-inference" | "ai-training";
+        releaseDigest: string;
+    }[];
+    projectId: string;
+    teamId: string;
+    environment: "production" | "staging";
+    provider: "hyperstack";
+    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;
+}, {
+    schemaVersion: "treeseed.ai-hosting-deployment/v1";
+    components: {
+        componentId: "ai-inference" | "ai-training";
+        releaseDigest: string;
+    }[];
+    projectId: string;
+    teamId: string;
+    environment: "production" | "staging";
+    provider: "hyperstack";
+    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;
+}>, {
+    schemaVersion: "treeseed.ai-hosting-deployment/v1";
+    components: {
+        componentId: "ai-inference" | "ai-training";
+        releaseDigest: string;
+    }[];
+    projectId: string;
+    teamId: string;
+    environment: "production" | "staging";
+    provider: "hyperstack";
+    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;
+}, {
+    schemaVersion: "treeseed.ai-hosting-deployment/v1";
+    components: {
+        componentId: "ai-inference" | "ai-training";
+        releaseDigest: string;
+    }[];
+    projectId: string;
+    teamId: string;
+    environment: "production" | "staging";
+    provider: "hyperstack";
+    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,48 @@
+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>;

package/dist/deployment/ai-instance.js

@@ -0,0 +1,23 @@
+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." });
+});
+export {
+  aiInstanceDraftSchema
+};