@treeseed/sdk 0.13.0-rc.47 → 0.13.0-rc.49

package/dist/deployment/schemas.js

@@ -3,6 +3,10 @@ const identifier = z.string().regex(/^[a-z][a-z0-9.-]{1,63}$/u);
 const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
 const gitCommit = z.string().regex(/^[a-f0-9]{40}$/u);
 const packageVersion = z.string().min(1).regex(/^[0-9][0-9A-Za-z.+:~-]*$/u);
+const ociRepository = z.string().min(1).max(255).regex(
+  /^(?:(?:localhost|[a-z0-9]+(?:[.-][a-z0-9]+)+)(?::[1-9][0-9]{0,4})?\/)?[a-z0-9]+(?:[._-][a-z0-9]+)*(?:\/[a-z0-9]+(?:[._-][a-z0-9]+)*)*$/u,
+  "OCI repositories must be normalized lowercase names without a scheme, tag, digest, credentials, or traversal."
+);
 const localAlias = z.string().regex(
   /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*\.localhost$/u,
   "Host aliases must use the .localhost namespace."
@@ -146,7 +150,7 @@ const packageRuntimeSchema = z.object({
   if (new Set(endpointIds).size !== endpointIds.length) context.addIssue({ code: z.ZodIssueCode.custom, path: ["services"], message: "Endpoint identities must be unique within a component." });
 });
 const catalogPackageSchema = z.object({ name: z.string().regex(/^treeseed(?:-[a-z0-9-]+)?$/u), version: packageVersion, architecture: z.enum(["amd64", "all"]), origin: z.literal("TreeSeed Deployment"), order: z.number().int().nonnegative() }).strict();
-const catalogImageSchema = z.object({ role: identifier, repository: z.string().regex(/^treeseed\/[a-z0-9-]+$/u), digest, platforms: z.array(z.enum(["linux/amd64", "linux/arm64"])).min(1), consumers: z.array(identifier).min(1) }).strict();
+const catalogImageSchema = z.object({ role: identifier, repository: ociRepository, digest, platforms: z.array(z.enum(["linux/amd64", "linux/arm64"])).min(1), consumers: z.array(identifier).min(1) }).strict();
 const componentReleaseSchema = z.object({
   schemaVersion: z.literal("treeseed.component-release/v1"),
   componentId: identifier,

package/dist/operator-contracts/canonical-command-tree.js

@@ -8,6 +8,7 @@ const local = (handlerId) => ({ kind: "local", handlerId });
 const field = (target, name, source, sourceName = name, required = false, transform = "identity") => ({ target, field: name, source, name: sourceName, required, transform });
 const operation = (operationId, input = []) => ({ kind: "operation", operationId, input });
 const page = () => [field("query", "status", "option"), field("query", "limit", "option", "limit", false, "integer"), field("query", "cursor", "option")];
+const aiNode = () => field("path", "nodeId", "context", "node", true);
 const operationBindings = {
   "auth login": protocol("protocol.oauth.device.login"),
   "auth logout": protocol("protocol.oauth.revoke"),
@@ -110,6 +111,21 @@ const operationBindings = {
   "projects treedx workspaces list": operation("treedx.workspaces.list", [field("path", "projectId", "argument", "project", true), ...page()]),
   "projects treedx workspaces show": operation("treedx.workspaces.show", [field("path", "projectId", "context", "project", true), field("path", "workspaceId", "argument", "workspace", true)]),
   "projects treedx workspaces abandon": operation("treedx.workspaces.abandon", [field("path", "projectId", "context", "project", true), field("path", "workspaceId", "argument", "workspace", true)]),
+  "ai status": operation("treeai.qualification.get.status", [aiNode()]),
+  "ai mode show": operation("treeai.qualification.get.mode", [aiNode()]),
+  "ai mode set": operation("treeai.qualification.post.mode", [aiNode(), field("body", "mode", "argument", "mode", true)]),
+  "ai inference models": operation("treeai.inference.get.models", [aiNode()]),
+  "ai inference jobs": operation("treeai.inference.get.jobs", [aiNode()]),
+  "ai inference rollback": operation("treeai.inference.post.deployments.rollback", [aiNode()]),
+  "ai training libraries": operation("treeai.training.get.libraries", [aiNode()]),
+  "ai training jobs": operation("treeai.training.get.jobs", [aiNode()]),
+  "ai training runs": operation("treeai.training.get.library.runs", [aiNode()]),
+  "ai lab status": operation("treeai.lab.get.status", [aiNode()]),
+  "ai lab agents": operation("treeai.lab.get.agents", [aiNode()]),
+  "ai lab libraries": operation("treeai.lab.get.libraries", [aiNode()]),
+  "ai qualify status": operation("treeai.qualification.get.qualification.profile", [aiNode()]),
+  "ai qualify run": operation("treeai.qualification.post.qualification.campaigns", [aiNode()]),
+  "ai qualify campaigns": operation("treeai.qualification.get.qualification.campaigns", [aiNode()]),
   "library show": local("local.library.show"),
   "library status": local("local.library.status"),
   "library paths": local("local.library.paths"),
@@ -299,6 +315,14 @@ const commandTree = {
       leaf("capabilities", "read", "project"),
       branch("workspaces", [leaf("list", "read", "project"), leaf("show", "read", "workspace"), leaf("abandon", "mutation", "workspace", "destructive")])
     ])]),
+    branch("ai", [
+      leaf("status"),
+      branch("mode", [leaf("show"), leaf("set", "mutation", "mode", "authority")]),
+      branch("inference", [leaf("models"), leaf("jobs"), leaf("rollback", "mutation", void 0, "destructive")]),
+      branch("training", [leaf("libraries"), leaf("jobs"), leaf("runs")]),
+      branch("lab", [leaf("status"), leaf("agents"), leaf("libraries")]),
+      branch("qualify", [leaf("status"), leaf("run", "mutation", void 0, "authority"), leaf("campaigns")])
+    ]),
     branch("library", [
       libraryRead("show"),
       libraryRead("status"),

package/dist/operator-contracts/catalog/treeai-operations.d.ts

@@ -0,0 +1,14 @@
+import type { ControlPlaneOperationBinding } from '../control-plane-operation.js';
+export declare const TREEAI_OPENAPI_DIGESTS: {
+    readonly inference: "sha256:3a00f1d91635d87d0aad2c6d329f495ff210f393bc9851570aa3e3ad1f5c1db4";
+    readonly training: "sha256:89dc70cecc85079853e4f177827d681e66f4b24b93ef17713051b99f07c2fe00";
+    readonly lab: "sha256:bccafa27b00a63b9fb22b132b850f9af6e77d44047dbc8966344088266d65898";
+    readonly qualification: "sha256:3f68b78845ec19c5de389663f1cb677ab4df0683ecd113c4f5780885a89370b7";
+};
+export declare const TREEAI_CONTROL_PLANE_OPERATION_LIST: readonly ControlPlaneOperationBinding<{
+    nodeId: string;
+}, {}, Record<string, unknown> | undefined, Record<string, unknown>>[];
+export declare const TREEAI_CONTROL_PLANE_OPERATIONS: Readonly<Record<string, ControlPlaneOperationBinding<any, any, any, any>>>;
+export declare function treeAiControlPlaneOperation(upstreamOperationId: string): ControlPlaneOperationBinding<{
+    nodeId: string;
+}, {}, Record<string, unknown> | undefined, Record<string, unknown>>;

package/dist/operator-contracts/catalog/treeai-operations.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-builder.js";
+import { TREEAI_UPSTREAM_OPERATIONS } from "../../treeai/generated/upstream.js";
+const TREEAI_OPENAPI_DIGESTS = {
+  inference: "sha256:3a00f1d91635d87d0aad2c6d329f495ff210f393bc9851570aa3e3ad1f5c1db4",
+  training: "sha256:89dc70cecc85079853e4f177827d681e66f4b24b93ef17713051b99f07c2fe00",
+  lab: "sha256:bccafa27b00a63b9fb22b132b850f9af6e77d44047dbc8966344088266d65898",
+  qualification: "sha256:3f68b78845ec19c5de389663f1cb677ab4df0683ecd113c4f5780885a89370b7"
+};
+function treeSeedOperationId(operation) {
+  return `treeai.${operation.operationId.toLowerCase().replace(/[^a-z0-9]+/gu, ".").replace(/^\.|\.$/gu, "")}`;
+}
+function risk(operation) {
+  if (/rollback|cancel|disable/u.test(operation.operationId)) return "destructive";
+  if (operation.kind === "mutation" && (/promot|enable|activate|campaigns/u.test(operation.operationId) || /(?:^|\.)mode(?:\.|$)/u.test(operation.operationId))) return "authority";
+  return "ordinary";
+}
+function pathShape(path) {
+  return Object.fromEntries([...path.matchAll(/\{([^}]+)\}/gu)].map((match) => [match[1], z.string().min(1)]));
+}
+function binding(operation) {
+  const method = operation.method;
+  const kind = operation.kind;
+  const riskClass = risk(operation);
+  const path = `/v1/ai/nodes/{nodeId}/${operation.service}${operation.path}`;
+  return defineOperation({
+    operationId: treeSeedOperationId(operation),
+    description: `${operation.summary} through a node-scoped TreeAI proxy.`,
+    rest: { method, path },
+    parameters: `treeseed.${treeSeedOperationId(operation)}.parameters/v1`,
+    capability: `treeai.${operation.service}.${kind}`,
+    authentication: "oauth_or_provider",
+    oauthScopes: kind === "read" ? ["treeseed:read"] : ["treeseed:execution"],
+    kind,
+    riskClass,
+    confirmation: riskClass === "ordinary" ? "never" : "input_required",
+    idempotencyRequired: kind === "mutation",
+    surfaces: ["rest", "cli"],
+    cacheScope: kind === "read" ? "principal" : "none",
+    pagination: "none",
+    redactedPaths: ["headers.authorization"],
+    upstream: { service: "treeai", operationId: operation.operationId, contractVersion: "3.1.1", contractDigest: TREEAI_OPENAPI_DIGESTS[operation.service] }
+  }, {
+    path: z.object({ nodeId: z.string().min(1), ...pathShape(operation.path) }).strict(),
+    query: kind === "read" ? z.record(z.unknown()) : z.object({}).strict(),
+    body: kind === "read" ? z.undefined() : z.record(z.unknown()),
+    output: z.record(z.unknown())
+  });
+}
+const TREEAI_CONTROL_PLANE_OPERATION_LIST = Object.freeze(TREEAI_UPSTREAM_OPERATIONS.map(binding));
+const TREEAI_CONTROL_PLANE_OPERATIONS = Object.freeze(Object.fromEntries(TREEAI_CONTROL_PLANE_OPERATION_LIST.map((item) => [item.descriptor.operationId, item])));
+function treeAiControlPlaneOperation(upstreamOperationId) {
+  const operation = TREEAI_CONTROL_PLANE_OPERATION_LIST.find((item) => item.descriptor.upstream?.operationId === upstreamOperationId);
+  if (!operation) throw new Error(`Unknown TreeAI operation ${upstreamOperationId}.`);
+  return operation;
+}
+export {
+  TREEAI_CONTROL_PLANE_OPERATIONS,
+  TREEAI_CONTROL_PLANE_OPERATION_LIST,
+  TREEAI_OPENAPI_DIGESTS,
+  treeAiControlPlaneOperation
+};

package/dist/operator-contracts/control-plane-operation.d.ts

@@ -28,7 +28,7 @@ export interface ControlPlaneConcurrencyContract {
     writeHeader: 'If-Match';
 }
 export interface ControlPlaneUpstreamBinding {
-    service: 'treedx';
+    service: 'treedx' | 'treeai';
     operationId: string;
     contractVersion: string;
     contractDigest: `sha256:${string}`;

package/dist/operator-contracts/control-plane-operations.d.ts

@@ -1,5 +1,6 @@
 import { type ControlPlaneOperationBinding, type ControlPlaneOperationDescriptor } from './control-plane-operation.js';
 export declare const CONTROL_PLANE_OPERATIONS: {
+    readonly treeai: Readonly<Record<string, ControlPlaneOperationBinding<any, any, any, any>>>;
     readonly status: {
         readonly show: ControlPlaneOperationBinding<{}, {}, undefined, Record<string, unknown>>;
     };
@@ -999,8 +1000,8 @@ export declare const CONTROL_PLANE_OPERATIONS: {
             }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
             readonly node: ControlPlaneOperationBinding<{
                 projectId: string;
-                repoId: string;
                 nodeId: string;
+                repoId: string;
             }, {}, Record<string, unknown> | undefined, Record<string, unknown>>;
             readonly related: ControlPlaneOperationBinding<{
                 projectId: string;

package/dist/operator-contracts/control-plane-operations.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { defineOperation as define, defineTreeDxProxyOperation as treedxProxy } from "./operation-builder.js";
 import { communicationOperations, providerDiscussionResponseOperation } from "./catalog/communication-operations.js";
 import { adminAccountOperations, adminTeamOperations } from "./catalog/admin-account-team-operations.js";
+import { TREEAI_CONTROL_PLANE_OPERATIONS } from "./catalog/treeai-operations.js";
 const empty = z.object({}).strict();
 const none = z.undefined();
 const record = z.record(z.unknown());
@@ -96,6 +97,7 @@ function resource(operationId, method, path, pathShape, options = { capability:
   }, { path: z.object(pathShape).strict(), query: kind === "read" ? record : empty, body: kind === "read" ? none : record, output: payload });
 }
 const CONTROL_PLANE_OPERATIONS = {
+  treeai: TREEAI_CONTROL_PLANE_OPERATIONS,
   status: {
     show: read("status.show", "/v1/status", "status.read", ["rest", "cli", "mcp_tool", "mcp_resource"])
   },

package/dist/treeai/catalog.d.ts

@@ -0,0 +1 @@
+export * from '../operator-contracts/catalog/treeai-operations.js';

package/dist/treeai/catalog.js

@@ -0,0 +1 @@
+export * from "../operator-contracts/catalog/treeai-operations.js";