@standardagents/cli 0.13.1 → 0.14.0

package/dist/index.js

@@ -10,7 +10,9 @@ import { parse, modify, applyEdits } from 'jsonc-parser';
 import { loadFile, writeFile, generateCode } from 'magicast';
 import { addVitePlugin } from 'magicast/helpers';
 import net from 'net';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
+import os from 'os';
+import { copySkill, readSkillFile } from '@standardagents/skill';
 
 var logger = {
   success: (message) => {
@@ -227,7 +229,7 @@ Models define which LLM provider and model to use for prompts.
 | Property | Type | Required | Description |
 |----------|------|----------|-------------|
 | \`name\` | \`string\` | Yes | Unique identifier for this model configuration |
-| \`provider\` | \`'openai' \\| 'anthropic' \\| 'openrouter' \\| 'google' \\| 'cerebras'\` | Yes | LLM provider |
+| \`provider\` | \`'openai' \\| 'anthropic' \\| 'openrouter' \\| 'google' \\| 'cerebras' \\| 'groq' \\| 'xai'\` | Yes | LLM provider |
 | \`model\` | \`string\` | Yes | Model ID sent to provider API |
 | \`fallbacks\` | \`string[]\` | No | Fallback model names to try if primary fails |
 | \`inputPrice\` | \`number\` | No | Cost per 1M input tokens (USD) |
@@ -266,10 +268,12 @@ Set these environment variables in \`.dev.vars\` (local) or Cloudflare secrets (
 | Provider | Environment Variable |
 |----------|---------------------|
 | Cerebras | \`CEREBRAS_API_KEY\` |
+| Groq | \`GROQ_API_KEY\` |
 | OpenAI | \`OPENAI_API_KEY\` |
 | Anthropic | \`ANTHROPIC_API_KEY\` |
 | OpenRouter | \`OPENROUTER_API_KEY\` |
 | Google | \`GOOGLE_API_KEY\` |
+| xAI | \`XAI_API_KEY\` |
 
 ## Fallback Strategy
 
@@ -298,7 +302,8 @@ export default defineModel({
 
 - **Name by use case**, not model ID (e.g., \`fast\`, \`default\`, \`heavy\`)
 - **Configure fallbacks** for production reliability
-- **Set pricing** for cost tracking in logs
+- **Set pricing** for cost tracking in logs when your provider or runtime does not supply it automatically
+- **Cerebras note:** documented Cerebras models have built-in fallback pricing for request logs, but custom/private Cerebras models should still set \`inputPrice\` and \`outputPrice\`
 - **Use environment variables** for API keys, never hardcode
 
 ## Documentation
@@ -529,10 +534,10 @@ Agents orchestrate conversations by defining prompts, stop conditions, and turn
 | \`stopOnResponse\` | \`boolean\` | No | Stop turn when LLM returns text (default: true) |
 | \`stopTool\` | \`string\` | No | Tool that stops this side's turn |
 | \`stopToolResponseProperty\` | \`string\` | No | Property to extract from stop tool result |
-| \`endConversationTool\` | \`string\` | No | Tool that ends the entire conversation |
-| \`failSessionTool\` | \`string\` | No | Tool that fails and ends the entire conversation |
-| \`statusTool\` | \`string\` | No | Tool that reports subagent status to a parent registry |
-| \`maxTurns\` | \`number\` | No | Maximum turns for this side |
+| \`maxSteps\` | \`number\` | No | Maximum step budget for this side |
+| \`sessionStop\` | \`string \\| SessionToolBinding\` | No | Terminal success lifecycle binding |
+| \`sessionFail\` | \`string \\| SessionToolBinding\` | No | Terminal failure lifecycle binding |
+| \`sessionStatus\` | \`string \\| SessionToolBinding\` | No | Non-terminal status lifecycle binding |
 | \`manualStopCondition\` | \`boolean\` | No | Enable custom stop handling via hooks |
 
 ## Basic Example (AI-Human)
@@ -547,8 +552,8 @@ export default defineAgent({
     label: 'Support',
     prompt: 'customer_support',
     stopOnResponse: true,
-    endConversationTool: 'close_ticket',
-    maxTurns: 50,
+    sessionStop: 'close_ticket',
+    maxSteps: 50,
   },
   tags: ['support', 'tier-1'],
 });
@@ -592,9 +597,9 @@ export default defineAgent({
   sideA: {
     label: 'Worker',
     prompt: 'research_worker',
-    statusTool: 'set_subagent_status',
-    failSessionTool: 'fail_research_subagent',
-    endConversationTool: 'finish_subagent',
+    sessionStatus: 'set_subagent_status',
+    sessionFail: 'fail_research_subagent',
+    sessionStop: 'finish_subagent',
   },
   sideB: {
     label: 'Reviewer',
@@ -624,10 +629,10 @@ Other prompts can then include the agent name in their \`tools\` array to enable
 
 ## Stop Conditions (Priority Order)
 
-1. **failSessionTool** - Ends entire conversation with a terminal failure
-2. **endConversationTool** - Ends entire conversation successfully
+1. **sessionFail** - Ends entire conversation with a terminal failure
+2. **sessionStop** - Ends entire conversation successfully
 3. **stopTool** - Ends current side's turn
-4. **maxTurns** - Ends side's participation when reached
+4. **maxSteps** - Ends side execution when the safety budget is reached
 5. **stopOnResponse** - Ends turn when LLM returns text
 6. **maxSessionTurns** - Ends conversation (hard limit: 250)
 
@@ -657,7 +662,7 @@ This convention is enforced by the builder UI and makes agents easily identifiab
 
 - **Use descriptive names** (\`customer_support_agent\` not \`agent1\`)
 - **Always use the _agent suffix** - names like \`support_agent\`, \`research_agent\`
-- **Always set maxTurns** as a safety limit
+- **Always set maxSteps or maxSessionTurns** as safety limits
 - **Match stop conditions to use case** - chat apps use stopOnResponse, workflows use stopTool
 - **Use labels** for clarity in logs and UI
 - **Organize with tags** for filtering
@@ -1273,13 +1278,15 @@ Full reference: https://docs.standardagentbuilder.com/core-concepts/api
 `;
 
 // src/commands/scaffold.ts
+function getScaffoldCompatibilityDate() {
+  return "2025-08-13";
+}
 var WRANGLER_TEMPLATE = (name) => {
-  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   return `{
   "$schema": "node_modules/wrangler/config-schema.json",
   "name": "${name}",
   "main": "worker/index.ts",
-  "compatibility_date": "${today}",
+  "compatibility_date": "${getScaffoldCompatibilityDate()}",
   "compatibility_flags": ["nodejs_compat"],
   "observability": {
     "enabled": true
@@ -1802,6 +1809,33 @@ function runCommand(command, args, cwd, env) {
 function toKebabCase(str) {
   return str.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
+function findWorkspaceRoot(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    if (fs3.existsSync(path3.join(currentDir, "pnpm-workspace.yaml"))) {
+      return currentDir;
+    }
+    const parentDir = path3.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function getPnpmWorkspaceFilterTarget(projectPath) {
+  if (process.env.STANDARDAGENTS_WORKSPACE !== "1") {
+    return null;
+  }
+  const workspaceRoot = findWorkspaceRoot(projectPath);
+  if (!workspaceRoot) {
+    return null;
+  }
+  const relativeProjectPath = path3.relative(workspaceRoot, projectPath).split(path3.sep).join("/");
+  return {
+    cwd: workspaceRoot,
+    filterTarget: relativeProjectPath.startsWith(".") ? relativeProjectPath : `./${relativeProjectPath}`
+  };
+}
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent;
   if (userAgent) {
@@ -1815,11 +1849,61 @@ function detectPackageManager() {
   if (fs3.existsSync("package-lock.json")) return "npm";
   return "npm";
 }
-function getPackageVersion() {
+function normalizeScaffoldedPackageJson(packageJson, projectName, versions) {
+  const normalized = { ...packageJson };
+  normalized.name = toKebabCase(projectName);
+  normalized.devDependencies = {
+    ...normalized.devDependencies || {},
+    vite: versions.vite,
+    typescript: versions.typescript,
+    "@cloudflare/vite-plugin": versions.cloudflareVitePlugin,
+    wrangler: versions.wrangler
+  };
+  return normalized;
+}
+function applyPackageSpecifiers(packageJson, key, specifiers) {
+  packageJson[key] = {
+    ...packageJson[key] || {}
+  };
+  for (const specifier of specifiers) {
+    const atIndex = specifier.lastIndexOf("@");
+    if (atIndex <= 0) {
+      packageJson[key][specifier] = "^4.0.0";
+      continue;
+    }
+    const name = specifier.slice(0, atIndex);
+    const version = specifier.slice(atIndex + 1);
+    packageJson[key][name] = version;
+  }
+}
+function getWorkspacePackageVersion() {
   if (process.env.STANDARDAGENTS_WORKSPACE === "1") {
     return "workspace:*";
   }
-  return "0.13.1";
+  return "0.14.0";
+}
+function getSipPackageVersion() {
+  return "1.0.1";
+}
+function getScaffoldToolchainVersions() {
+  return {
+    vite: "^7.0.6",
+    typescript: "^5.9.0",
+    cloudflareVitePlugin: "^1.17.0",
+    wrangler: "^4.54.0"
+  };
+}
+async function runPackageBinary(packageManager, binary, binaryArgs, cwd, env) {
+  switch (packageManager) {
+    case "pnpm":
+      return runCommand("pnpm", ["exec", binary, ...binaryArgs], cwd, env);
+    case "yarn":
+      return runCommand("yarn", ["exec", binary, ...binaryArgs], cwd, env);
+    case "bun":
+      return runCommand("bunx", [binary, ...binaryArgs], cwd, env);
+    default:
+      return runCommand("npx", [binary, ...binaryArgs], cwd, env);
+  }
 }
 async function selectPackageManager(detected) {
   const options = ["npm", "pnpm", "yarn", "bun"];
@@ -1953,27 +2037,40 @@ export default defineConfig({
   const packageJsonPath = path3.join(projectPath, "package.json");
   if (fs3.existsSync(packageJsonPath)) {
     const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
-    const kebabName = toKebabCase(projectName);
-    if (packageJson.name !== kebabName) {
-      packageJson.name = kebabName;
-      fs3.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
-    }
+    const normalizedPackageJson = normalizeScaffoldedPackageJson(
+      packageJson,
+      projectName,
+      getScaffoldToolchainVersions()
+    );
+    fs3.writeFileSync(packageJsonPath, JSON.stringify(normalizedPackageJson, null, 2) + "\n", "utf-8");
   }
   logger.log("");
   logger.info("Step 2: Configuring environment variables...");
   logger.log("");
   const encryptionKey = crypto.randomBytes(32).toString("hex");
+  let cloudflareToken = "";
+  let cloudflareAccountId = "";
   let cerebrasKey = "";
+  let googleKey = "";
+  let groqKey = "";
   let openrouterKey = "";
   let openaiKey = "";
+  let xaiKey = "";
   let adminPassword = "";
   if (!options.yes) {
     logger.log("API keys are optional but required to use AI models.");
     logger.log("You can add them later by editing .dev.vars");
     logger.log("");
+    cloudflareToken = await prompt("Cloudflare Workers AI API token (optional, press Enter to skip): ");
+    if (cloudflareToken) {
+      cloudflareAccountId = await prompt("Cloudflare Account ID: ");
+    }
     cerebrasKey = await prompt("Cerebras API key (optional, press Enter to skip): ");
+    googleKey = await prompt("Google Gemini API key (optional, press Enter to skip): ");
+    groqKey = await prompt("Groq API key (optional, press Enter to skip): ");
     openrouterKey = await prompt("OpenRouter API key (optional, press Enter to skip): ");
     openaiKey = await prompt("OpenAI API key (optional, press Enter to skip): ");
+    xaiKey = await prompt("xAI API key (optional, press Enter to skip): ");
     logger.log("");
     logger.log("Set a temporary admin password for development access.");
     logger.log('Press Enter to use the default password "admin".');
@@ -2003,29 +2100,78 @@ export default defineConfig({
   try {
     const installCmd = pm === "npm" ? "install" : "add";
     const devFlag = pm === "npm" ? "--save-dev" : "-D";
-    const packageVersion = getPackageVersion();
-    await runCommand(pm, [
-      installCmd,
-      devFlag,
-      "@cloudflare/vite-plugin",
-      "wrangler"
-    ], projectPath);
+    const workspacePackageVersion = getWorkspacePackageVersion();
+    const sipPackageVersion = getSipPackageVersion();
+    const isWorkspaceMode = pm === "pnpm" && process.env.STANDARDAGENTS_WORKSPACE === "1";
+    const pnpmWorkspaceFilter = pm === "pnpm" ? getPnpmWorkspaceFilterTarget(projectPath) : null;
+    const installPackages = async (packages, { dev = false } = {}) => {
+      if (pm === "pnpm" && pnpmWorkspaceFilter) {
+        await runCommand(
+          pm,
+          [
+            installCmd,
+            ...dev ? [devFlag] : [],
+            ...packages,
+            "--filter",
+            pnpmWorkspaceFilter.filterTarget
+          ],
+          pnpmWorkspaceFilter.cwd
+        );
+        return;
+      }
+      await runCommand(
+        pm,
+        [
+          installCmd,
+          ...dev ? [devFlag] : [],
+          ...packages
+        ],
+        projectPath
+      );
+    };
     const deps = [
-      `@standardagents/builder@${packageVersion}`,
-      `@standardagents/spec@${packageVersion}`,
-      `@standardagents/sip@${packageVersion}`,
+      `@standardagents/builder@${workspacePackageVersion}`,
+      `@standardagents/spec@${workspacePackageVersion}`,
+      `@standardagents/sip@${sipPackageVersion}`,
       "zod"
     ];
+    if (cloudflareToken) {
+      deps.push(`@standardagents/cloudflare@${workspacePackageVersion}`);
+    }
     if (cerebrasKey) {
-      deps.push(`@standardagents/cerebras@${packageVersion}`);
+      deps.push(`@standardagents/cerebras@${workspacePackageVersion}`);
+    }
+    if (googleKey) {
+      deps.push(`@standardagents/google@${workspacePackageVersion}`);
+    }
+    if (groqKey) {
+      deps.push(`@standardagents/groq@${workspacePackageVersion}`);
     }
     if (openaiKey) {
-      deps.push(`@standardagents/openai@${packageVersion}`);
+      deps.push(`@standardagents/openai@${workspacePackageVersion}`);
     }
     if (openrouterKey) {
-      deps.push(`@standardagents/openrouter@${packageVersion}`);
+      deps.push(`@standardagents/openrouter@${workspacePackageVersion}`);
+    }
+    if (xaiKey) {
+      deps.push(`@standardagents/xai@${workspacePackageVersion}`);
+    }
+    if (isWorkspaceMode) {
+      const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+      applyPackageSpecifiers(packageJson, "devDependencies", [
+        `@cloudflare/vite-plugin@${getScaffoldToolchainVersions().cloudflareVitePlugin}`,
+        `wrangler@${getScaffoldToolchainVersions().wrangler}`
+      ]);
+      applyPackageSpecifiers(packageJson, "dependencies", deps);
+      fs3.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+      logger.info("Workspace mode detected: wrote dependency specs to package.json and deferred install.");
+    } else {
+      await installPackages([
+        `@cloudflare/vite-plugin@${getScaffoldToolchainVersions().cloudflareVitePlugin}`,
+        `wrangler@${getScaffoldToolchainVersions().wrangler}`
+      ], { dev: true });
+      await installPackages(deps);
     }
-    await runCommand(pm, [installCmd, ...deps], projectPath);
   } catch (error) {
     logger.error("Failed to install dependencies");
     process.exit(1);
@@ -2052,11 +2198,28 @@ export default defineConfig({
     "# AI Provider API Keys",
     "# Uncomment and add your keys as needed"
   ];
+  if (cloudflareToken) {
+    devVarsLines.push(`CLOUDFLARE_API_TOKEN=${cloudflareToken}`);
+    devVarsLines.push(`CLOUDFLARE_ACCOUNT_ID=${cloudflareAccountId}`);
+  } else {
+    devVarsLines.push("# CLOUDFLARE_API_TOKEN=your-cloudflare-workers-ai-token");
+    devVarsLines.push("# CLOUDFLARE_ACCOUNT_ID=your-cloudflare-account-id");
+  }
   if (cerebrasKey) {
     devVarsLines.push(`CEREBRAS_API_KEY=${cerebrasKey}`);
   } else {
     devVarsLines.push("# CEREBRAS_API_KEY=your-cerebras-key");
   }
+  if (googleKey) {
+    devVarsLines.push(`GOOGLE_API_KEY=${googleKey}`);
+  } else {
+    devVarsLines.push("# GOOGLE_API_KEY=your-google-gemini-key");
+  }
+  if (groqKey) {
+    devVarsLines.push(`GROQ_API_KEY=${groqKey}`);
+  } else {
+    devVarsLines.push("# GROQ_API_KEY=your-groq-key");
+  }
   if (openrouterKey) {
     devVarsLines.push(`OPENROUTER_API_KEY=${openrouterKey}`);
   } else {
@@ -2067,6 +2230,11 @@ export default defineConfig({
   } else {
     devVarsLines.push("# OPENAI_API_KEY=your-openai-key");
   }
+  if (xaiKey) {
+    devVarsLines.push(`XAI_API_KEY=${xaiKey}`);
+  } else {
+    devVarsLines.push("# XAI_API_KEY=your-xai-key");
+  }
   devVarsLines.push("");
   const devVarsPath = path3.join(projectPath, ".dev.vars");
   fs3.writeFileSync(devVarsPath, devVarsLines.join("\n"), "utf-8");
@@ -2082,10 +2250,14 @@ export default defineConfig({
   logger.log("");
   logger.info("Step 5: Generating Cloudflare types...");
   logger.log("");
-  try {
-    await runCommand("npx", ["wrangler", "types"], projectPath);
-  } catch (error) {
-    logger.warning('Could not generate types automatically. Run "npx wrangler types" manually.');
+  if (pm === "pnpm" && process.env.STANDARDAGENTS_WORKSPACE === "1") {
+    logger.info("Workspace mode detected: skipping Wrangler type generation until dependencies are installed.");
+  } else {
+    try {
+      await runPackageBinary(pm, "wrangler", ["types"], projectPath);
+    } catch (error) {
+      logger.warning("Could not generate types automatically. Run your package manager's Wrangler types command manually.");
+    }
   }
   logger.log("");
   logger.success("Project created successfully!");
@@ -3337,10 +3509,609 @@ async function deploy(options) {
     process.exit(1);
   }
 }
+var DEFAULT_SKILL_NAME = "agentbuilder";
+function resolveCodexHome(env = process.env, homeDir = os.homedir()) {
+  return env.CODEX_HOME || path3.join(homeDir, ".codex");
+}
+function resolveClaudeHome(homeDir = os.homedir()) {
+  return path3.join(homeDir, ".claude");
+}
+function expandHomePath(inputPath, homeDir = os.homedir()) {
+  if (inputPath === "~") {
+    return homeDir;
+  }
+  if (inputPath.startsWith("~/")) {
+    return path3.join(homeDir, inputPath.slice(2));
+  }
+  return inputPath;
+}
+function buildInstallTargets(options = {}, env = process.env, homeDir = os.homedir()) {
+  const customRoot = options.dir ? path3.resolve(expandHomePath(options.dir, homeDir)) : null;
+  const codexHome = resolveCodexHome(env, homeDir);
+  const claudeHome = resolveClaudeHome(homeDir);
+  return [
+    {
+      id: "codex",
+      label: "Codex",
+      summary: "Install as a Codex skill folder",
+      detected: fs3.existsSync(codexHome),
+      installPath: customRoot ?? path3.join(codexHome, "skills")
+    },
+    {
+      id: "claude",
+      label: "Claude Code",
+      summary: "Install as a Claude Code user subagent",
+      detected: fs3.existsSync(claudeHome),
+      installPath: customRoot ?? path3.join(claudeHome, "agents")
+    }
+  ];
+}
+function resolveSelectedTarget(targetId, options = {}, env = process.env, homeDir = os.homedir()) {
+  const target = buildInstallTargets(options, env, homeDir).find(
+    (candidate) => candidate.id === targetId
+  );
+  if (!target) {
+    throw new Error(`Unknown install target "${targetId}".`);
+  }
+  return target;
+}
+function buildClaudeSubagentMarkdown(skillName, description, body) {
+  const normalizedBody = body.replace(/^\uFEFF/, "").trim();
+  return [
+    "---",
+    `name: ${skillName}`,
+    `description: ${description}`,
+    "---",
+    "",
+    normalizedBody,
+    ""
+  ].join("\n");
+}
+async function selectInstallTarget(targets) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let selectedIndex = 0;
+    const render = (initial = false) => {
+      const lines = [];
+      lines.push("Choose where to install the AgentBuilder skill:");
+      lines.push("");
+      for (let i = 0; i < targets.length; i++) {
+        const target = targets[i];
+        const isSelected = i === selectedIndex;
+        const cursor = isSelected ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const title = isSelected ? "\x1B[36m" : "\x1B[90m";
+        const detection = target.detected ? "\x1B[32m(detected)\x1B[0m" : "\x1B[90m(not found yet)\x1B[0m";
+        lines.push(`${cursor} ${title}${target.label}\x1B[0m ${detection}`);
+        lines.push(`  ${target.summary}`);
+        lines.push(`  ${target.installPath}`);
+        lines.push("");
+      }
+      lines.push("Use arrows to move, Enter to install, Ctrl+C to cancel.");
+      if (!initial) {
+        stdout.write("\x1B[?25l");
+        stdout.write(`\x1B[${lines.length}A`);
+        stdout.write("\x1B[0J");
+      }
+      stdout.write(lines.join("\n") + "\n");
+    };
+    render(true);
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stdout.write("\x1B[?25h");
+    };
+    const onData = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        selectedIndex = (selectedIndex - 1 + targets.length) % targets.length;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        selectedIndex = (selectedIndex + 1) % targets.length;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve(targets[selectedIndex]);
+      } else if (key === "") {
+        cleanup();
+        stdout.write("\n");
+        process.exit(1);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function installBundledSkill(targetId, skillName = DEFAULT_SKILL_NAME, options = {}) {
+  const target = resolveSelectedTarget(targetId, options);
+  if (target.id === "codex") {
+    const targetDir = path3.join(target.installPath, skillName);
+    if (fs3.existsSync(targetDir) && !options.force) {
+      throw new Error(
+        `Skill already exists at ${targetDir}. Re-run with --force to overwrite it.`
+      );
+    }
+    return copySkill(skillName, target.installPath, {
+      overwrite: options.force ?? false
+    });
+  }
+  const targetFile = path3.join(target.installPath, `${skillName}.md`);
+  if (fs3.existsSync(targetFile) && !options.force) {
+    throw new Error(
+      `Claude subagent already exists at ${targetFile}. Re-run with --force to overwrite it.`
+    );
+  }
+  const skillBody = await readSkillFile(skillName);
+  const subagentMarkdown = buildClaudeSubagentMarkdown(
+    skillName,
+    "Use for Standard Agents and AgentBuilder architecture, composition, subagent design, and implementation work.",
+    skillBody
+  );
+  fs3.mkdirSync(target.installPath, { recursive: true });
+  fs3.writeFileSync(targetFile, subagentMarkdown, "utf8");
+  return targetFile;
+}
+function isInteractiveTerminal() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function skill(options = {}) {
+  try {
+    const selectedTarget = options.agent ? resolveSelectedTarget(options.agent, options) : isInteractiveTerminal() ? await selectInstallTarget(buildInstallTargets(options)) : resolveSelectedTarget("codex", options);
+    logger.log("");
+    logger.info(`Installing AgentBuilder skill into ${selectedTarget.label}...`);
+    const installedPath = await installBundledSkill(
+      selectedTarget.id,
+      DEFAULT_SKILL_NAME,
+      options
+    );
+    logger.success(`Installed ${DEFAULT_SKILL_NAME} into ${selectedTarget.label}`);
+    logger.log("");
+    logger.log(`Path: ${installedPath}`);
+    logger.log("");
+    logger.log("Next steps:");
+    if (selectedTarget.id === "codex") {
+      logger.log("  Restart Codex if it is already running");
+      logger.log(`  Edit ${path3.join(installedPath, "SKILL.md")} to continue customizing the skill`);
+    } else {
+      logger.log("  Restart Claude Code if it is already running");
+      logger.log(`  Edit ${installedPath} to continue customizing the subagent`);
+    }
+  } catch (error) {
+    logger.log("");
+    logger.error(error instanceof Error ? error.message : "Failed to install skill");
+    process.exit(1);
+  }
+}
+var UUID_LIKE_MODEL_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var CLOUDFLARE_PROVIDER_MODEL_ID = /^@cf\//i;
+var PAGE_SIZE = 100;
+var MAX_PAGES = 1e3;
+var CURRENT_MODELS_URLS = [
+  "https://standardagentspec.org/models.md",
+  "https://standardagentspec.com/models.md"
+];
+var PROVIDER_DEFINITIONS = [
+  {
+    name: "cloudflare",
+    packageName: "@standardagents/cloudflare",
+    exportName: "cloudflare",
+    label: "Cloudflare Workers AI",
+    envKeys: ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"]
+  },
+  {
+    name: "cerebras",
+    packageName: "@standardagents/cerebras",
+    exportName: "cerebras",
+    label: "Cerebras",
+    envKeys: ["CEREBRAS_API_KEY"]
+  },
+  {
+    name: "google",
+    packageName: "@standardagents/google",
+    exportName: "google",
+    label: "Google Gemini",
+    envKeys: ["GOOGLE_API_KEY"]
+  },
+  {
+    name: "groq",
+    packageName: "@standardagents/groq",
+    exportName: "groq",
+    label: "Groq",
+    envKeys: ["GROQ_API_KEY"]
+  },
+  {
+    name: "openai",
+    packageName: "@standardagents/openai",
+    exportName: "openai",
+    label: "OpenAI",
+    envKeys: ["OPENAI_API_KEY"]
+  },
+  {
+    name: "openrouter",
+    packageName: "@standardagents/openrouter",
+    exportName: "openrouter",
+    label: "OpenRouter",
+    envKeys: ["OPENROUTER_API_KEY"]
+  },
+  {
+    name: "xai",
+    packageName: "@standardagents/xai",
+    exportName: "xai",
+    label: "xai",
+    envKeys: ["XAI_API_KEY"]
+  }
+];
+function isOpaqueModelId(modelId) {
+  if (!modelId) return true;
+  return UUID_LIKE_MODEL_ID.test(modelId) || CLOUDFLARE_PROVIDER_MODEL_ID.test(modelId);
+}
+function getProviderDefinition(name) {
+  return PROVIDER_DEFINITIONS.find((provider) => provider.name === name);
+}
+function parseEnvFile2(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const withoutExport = trimmed.startsWith("export ") ? trimmed.slice("export ".length).trim() : trimmed;
+    const eqIndex = withoutExport.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = withoutExport.slice(0, eqIndex).trim();
+    let value = withoutExport.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1).replace(/\\"/g, '"');
+    } else if (value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = path3.resolve(startDir);
+  while (true) {
+    if (fs3.existsSync(path3.join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    const parentDir = path3.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return path3.resolve(startDir);
+    }
+    currentDir = parentDir;
+  }
+}
+function readProjectPackageJson(projectRoot) {
+  const packagePath = path3.join(projectRoot, "package.json");
+  if (!fs3.existsSync(packagePath)) {
+    return {};
+  }
+  return JSON.parse(fs3.readFileSync(packagePath, "utf8"));
+}
+function getDeclaredProviderPackages(projectRoot) {
+  const pkg = readProjectPackageJson(projectRoot);
+  const combined = {
+    ...pkg.dependencies ?? {},
+    ...pkg.devDependencies ?? {},
+    ...pkg.optionalDependencies ?? {},
+    ...pkg.peerDependencies ?? {}
+  };
+  return PROVIDER_DEFINITIONS.map((provider) => provider.packageName).filter((packageName) => typeof combined[packageName] === "string");
+}
+function resolvePackageEntry(packageName, projectRoot) {
+  const packageDir = findInstalledPackageDir(packageName, projectRoot);
+  if (!packageDir) {
+    return null;
+  }
+  const packageJsonPath = path3.join(packageDir, "package.json");
+  try {
+    const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+    const exportPath = resolvePackageExportPath(packageJson.exports) || packageJson.main || "index.js";
+    return path3.join(packageDir, exportPath);
+  } catch {
+    return null;
+  }
+}
+function findInstalledPackageDir(packageName, projectRoot) {
+  let currentDir = path3.resolve(projectRoot);
+  while (true) {
+    const candidate = path3.join(currentDir, "node_modules", ...packageName.split("/"));
+    if (fs3.existsSync(candidate)) {
+      return candidate;
+    }
+    const parentDir = path3.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolvePackageExportPath(exportsField) {
+  if (typeof exportsField === "string") {
+    return exportsField;
+  }
+  if (!exportsField || typeof exportsField !== "object") {
+    return null;
+  }
+  const rootExport = exportsField["."];
+  if (typeof rootExport === "string") {
+    return rootExport;
+  }
+  if (!rootExport || typeof rootExport !== "object") {
+    return null;
+  }
+  const rootExportRecord = rootExport;
+  const candidate = rootExportRecord.import || rootExportRecord.default || rootExportRecord.require;
+  return typeof candidate === "string" ? candidate : null;
+}
+function isProviderPackageInstalled(packageName, projectRoot) {
+  return resolvePackageEntry(packageName, projectRoot) !== null;
+}
+function loadProjectEnv(projectRoot, processEnv = process.env) {
+  const result = {};
+  const envFiles = [".env", ".env.local", ".dev.vars", ".dev.vars.local"];
+  for (const fileName of envFiles) {
+    const filePath = path3.join(projectRoot, fileName);
+    if (!fs3.existsSync(filePath)) continue;
+    Object.assign(result, parseEnvFile2(fs3.readFileSync(filePath, "utf8")));
+  }
+  for (const [key, value] of Object.entries(processEnv)) {
+    if (typeof value === "string") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function detectProviders(projectRoot, env = loadProjectEnv(projectRoot)) {
+  const declaredPackages = new Set(getDeclaredProviderPackages(projectRoot));
+  return PROVIDER_DEFINITIONS.filter((provider) => declaredPackages.has(provider.packageName)).map((provider) => {
+    const installed = isProviderPackageInstalled(provider.packageName, projectRoot);
+    const missingEnvKeys = provider.envKeys.filter((envKey) => !env[envKey]);
+    return {
+      ...provider,
+      declared: true,
+      installed,
+      configured: installed && missingEnvKeys.length === 0,
+      missingEnvKeys
+    };
+  });
+}
+async function loadProviderFactory(provider, projectRoot) {
+  const entryPath = resolvePackageEntry(provider.packageName, projectRoot);
+  if (!entryPath) {
+    throw new Error(`Provider package ${provider.packageName} is not installed in ${projectRoot}.`);
+  }
+  const moduleUrl = entryPath.startsWith("file:") ? entryPath : pathToFileURL(entryPath).href;
+  const providerModule = await import(moduleUrl);
+  const factory = providerModule[provider.exportName];
+  if (typeof factory !== "function") {
+    throw new Error(`Provider package ${provider.packageName} does not export ${provider.exportName}().`);
+  }
+  return factory;
+}
+function buildProviderConfig(provider, env) {
+  const apiKey = env[provider.envKeys[0]] || "";
+  if (provider.name === "cloudflare") {
+    const accountId = env.CLOUDFLARE_ACCOUNT_ID;
+    return {
+      apiKey,
+      accountId,
+      baseUrl: accountId ? `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/v1` : void 0
+    };
+  }
+  return { apiKey };
+}
+async function collectProviderModels(providerName, providerInstance) {
+  const rawModels = [];
+  if (providerInstance.getModelsPage) {
+    for (let page = 1; page <= MAX_PAGES; page += 1) {
+      const result = await providerInstance.getModelsPage({ page, perPage: PAGE_SIZE });
+      rawModels.push(...result.models);
+      if (!result.hasNextPage) {
+        return normalizeProviderModels(providerName, rawModels);
+      }
+    }
+    throw new Error(`Provider ${providerName} exceeded ${MAX_PAGES} model pages without terminating pagination.`);
+  }
+  if (providerInstance.getModels) {
+    rawModels.push(...await providerInstance.getModels());
+    return normalizeProviderModels(providerName, rawModels);
+  }
+  throw new Error(`Provider ${providerName} does not support model discovery.`);
+}
+async function fetchAvailableModelsForProvider(providerName, projectRoot, env, factoryLoader = loadProviderFactory) {
+  const provider = getProviderDefinition(providerName);
+  if (!provider) {
+    throw new Error(`Unknown provider "${providerName}".`);
+  }
+  const factory = await factoryLoader(provider, projectRoot);
+  const providerInstance = factory(buildProviderConfig(provider, env));
+  return collectProviderModels(provider.name, providerInstance);
+}
+async function fetchCurrentModelsMarkdown(urls = CURRENT_MODELS_URLS) {
+  let lastError = null;
+  for (const url of urls) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status} ${response.statusText}`.trim());
+      }
+      return {
+        url,
+        content: await response.text()
+      };
+    } catch (error) {
+      lastError = error instanceof Error ? new Error(`Failed to fetch ${url}: ${error.message}`) : new Error(`Failed to fetch ${url}.`);
+    }
+  }
+  throw lastError ?? new Error("No current models URLs configured.");
+}
+function buildProviderSelectionHelp(providers) {
+  const providerNames = providers.map((provider) => provider.name).join(", ");
+  const examples = providers.map((provider) => `  agents available-models --provider=${provider.name}`).join("\n");
+  return [
+    `Multiple configured providers were found: ${providerNames}`,
+    "Re-run with a specific provider to fetch all model IDs:",
+    examples
+  ].join("\n");
+}
+function describeProviderAvailability(provider) {
+  if (!provider.installed) {
+    return `${provider.name}: not installed`;
+  }
+  if (provider.missingEnvKeys.length > 0) {
+    return `${provider.name}: missing ${provider.missingEnvKeys.join(", ")}`;
+  }
+  return `${provider.name}: unavailable`;
+}
+function formatAvailableModelsOutput(provider, models) {
+  const lines = [
+    `# ${provider.label} models`,
+    "",
+    "Use the `model` values exactly as shown in `defineModel({ model: ... })`.",
+    "",
+    "| model | label | context | notes |",
+    "| --- | --- | ---: | --- |"
+  ];
+  for (const model of models) {
+    const context = model.contextLength ? model.contextLength.toLocaleString("en-US") : "";
+    lines.push(
+      `| \`${escapeTableCell(model.value)}\` | ${escapeTableCell(model.label)} | ${context} | ${escapeTableCell(model.description)} |`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+function normalizeProviderModels(providerName, rawModels) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const model of rawModels) {
+    const value = getExecutableModelId(providerName, model);
+    if (!value) continue;
+    if (!deduped.has(value)) {
+      deduped.set(value, {
+        value,
+        label: model.name || value,
+        description: model.description || "",
+        contextLength: model.contextLength,
+        slug: model.slug
+      });
+    }
+  }
+  return [...deduped.values()].sort((left, right) => left.value.localeCompare(right.value));
+}
+function getExecutableModelId(providerName, model) {
+  if (model.id && !isOpaqueModelId(model.id)) {
+    return model.id;
+  }
+  if (providerName === "cloudflare") {
+    const publicCloudflareId = [model.name, model.slug].find((value) => typeof value === "string" && value.includes("/"));
+    if (publicCloudflareId) {
+      return publicCloudflareId.startsWith("@cf/") ? publicCloudflareId : `@cf/${publicCloudflareId.replace(/^@cf\//, "")}`;
+    }
+  }
+  return model.slug || model.name || model.id;
+}
+function escapeTableCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/\n/g, "<br />");
+}
+
+// src/commands/current-models.ts
+async function currentModels(options = {}) {
+  try {
+    const { content } = await fetchCurrentModelsMarkdown(
+      options.url ? [options.url] : void 0
+    );
+    process.stdout.write(content.endsWith("\n") ? content : `${content}
+`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to fetch current models.";
+    process.stderr.write(`${message}
+`);
+    process.exit(1);
+  }
+}
+
+// src/commands/available-models.ts
+function writeError(message) {
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+}
+async function availableModels(options = {}) {
+  const projectRoot = findProjectRoot(process.cwd());
+  const env = loadProjectEnv(projectRoot);
+  const detectedProviders = detectProviders(projectRoot, env);
+  if (detectedProviders.length === 0) {
+    writeError(
+      [
+        `No installed provider packages were found in ${projectRoot}.`,
+        "Add a provider package such as `@standardagents/cerebras`, then run this command again."
+      ].join("\n")
+    );
+  }
+  const providerName = options.provider?.trim();
+  if (providerName) {
+    const provider2 = detectedProviders.find((candidate) => candidate.name === providerName);
+    if (!getProviderDefinition(providerName)) {
+      writeError(
+        `Unknown provider "${providerName}". Supported providers: ${detectedProviders.map((candidate) => candidate.name).join(", ")}.`
+      );
+    }
+    if (!provider2) {
+      writeError(
+        [
+          `Provider "${providerName}" is not installed in ${projectRoot}.`,
+          `Install ${getProviderDefinition(providerName)?.packageName || providerName} and try again.`
+        ].join("\n")
+      );
+    }
+    if (!provider2.configured) {
+      writeError(
+        [
+          `Provider "${providerName}" is missing required environment variables.`,
+          `Missing: ${provider2.missingEnvKeys.join(", ")}`
+        ].join("\n")
+      );
+    }
+    try {
+      const models = await fetchAvailableModelsForProvider(provider2.name, projectRoot, env);
+      process.stdout.write(formatAvailableModelsOutput(provider2, models));
+      return;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : `Failed to fetch models for ${providerName}.`;
+      writeError(message);
+    }
+  }
+  const configuredProviders = detectedProviders.filter((provider2) => provider2.configured);
+  if (configuredProviders.length === 0) {
+    const missingSummary = detectedProviders.map((provider2) => describeProviderAvailability(provider2)).join("\n");
+    writeError(
+      [
+        "No installed providers are fully configured yet.",
+        missingSummary
+      ].join("\n")
+    );
+  }
+  if (configuredProviders.length > 1) {
+    writeError(buildProviderSelectionHelp(configuredProviders));
+  }
+  const provider = configuredProviders[0];
+  try {
+    const models = await fetchAvailableModelsForProvider(provider.name, projectRoot, env);
+    process.stdout.write(formatAvailableModelsOutput(provider, models));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : `Failed to fetch models for ${provider.name}.`;
+    writeError(message);
+  }
+}
 
 // src/index.ts
 var program = new Command();
-program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.13.1");
+program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.14.0");
 program.command("init [project-name]").description("Create a new Standard Agents project (runs create vite, then scaffold)").option("-y, --yes", "Skip prompts and use defaults").option("--template <template>", "Vite template to use", "vanilla-ts").action(init);
 program.command("scaffold").description("Add Standard Agents to an existing Vite project").option("--force", "Overwrite existing configuration").action(scaffold);
 program.command("init-chat [project-name]").description("Scaffold a frontend chat application").option("-y, --yes", "Skip prompts and use defaults").option("--framework <framework>", "Framework to use (vite or nextjs)").action(initChat);
@@ -3348,6 +4119,9 @@ program.command("pack [agent-name]").description("Pack an agent with all its dep
 program.command("unpack [package]").description("Unpack a packed agent to the local agents directory").option("--no-signatures", "Remove package signatures (fully editable)").action(unpack);
 program.command("list-packed").description("List all discovered packed agents").action(listPacked);
 program.command("deploy").description("Build and deploy your project to the Standard Agents platform").option("--api-key <key>", "Platform API key (overrides PLATFORM_API_KEY env var)").option("--endpoint <url>", "Platform API endpoint (default: https://api.standardagents.ai)").action(deploy);
+program.command("skill").description("Install the bundled AgentBuilder guidance into a supported coding agent").option("--agent <target>", "Install target: codex or claude").option("--dir <path>", "Install directory override for the selected target").option("--force", "Overwrite an existing installed skill").action(skill);
+program.command("current-models").description("Print the live curated model guide from standardagentspec.com").option("--url <url>", "Override the models markdown URL").action(currentModels);
+program.command("available-models").description("List every available model for one configured provider in the current project").option("--provider <provider>", "Provider to query, for example cerebras or openai").action(availableModels);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map