@m6d/cortex-cli 0.8.1 → 0.10.0

package/README.md

@@ -44,8 +44,8 @@ hard error rather than a hang.
 | `--control-center` / `--no-control-center` | off        | `controlCenter`                                                           |
 | `--yes`                                    |            | Accept the defaults instead of asking                                     |
 
-Unselected features are still written to `cortex.config.ts`, commented out, alongside `fastModel`,
-`reranker`, and `context` — the generated config documents what else exists. Every credential and
+Unselected features are still written to `cortex.config.ts`, commented out, alongside `reranker`
+and `context` — the generated config documents what else exists. Every credential and
 URL is a placeholder in `.env`; none of them is prompted for.
 
 ## `cortex swagger sync` / `check`

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@m6d/cortex-cli",
-    "version": "0.8.1",
+    "version": "0.10.0",
     "description": "Scaffold and operate Cortex servers",
     "license": "MIT",
     "type": "module",

package/src/contracts/runtime/api.ts

@@ -14,6 +14,7 @@ import {
     variableDeclarationSchema,
 } from "./grammar";
 import { publishedAuthSchema } from "./auth";
+import { runtimeModelsSchema } from "./models";
 import { triggerDeclarationSchema } from "./triggers";
 import { datasetHostDeclarationSchema, datasetIdentifierSchema } from "./datasets";
 
@@ -115,7 +116,7 @@ const toolSignatureBaseSchema = z.object({
      * binding, so the schema travels with it.
      */
     requiresApproval: z.boolean(),
-    /** The question the widget asks before an approval-gated call runs; only such tools carry one. */
+    /** The action the widget's approval card names before an approval-gated call runs; only such tools carry one. */
     approvalMessage: localizedTextSchema.optional(),
     tags: z.array(z.string()),
     signature: z.string(),
@@ -216,6 +217,12 @@ export const runtimeAgentConfigSchema = z.object({
     suggestions: suggestionsSchema,
     /** Operational like `suggestions`. */
     greeting: greetingSchema,
+    /**
+     * The model picks of the agent's server and of the agent, with the
+     * providers they and the agent's triggers name. Operational like
+     * `greeting`: edited without republishing.
+     */
+    models: runtimeModelsSchema,
     /** The resolved agent's id; reports about it carry this so they attach to it whatever the slug or alias later means. */
     agentRef: agentRefSchema,
     catalogVersion: catalogVersionSchema,

package/src/contracts/runtime/index.ts

@@ -7,6 +7,7 @@ export * from "./grammar";
 export * from "./auth";
 export * from "./api";
 export * from "./triggers";
+export * from "./models";
 export * from "./datasets";
 export * from "./dataset-sql";
 export * from "./dataset-sql-guide";

package/src/contracts/runtime/models.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+/**
+ * One level's pick of what a run talks to: a model a Control Center
+ * provider lists, the reasoning effort sent with it, both, or neither. An
+ * unset part inherits from the level above (trigger, then agent, then
+ * server, then the server's code config). An effort carries down only as
+ * far as the level that picked the model, and is sent only when that
+ * model's provider lists it.
+ */
+export const modelChoiceSchema = z
+    .object({
+        provider: z.string().min(1).nullable(),
+        model: z.string().min(1).nullable(),
+        effort: z.string().min(1).nullable(),
+    })
+    .refine((choice) => (choice.provider === null) === (choice.model === null), {
+        error: "A provider and its model are picked together.",
+    });
+export type ModelChoice = z.infer<typeof modelChoiceSchema>;
+
+/** A pick that inherits everything. */
+export const INHERIT_MODEL = {
+    provider: null,
+    model: null,
+    effort: null,
+} satisfies ModelChoice;
+
+/**
+ * An OpenAI-compatible endpoint as a server calls it: cc resolves the key
+ * from the provider's secret, and `efforts` are the values it accepts as
+ * `reasoning_effort`.
+ */
+export const modelProviderEndpointSchema = z.object({
+    baseURL: z.url(),
+    apiKey: z.string().min(1),
+    efforts: z.array(z.string().min(1)),
+});
+
+/**
+ * The model picks a server needs to run one agent: its server's and the
+ * agent's own (each trigger carries its own on its declaration), plus every
+ * provider any of them names.
+ */
+export const runtimeModelsSchema = z.object({
+    providers: z.record(z.string(), modelProviderEndpointSchema),
+    server: modelChoiceSchema,
+    agent: modelChoiceSchema,
+});
+export type RuntimeModels = z.infer<typeof runtimeModelsSchema>;

package/src/contracts/runtime/triggers.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { datasetIdentifierSchema } from "./datasets";
+import { modelChoiceSchema } from "./models";
 import {
     agentRefSchema,
     agentSlugSchema,
@@ -122,6 +123,8 @@ export const triggerDeclarationSchema = z.object({
     /** Consecutive failed or rejected firings before the trigger disables itself. */
     disableAfterFailures: z.number().int().positive(),
     hasCredential: z.boolean(),
+    /** What runs of this trigger talk to, over the agent's pick; read live like the credential. */
+    modelChoice: modelChoiceSchema,
     /**
      * sha256 of the fire secret, so a server checks a presented bearer in
      * process; the Control Center hears only about console test secrets,

package/src/contracts/wire/index.ts

@@ -142,8 +142,15 @@ export type Greeting = Record<Locale, string>;
 export type LocalizedText = Record<Locale, string>;
 
 /**
- * What cortex stamps on a tool-call part's `metadata.cortex`: the sentence
- * the widget asks with when the call needs the user's approval, in the
+ * Cortex's own tools whose input carries `status`: the model's one-line
+ * statement of the call, which the widget draws in place of a generic label.
+ * Any other tool's `status` is that tool's own data.
+ */
+export const STATEMENT_TOOLS = ["executeCode", "queryDataset", "describeDataset"] as const;
+
+/**
+ * What cortex stamps on a tool-call part's `metadata.cortex`: the action the
+ * approval card names when the call needs the user's approval, in the
  * author's words rather than the function's name.
  */
 export type ToolCallMetadata = {

package/src/scaffold/files.ts

@@ -27,7 +27,7 @@ export type Database = "postgres" | "mssql";
 // sync (scripts/sync-package-versions.ts) restamps it and files.test.ts holds
 // them to that.
 export const DEPENDENCIES = {
-    "@m6d/cortex-server": "~0.8.1",
+    "@m6d/cortex-server": "~0.10.0",
     "@tanstack/ai": "^0.55.0",
     "@tanstack/ai-openai": "^0.22.8",
     hono: "^4.12.3",
@@ -86,18 +86,10 @@ function packageJson(name: string) {
 
 /**
  * Never toggled, so they only ever appear commented out: `context` is fully
- * defaulted, and the other two are what you reach for once a real problem shows
- * up — noisy graph retrieval, a cheap-model path — not on day one.
+ * defaulted, and `reranker` is what you reach for once graph retrieval comes
+ * back noisy, not on day one.
  */
 const NEVER_SCAFFOLDED = [
-    [
-        "A cheaper, faster model for auxiliary passes. Same shape as `model`.",
-        `fastModel: {
-    baseURL: process.env["CORTEX_FAST_MODEL_URL"]!,
-    apiKey: process.env["CORTEX_FAST_MODEL_KEY"]!,
-    modelName: process.env["CORTEX_FAST_MODEL_NAME"]!,
-},`,
-    ],
     [
         "Re-ranks knowledge-graph retrieval when it comes back noisy.",
         `reranker: {