@runtypelabs/cli 2.13.0 → 2.15.0

package/dist/index.js

@@ -131,8 +131,8 @@ var init_credential_store = __esm({
 });
 
 // src/index.ts
-import { Command as Command24 } from "commander";
-import chalk31 from "chalk";
+import { Command as Command25 } from "commander";
+import chalk32 from "chalk";
 
 // src/lib/load-env.ts
 import { readFileSync } from "fs";
@@ -35408,15 +35408,17 @@ var FlowInputSchema = external_exports.object({
   id: external_exports.string().min(1).optional(),
   name: external_exports.string().min(1).optional(),
   description: external_exports.string().optional(),
-  steps: external_exports.array(external_exports.any()).optional()
+  steps: external_exports.array(external_exports.any()).optional(),
+  contentHash: external_exports.string().length(64).optional()
 }).refine(
   (data) => {
     const hasFlowId = !!data.id;
     const hasSteps = !!(data.name && data.steps && data.steps.length > 0);
-    return hasFlowId || hasSteps;
+    const hasPersistedFlow = !!(data.name && data.contentHash);
+    return hasFlowId || hasSteps || hasPersistedFlow;
   },
   {
-    message: "Either 'id' or flow definition with 'name' and 'steps' must be provided."
+    message: "Either 'id', flow definition with 'name' and 'steps', or persisted flow with 'name' and 'contentHash' must be provided."
   }
 );
 var AgentLoopConfigSchema = external_exports.object({
@@ -52940,9 +52942,283 @@ flowVersionsCommand.command("publish <flowId>").description("Publish a version")
   await waitUntilExit();
 });
 
-// src/commands/tail.ts
+// src/commands/agent-versions.ts
 import { Command as Command21 } from "commander";
 import chalk27 from "chalk";
+import React19 from "react";
+import { render as render19 } from "ink";
+import { useState as useState33, useEffect as useEffect30 } from "react";
+import { Text as Text35 } from "ink";
+var agentVersionsCommand = new Command21("agent-versions").description(
+  "Manage agent versions"
+);
+agentVersionsCommand.command("list <agentId>").description("List all versions for an agent").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (agentId, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const client = new ApiClient(apiKey);
+  if (!isTTY(options) || options.json) {
+    try {
+      const data = await client.get(`/agent-versions/${agentId}`);
+      if (options.json) {
+        printJson(data);
+      } else {
+        const versions = data.versions ?? [];
+        if (versions.length === 0) {
+          console.log(chalk27.gray("No versions found"));
+          return;
+        }
+        console.log(chalk27.cyan(`Versions for agent ${agentId}:`));
+        for (const v of versions) {
+          const isPublished = v.id === data.publishedVersionId;
+          const liveTag = isPublished ? chalk27.green(" [live]") : "";
+          const versionLabel = v.label || (v.versionNumber !== void 0 ? `v${v.versionNumber}` : v.id);
+          const date5 = v.createdAt ? chalk27.gray(` ${v.createdAt}`) : "";
+          console.log(`  ${chalk27.green(v.id)} ${versionLabel}${liveTag}${date5}`);
+        }
+      }
+    } catch (error51) {
+      const message = error51 instanceof Error ? error51.message : "Unknown error";
+      console.error(chalk27.red("Failed to fetch versions"));
+      console.error(chalk27.red(message));
+      process.exit(1);
+    }
+    return;
+  }
+  const App = () => {
+    const [loading, setLoading] = useState33(true);
+    const [items, setItems] = useState33(null);
+    const [publishedId, setPublishedId] = useState33(null);
+    const [error51, setError] = useState33(null);
+    useEffect30(() => {
+      const run = async () => {
+        try {
+          const data = await client.get(`/agent-versions/${agentId}`);
+          setItems(data.versions ?? []);
+          setPublishedId(data.publishedVersionId ?? null);
+          setLoading(false);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+          setLoading(false);
+        }
+      };
+      run();
+    }, []);
+    return React19.createElement(DataList, {
+      title: `Versions for agent ${agentId}`,
+      items,
+      error: error51,
+      loading,
+      emptyMessage: "No versions found",
+      renderCard: (item) => {
+        const v = item;
+        const liveTag = v.id === publishedId ? " [live]" : "";
+        const versionLabel = v.label || (v.versionNumber !== void 0 ? `v${v.versionNumber}` : v.id);
+        return React19.createElement(
+          Text35,
+          null,
+          `  ${v.id} ${versionLabel}${liveTag}${v.createdAt ? ` ${v.createdAt}` : ""}`
+        );
+      }
+    });
+  };
+  const { waitUntilExit } = render19(React19.createElement(App));
+  await waitUntilExit();
+});
+agentVersionsCommand.command("get <agentId> <versionId>").description("Get a specific version").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(
+  async (agentId, versionId, options) => {
+    const apiKey = await ensureAuth();
+    if (!apiKey) return;
+    const client = new ApiClient(apiKey);
+    if (!isTTY(options) || options.json) {
+      try {
+        const data = await client.get(`/agent-versions/${agentId}/${versionId}`);
+        if (options.json) {
+          printJson(data);
+        } else {
+          printDetail("Agent Version", [
+            { label: "ID", value: data.id },
+            { label: "Agent ID", value: data.agentId },
+            { label: "Version", value: data.versionNumber },
+            { label: "Type", value: data.versionType },
+            { label: "Label", value: data.label ?? void 0 },
+            { label: "Notes", value: data.notes ?? void 0 },
+            { label: "Created", value: data.createdAt }
+          ]);
+        }
+      } catch (error51) {
+        const message = error51 instanceof Error ? error51.message : "Unknown error";
+        console.error(chalk27.red("Failed to fetch version"));
+        console.error(chalk27.red(message));
+        process.exit(1);
+      }
+      return;
+    }
+    const App = () => {
+      const [loading, setLoading] = useState33(true);
+      const [success2, setSuccess] = useState33(null);
+      const [error51, setError] = useState33(null);
+      const [resultNode, setResultNode] = useState33(void 0);
+      useEffect30(() => {
+        const run = async () => {
+          try {
+            const data = await client.get(`/agent-versions/${agentId}/${versionId}`);
+            setResultNode(
+              React19.createElement(EntityCard, {
+                fields: [
+                  { label: "ID", value: data.id },
+                  { label: "Agent ID", value: data.agentId },
+                  { label: "Version", value: data.versionNumber },
+                  { label: "Type", value: data.versionType },
+                  { label: "Label", value: data.label ?? void 0 },
+                  { label: "Notes", value: data.notes ?? void 0 },
+                  { label: "Created", value: data.createdAt }
+                ]
+              })
+            );
+            setSuccess(true);
+            setLoading(false);
+          } catch (err) {
+            setError(err instanceof Error ? err : new Error(String(err)));
+            setSuccess(false);
+            setLoading(false);
+          }
+        };
+        run();
+      }, []);
+      return React19.createElement(MutationResult, {
+        loading,
+        loadingLabel: "Fetching version...",
+        success: success2,
+        successMessage: "Agent Version",
+        error: error51,
+        result: resultNode
+      });
+    };
+    const { waitUntilExit } = render19(React19.createElement(App));
+    await waitUntilExit();
+  }
+);
+agentVersionsCommand.command("published <agentId>").description("Get the published version for an agent").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (agentId, options) => {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const client = new ApiClient(apiKey);
+  if (!isTTY(options) || options.json) {
+    try {
+      const data = await client.get(`/agent-versions/${agentId}/published`);
+      if (options.json) {
+        printJson(data);
+      } else {
+        printDetail("Published Version", [
+          { label: "ID", value: data.id },
+          { label: "Version", value: data.versionNumber },
+          { label: "Label", value: data.label ?? void 0 },
+          { label: "Created", value: data.createdAt }
+        ]);
+      }
+    } catch (error51) {
+      const message = error51 instanceof Error ? error51.message : "Unknown error";
+      console.error(chalk27.red("Failed to fetch published version"));
+      console.error(chalk27.red(message));
+      process.exit(1);
+    }
+    return;
+  }
+  const App = () => {
+    const [loading, setLoading] = useState33(true);
+    const [success2, setSuccess] = useState33(null);
+    const [error51, setError] = useState33(null);
+    const [resultNode, setResultNode] = useState33(void 0);
+    useEffect30(() => {
+      const run = async () => {
+        try {
+          const data = await client.get(`/agent-versions/${agentId}/published`);
+          setResultNode(
+            React19.createElement(EntityCard, {
+              fields: [
+                { label: "ID", value: data.id },
+                { label: "Version", value: data.versionNumber },
+                { label: "Label", value: data.label ?? void 0 },
+                { label: "Created", value: data.createdAt }
+              ]
+            })
+          );
+          setSuccess(true);
+          setLoading(false);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+          setSuccess(false);
+          setLoading(false);
+        }
+      };
+      run();
+    }, []);
+    return React19.createElement(MutationResult, {
+      loading,
+      loadingLabel: "Fetching published version...",
+      success: success2,
+      successMessage: "Published Version",
+      error: error51,
+      result: resultNode
+    });
+  };
+  const { waitUntilExit } = render19(React19.createElement(App));
+  await waitUntilExit();
+});
+agentVersionsCommand.command("publish <agentId>").description("Publish a version").requiredOption("-v, --version <versionId>", "Version ID to publish").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(
+  async (agentId, options) => {
+    const apiKey = await ensureAuth();
+    if (!apiKey) return;
+    const client = new ApiClient(apiKey);
+    if (!isTTY(options)) {
+      try {
+        await client.post(`/agent-versions/${agentId}/publish`, {
+          versionId: options.version
+        });
+        console.log(chalk27.green("Version published"));
+      } catch (error51) {
+        const message = error51 instanceof Error ? error51.message : "Unknown error";
+        console.error(chalk27.red("Failed to publish version"));
+        console.error(chalk27.red(message));
+        process.exit(1);
+      }
+      return;
+    }
+    const App = () => {
+      const [loading, setLoading] = useState33(true);
+      const [success2, setSuccess] = useState33(null);
+      const [error51, setError] = useState33(null);
+      useEffect30(() => {
+        const run = async () => {
+          try {
+            await client.post(`/agent-versions/${agentId}/publish`, {
+              versionId: options.version
+            });
+            setSuccess(true);
+            setLoading(false);
+          } catch (err) {
+            setError(err instanceof Error ? err : new Error(String(err)));
+            setSuccess(false);
+            setLoading(false);
+          }
+        };
+        run();
+      }, []);
+      return React19.createElement(MutationResult, {
+        loading,
+        loadingLabel: "Publishing version...",
+        success: success2,
+        successMessage: "Version published",
+        error: error51
+      });
+    };
+    const { waitUntilExit } = render19(React19.createElement(App));
+    await waitUntilExit();
+  }
+);
+
+// src/commands/tail.ts
+import { Command as Command22 } from "commander";
+import chalk28 from "chalk";
 function abbreviateId(id) {
   const underscoreIdx = id.lastIndexOf("_");
   if (underscoreIdx === -1) {
@@ -52961,20 +53237,20 @@ function formatTime(ts) {
   return `${hh}:${mm}:${ss}.${ms}`;
 }
 var LEVEL_COLORS = {
-  debug: chalk27.gray,
-  info: chalk27.blue,
-  warn: chalk27.yellow,
-  error: chalk27.red
+  debug: chalk28.gray,
+  info: chalk28.blue,
+  warn: chalk28.yellow,
+  error: chalk28.red
 };
 function levelBadge(level, useColor) {
   const tag = level.toUpperCase().padEnd(5);
   if (!useColor) return `[${tag}]`;
-  const colorFn = LEVEL_COLORS[level] || chalk27.white;
+  const colorFn = LEVEL_COLORS[level] || chalk28.white;
   return colorFn(`[${tag}]`);
 }
 function categoryBadge(category, useColor) {
   if (!useColor) return `[${category}]`;
-  return chalk27.magenta(`[${category}]`);
+  return chalk28.magenta(`[${category}]`);
 }
 function formatTailData(data) {
   return Object.entries(data).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
@@ -52989,14 +53265,14 @@ function formatContextIds(event, useColor) {
   if (event.conversationId) ids.push(`conv=${abbreviateId(event.conversationId)}`);
   if (ids.length === 0) return "";
   const text = ids.join(" ");
-  return useColor ? chalk27.gray(` ${text}`) : ` ${text}`;
+  return useColor ? chalk28.gray(` ${text}`) : ` ${text}`;
 }
 function formatEvent(event, useColor) {
-  const time3 = useColor ? chalk27.gray(formatTime(event.timestamp)) : formatTime(event.timestamp);
+  const time3 = useColor ? chalk28.gray(formatTime(event.timestamp)) : formatTime(event.timestamp);
   const level = levelBadge(event.level, useColor);
   const cat = categoryBadge(event.category, useColor);
   const ctx = formatContextIds(event, useColor);
-  const data = event.tailData && Object.keys(event.tailData).length > 0 ? useColor ? chalk27.gray(` | ${formatTailData(event.tailData)}`) : ` | ${formatTailData(event.tailData)}` : "";
+  const data = event.tailData && Object.keys(event.tailData).length > 0 ? useColor ? chalk28.gray(` | ${formatTailData(event.tailData)}`) : ` | ${formatTailData(event.tailData)}` : "";
   return `${time3} ${level} ${cat} ${event.message}${data}${ctx}`;
 }
 async function consumeSSEStream(reader, options, signal) {
@@ -53035,17 +53311,17 @@ async function consumeSSEStream(reader, options, signal) {
           break;
         case "tail_gap":
           process.stderr.write(
-            (useColor ? chalk27.yellow(`[warn] Dropped ${msg.droppedCount} event(s) between ${msg.fromTimestamp} and ${msg.toTimestamp}`) : `[warn] Dropped ${msg.droppedCount} event(s) between ${msg.fromTimestamp} and ${msg.toTimestamp}`) + "\n"
+            (useColor ? chalk28.yellow(`[warn] Dropped ${msg.droppedCount} event(s) between ${msg.fromTimestamp} and ${msg.toTimestamp}`) : `[warn] Dropped ${msg.droppedCount} event(s) between ${msg.fromTimestamp} and ${msg.toTimestamp}`) + "\n"
           );
           break;
         case "tail_connected":
           process.stderr.write(
-            (useColor ? chalk27.green(`Connected to tail session ${msg.sessionId}`) : `Connected to tail session ${msg.sessionId}`) + "\n"
+            (useColor ? chalk28.green(`Connected to tail session ${msg.sessionId}`) : `Connected to tail session ${msg.sessionId}`) + "\n"
           );
           break;
         case "tail_error":
           process.stderr.write(
-            (useColor ? chalk27.red(`[error] ${msg.error}`) : `[error] ${msg.error}`) + "\n"
+            (useColor ? chalk28.red(`[error] ${msg.error}`) : `[error] ${msg.error}`) + "\n"
           );
           break;
       }
@@ -53125,7 +53401,7 @@ async function runTail(options) {
   const useColor = options.color;
   const activeFilters = Object.entries(filters).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${v}`);
   process.stderr.write(
-    (useColor ? chalk27.gray(`Connecting to ${apiUrl}...${activeFilters.length ? ` filters: ${activeFilters.join(", ")}` : ""}`) : `Connecting to ${apiUrl}...${activeFilters.length ? ` filters: ${activeFilters.join(", ")}` : ""}`) + "\n"
+    (useColor ? chalk28.gray(`Connecting to ${apiUrl}...${activeFilters.length ? ` filters: ${activeFilters.join(", ")}` : ""}`) : `Connecting to ${apiUrl}...${activeFilters.length ? ` filters: ${activeFilters.join(", ")}` : ""}`) + "\n"
   );
   const controller = new AbortController();
   let shuttingDown = false;
@@ -53133,7 +53409,7 @@ async function runTail(options) {
     if (shuttingDown) return;
     shuttingDown = true;
     process.stderr.write(
-      (useColor ? chalk27.gray("\nDisconnecting...") : "\nDisconnecting...") + "\n"
+      (useColor ? chalk28.gray("\nDisconnecting...") : "\nDisconnecting...") + "\n"
     );
     controller.abort();
   };
@@ -53147,7 +53423,7 @@ async function runTail(options) {
       const result = await connectAndStream(session.sseUrl, apiKey, options, controller.signal);
       if (result === "aborted" || shuttingDown) break;
       process.stderr.write(
-        (useColor ? chalk27.yellow("Stream ended, reconnecting...") : "Stream ended, reconnecting...") + "\n"
+        (useColor ? chalk28.yellow("Stream ended, reconnecting...") : "Stream ended, reconnecting...") + "\n"
       );
     } catch (err) {
       if (shuttingDown || controller.signal.aborted) break;
@@ -53155,16 +53431,16 @@ async function runTail(options) {
       const delay = Math.min(BASE_DELAY_MS * Math.pow(2, attempt - 1), MAX_DELAY_MS);
       const message = err instanceof Error ? err.message : String(err);
       process.stderr.write(
-        (useColor ? chalk27.red(`Connection error: ${message}`) : `Connection error: ${message}`) + "\n"
+        (useColor ? chalk28.red(`Connection error: ${message}`) : `Connection error: ${message}`) + "\n"
       );
       if (attempt >= MAX_ATTEMPTS) {
         process.stderr.write(
-          (useColor ? chalk27.red(`Max reconnect attempts (${MAX_ATTEMPTS}) reached. Exiting.`) : `Max reconnect attempts (${MAX_ATTEMPTS}) reached. Exiting.`) + "\n"
+          (useColor ? chalk28.red(`Max reconnect attempts (${MAX_ATTEMPTS}) reached. Exiting.`) : `Max reconnect attempts (${MAX_ATTEMPTS}) reached. Exiting.`) + "\n"
         );
         process.exit(1);
       }
       process.stderr.write(
-        (useColor ? chalk27.gray(`Retrying in ${delay / 1e3}s (attempt ${attempt}/${MAX_ATTEMPTS})...`) : `Retrying in ${delay / 1e3}s (attempt ${attempt}/${MAX_ATTEMPTS})...`) + "\n"
+        (useColor ? chalk28.gray(`Retrying in ${delay / 1e3}s (attempt ${attempt}/${MAX_ATTEMPTS})...`) : `Retrying in ${delay / 1e3}s (attempt ${attempt}/${MAX_ATTEMPTS})...`) + "\n"
       );
       await new Promise((resolve10) => {
         const timer = setTimeout(resolve10, delay);
@@ -53179,16 +53455,16 @@ async function runTail(options) {
   process.removeListener("SIGINT", shutdown);
   process.removeListener("SIGTERM", shutdown);
 }
-var tailCommand = new Command21("tail").description("Stream live execution logs from the Runtype API").option("--flow <id>", "Filter by flow ID").option("--agent <id>", "Filter by agent ID").option("--surface <id>", "Filter by surface ID").option("--execution <id>", "Filter by execution ID").option("--level <level>", "Filter by level (debug/info/warn/error)").option("--category <category>", "Filter by category (execution/agent/tool/model/system/error)").option("--json", "Output raw JSON (one object per line)").option("--no-color", "Disable color output").action(async (options) => {
+var tailCommand = new Command22("tail").description("Stream live execution logs from the Runtype API").option("--flow <id>", "Filter by flow ID").option("--agent <id>", "Filter by agent ID").option("--surface <id>", "Filter by surface ID").option("--execution <id>", "Filter by execution ID").option("--level <level>", "Filter by level (debug/info/warn/error)").option("--category <category>", "Filter by category (execution/agent/tool/model/system/error)").option("--json", "Output raw JSON (one object per line)").option("--no-color", "Disable color output").action(async (options) => {
   await runTail(options);
 });
 
 // src/commands/validate-product.ts
-import { Command as Command22, Option } from "commander";
-import chalk28 from "chalk";
+import { Command as Command23, Option } from "commander";
+import chalk29 from "chalk";
 import { readFileSync as readFileSync15 } from "fs";
 function createValidateProductCommand() {
-  return new Command22("validate-product").description("Validate a product (FPO) or FPO template locally (no API call)").argument(
+  return new Command23("validate-product").description("Validate a product (FPO) or FPO template locally (no API call)").argument(
     "[input]",
     'Path to JSON file, raw JSON string (starts with "{"), or "-" for stdin'
   ).option("--template", "Force FPO template validation").option("--fpo", "Force FPO (non-template) validation").addOption(
@@ -53212,7 +53488,7 @@ var validateProductCommand = createValidateProductCommand();
 async function runValidateAction(input, _options) {
   const options = this.optsWithGlobals();
   if (options.template && options.fpo) {
-    console.error(chalk28.red("Error: --template and --fpo are mutually exclusive"));
+    console.error(chalk29.red("Error: --template and --fpo are mutually exclusive"));
     process.exit(1);
   }
   let raw;
@@ -53220,7 +53496,7 @@ async function runValidateAction(input, _options) {
     raw = await readInput(input);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(chalk28.red(`Failed to read input: ${message}`));
+    console.error(chalk29.red(`Failed to read input: ${message}`));
     process.exit(1);
     return;
   }
@@ -53229,7 +53505,7 @@ async function runValidateAction(input, _options) {
     parsed = JSON.parse(raw);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(chalk28.red(`Invalid JSON: ${message}`));
+    console.error(chalk29.red(`Invalid JSON: ${message}`));
     process.exit(1);
     return;
   }
@@ -53319,16 +53595,16 @@ function runValidation(body, kind) {
 function printHumanResult(kind, result) {
   const label = kind === "template" ? "FPO template" : "FPO";
   const overallValid = !hasAnyErrors(result);
-  const headline = overallValid ? chalk28.green(`\u2713 Valid ${label}`) : chalk28.red(`\u2717 Invalid ${label}`);
+  const headline = overallValid ? chalk29.green(`\u2713 Valid ${label}`) : chalk29.red(`\u2717 Invalid ${label}`);
   console.log(headline);
   console.log(
-    chalk28.gray(
+    chalk29.gray(
       `  ${result.errors.length} error(s), ${result.warnings.length} warning(s), ${result.recommendations.length} recommendation(s)`
     )
   );
-  printIssues("Errors", result.errors, chalk28.red);
-  printIssues("Warnings", result.warnings, chalk28.yellow);
-  printIssues("Recommendations", result.recommendations, chalk28.blue);
+  printIssues("Errors", result.errors, chalk29.red);
+  printIssues("Warnings", result.warnings, chalk29.yellow);
+  printIssues("Recommendations", result.recommendations, chalk29.blue);
   if (result.kind === "template") {
     const defaults = result.defaultsValidation;
     const structuralErrors = defaults.errors.filter(
@@ -53340,22 +53616,22 @@ function printHumanResult(kind, result) {
     if (structuralErrors.length > 0) {
       console.log();
       console.log(
-        chalk28.red(
+        chalk29.red(
           `Defaults validation: template defaults do not produce a valid FPO`
         )
       );
-      printIssues("Default-resolution errors", structuralErrors, chalk28.red);
-      printIssues("Default-resolution warnings", defaults.warnings, chalk28.yellow);
+      printIssues("Default-resolution errors", structuralErrors, chalk29.red);
+      printIssues("Default-resolution warnings", defaults.warnings, chalk29.yellow);
     }
     if (missingVars.length > 0) {
       console.log();
       console.log(
-        chalk28.gray(
+        chalk29.gray(
           `Template variables needing deploy-time values (${missingVars.length}):`
         )
       );
       for (const issue2 of missingVars) {
-        console.log(chalk28.gray(`  \u2022 ${issue2.path} \u2014 ${issue2.message}`));
+        console.log(chalk29.gray(`  \u2022 ${issue2.path} \u2014 ${issue2.message}`));
       }
     }
   }
@@ -53365,17 +53641,17 @@ function printIssues(title, issues, color) {
   console.log();
   console.log(color(`${title}:`));
   for (const issue2 of issues) {
-    const pathLabel = issue2.path ? chalk28.gray(` [${issue2.path}]`) : "";
-    console.log(`  ${color("\u2022")} ${chalk28.bold(issue2.code)}${pathLabel} ${issue2.message}`);
+    const pathLabel = issue2.path ? chalk29.gray(` [${issue2.path}]`) : "";
+    console.log(`  ${color("\u2022")} ${chalk29.bold(issue2.code)}${pathLabel} ${issue2.message}`);
     if (issue2.suggestedFix) {
-      console.log(`    ${chalk28.gray("fix:")} ${issue2.suggestedFix}`);
+      console.log(`    ${chalk29.gray("fix:")} ${issue2.suggestedFix}`);
     }
   }
 }
 
 // src/commands/deploy.ts
-import { Command as Command23 } from "commander";
-import chalk29 from "chalk";
+import { Command as Command24 } from "commander";
+import chalk30 from "chalk";
 import * as fs14 from "fs";
 import * as path14 from "path";
 function bashSingleQuote(s) {
@@ -53696,6 +53972,612 @@ gcloud run deploy runtype-deploy \\
 \`GET /health\` returns \`{"status":"ok","agents":[...]}\`.
 `;
 }
+function workerIndexTs(agentSlugs) {
+  const imports = agentSlugs.map((slug, i) => `import agent${i}Json from '../agents/${slug}.json'`).join("\n");
+  const agentFiles = agentSlugs.map((slug, i) => `  ['${slug}.json', agent${i}Json],`).join("\n");
+  return `/**
+ * Generated by \`runtype deploy --target cloudflare\`.
+ *
+ * Routes:
+ *   GET  /health           \u2014 liveness probe (lists registered agent names)
+ *   POST /agent/:name      \u2014 SSE stream of the agent event schema
+ *
+ * Agent definitions are statically imported so Wrangler bundles them.
+ * To add a new agent:
+ *   1. Export it with \`runtype deploy --agent <id> --target cloudflare\`
+ *   2. Or drop a JSON file under agents/ and add an import + entry below
+ *   3. Run \`wrangler deploy\`
+ */
+import {
+  CloudflareAdapter,
+  createRuntime,
+  exportedAgentSchema,
+  type ExportedAgent,
+} from '@runtypelabs/runtime'
+
+// ---------------------------------------------------------------------------
+// Agent registry \u2014 static imports bundled by Wrangler at deploy time
+// ---------------------------------------------------------------------------
+
+${imports}
+
+function parseAgent(json: unknown, filename: string): ExportedAgent {
+  try {
+    return exportedAgentSchema.parse(json)
+  } catch (err) {
+    throw new Error(
+      \`[runtype] invalid agent JSON in \${filename}: \${
+        err instanceof Error ? err.message : String(err)
+      }\`
+    )
+  }
+}
+
+const agentFiles: Array<[string, unknown]> = [
+${agentFiles}
+]
+
+const agentRegistry: Record<string, ExportedAgent> = {}
+for (const [filename, json] of agentFiles) {
+  const agent = parseAgent(json, filename)
+  if (agentRegistry[agent.name]) {
+    throw new Error(\`[runtype] duplicate agent name "\${agent.name}" in \${filename}\`)
+  }
+  agentRegistry[agent.name] = agent
+}
+
+// ---------------------------------------------------------------------------
+// Env \u2014 Wrangler injects secrets + bindings here
+// ---------------------------------------------------------------------------
+
+export interface Env {
+  // Secrets \u2014 set via \`wrangler secret put <NAME>\`
+  ANTHROPIC_API_KEY?: string
+  OPENAI_API_KEY?: string
+  GOOGLE_API_KEY?: string
+  MIXLAYER_API_KEY?: string
+  // Optional: narrow CORS from * to specific origins (comma-separated)
+  ALLOWED_ORIGINS?: string
+  // Optional: KV namespace binding for durable cross-request caching
+  CACHE_KV?: KVNamespace
+}
+
+// ---------------------------------------------------------------------------
+// Worker
+// ---------------------------------------------------------------------------
+
+export default {
+  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    const url = new URL(request.url)
+    const cors = corsHeaders(request, env.ALLOWED_ORIGINS)
+
+    if (request.method === 'OPTIONS') {
+      return new Response(null, { status: 204, headers: cors })
+    }
+
+    if (request.method === 'GET' && url.pathname === '/health') {
+      return json({ status: 'ok', agents: Object.keys(agentRegistry) }, 200, cors)
+    }
+
+    const agentMatch = url.pathname.match(/^\\/agent\\/([^/]+)$/)
+    if (request.method === 'POST' && agentMatch) {
+      const name = decodeURIComponent(agentMatch[1])
+      if (!agentRegistry[name]) {
+        return json({ error: \`unknown agent: \${name}\` }, 404, cors)
+      }
+
+      const runtime = createRuntime({
+        agents: agentRegistry,
+        keys: { mode: 'own' },
+        adapter: new CloudflareAdapter(env, {
+          kvNamespace: env.CACHE_KV,
+          waitUntil: ctx.waitUntil.bind(ctx),
+        }),
+      })
+
+      let body: { messages?: Array<{ role: string; content: string }> } = {}
+      try {
+        body = (await request.json()) as typeof body
+      } catch {
+        return json({ error: 'request body must be JSON' }, 400, cors)
+      }
+      const messages = Array.isArray(body.messages) ? body.messages : []
+
+      try {
+        const response = await runtime.executeAgent(name, {
+          messages: messages as Array<{
+            role: 'system' | 'user' | 'assistant'
+            content: string
+          }>,
+          signal: request.signal,
+        })
+        const headers = new Headers(response.headers)
+        for (const [k, v] of Object.entries(cors)) headers.set(k, v)
+        return new Response(response.body, { status: response.status, headers })
+      } catch (err) {
+        return json({ error: err instanceof Error ? err.message : 'unknown error' }, 500, cors)
+      }
+    }
+
+    return json({ error: 'not found' }, 404, cors)
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function json(body: unknown, status: number, extra: Record<string, string>): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json', ...extra },
+  })
+}
+
+function corsHeaders(request: Request, allowedOriginsEnv?: string): Record<string, string> {
+  const origin = request.headers.get('Origin') ?? ''
+  let allow = '*'
+  if (allowedOriginsEnv) {
+    const list = allowedOriginsEnv.split(',').map((o) => o.trim()).filter(Boolean)
+    allow = list.includes(origin) ? origin : (list[0] ?? '*')
+  }
+  const headers: Record<string, string> = {
+    'Access-Control-Allow-Origin': allow,
+    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    'Access-Control-Max-Age': '86400',
+  }
+  if (allow !== '*') headers['Vary'] = 'Origin'
+  return headers
+}
+`;
+}
+function wranglerToml(projectName) {
+  return `name = "${projectName}"
+main = "src/index.ts"
+compatibility_date = "2025-01-01"
+
+# Secrets \u2014 set via \`wrangler secret put <NAME>\`
+# Run this for each API key your agents need:
+#   wrangler secret put ANTHROPIC_API_KEY
+#   wrangler secret put OPENAI_API_KEY
+#   wrangler secret put GOOGLE_API_KEY
+#   wrangler secret put MIXLAYER_API_KEY
+
+# Optional: KV namespace for durable cross-request caching.
+# Without this the adapter uses a per-isolate in-memory Map (ephemeral).
+# To enable:
+#   1. wrangler kv namespace create CACHE_KV
+#   2. Uncomment the block below and paste the generated id.
+# [[kv_namespaces]]
+# binding = "CACHE_KV"
+# id = "<paste your KV namespace id here>"
+
+# Optional: Workers AI binding (for @cf/* and workers-ai/* model ids).
+# [ai]
+# binding = "AI"
+
+# CORS: narrow from * to specific origins via ALLOWED_ORIGINS env var.
+# [vars]
+# ALLOWED_ORIGINS = "https://yourapp.com,https://persona-chat.dev"
+`;
+}
+function workerPackageJson(name, runtimeDep) {
+  return JSON.stringify(
+    {
+      name,
+      version: "0.0.0",
+      private: true,
+      scripts: {
+        dev: "wrangler dev",
+        deploy: "wrangler deploy",
+        typecheck: "tsc --noEmit"
+      },
+      dependencies: {
+        "@runtypelabs/runtime": runtimeDep
+      },
+      devDependencies: {
+        "@cloudflare/workers-types": "^4.0.0",
+        typescript: "^5.3.3",
+        wrangler: "^4.0.0"
+      }
+    },
+    null,
+    2
+  );
+}
+function workerTsconfigJson() {
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ES2022",
+        moduleResolution: "bundler",
+        strict: true,
+        resolveJsonModule: true,
+        types: ["@cloudflare/workers-types"]
+      },
+      include: ["src"]
+    },
+    null,
+    2
+  );
+}
+function workerSetupSh(monorepoRoot) {
+  return `#!/usr/bin/env bash
+# Generated by \`runtype deploy --target cloudflare\`.
+#
+# Builds and packs @runtypelabs/runtime from your local monorepo, then
+# installs all dependencies so you can run \`wrangler dev\` or deploy with
+# \`wrangler deploy\`.
+#
+# Usage (from this directory):
+#   ./setup.sh
+
+set -euo pipefail
+
+DEPLOY_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+MONOREPO_ROOT=${bashSingleQuote(monorepoRoot)}
+TARBALL_DIR="\${DEPLOY_DIR}/packages"
+
+echo "[setup] building @runtypelabs/runtime..."
+pnpm --dir "\${MONOREPO_ROOT}" --filter @runtypelabs/runtime build
+
+mkdir -p "\${TARBALL_DIR}"
+
+echo "[setup] packing @runtypelabs/runtime tarball..."
+pnpm --dir "\${MONOREPO_ROOT}/packages/runtime" pack \\
+  --pack-destination "\${TARBALL_DIR}"
+
+RUNTIME_TGZ="$(ls "\${TARBALL_DIR}"/runtypelabs-runtime-*.tgz | head -n 1)"
+if [ -z "\${RUNTIME_TGZ}" ]; then
+  echo "[setup] error: no tarball produced by pnpm pack" >&2
+  exit 1
+fi
+RUNTIME_TGZ_NAME="$(basename "\${RUNTIME_TGZ}")"
+
+echo "[setup] updating package.json with file: dependency..."
+node -e "
+const fs = require('fs');
+const pkg = JSON.parse(fs.readFileSync('\${DEPLOY_DIR}/package.json', 'utf8'));
+pkg.dependencies['@runtypelabs/runtime'] = 'file:./packages/\${RUNTIME_TGZ_NAME}';
+fs.writeFileSync('\${DEPLOY_DIR}/package.json', JSON.stringify(pkg, null, 2) + '\\\\n');
+"
+
+echo "[setup] installing dependencies..."
+npm install --no-audit --no-fund
+
+echo ""
+echo "[setup] Done! Next steps:"
+echo "  wrangler dev             \u2014 preview locally"
+echo "  wrangler deploy          \u2014 deploy to Cloudflare Workers"
+`;
+}
+function workerReadme(agentNames, secretNames) {
+  const agentList = agentNames.map((n) => `  - ${n}`).join("\n");
+  const secretList = secretNames.length > 0 ? secretNames.map((s) => `  wrangler secret put ${s}`).join("\n") : "  (none detected)";
+  return `# Runtype Cloudflare Workers Deployment
+
+Generated by \`runtype deploy --target cloudflare\`. Contains the following agents:
+
+${agentList}
+
+## Setup
+
+\`\`\`bash
+chmod +x setup.sh && ./setup.sh   # build runtime + install deps
+\`\`\`
+
+## Secrets
+
+Set each API key your agents use:
+
+\`\`\`bash
+${secretList}
+\`\`\`
+
+## Run locally
+
+\`\`\`bash
+wrangler dev
+\`\`\`
+
+## Deploy
+
+\`\`\`bash
+wrangler deploy
+\`\`\`
+
+## Health check
+
+\`GET /health\` returns \`{"status":"ok","agents":[...]}\`.
+
+## Call an agent
+
+\`\`\`bash
+curl https://<worker-subdomain>.workers.dev/agent/<name> \\
+  -H 'Content-Type: application/json' \\
+  -d '{"messages":[{"role":"user","content":"Hello"}]}'
+\`\`\`
+`;
+}
+function vercelRouteTs(agentSlugs) {
+  const imports = agentSlugs.map((slug, i) => `import agent${i}Json from '../agents/${slug}.json'`).join("\n");
+  const agentFiles = agentSlugs.map((slug, i) => `  ['${slug}.json', agent${i}Json],`).join("\n");
+  return `/**
+ * Generated by \`runtype deploy --target vercel\`.
+ *
+ * Catch-all Vercel Function. All traffic is rewritten here by vercel.json.
+ * Routes:
+ *   GET  /health           \u2014 liveness probe (lists registered agent names)
+ *   POST /agent/:name      \u2014 SSE stream of the agent event schema
+ *
+ * Agent definitions are statically imported and bundled by Vercel.
+ * To add a new agent:
+ *   1. Export it with \`runtype deploy --agent <id> --target vercel\`
+ *   2. Or drop a JSON file under agents/ and add an import + entry below
+ *   3. Run \`vercel deploy\`
+ */
+import { Hono } from 'hono'
+import { handle } from 'hono/vercel'
+import { cors } from 'hono/cors'
+import {
+  VercelAdapter,
+  createRuntime,
+  exportedAgentSchema,
+  type ExportedAgent,
+} from '@runtypelabs/runtime'
+
+// ---------------------------------------------------------------------------
+// Agent registry \u2014 built at module load, cached across warm invocations
+// ---------------------------------------------------------------------------
+
+${imports}
+
+function parseAgent(json: unknown, filename: string): ExportedAgent {
+  try {
+    return exportedAgentSchema.parse(json)
+  } catch (err) {
+    throw new Error(
+      \`[runtype] invalid agent JSON in \${filename}: \${
+        err instanceof Error ? err.message : String(err)
+      }\`
+    )
+  }
+}
+
+const agentFiles: Array<[string, unknown]> = [
+${agentFiles}
+]
+
+const agentRegistry: Record<string, ExportedAgent> = {}
+for (const [filename, json] of agentFiles) {
+  const agent = parseAgent(json, filename)
+  if (agentRegistry[agent.name]) {
+    throw new Error(\`[runtype] duplicate agent name "\${agent.name}" in \${filename}\`)
+  }
+  agentRegistry[agent.name] = agent
+}
+
+// ---------------------------------------------------------------------------
+// Runtime \u2014 constructed at module scope (warm across invocations)
+// ---------------------------------------------------------------------------
+
+const runtime = createRuntime({
+  agents: agentRegistry,
+  keys: { mode: 'own' },
+  adapter: new VercelAdapter(),
+})
+
+// ---------------------------------------------------------------------------
+// Hono app
+// ---------------------------------------------------------------------------
+
+const app = new Hono()
+
+const allowedOriginsEnv = process.env.ALLOWED_ORIGINS?.trim()
+const allowedOrigins = allowedOriginsEnv
+  ? allowedOriginsEnv.split(',').map((o) => o.trim()).filter(Boolean)
+  : '*'
+
+app.use(
+  '*',
+  cors({
+    origin: allowedOrigins,
+    allowMethods: ['GET', 'POST', 'OPTIONS'],
+    allowHeaders: ['Content-Type', 'Authorization'],
+    maxAge: 86400,
+  })
+)
+
+app.get('/health', (c) => c.json({ status: 'ok', agents: Object.keys(agentRegistry) }))
+
+app.post('/agent/:name', async (c) => {
+  const name = c.req.param('name')
+  if (!runtime.getAgent(name)) {
+    return c.json({ error: \`unknown agent: \${name}\` }, 404)
+  }
+
+  let body: { messages?: Array<{ role: string; content: string }> } = {}
+  try {
+    body = (await c.req.json()) as typeof body
+  } catch {
+    return c.json({ error: 'request body must be JSON' }, 400)
+  }
+  const messages = Array.isArray(body.messages) ? body.messages : []
+
+  try {
+    const response = await runtime.executeAgent(name, {
+      messages: messages as Array<{
+        role: 'system' | 'user' | 'assistant'
+        content: string
+      }>,
+      signal: c.req.raw.signal,
+    })
+    return response
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : 'unknown error' }, 500)
+  }
+})
+
+export const GET = handle(app)
+export const POST = handle(app)
+`;
+}
+function vercelJson() {
+  return JSON.stringify(
+    {
+      rewrites: [{ source: "/(.*)", destination: "/api/[[...route]]" }],
+      functions: {
+        "api/[[...route]].ts": { maxDuration: 60 }
+      }
+    },
+    null,
+    2
+  );
+}
+function vercelPackageJson(name, runtimeDep) {
+  return JSON.stringify(
+    {
+      name,
+      version: "0.0.0",
+      private: true,
+      scripts: {
+        dev: "vercel dev",
+        deploy: "vercel deploy",
+        typecheck: "tsc --noEmit"
+      },
+      dependencies: {
+        "@runtypelabs/runtime": runtimeDep,
+        hono: "^4.12.16"
+      },
+      devDependencies: {
+        "@types/node": "^22.0.0",
+        "@vercel/node": "^5.0.0",
+        typescript: "^5.3.3",
+        vercel: "^44.0.0"
+      }
+    },
+    null,
+    2
+  );
+}
+function vercelTsconfigJson() {
+  return JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        strict: true,
+        resolveJsonModule: true,
+        esModuleInterop: true,
+        skipLibCheck: true
+      },
+      include: ["api"]
+    },
+    null,
+    2
+  );
+}
+function vercelSetupSh(monorepoRoot) {
+  return `#!/usr/bin/env bash
+# Generated by \`runtype deploy --target vercel\`.
+#
+# Builds and packs @runtypelabs/runtime from your local monorepo, then
+# installs all dependencies so you can run \`vercel dev\` or deploy with
+# \`vercel deploy\`.
+#
+# Usage (from this directory):
+#   ./setup.sh
+
+set -euo pipefail
+
+DEPLOY_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+MONOREPO_ROOT=${bashSingleQuote(monorepoRoot)}
+TARBALL_DIR="\${DEPLOY_DIR}/packages"
+
+echo "[setup] building @runtypelabs/runtime..."
+pnpm --dir "\${MONOREPO_ROOT}" --filter @runtypelabs/runtime build
+
+mkdir -p "\${TARBALL_DIR}"
+
+echo "[setup] packing @runtypelabs/runtime tarball..."
+pnpm --dir "\${MONOREPO_ROOT}/packages/runtime" pack \\
+  --pack-destination "\${TARBALL_DIR}"
+
+RUNTIME_TGZ="$(ls "\${TARBALL_DIR}"/runtypelabs-runtime-*.tgz | head -n 1)"
+if [ -z "\${RUNTIME_TGZ}" ]; then
+  echo "[setup] error: no tarball produced by pnpm pack" >&2
+  exit 1
+fi
+RUNTIME_TGZ_NAME="$(basename "\${RUNTIME_TGZ}")"
+
+echo "[setup] updating package.json with file: dependency..."
+node -e "
+const fs = require('fs');
+const pkg = JSON.parse(fs.readFileSync('\${DEPLOY_DIR}/package.json', 'utf8'));
+pkg.dependencies['@runtypelabs/runtime'] = 'file:./packages/\${RUNTIME_TGZ_NAME}';
+fs.writeFileSync('\${DEPLOY_DIR}/package.json', JSON.stringify(pkg, null, 2) + '\\\\n');
+"
+
+echo "[setup] installing dependencies..."
+npm install --no-audit --no-fund
+
+echo ""
+echo "[setup] Done! Next steps:"
+echo "  vercel dev              \u2014 preview locally"
+echo "  vercel deploy           \u2014 deploy to Vercel Functions"
+`;
+}
+function vercelReadme(agentNames, secretNames) {
+  const agentList = agentNames.map((n) => `  - ${n}`).join("\n");
+  const secretList = secretNames.length > 0 ? secretNames.map((s) => `  vercel env add ${s}`).join("\n") : "  (none detected)";
+  return `# Runtype Vercel Functions Deployment
+
+Generated by \`runtype deploy --target vercel\`. Contains the following agents:
+
+${agentList}
+
+## Setup
+
+\`\`\`bash
+chmod +x setup.sh && ./setup.sh   # build runtime + install deps
+\`\`\`
+
+## Secrets
+
+Set each API key your agents use via the Vercel dashboard or CLI:
+
+\`\`\`bash
+${secretList}
+\`\`\`
+
+## Run locally
+
+\`\`\`bash
+vercel dev
+\`\`\`
+
+## Deploy
+
+\`\`\`bash
+vercel deploy
+\`\`\`
+
+## Health check
+
+\`GET /health\` returns \`{"status":"ok","agents":[...]}\`.
+
+## Call an agent
+
+\`\`\`bash
+curl https://<your-project>.vercel.app/agent/<name> \\
+  -H 'Content-Type: application/json' \\
+  -d '{"messages":[{"role":"user","content":"Hello"}]}'
+\`\`\`
+`;
+}
 function collectSecretNames(agentDef) {
   const names = /* @__PURE__ */ new Set();
   const model = agentDef.config?.model?.toLowerCase();
@@ -53718,18 +54600,23 @@ function collectSecretNames(agentDef) {
 function slugify2(s) {
   return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 63);
 }
-var deployCommand = new Command23("deploy").description("Export an agent or flow and scaffold a Cloud Run deployment").option("--agent <id>", "Agent ID to export (may be repeated)", (v, acc) => {
+var deployCommand = new Command24("deploy").description("Export an agent or flow and scaffold a deployment (cloud-run, cloudflare, or vercel)").option("--agent <id>", "Agent ID to export (may be repeated)", (v, acc) => {
   acc.push(v);
   return acc;
 }, []).option("--flow <id>", "Flow ID to export (may be repeated)", (v, acc) => {
   acc.push(v);
   return acc;
-}, []).option("--output <dir>", "Output directory for the scaffold (default: ./runtype-deploy)", "./runtype-deploy").option("--name <name>", "Project name used in package.json (default: derived from output dir)").action(
+}, []).option("--output <dir>", "Output directory for the scaffold (default: ./runtype-deploy)", "./runtype-deploy").option("--name <name>", "Project name used in package.json (default: derived from output dir)").option("--target <target>", "Deployment target: cloud-run, cloudflare, or vercel (default: cloud-run)", "cloud-run").action(
   async (options) => {
     const agentIds = options.agent;
     const flowIds = options.flow;
     if (agentIds.length === 0 && flowIds.length === 0) {
-      console.error(chalk29.red("Error: provide at least one --agent <id> or --flow <id>"));
+      console.error(chalk30.red("Error: provide at least one --agent <id> or --flow <id>"));
+      process.exit(1);
+    }
+    const target = options.target;
+    if (target !== "cloud-run" && target !== "cloudflare" && target !== "vercel") {
+      console.error(chalk30.red(`Error: unknown --target "${target}". Must be one of: cloud-run, cloudflare, vercel`));
       process.exit(1);
     }
     const apiKey = await ensureAuth();
@@ -53737,30 +54624,30 @@ var deployCommand = new Command23("deploy").description("Export an agent or flow
     const client = new ApiClient(apiKey);
     const outDir = path14.resolve(options.output);
     const projectName = options.name ?? slugify2(path14.basename(outDir));
-    console.log(chalk29.cyan(`
-Scaffolding deployment to ${outDir}
+    console.log(chalk30.cyan(`
+Scaffolding ${target} deployment to ${outDir}
 `));
     const agentDefs = [];
     for (const id of agentIds) {
-      process.stdout.write(`  Exporting agent ${chalk29.green(id)}... `);
+      process.stdout.write(`  Exporting agent ${chalk30.green(id)}... `);
       try {
         const def = await client.get(`/agents/${id}/export-runtime`);
         agentDefs.push({ id, name: String(def.name ?? id), def });
-        process.stdout.write(chalk29.green("\u2713\n"));
+        process.stdout.write(chalk30.green("\u2713\n"));
       } catch (err) {
         const msg = err instanceof ApiError ? err.message : String(err);
-        process.stdout.write(chalk29.red(`\u2717
+        process.stdout.write(chalk30.red(`\u2717
 `));
-        console.error(chalk29.red(`  Failed to export agent ${id}: ${msg}`));
+        console.error(chalk30.red(`  Failed to export agent ${id}: ${msg}`));
         if (err instanceof ApiError && err.statusCode === 404) {
-          console.error(chalk29.yellow("  The export-runtime feature may not be enabled on your account or environment."));
-          console.error(chalk29.gray("  If you have your own environment, try: RUNTYPE_API_URL={API Base URI} runtype deploy ..."));
+          console.error(chalk30.yellow("  The export-runtime feature may not be enabled on your account or environment."));
+          console.error(chalk30.gray("  If you have your own environment, try: RUNTYPE_API_URL={API Base URI} runtype deploy ..."));
         }
         process.exit(1);
       }
     }
     for (const id of flowIds) {
-      process.stdout.write(`  Exporting flow ${chalk29.green(id)}... `);
+      process.stdout.write(`  Exporting flow ${chalk30.green(id)}... `);
       try {
         const def = await client.get(`/flows/${id}/export-runtime`);
         const wrappedName = String(def.name ?? id);
@@ -53776,49 +54663,39 @@ Scaffolding deployment to ${outDir}
             primaryFlow: def
           }
         });
-        process.stdout.write(chalk29.green("\u2713\n"));
+        process.stdout.write(chalk30.green("\u2713\n"));
       } catch (err) {
         const msg = err instanceof ApiError ? err.message : String(err);
-        process.stdout.write(chalk29.red(`\u2717
+        process.stdout.write(chalk30.red(`\u2717
 `));
-        console.error(chalk29.red(`  Failed to export flow ${id}: ${msg}`));
+        console.error(chalk30.red(`  Failed to export flow ${id}: ${msg}`));
         if (err instanceof ApiError && err.statusCode === 404) {
-          console.error(chalk29.yellow("  The export-runtime feature may not be enabled on your account or environment."));
-          console.error(chalk29.gray("  If you have your own environment, try: RUNTYPE_API_URL={API Base URI} runtype deploy ..."));
+          console.error(chalk30.yellow("  The export-runtime feature may not be enabled on your account or environment."));
+          console.error(chalk30.gray("  If you have your own environment, try: RUNTYPE_API_URL={API Base URI} runtype deploy ..."));
         }
         process.exit(1);
       }
     }
+    const agentSlugs = agentDefs.map(({ name }) => slugify2(name));
+    const slugSet = /* @__PURE__ */ new Set();
+    for (let i = 0; i < agentSlugs.length; i++) {
+      const slug = agentSlugs[i];
+      if (slugSet.has(slug)) {
+        const colliders = agentDefs.filter(({ name }) => slugify2(name) === slug).map(({ name }) => `"${name}"`).join(" and ");
+        console.error(chalk30.red(`Error: agents ${colliders} produce the same slug "${slug}".`));
+        console.error(chalk30.yellow("  Rename one of them in the Runtype dashboard to make slugs unique."));
+        process.exit(1);
+      }
+      slugSet.add(slug);
+    }
     fs14.mkdirSync(path14.join(outDir, "agents"), { recursive: true });
     fs14.mkdirSync(path14.join(outDir, "packages"), { recursive: true });
     for (const { name, def } of agentDefs) {
       const filename = `${slugify2(name)}.json`;
-      fs14.writeFileSync(
-        path14.join(outDir, "agents", filename),
-        JSON.stringify(def, null, 2)
-      );
+      fs14.writeFileSync(path14.join(outDir, "agents", filename), JSON.stringify(def, null, 2));
       console.log(`  Wrote agents/${filename}`);
     }
-    fs14.writeFileSync(
-      path14.join(outDir, "server.ts"),
-      serverTs()
-    );
-    fs14.writeFileSync(
-      path14.join(outDir, "Dockerfile"),
-      dockerfile()
-    );
-    fs14.writeFileSync(
-      path14.join(outDir, ".dockerignore"),
-      dockerignore()
-    );
-    fs14.writeFileSync(
-      path14.join(outDir, "tsconfig.json"),
-      tsconfigJson()
-    );
-    fs14.writeFileSync(
-      path14.join(outDir, "package.json"),
-      packageJson(projectName, "workspace:*")
-    );
+    const agentNames = agentDefs.map((a) => a.name);
     let monorepoRoot = process.cwd();
     for (let i = 0; i < 8; i++) {
       if (fs14.existsSync(path14.join(monorepoRoot, "pnpm-workspace.yaml"))) break;
@@ -53826,46 +54703,90 @@ Scaffolding deployment to ${outDir}
       if (parent === monorepoRoot) break;
       monorepoRoot = parent;
     }
-    const setupScript = setupSh(monorepoRoot);
-    const setupPath = path14.join(outDir, "setup.sh");
-    fs14.writeFileSync(setupPath, setupScript);
-    fs14.chmodSync(setupPath, 493);
     const allSecrets = /* @__PURE__ */ new Set();
     for (const { def } of agentDefs) {
       for (const s of collectSecretNames(def)) allSecrets.add(s);
     }
     const secretNames = Array.from(allSecrets);
-    fs14.writeFileSync(
-      path14.join(outDir, "README.md"),
-      readme(
-        agentDefs.map((a) => a.name),
-        secretNames
-      )
-    );
+    if (target === "cloudflare") {
+      fs14.mkdirSync(path14.join(outDir, "src"), { recursive: true });
+      fs14.writeFileSync(path14.join(outDir, "src", "index.ts"), workerIndexTs(agentSlugs));
+      fs14.writeFileSync(path14.join(outDir, "wrangler.toml"), wranglerToml(projectName));
+      fs14.writeFileSync(path14.join(outDir, "package.json"), workerPackageJson(projectName, "workspace:*"));
+      fs14.writeFileSync(path14.join(outDir, "tsconfig.json"), workerTsconfigJson());
+      const setupPath = path14.join(outDir, "setup.sh");
+      fs14.writeFileSync(setupPath, workerSetupSh(monorepoRoot));
+      fs14.chmodSync(setupPath, 493);
+      fs14.writeFileSync(path14.join(outDir, "README.md"), workerReadme(agentNames, secretNames));
+    } else if (target === "vercel") {
+      fs14.mkdirSync(path14.join(outDir, "api"), { recursive: true });
+      fs14.writeFileSync(path14.join(outDir, "api", "[[...route]].ts"), vercelRouteTs(agentSlugs));
+      fs14.writeFileSync(path14.join(outDir, "vercel.json"), vercelJson());
+      fs14.writeFileSync(path14.join(outDir, "package.json"), vercelPackageJson(projectName, "workspace:*"));
+      fs14.writeFileSync(path14.join(outDir, "tsconfig.json"), vercelTsconfigJson());
+      const setupPath = path14.join(outDir, "setup.sh");
+      fs14.writeFileSync(setupPath, vercelSetupSh(monorepoRoot));
+      fs14.chmodSync(setupPath, 493);
+      fs14.writeFileSync(path14.join(outDir, "README.md"), vercelReadme(agentNames, secretNames));
+    } else {
+      fs14.writeFileSync(path14.join(outDir, "server.ts"), serverTs());
+      fs14.writeFileSync(path14.join(outDir, "Dockerfile"), dockerfile());
+      fs14.writeFileSync(path14.join(outDir, ".dockerignore"), dockerignore());
+      fs14.writeFileSync(path14.join(outDir, "tsconfig.json"), tsconfigJson());
+      fs14.writeFileSync(path14.join(outDir, "package.json"), packageJson(projectName, "workspace:*"));
+      const setupPath = path14.join(outDir, "setup.sh");
+      fs14.writeFileSync(setupPath, setupSh(monorepoRoot));
+      fs14.chmodSync(setupPath, 493);
+      fs14.writeFileSync(path14.join(outDir, "README.md"), readme(agentNames, secretNames));
+    }
     console.log("");
-    console.log(chalk29.green(`\u2713 Scaffold written to ${outDir}`));
+    console.log(chalk30.green(`\u2713 Scaffold written to ${outDir}`));
     console.log("");
-    console.log(chalk29.bold("Next steps:"));
+    console.log(chalk30.bold("Next steps:"));
     console.log(`  cd ${options.output}`);
     console.log("  chmod +x setup.sh && ./setup.sh   # pack runtime + install deps");
-    console.log("  npm run dev                        # test locally");
-    console.log("");
-    if (secretNames.length > 0) {
-      console.log(chalk29.yellow("Required secrets (set before deploying):"));
-      for (const s of secretNames) {
-        console.log(`  ${chalk29.cyan(s)}`);
+    if (target === "cloudflare") {
+      console.log("  wrangler dev                       # test locally");
+      console.log("");
+      if (secretNames.length > 0) {
+        console.log(chalk30.yellow("Required secrets (set via wrangler):"));
+        for (const s of secretNames) {
+          console.log(`  wrangler secret put ${chalk30.cyan(s)}`);
+        }
+        console.log("");
       }
+      console.log("Deploy to Cloudflare Workers:");
+      console.log("  wrangler deploy");
+    } else if (target === "vercel") {
+      console.log("  vercel dev                         # test locally");
       console.log("");
-      console.log("  Set via Cloud Run:  gcloud run deploy \u2026 --set-secrets KEY=NAME:latest");
-      console.log("  Or export locally:  export KEY=<value>");
+      if (secretNames.length > 0) {
+        console.log(chalk30.yellow("Required secrets (set via Vercel):"));
+        for (const s of secretNames) {
+          console.log(`  vercel env add ${chalk30.cyan(s)}`);
+        }
+        console.log("");
+      }
+      console.log("Deploy to Vercel Functions:");
+      console.log("  vercel deploy");
+    } else {
+      console.log("  npm run dev                        # test locally");
       console.log("");
+      if (secretNames.length > 0) {
+        console.log(chalk30.yellow("Required secrets (set before deploying):"));
+        for (const s of secretNames) {
+          console.log(`  ${chalk30.cyan(s)}`);
+        }
+        console.log("");
+        console.log("  Set via Cloud Run:  gcloud run deploy \u2026 --set-secrets KEY=NAME:latest");
+        console.log("  Or export locally:  export KEY=<value>");
+        console.log("");
+      }
+      console.log("Deploy to Cloud Run:");
+      console.log(`  gcloud run deploy ${projectName} --source ${options.output} \\`);
+      console.log("    --region us-central1 --platform managed \\");
+      console.log("    --allow-unauthenticated --port 8080");
     }
-    console.log("Deploy to Cloud Run:");
-    console.log(
-      `  gcloud run deploy ${projectName} --source ${options.output} \\`
-    );
-    console.log("    --region us-central1 --platform managed \\");
-    console.log("    --allow-unauthenticated --port 8080");
   }
 );
 
@@ -53873,7 +54794,7 @@ Scaffolding deployment to ${outDir}
 init_credential_store();
 
 // src/lib/update-check.ts
-import chalk30 from "chalk";
+import chalk31 from "chalk";
 import Conf3 from "conf";
 var UPDATE_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1e3;
 var UPDATE_NOTIFY_INTERVAL_MS = 24 * 60 * 60 * 1e3;
@@ -53967,7 +54888,7 @@ function notifyFromCachedCliUpdate(args, options = {}) {
     console.error(message);
   });
   notify(
-    `${chalk30.yellow("Update available:")} ${chalk30.red(currentVersion)} ${chalk30.gray("->")} ${chalk30.green(latestVersion)}  ${chalk30.gray(`(${getUpgradeCommand()})`)}`
+    `${chalk31.yellow("Update available:")} ${chalk31.red(currentVersion)} ${chalk31.gray("->")} ${chalk31.green(latestVersion)}  ${chalk31.gray(`(${getUpgradeCommand()})`)}`
   );
   store.set("lastNotifiedAt", now.toISOString());
   store.set("lastNotifiedVersion", latestVersion);
@@ -54009,7 +54930,7 @@ function maybeNotifyAboutCliUpdate(args, options = {}) {
 // src/index.ts
 loadEnv();
 setCliTitle();
-var program = new Command24();
+var program = new Command25();
 program.name("runtype").description("CLI for Runtype AI Platform").version(getCliVersion()).option("-v, --verbose", "Enable verbose output").option("--api-url <url>", "Override API URL").option("--json", "Output in JSON format");
 program.addCommand(initCommand);
 program.addCommand(loginCommand);
@@ -54031,6 +54952,7 @@ program.addCommand(personaCommand);
 program.addCommand(analyticsCommand);
 program.addCommand(billingCommand);
 program.addCommand(flowVersionsCommand);
+program.addCommand(agentVersionsCommand);
 program.addCommand(createMarathonCommand());
 program.addCommand(tailCommand);
 program.addCommand(validateProductCommand);
@@ -54048,15 +54970,15 @@ try {
 } catch (error51) {
   const commanderError = error51;
   if (commanderError.code === "commander.missingArgument") {
-    console.error(chalk31.red(`Error: ${commanderError.message}`));
+    console.error(chalk32.red(`Error: ${commanderError.message}`));
     process.exit(1);
   } else if (commanderError.code === "commander.unknownOption") {
-    console.error(chalk31.red(`Error: ${commanderError.message}`));
+    console.error(chalk32.red(`Error: ${commanderError.message}`));
     process.exit(1);
   } else if (commanderError.code === "commander.help" || commanderError.code === "commander.version") {
     process.exit(0);
   } else {
-    console.error(chalk31.red("An unexpected error occurred:"));
+    console.error(chalk32.red("An unexpected error occurred:"));
     console.error(error51);
     process.exit(1);
   }
@@ -54065,12 +54987,12 @@ async function handleNoCommand() {
   const store = new CredentialStore();
   const hasCredentials = await store.hasCredentials();
   if (!hasCredentials) {
-    console.log(chalk31.cyan("\nWelcome to Runtype CLI!\n"));
+    console.log(chalk32.cyan("\nWelcome to Runtype CLI!\n"));
     console.log("It looks like this is your first time. Run the setup wizard:");
-    console.log(`  ${chalk31.green("runtype init")}
+    console.log(`  ${chalk32.green("runtype init")}
 `);
     console.log("Or see all available commands:");
-    console.log(`  ${chalk31.green("runtype --help")}
+    console.log(`  ${chalk32.green("runtype --help")}
 `);
   } else {
     try {