@formthefog/stratus 2026.2.24 → 2026.3.20

package/index.ts

@@ -4,6 +4,9 @@ import type { StratusPluginConfig } from "./src/types.js";
 import { createStratusClient } from "./src/client.js";
 import { StratusConfigSchema } from "./src/config.js";
 import { setupStratus } from "./src/setup.js";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 
 const PROVIDER_ID = "stratus";
 const PROVIDER_LABEL = "Stratus";
@@ -26,59 +29,108 @@ function buildModelDefinition(params: {
   };
 }
 
-const STRATUS_SIZES = ["small", "base", "large", "xl", "huge"] as const;
-
-const OPENAI_MODELS = [
-  { id: "gpt-4o", name: "GPT-4o", context: 128000, tokens: 8192 },
-  { id: "gpt-4o-mini", name: "GPT-4o Mini", context: 128000, tokens: 8192 },
-  { id: "gpt-4-turbo", name: "GPT-4 Turbo", context: 128000, tokens: 4096 },
-  { id: "gpt-4", name: "GPT-4", context: 8192, tokens: 4096 },
-  { id: "gpt-3.5-turbo", name: "GPT-3.5 Turbo", context: 16385, tokens: 4096 },
-] as const;
-
-const ANTHROPIC_MODELS = [
-  { id: "claude-sonnet-4-5", name: "Claude 4.5 Sonnet", context: 200000, tokens: 8192 },
-  { id: "claude-opus-4-5", name: "Claude 4.5 Opus", context: 200000, tokens: 8192 },
-  { id: "claude-sonnet-4", name: "Claude 4 Sonnet", context: 200000, tokens: 8192 },
-  { id: "claude-opus-4", name: "Claude 4 Opus", context: 200000, tokens: 8192 },
-  { id: "claude-haiku-4-5", name: "Claude 4.5 Haiku", context: 200000, tokens: 8192 },
-  { id: "claude-3-7-sonnet", name: "Claude 3.7 Sonnet", context: 200000, tokens: 8192 },
-  { id: "claude-3-5-sonnet", name: "Claude 3.5 Sonnet", context: 200000, tokens: 8192 },
-  { id: "claude-3-opus", name: "Claude 3 Opus", context: 200000, tokens: 4096 },
-  { id: "claude-3-sonnet", name: "Claude 3 Sonnet", context: 200000, tokens: 4096 },
-  { id: "claude-3-haiku", name: "Claude 3 Haiku", context: 200000, tokens: 4096 },
-] as const;
-
-function generateAllModels() {
-  const models = [];
-
-  for (const size of STRATUS_SIZES) {
-    const sizeLabel = size.charAt(0).toUpperCase() + size.slice(1);
-
-    for (const llm of OPENAI_MODELS) {
-      models.push(
-        buildModelDefinition({
-          id: `stratus-x1ac-${size}-${llm.id}`,
-          name: `Stratus X1AC ${sizeLabel} (${llm.name})`,
-          contextWindow: llm.context,
-          maxTokens: llm.tokens,
-        }),
-      );
-    }
+// Model metadata for naming/context/tokens (fallback if API doesn't provide details)
+const MODEL_METADATA: Record<string, { name: string; context: number; tokens: number }> = {
+  "gpt-4o": { name: "GPT-4o", context: 128000, tokens: 8192 },
+  "gpt-4o-mini": { name: "GPT-4o Mini", context: 128000, tokens: 8192 },
+  "gpt-4-turbo": { name: "GPT-4 Turbo", context: 128000, tokens: 4096 },
+  "gpt-4": { name: "GPT-4", context: 8192, tokens: 4096 },
+  "gpt-3.5-turbo": { name: "GPT-3.5 Turbo", context: 16385, tokens: 4096 },
+  "claude-sonnet-4-6": { name: "Claude 4.6 Sonnet", context: 200000, tokens: 8192 },
+  "claude-opus-4-6": { name: "Claude 4.6 Opus", context: 200000, tokens: 8192 },
+  "claude-sonnet-4-5": { name: "Claude 4.5 Sonnet", context: 200000, tokens: 8192 },
+  "claude-opus-4-5": { name: "Claude 4.5 Opus", context: 200000, tokens: 8192 },
+  "claude-haiku-4-5": { name: "Claude 4.5 Haiku", context: 200000, tokens: 8192 },
+  "claude-sonnet-4": { name: "Claude 4 Sonnet", context: 200000, tokens: 8192 },
+  "claude-opus-4-1": { name: "Claude 4.1 Opus", context: 200000, tokens: 8192 },
+  "claude-opus-4": { name: "Claude 4 Opus", context: 200000, tokens: 8192 },
+  "claude-3-7-sonnet": { name: "Claude 3.7 Sonnet", context: 200000, tokens: 8192 },
+  "claude-3-5-sonnet": { name: "Claude 3.5 Sonnet", context: 200000, tokens: 8192 },
+  "claude-3-opus": { name: "Claude 3 Opus", context: 200000, tokens: 4096 },
+  "claude-3-sonnet": { name: "Claude 3 Sonnet", context: 200000, tokens: 4096 },
+  "claude-3-haiku": { name: "Claude 3 Haiku", context: 200000, tokens: 4096 },
+  "gemini-2.0-flash": { name: "Gemini 2.0 Flash", context: 1048576, tokens: 8192 },
+  "gemini-1.5-pro": { name: "Gemini 1.5 Pro", context: 2097152, tokens: 8192 },
+  "gemini-1.5-flash": { name: "Gemini 1.5 Flash", context: 1048576, tokens: 8192 },
+  "gemini-pro": { name: "Gemini Pro", context: 32768, tokens: 8192 },
+};
 
-    for (const llm of ANTHROPIC_MODELS) {
-      models.push(
-        buildModelDefinition({
-          id: `stratus-x1ac-${size}-${llm.id}`,
-          name: `Stratus X1AC ${sizeLabel} (${llm.name})`,
-          contextWindow: llm.context,
-          maxTokens: llm.tokens,
-        }),
-      );
-    }
+function generateModelName(modelId: string): string {
+  // Parse model ID like "stratus-x1ac-base-claude-sonnet-4-5"
+  const parts = modelId.split("-");
+  
+  // Extract size (small/base/large/xl/huge)
+  let size = "";
+  let baseModelId = "";
+  
+  if (parts.length >= 4 && parts[0] === "stratus" && parts[1] === "x1ac") {
+    size = parts[2];
+    baseModelId = parts.slice(3).join("-");
+  } else {
+    // Fallback for non-standard format
+    return modelId;
+  }
+  
+  const sizeLabel = size.charAt(0).toUpperCase() + size.slice(1);
+  const metadata = MODEL_METADATA[baseModelId];
+  
+  if (metadata) {
+    return `Stratus X1AC ${sizeLabel} (${metadata.name})`;
   }
+  
+  // Fallback: capitalize base model
+  return `Stratus X1AC ${sizeLabel} (${baseModelId})`;
+}
 
-  return models;
+async function generateAllModels(apiKey?: string, baseUrl?: string) {
+  const root = (baseUrl || DEFAULT_BASE_URL).replace(/\/v\d+\/?$/, "");
+  try {
+    const url = `${root}/v1/models`;
+    const headers: Record<string, string> = {};
+    if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+
+    const response = await fetch(url, { headers, signal: AbortSignal.timeout(5000) });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const data = await response.json() as { data: Array<{ id: string }> };
+
+    return data.data.map((model) => {
+      const modelId = model.id;
+      const baseModelId = modelId.replace(/^stratus-x1ac-(small|base|large|xl|huge)-/, "");
+      const metadata = MODEL_METADATA[baseModelId];
+      return buildModelDefinition({
+        id: modelId,
+        name: generateModelName(modelId),
+        contextWindow: metadata?.context || 128000,
+        maxTokens: metadata?.tokens || 8192,
+      });
+    });
+  } catch (error) {
+    console.error("[stratus] Failed to fetch models from API:", error);
+    return [
+      buildModelDefinition({
+        id: "stratus-x1ac-base-claude-sonnet-4-5",
+        name: "Stratus X1AC Base (Claude 4.5 Sonnet)",
+        contextWindow: 200000,
+        maxTokens: 8192,
+      }),
+    ];
+  }
+}
+
+async function updateStoredModels(models: ReturnType<typeof buildModelDefinition>[]) {
+  const configPath = join(homedir(), ".openclaw", "openclaw.json");
+  if (!existsSync(configPath)) return;
+
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    if (!config?.models?.providers?.stratus) return;
+
+    config.models.providers.stratus.models = models;
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+  } catch {
+    // Silent fail — stale models are better than a crash
+  }
 }
 
 const stratusPlugin = {
@@ -98,15 +150,13 @@ const stratusPlugin = {
       auth: [
         {
           id: "api-key",
-          label: "API Key",
+          label: "API Key (optional — Formation pool available)",
           kind: "api_key",
           run: async (ctx) => {
             const apiKey = await ctx.prompter.text({
-              message: "Enter your Stratus API key:",
+              message: "Enter your Stratus API key (leave blank for Formation pool — zero-config):",
               validate: (val: string) => {
-                if (!val.trim()) {
-                  return "API key is required";
-                }
+                if (!val.trim()) return undefined;
                 if (!val.startsWith("stratus_sk_")) {
                   return "API key must start with 'stratus_sk_'";
                 }
@@ -114,36 +164,30 @@ const stratusPlugin = {
               },
             });
 
-            const profileId = `${PROVIDER_ID}:default`;
+            const usingPool = !apiKey?.trim();
+            const resolvedKey = usingPool ? undefined : apiKey;
+            const profileId = `${PROVIDER_ID}:${usingPool ? "formation-pool" : "default"}`;
+
+            const models = await generateAllModels(resolvedKey, DEFAULT_BASE_URL);
+
+            const credential = usingPool
+              ? { type: "formation_pool" as const, provider: PROVIDER_ID }
+              : { type: "api_key" as const, provider: PROVIDER_ID, key: resolvedKey! };
+
+            const authMode = usingPool
+              ? "Formation pool (zero-config, 25% markup)"
+              : "BYOK (no markup)";
 
             return {
-              profiles: [
-                {
-                  profileId,
-                  credential: {
-                    type: "api_key",
-                    provider: PROVIDER_ID,
-                    key: apiKey,
-                  },
-                },
-              ],
+              profiles: [{ profileId, credential }],
               configPatch: {
                 models: {
                   providers: {
                     [PROVIDER_ID]: {
                       baseUrl: DEFAULT_BASE_URL,
-                      apiKey: apiKey,
+                      ...(resolvedKey ? { apiKey: resolvedKey } : {}),
                       api: "openai-completions",
-                      models: generateAllModels(),
-                    },
-                  },
-                },
-                agents: {
-                  defaults: {
-                    models: {
-                      [`${PROVIDER_ID}/stratus-x1ac-base-claude-sonnet-4-5`]: {
-                        alias: "stratus",
-                      },
+                      models: models,
                     },
                   },
                 },
@@ -152,20 +196,26 @@ const stratusPlugin = {
               notes: [
                 "🌊 Stratus X1-AC: World Model + Collective Intelligence System",
                 "",
+                `🔒 Auth: ${authMode}`,
+                "",
                 "NOT just an LLM wrapper — this is predictive planning:",
                 "  Traditional agents: see → think → act → see again",
                 "  Stratus agents: see → simulate outcomes → pick best → act",
                 "",
                 "Architecture:",
                 "  • World Model (X1): Predicts future states from actions (JEPA-based)",
-                "  • Policy Head (X1-AC): Selects optimal actions toward goals",
+                "  • Policy Head v3 (X1-AC): 94.4% accuracy, brain-guided action sequencing",
                 "  • Collective Network: Agents learn from each other in real-time",
                 "",
+                `Loaded ${models.length} models dynamically from Stratus API`,
+                "  2050+ models via OpenRouter — OpenAI, Anthropic, Google, and more",
+                "  BYOK support: pass your own provider keys to bypass Formation pool",
+                "",
                 "Available Tools:",
                 "  • stratus_embeddings() - 768-dim semantic state embeddings",
-                "  • stratus_rollout() - Multi-step action sequence planning",
+                "  • stratus_rollout() - Multi-step action sequence planning (Policy Head v3)",
                 "",
-                "Learn more: /stratus-info (bundled skill)",
+                "Commands: /stratus setup | /stratus verify | /stratus models",
                 "Technical docs: https://stratus.run/docs/technical-overview",
               ],
             };
@@ -174,6 +224,42 @@ const stratusPlugin = {
       ],
     });
 
+    api.on("gateway_start", async () => {
+      const apiKey = pluginConfig.apiKey || process.env.STRATUS_API_KEY;
+      try {
+        const models = await generateAllModels(apiKey, pluginConfig.baseUrl);
+        await updateStoredModels(models);
+      } catch {
+        // Silent fail — don't disrupt gateway startup
+      }
+
+      if (apiKey) {
+        try {
+          const authPath = join(homedir(), ".openclaw", "agents", "main", "agent", "auth-profiles.json");
+          let authConfig: any = { version: 1, profiles: {}, lastGood: {}, usageStats: {} };
+          if (existsSync(authPath)) {
+            authConfig = JSON.parse(readFileSync(authPath, "utf-8"));
+          }
+          const existingProfile = authConfig.profiles["stratus:default"];
+          if (!existingProfile || existingProfile.key !== apiKey) {
+            authConfig.profiles["stratus:default"] = {
+              type: "api_key",
+              provider: "stratus",
+              key: apiKey,
+            };
+            authConfig.lastGood.stratus = "stratus:default";
+            const authDir = join(homedir(), ".openclaw", "agents", "main", "agent");
+            if (!existsSync(authDir)) {
+              mkdirSync(authDir, { recursive: true });
+            }
+            writeFileSync(authPath, JSON.stringify(authConfig, null, 2));
+          }
+        } catch {
+          // Silent fail — don't disrupt gateway startup
+        }
+      }
+    });
+
     if (!pluginConfig.tools?.embeddings?.enabled && !pluginConfig.tools?.rollout?.enabled) {
       return;
     }
@@ -285,11 +371,24 @@ const stratusPlugin = {
               ? `Successfully planned ${steps.length} steps to reach goal`
               : `Planning incomplete (${steps.length} steps generated)`;
 
+            const meta = response.metadata;
+            const metaLines: string[] = [];
+            if (meta?.brain_confidence != null) {
+              metaLines.push(`Brain confidence: ${(meta.brain_confidence * 100).toFixed(1)}%`);
+            }
+            if (meta?.brain_goal_proximity != null) {
+              metaLines.push(`Goal proximity: ${(meta.brain_goal_proximity * 100).toFixed(1)}%`);
+            }
+            if (meta?.key_source) {
+              metaLines.push(`Key source: ${meta.key_source}${meta.formation_markup_applied ? ` (${meta.formation_markup_applied * 100}% markup)` : ""}`);
+            }
+            const metaText = metaLines.length > 0 ? `\n\n${metaLines.join("\n")}` : "";
+
             return {
               content: [
                 {
                   type: "text",
-                  text: `${summary}\nGoal: ${response.goal}\n\nSteps:\n${stepText}`,
+                  text: `${summary}\nGoal: ${response.goal}\n\nSteps:\n${stepText}${metaText}`,
                 },
               ],
               details: response,
@@ -312,8 +411,10 @@ const stratusPlugin = {
           const subcommand = (tokens[0] || "help").toLowerCase();
 
           if (subcommand === "setup") {
-            // Run setup
-            const result = await setupStratus(ctx.prompter);
+            const keyArg = tokens[1];
+            const result = keyArg
+              ? await setupStratus({ apiKey: keyArg, silent: true })
+              : await setupStratus(ctx.prompter);
 
             if (result.success) {
               console.log(`\n✅ ${result.message}\n`);
@@ -327,52 +428,92 @@ const stratusPlugin = {
               }
               process.exit(1);
             }
-            return { text: "" }; // Return empty to avoid double output
+            return { text: "" };
+          } else if (subcommand === "models") {
+            const apiKey = pluginConfig.apiKey || process.env.STRATUS_API_KEY;
+            const models = await generateAllModels(apiKey, pluginConfig.baseUrl);
+
+            await updateStoredModels(models);
+
+            const sizes = ["small", "base", "large", "xl", "huge"];
+            const grouped = sizes
+              .map((size) => {
+                const sizeModels = models.filter(
+                  (m) => m.id.includes(`-x1ac-${size}-`) || m.id.endsWith(`-x1ac-${size}`)
+                );
+                if (sizeModels.length === 0) return null;
+                return `  ${size.toUpperCase()} (${sizeModels.length})\n` +
+                  sizeModels.map((m) => `    • ${m.id}`).join("\n");
+              })
+              .filter(Boolean)
+              .join("\n\n");
+
+            return {
+              text:
+                `Stratus Models (${models.length} total)\n` +
+                `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n` +
+                grouped +
+                `\n\nConfig synced. Run /models to see the full list.`,
+            };
           } else if (subcommand === "verify") {
-            // Run verify
             console.log("🔍 Verifying Stratus configuration...\n");
 
-            let errors = 0;
+            const hasKey = !!(pluginConfig.apiKey || process.env.STRATUS_API_KEY);
 
-            // Check 1: Environment variable
-            console.log("1️⃣  Checking STRATUS_API_KEY...");
-            if (process.env.STRATUS_API_KEY) {
-              console.log("   ✓ STRATUS_API_KEY is set");
+            console.log("1️⃣  Auth mode:");
+            if (hasKey) {
+              console.log("   ✓ BYOK — using STRATUS_API_KEY (no markup)");
             } else {
-              console.log("   ❌ STRATUS_API_KEY not found");
-              errors++;
+              console.log("   ✓ Formation pool — zero-config (25% markup)");
+              console.log("   💡 Set STRATUS_API_KEY to remove markup");
             }
 
-            // Check 2: Config exists
-            console.log("\n2️⃣  Checking plugin configuration...");
-            if (pluginConfig.apiKey || process.env.STRATUS_API_KEY) {
-              console.log("   ✓ API key configured");
-            } else {
-              console.log("   ❌ API key not configured");
-              errors++;
+            console.log("\n2️⃣  API connectivity...");
+            try {
+              const models = await generateAllModels(
+                hasKey ? (pluginConfig.apiKey || process.env.STRATUS_API_KEY) : undefined,
+                pluginConfig.baseUrl,
+              );
+              console.log(`   ✓ Connected — ${models.length} models available`);
+            } catch {
+              console.log("   ⚠ Could not reach API (may still work at runtime)");
             }
 
-            console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
-            if (errors === 0) {
-              console.log("✅ All checks passed!");
-              console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
-              console.log("🎯 Try it out:");
-              console.log("   openclaw agent 'Hello Stratus!' --model stratus\n");
-            } else {
-              console.log(`❌ ${errors} issue(s) found`);
-              console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
-              console.log("💡 Run: openclaw stratus setup\n");
-              process.exit(1);
+            console.log("\n3️⃣  Inline BYOK keys:");
+            const envKeys = [
+              ["OPENAI_API_KEY", process.env.OPENAI_API_KEY],
+              ["ANTHROPIC_API_KEY", process.env.ANTHROPIC_API_KEY],
+              ["GOOGLE_API_KEY", process.env.GOOGLE_API_KEY],
+            ] as const;
+            let anyInline = false;
+            for (const [name, val] of envKeys) {
+              if (val) {
+                console.log(`   ✓ ${name} detected (BYOK passthrough)`);
+                anyInline = true;
+              }
             }
-            return { text: "" }; // Return empty to avoid double output
+            if (!anyInline) {
+              console.log("   – None set (optional — Formation pool covers all providers)");
+            }
+
+            console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+            console.log("✅ Stratus is ready!");
+            console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
+            console.log("🎯 Try it out:");
+            console.log("   openclaw agent 'Hello Stratus!' --model stratus\n");
+            return { text: "" };
           } else {
-            // Show help
             return {
               text:
                 "🌊 Stratus X1-AC Plugin\n\n" +
                 "Commands:\n" +
-                "  /stratus setup   - Interactive setup wizard\n" +
-                "  /stratus verify  - Verify configuration\n\n" +
+                "  /stratus setup                    - Interactive setup wizard (Formation pool)\n" +
+                "  /stratus setup <stratus_sk_...>   - Non-interactive setup with API key\n" +
+                "  /stratus verify                   - Verify configuration & connectivity\n" +
+                "  /stratus models                   - List all available models (live from API)\n\n" +
+                "Agent/programmatic setup:\n" +
+                "  /stratus setup stratus_sk_your_key_here\n" +
+                "  # Or: set STRATUS_API_KEY env var → gateway auto-configures on start\n\n" +
                 "Get your API key: https://stratus.run\n" +
                 "Docs: https://stratus.run/docs\n" +
                 "Issues: https://github.com/formthefog/openclaw-stratus-x1-plugin/issues",

package/openclaw.plugin.json

@@ -12,46 +12,70 @@
         "default": true,
         "description": "Enable Stratus plugin"
       },
-      "apiKey": {
-        "type": "string",
-        "description": "Stratus API key (or use STRATUS_API_KEY env var)"
-      },
-      "baseUrl": {
-        "type": "string",
-        "default": "https://api.stratus.run",
-        "description": "Stratus API base URL"
-      },
-      "provider": {
+      "config": {
         "type": "object",
+        "description": "Stratus plugin configuration",
         "properties": {
-          "enabled": {
-            "type": "boolean",
-            "default": true
+          "apiKey": {
+            "type": "string",
+            "description": "Stratus API key (optional — Formation pool used as fallback)"
           },
-          "defaultModel": {
+          "baseUrl": {
             "type": "string",
-            "default": "stratus-x1ac-base-claude-sonnet-4-5"
-          }
-        }
-      },
-      "tools": {
-        "type": "object",
-        "properties": {
-          "embeddings": {
+            "default": "https://api.stratus.run",
+            "description": "Stratus API base URL"
+          },
+          "inlineKeys": {
             "type": "object",
+            "description": "Optional BYOK keys passed per-request to bypass Formation pool",
             "properties": {
-              "enabled": {
-                "type": "boolean",
-                "default": true
+              "openai_key": {
+                "type": "string",
+                "description": "OpenAI API key for BYOK passthrough"
+              },
+              "anthropic_key": {
+                "type": "string",
+                "description": "Anthropic API key for BYOK passthrough"
+              },
+              "gemini_key": {
+                "type": "string",
+                "description": "Google Gemini API key for BYOK passthrough (also sent as X-Google-Key header)"
               }
             }
           },
-          "rollout": {
+          "provider": {
             "type": "object",
             "properties": {
               "enabled": {
                 "type": "boolean",
                 "default": true
+              },
+              "defaultModel": {
+                "type": "string",
+                "default": "stratus-x1ac-base-claude-sonnet-4-5"
+              }
+            }
+          },
+          "tools": {
+            "type": "object",
+            "properties": {
+              "embeddings": {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean",
+                    "default": true
+                  }
+                }
+              },
+              "rollout": {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean",
+                    "default": true
+                  }
+                }
               }
             }
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formthefog/stratus",
-  "version": "2026.2.24",
+  "version": "2026.3.20",
   "description": "Stratus API integration for OpenClaw - action-conditioned JEPA for autonomous agent planning",
   "keywords": [
     "agent",