@standardagents/cli 0.13.2 → 0.14.0

package/dist/index.js

@@ -10,7 +10,7 @@ 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';
 
@@ -534,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)
@@ -552,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'],
 });
@@ -597,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',
@@ -629,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)
 
@@ -662,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
@@ -1278,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
@@ -1807,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) {
@@ -1820,15 +1849,62 @@ function detectPackageManager() {
   if (fs3.existsSync("package-lock.json")) return "npm";
   return "npm";
 }
+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.2";
+  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"];
   const detectedIndex = options.indexOf(detected);
@@ -1961,11 +2037,12 @@ 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...");
@@ -2025,12 +2102,33 @@ export default defineConfig({
     const devFlag = pm === "npm" ? "--save-dev" : "-D";
     const workspacePackageVersion = getWorkspacePackageVersion();
     const sipPackageVersion = getSipPackageVersion();
-    await runCommand(pm, [
-      installCmd,
-      devFlag,
-      "@cloudflare/vite-plugin",
-      "wrangler"
-    ], projectPath);
+    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@${workspacePackageVersion}`,
       `@standardagents/spec@${workspacePackageVersion}`,
@@ -2058,7 +2156,22 @@ export default defineConfig({
     if (xaiKey) {
       deps.push(`@standardagents/xai@${workspacePackageVersion}`);
     }
-    await runCommand(pm, [installCmd, ...deps], projectPath);
+    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);
+    }
   } catch (error) {
     logger.error("Failed to install dependencies");
     process.exit(1);
@@ -2137,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!");
@@ -3570,10 +3687,431 @@ async function skill(options = {}) {
     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.2");
+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);
@@ -3582,6 +4120,8 @@ program.command("unpack [package]").description("Unpack a packed agent to the lo
 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