@m6d/cortex-cli 0.18.0 → 0.19.0

package/src/contracts/manifest/index.ts

@@ -1476,22 +1476,6 @@ export const agentSettingsSchema = z.strictObject({
     /** Off, end users cannot message the agent: only its triggers reach it. */
     messageTrigger: z.boolean().default(true),
     defaultLocale: localeSchema.default(BASE_LOCALE),
-    rateLimits: z
-        .strictObject({
-            allUsers: z
-                .strictObject({
-                    messagesPerMinute: rateLimit(agentRateLimits.messagesPerMinute, "allUsers"),
-                    tokensPerDay: rateLimit(agentRateLimits.tokensPerDay, "allUsers"),
-                })
-                .prefault({}),
-            perUser: z
-                .strictObject({
-                    messagesPerMinute: rateLimit(agentRateLimits.messagesPerMinute, "perUser"),
-                    tokensPerDay: rateLimit(agentRateLimits.tokensPerDay, "perUser"),
-                })
-                .prefault({}),
-        })
-        .prefault({}),
     context: z
         .strictObject({
             maxContextTokens: setting(agentContext.maxContextTokens),
@@ -1536,9 +1520,34 @@ const manifestAgentSchema = z.strictObject({
         })
         .default({}),
     settings: agentSettingsSchema.prefault({}),
+    /** Messages a minute and model tokens a UTC day, for all users together and for each; null, no limit. */
+    rateLimits: z
+        .strictObject({
+            allUsers: z
+                .strictObject({
+                    messagesPerMinute: rateLimit(agentRateLimits.messagesPerMinute, "allUsers"),
+                    tokensPerDay: rateLimit(agentRateLimits.tokensPerDay, "allUsers"),
+                })
+                .prefault({}),
+            perUser: z
+                .strictObject({
+                    messagesPerMinute: rateLimit(agentRateLimits.messagesPerMinute, "perUser"),
+                    tokensPerDay: rateLimit(agentRateLimits.tokensPerDay, "perUser"),
+                })
+                .prefault({}),
+        })
+        .prefault({}),
     suggestions: suggestionsSchema.default(() => byLocale(() => [])),
     greeting: greetingSchema.default(() => byLocale(() => "")),
-    overridable: overridable(["name", "prompt", "models", "settings", "suggestions", "greeting"]),
+    overridable: overridable([
+        "name",
+        "prompt",
+        "models",
+        "settings",
+        "rateLimits",
+        "suggestions",
+        "greeting",
+    ]),
 });
 export type ManifestAgent = z.input<typeof manifestAgentSchema>;
 

package/src/management/client.ts

@@ -2,7 +2,8 @@ import { createHash } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
-import { isRecord } from "@cortex/contracts/json";
+import { createManagementClient, MANAGEMENT_BASE_PATH } from "@cortex/contracts/management";
+import type { ManagementTarget } from "@cortex/contracts/management";
 import { z } from "zod";
 
 import { profilesPath } from "./profiles";
@@ -109,7 +110,7 @@ export async function loadOpenApi(url: string) {
     const path = cachePath(url);
     const cached = readCache(path);
     try {
-        const response = await fetch(`${url}/api/management/openapi.json`, {
+        const response = await fetch(`${url}${MANAGEMENT_BASE_PATH}/openapi.json`, {
             headers: cached ? { "If-None-Match": cached.etag } : {},
         });
         if (response.status === 304 && cached)
@@ -159,71 +160,28 @@ export function inputSchemaOf(operation: OpenApiOperation) {
 }
 
 /**
- * One management call. A query's input object is spread over the query
- * string, one parameter per field, with a scalar written plainly and
- * anything else JSON-encoded, which is how the document declares it. A
- * mutation posts its input as the JSON body. A refusal throws
- * `ManagementError` with the error body's code, message, detail and sentence.
+ * Where `profile`'s management calls go; a Cortex that does not answer at
+ * all rejects as `UnreachableError`, apart from one that refused.
  */
-export async function callManagement(
-    profile: { url: string; key: string },
-    method: "get" | "post",
-    path: string,
-    input: unknown,
-) {
-    const base = `${profile.url}/api/management${path}`;
-    const url = method === "get" && isRecord(input) ? `${base}${queryString(input)}` : base;
-    const response = await fetch(url, {
-        method: method.toUpperCase(),
-        headers: {
-            Authorization: `Bearer ${profile.key}`,
-            ...(method === "post" ? { "Content-Type": "application/json" } : {}),
-        },
-        body: method === "post" && input !== undefined ? JSON.stringify(input) : undefined,
-    }).catch((error: unknown) => {
-        throw new UnreachableError(error);
-    });
-    const body: unknown = await response.json().catch(() => null);
-    if (!response.ok) {
-        const { code, message, refusal, cause } = (body ?? {}) as {
-            code?: string;
-            message?: string;
-            refusal?: string;
-            cause?: unknown;
-        };
-        throw new ManagementError(
-            response.status,
-            code ?? "error",
-            message ?? response.statusText,
-            isRecord(cause) ? cause : undefined,
-            refusal,
-        );
-    }
-    return body;
-}
-
-function isScalar(value: unknown): value is string | number | boolean | null {
-    return value === null || ["string", "number", "boolean"].includes(typeof value);
+export function managementTarget(profile: { url: string; key: string }) {
+    return {
+        ...profile,
+        fetch: (url: string, init: RequestInit) =>
+            fetch(url, init).catch((error: unknown) => {
+                throw new UnreachableError(error);
+            }),
+    } satisfies ManagementTarget;
 }
 
-/** A scalar as itself, an array of scalars as a repeated parameter, anything else as JSON, matching what the document declares. */
-function queryString(input: Record<string, unknown>) {
-    const params = new URLSearchParams();
-    for (const [name, value] of Object.entries(input)) {
-        if (value === undefined) continue;
-        if (isScalar(value)) params.set(name, String(value));
-        else if (Array.isArray(value) && value.length > 0 && value.every(isScalar)) {
-            for (const item of value) params.append(name, String(item));
-        } else params.set(name, JSON.stringify(value));
-    }
-    const encoded = params.toString();
-    return encoded === "" ? "" : `?${encoded}`;
+/** The typed client for the calls the CLI makes by name, over `managementTarget`. */
+export function managementClient(profile: { url: string; key: string }) {
+    return createManagementClient(managementTarget(profile));
 }
 
 /**
  * Cortex did not answer at all: refused, reset, unresolvable. `fetch` rejects
  * only for these, with whatever its runtime throws (Bun's is a plain `Error`
- * with a `code`), so `callManagement` names them once here.
+ * with a `code`), so `managementTarget` names them once here.
  */
 export class UnreachableError extends Error {
     public constructor(cause: unknown) {
@@ -231,21 +189,3 @@ export class UnreachableError extends Error {
         this.name = "UnreachableError";
     }
 }
-
-/**
- * A refusal; `detail` is what the refusal names, when it names something (an
- * entry, the row holding a name), and `refusal` the sentence Cortex words it
- * in, when it has one.
- */
-export class ManagementError extends Error {
-    public constructor(
-        public readonly status: number,
-        public readonly code: string,
-        message: string,
-        public readonly detail?: Record<string, unknown>,
-        public readonly refusal?: string,
-    ) {
-        super(message);
-        this.name = "ManagementError";
-    }
-}

package/src/scaffold/files.ts

@@ -29,7 +29,7 @@ import { applyPorts, type Ports } from "@/scaffold/ports";
  * `@m6d/cortex` range below are stamped by scripts/sync-package-versions.ts
  * before the CLI publishes, so a scaffold pins what was current then.
  */
-const CORTEX_VERSION = "0.17.0";
+const CORTEX_VERSION = "0.18.0";
 
 /** This machine as Cortex's containers name it: the one private host the stack's egress policy admits. */
 export const DOCKER_HOST = "host.docker.internal";
@@ -150,7 +150,7 @@ function packageJson({ name, datasets, setup }: Project) {
                 verify: "bun run format:check && bun run lint && bun run spellcheck && bun run check && bun run audit",
             },
             dependencies: {
-                "@m6d/cortex": "~0.5.0",
+                "@m6d/cortex": "~0.6.0",
                 // drizzle 1.0 is in beta; this is the build `@m6d/cortex/drizzle` is tested against.
                 ...(datasets ? { "drizzle-orm": "1.0.0-beta.15-859cf75" } : {}),
                 hono: "^4.12.3",