@runtypelabs/cli 2.6.2 → 2.7.1

package/dist/index.js

@@ -10906,7 +10906,8 @@ var require_builtin_tools_registry = __commonJS({
       TEXT_TO_SPEECH: "text_to_speech",
       VOICE_PROCESSING: "voice_processing",
       THIRD_PARTY_API: "third_party_api",
-      ARTIFACT: "artifact"
+      ARTIFACT: "artifact",
+      DATA_MANAGEMENT: "data_management"
     };
     exports.BuiltInToolIdPrefix = {
       BUILTIN: "builtin",
@@ -11439,6 +11440,170 @@ var require_builtin_tools_registry = __commonJS({
         },
         executionHint: "platform",
         hidden: true
+      },
+      // Record Management Tools — CRUD operations on Runtype records
+      {
+        id: "runtype_record_upsert",
+        name: "Upsert Record",
+        description: "Create or update a Runtype record with structured metadata. Records are identified by type and name. If a record with the same type and name already exists, it will be updated based on the merge strategy.",
+        category: exports.BuiltInToolCategory.DATA_MANAGEMENT,
+        providers: [exports.BuiltInToolProvider.MULTI],
+        parametersSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              description: 'Record type category (e.g., "customer", "order", "note", "task")'
+            },
+            name: {
+              type: "string",
+              description: "Unique name for this record within its type"
+            },
+            metadata: {
+              type: "object",
+              description: "JSON object containing the record data"
+            },
+            mergeStrategy: {
+              type: "string",
+              description: 'How to handle existing data when updating: "merge" (shallow merge, new keys override) or "replace" (completely replace metadata)',
+              enum: ["merge", "replace"],
+              default: "merge"
+            }
+          },
+          required: ["type", "name", "metadata"]
+        },
+        executionHint: "platform",
+        requiresApiKey: false,
+        platformKeySupport: false
+      },
+      {
+        id: "runtype_record_batch_upsert",
+        name: "Batch Upsert Records",
+        description: "Create or update multiple Runtype records at once in a single transaction. Each record is identified by type and name. Maximum 100 records per call.",
+        category: exports.BuiltInToolCategory.DATA_MANAGEMENT,
+        providers: [exports.BuiltInToolProvider.MULTI],
+        parametersSchema: {
+          type: "object",
+          properties: {
+            records: {
+              type: "array",
+              description: "Array of records to upsert (max 100)",
+              items: {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string",
+                    description: "Record type category"
+                  },
+                  name: {
+                    type: "string",
+                    description: "Unique name within this type"
+                  },
+                  metadata: {
+                    type: "object",
+                    description: "JSON object containing the record data"
+                  }
+                },
+                required: ["type", "name", "metadata"]
+              }
+            },
+            mergeStrategy: {
+              type: "string",
+              description: 'How to handle existing data: "merge" or "replace". Applies to all records.',
+              enum: ["merge", "replace"],
+              default: "merge"
+            }
+          },
+          required: ["records"]
+        },
+        executionHint: "platform",
+        requiresApiKey: false,
+        platformKeySupport: false
+      },
+      {
+        id: "runtype_record_get",
+        name: "Get Record",
+        description: "Retrieve a single Runtype record by its type and name. Returns the full record including metadata, or null if not found.",
+        category: exports.BuiltInToolCategory.DATA_MANAGEMENT,
+        providers: [exports.BuiltInToolProvider.MULTI],
+        parametersSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              description: "Record type to look up"
+            },
+            name: {
+              type: "string",
+              description: "Record name to look up"
+            }
+          },
+          required: ["type", "name"]
+        },
+        executionHint: "platform",
+        requiresApiKey: false,
+        platformKeySupport: false
+      },
+      {
+        id: "runtype_record_list",
+        name: "List Records",
+        description: "List and search Runtype records with optional filtering by type and text search. Returns paginated results.",
+        category: exports.BuiltInToolCategory.DATA_MANAGEMENT,
+        providers: [exports.BuiltInToolProvider.MULTI],
+        parametersSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              description: "Filter by record type (optional)"
+            },
+            search: {
+              type: "string",
+              description: "Text search across record names (optional, case-insensitive)"
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of records to return (1-50, default 20)",
+              minimum: 1,
+              maximum: 50,
+              default: 20
+            },
+            offset: {
+              type: "number",
+              description: "Number of records to skip for pagination (default 0)",
+              minimum: 0,
+              default: 0
+            }
+          },
+          required: []
+        },
+        executionHint: "platform",
+        requiresApiKey: false,
+        platformKeySupport: false
+      },
+      {
+        id: "runtype_record_delete",
+        name: "Delete Record",
+        description: "Delete a Runtype record by its type and name. Returns whether the record was found and deleted.",
+        category: exports.BuiltInToolCategory.DATA_MANAGEMENT,
+        providers: [exports.BuiltInToolProvider.MULTI],
+        parametersSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              description: "Record type of the record to delete"
+            },
+            name: {
+              type: "string",
+              description: "Name of the record to delete"
+            }
+          },
+          required: ["type", "name"]
+        },
+        executionHint: "platform",
+        requiresApiKey: false,
+        platformKeySupport: false
       }
     ];
     exports.BUILTIN_TOOLS_REGISTRY = [
@@ -11655,6 +11820,7 @@ var require_generated_model_routing = __commonJS({
       "glm-4.7-flashx": ["vercel"],
       "glm-5": ["vercel"],
       "glm-5-turbo": ["vercel"],
+      "glm-5v-turbo": ["vercel"],
       "gpt-3-5-turbo": ["vercel"],
       "gpt-3-5-turbo-instruct": ["vercel"],
       "gpt-3.5-turbo": ["openai", "vercel"],
@@ -12117,6 +12283,7 @@ var require_generated_model_routing = __commonJS({
       "glm-4-7-flashx": ["vercel"],
       "glm-5": ["vercel"],
       "glm-5-turbo": ["vercel"],
+      "glm-5v-turbo": ["vercel"],
       "gpt-3-5-turbo": ["openai", "vercel"],
       "gpt-3-5-turbo-0125": ["openai"],
       "gpt-3-5-turbo-0125-batch": ["openai"],
@@ -12917,6 +13084,9 @@ var require_generated_model_routing = __commonJS({
       "glm-5-turbo": {
         "vercel": "zai/glm-5-turbo"
       },
+      "glm-5v-turbo": {
+        "vercel": "zai/glm-5v-turbo"
+      },
       "gpt-3-5-turbo": {
         "openai": "gpt-3.5-turbo",
         "vercel": "openai/gpt-3-5-turbo"
@@ -15401,8 +15571,8 @@ var require_provider_routing = __commonJS({
 });
 
 // src/index.ts
-import { Command as Command21 } from "commander";
-import chalk28 from "chalk";
+import { Command as Command22 } from "commander";
+import chalk29 from "chalk";
 import { config as loadEnv } from "dotenv";
 
 // src/commands/auth.ts
@@ -16433,6 +16603,16 @@ authCommand.command("status").description("Show authentication status").option("
   const { waitUntilExit } = render(React.createElement(App));
   await waitUntilExit();
 });
+authCommand.command("export-key").description("Print the stored API key to stdout (for use in scripts and .env files)").action(async () => {
+  const store = new CredentialStore();
+  const apiKey = await store.getApiKey();
+  if (!apiKey) {
+    console.error("Not authenticated. Run `runtype auth login` first.");
+    process.exit(1);
+    return;
+  }
+  process.stdout.write(apiKey);
+});
 authCommand.command("logout").description("Remove stored credentials").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
   const store = new CredentialStore();
   if (!isTTY(options)) {
@@ -32858,11 +33038,254 @@ flowVersionsCommand.command("publish <flowId>").description("Publish a version")
   await waitUntilExit();
 });
 
+// src/commands/tail.ts
+import { Command as Command21 } from "commander";
+import chalk27 from "chalk";
+function abbreviateId(id) {
+  const underscoreIdx = id.lastIndexOf("_");
+  if (underscoreIdx === -1) {
+    return id.length > 8 ? `${id.slice(0, 8)}...` : id;
+  }
+  const prefix = id.slice(0, underscoreIdx);
+  const suffix = id.slice(underscoreIdx + 1);
+  return `${prefix}_${suffix.slice(0, 4)}...`;
+}
+function formatTime(ts) {
+  const d = new Date(ts);
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  const ms = String(d.getMilliseconds()).padStart(3, "0");
+  return `${hh}:${mm}:${ss}.${ms}`;
+}
+var LEVEL_COLORS = {
+  debug: chalk27.gray,
+  info: chalk27.blue,
+  warn: chalk27.yellow,
+  error: chalk27.red
+};
+function levelBadge(level, useColor) {
+  const tag = level.toUpperCase().padEnd(5);
+  if (!useColor) return `[${tag}]`;
+  const colorFn = LEVEL_COLORS[level] || chalk27.white;
+  return colorFn(`[${tag}]`);
+}
+function categoryBadge(category, useColor) {
+  if (!useColor) return `[${category}]`;
+  return chalk27.magenta(`[${category}]`);
+}
+function formatTailData(data) {
+  return Object.entries(data).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+}
+function formatContextIds(event, useColor) {
+  const ids = [];
+  if (event.executionId) ids.push(`exec=${abbreviateId(event.executionId)}`);
+  if (event.flowId) ids.push(`flow=${abbreviateId(event.flowId)}`);
+  if (event.agentId) ids.push(`agent=${abbreviateId(event.agentId)}`);
+  if (event.surfaceId) ids.push(`surface=${abbreviateId(event.surfaceId)}`);
+  if (event.requestId) ids.push(`req=${abbreviateId(event.requestId)}`);
+  if (event.conversationId) ids.push(`conv=${abbreviateId(event.conversationId)}`);
+  if (ids.length === 0) return "";
+  const text = ids.join(" ");
+  return useColor ? chalk27.gray(` ${text}`) : ` ${text}`;
+}
+function formatEvent(event, useColor) {
+  const time = useColor ? chalk27.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)}` : "";
+  return `${time} ${level} ${cat} ${event.message}${data}${ctx}`;
+}
+async function consumeSSEStream(reader, options, signal) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const useColor = options.color;
+  while (!signal.aborted) {
+    const { done, value } = await reader.read();
+    if (done) return "eof";
+    buffer += decoder.decode(value, { stream: true });
+    let boundary;
+    while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+      const chunk = buffer.slice(0, boundary);
+      buffer = buffer.slice(boundary + 2);
+      const dataLines = [];
+      for (const line of chunk.split("\n")) {
+        if (line.startsWith("data: ")) {
+          dataLines.push(line.slice(6));
+        }
+      }
+      if (dataLines.length === 0) continue;
+      const raw = dataLines.join("\n");
+      let msg;
+      try {
+        msg = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      switch (msg.type) {
+        case "tail_event":
+          if (options.json) {
+            process.stdout.write(JSON.stringify(msg.event) + "\n");
+          } else {
+            process.stdout.write(formatEvent(msg.event, useColor) + "\n");
+          }
+          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"
+          );
+          break;
+        case "tail_connected":
+          process.stderr.write(
+            (useColor ? chalk27.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"
+          );
+          break;
+      }
+    }
+  }
+  return "aborted";
+}
+async function createSession(apiUrl, apiKey, filters) {
+  const filter = {};
+  const arrayFields = {
+    flowId: "flowIds",
+    agentId: "agentIds",
+    surfaceId: "surfaceIds",
+    executionId: "executionIds",
+    level: "levels",
+    category: "categories"
+  };
+  for (const [k, v] of Object.entries(filters)) {
+    if (v !== void 0 && arrayFields[k]) {
+      filter[arrayFields[k]] = [v];
+    }
+  }
+  const body = Object.keys(filter).length > 0 ? { filter } : {};
+  const res = await fetch(`${apiUrl}/v1/tail/sessions`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "User-Agent": `Runtype-CLI/${getCliVersion()}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Failed to create tail session: ${res.status} ${res.statusText}${text ? ` \u2014 ${text}` : ""}`);
+  }
+  return await res.json();
+}
+async function connectAndStream(sseUrl, apiKey, options, signal) {
+  const res = await fetch(sseUrl, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      Accept: "text/event-stream",
+      "User-Agent": `Runtype-CLI/${getCliVersion()}`
+    },
+    signal
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`SSE connection failed: ${res.status} ${res.statusText}${text ? ` \u2014 ${text}` : ""}`);
+  }
+  if (!res.body) {
+    throw new Error("SSE response has no body");
+  }
+  const reader = res.body.getReader();
+  try {
+    return await consumeSSEStream(reader, options, signal);
+  } finally {
+    reader.releaseLock();
+  }
+}
+var BASE_DELAY_MS = 1e3;
+var MAX_DELAY_MS = 3e4;
+var MAX_ATTEMPTS = 10;
+async function runTail(options) {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const apiUrl = getApiUrl();
+  const filters = {
+    flowId: options.flow,
+    agentId: options.agent,
+    surfaceId: options.surface,
+    executionId: options.execution,
+    level: options.level,
+    category: options.category
+  };
+  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"
+  );
+  const controller = new AbortController();
+  let shuttingDown = false;
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    process.stderr.write(
+      (useColor ? chalk27.gray("\nDisconnecting...") : "\nDisconnecting...") + "\n"
+    );
+    controller.abort();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  let attempt = 0;
+  while (!shuttingDown && attempt < MAX_ATTEMPTS) {
+    try {
+      const session = await createSession(apiUrl, apiKey, filters);
+      attempt = 0;
+      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"
+      );
+    } catch (err) {
+      if (shuttingDown || controller.signal.aborted) break;
+      attempt++;
+      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"
+      );
+      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"
+        );
+        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"
+      );
+      await new Promise((resolve8) => {
+        const timer = setTimeout(resolve8, delay);
+        const onAbort = () => {
+          clearTimeout(timer);
+          resolve8();
+        };
+        controller.signal.addEventListener("abort", onAbort, { once: true });
+      });
+    }
+  }
+  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) => {
+  await runTail(options);
+});
+
 // src/index.ts
 init_credential_store();
 
 // src/lib/update-check.ts
-import chalk27 from "chalk";
+import chalk28 from "chalk";
 import Conf3 from "conf";
 var UPDATE_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1e3;
 var UPDATE_NOTIFY_INTERVAL_MS = 24 * 60 * 60 * 1e3;
@@ -32956,7 +33379,7 @@ function notifyFromCachedCliUpdate(args, options = {}) {
     console.error(message);
   });
   notify(
-    `${chalk27.yellow("Update available:")} ${chalk27.red(currentVersion)} ${chalk27.gray("->")} ${chalk27.green(latestVersion)}  ${chalk27.gray(`(${getUpgradeCommand()})`)}`
+    `${chalk28.yellow("Update available:")} ${chalk28.red(currentVersion)} ${chalk28.gray("->")} ${chalk28.green(latestVersion)}  ${chalk28.gray(`(${getUpgradeCommand()})`)}`
   );
   store.set("lastNotifiedAt", now.toISOString());
   store.set("lastNotifiedVersion", latestVersion);
@@ -32998,7 +33421,7 @@ function maybeNotifyAboutCliUpdate(args, options = {}) {
 // src/index.ts
 loadEnv();
 setCliTitle();
-var program = new Command21();
+var program = new Command22();
 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);
@@ -33021,6 +33444,7 @@ program.addCommand(analyticsCommand);
 program.addCommand(billingCommand);
 program.addCommand(flowVersionsCommand);
 program.addCommand(createMarathonCommand());
+program.addCommand(tailCommand);
 program.exitOverride();
 try {
   const userArgs = process.argv.slice(2);
@@ -33034,15 +33458,15 @@ try {
 } catch (error) {
   const commanderError = error;
   if (commanderError.code === "commander.missingArgument") {
-    console.error(chalk28.red(`Error: ${commanderError.message}`));
+    console.error(chalk29.red(`Error: ${commanderError.message}`));
     process.exit(1);
   } else if (commanderError.code === "commander.unknownOption") {
-    console.error(chalk28.red(`Error: ${commanderError.message}`));
+    console.error(chalk29.red(`Error: ${commanderError.message}`));
     process.exit(1);
   } else if (commanderError.code === "commander.help" || commanderError.code === "commander.version") {
     process.exit(0);
   } else {
-    console.error(chalk28.red("An unexpected error occurred:"));
+    console.error(chalk29.red("An unexpected error occurred:"));
     console.error(error);
     process.exit(1);
   }
@@ -33051,12 +33475,12 @@ async function handleNoCommand() {
   const store = new CredentialStore();
   const hasCredentials = await store.hasCredentials();
   if (!hasCredentials) {
-    console.log(chalk28.cyan("\nWelcome to Runtype CLI!\n"));
+    console.log(chalk29.cyan("\nWelcome to Runtype CLI!\n"));
     console.log("It looks like this is your first time. Run the setup wizard:");
-    console.log(`  ${chalk28.green("runtype init")}
+    console.log(`  ${chalk29.green("runtype init")}
 `);
     console.log("Or see all available commands:");
-    console.log(`  ${chalk28.green("runtype --help")}
+    console.log(`  ${chalk29.green("runtype --help")}
 `);
   } else {
     try {
@@ -33071,4 +33495,3 @@ async function handleNoCommand() {
     }
   }
 }
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/cli",
-  "version": "2.6.2",
+  "version": "2.7.1",
   "description": "Command-line interface for Runtype AI platform",
   "type": "module",
   "main": "dist/index.js",
@@ -22,8 +22,8 @@
     "uuid": "^9.0.1",
     "micromatch": "^4.0.8",
     "yaml": "^2.8.3",
-    "@runtypelabs/ink-components": "0.3.0",
-    "@runtypelabs/sdk": "1.13.0",
+    "@runtypelabs/sdk": "1.13.1",
+    "@runtypelabs/ink-components": "0.3.1",
     "@runtypelabs/terminal-animations": "0.2.0"
   },
   "devDependencies": {