@runtypelabs/cli 2.16.7 → 2.16.8

package/dist/index.js

@@ -544,6 +544,363 @@ import { RuntypeApiError } from "@runtypelabs/sdk";
 // src/lib/sdk-client.ts
 import { createClient } from "@runtypelabs/sdk";
 
+// ../shared/dist/chunk-MYXAZOFG.mjs
+var travrseConfig = {
+  name: "Travrse",
+  nameLower: "travrse",
+  tagline: "AI ambition, meet reality",
+  description: "Fast-track AI implementation for every team. API for developers, dashboard for business users. From idea to production in minutes, with or without code.",
+  url: "https://www.travrse.ai",
+  website: "https://travrse.ai",
+  domain: "travrse.ai",
+  npmScope: "@travrse",
+  cliCommand: "travrse",
+  githubOrg: "travrse-io",
+  legalEntity: "Travrse Labs, Inc",
+  support: {
+    email: "support@travrse.ai"
+  },
+  dashboardUrl: "https://run.travrse.ai",
+  apiUrl: "https://api.travrse.ai",
+  docsUrl: "https://docs.travrse.ai"
+};
+var runtypeConfig = {
+  name: "Runtype",
+  nameLower: "runtype",
+  tagline: "Your AI Product Platform",
+  description: "Build and deploy AI experiences faster than ever. Powerful API for developers, intuitive dashboard for teams.",
+  url: "https://www.runtype.com",
+  website: "https://runtype.com",
+  domain: "runtype.com",
+  npmScope: "@runtypelabs",
+  cliCommand: "runtype",
+  githubOrg: "runtypelabs",
+  legalEntity: "Travrse Labs, Inc",
+  support: {
+    email: "support@runtype.com"
+  },
+  dashboardUrl: "https://use.runtype.com",
+  apiUrl: "https://api.runtype.com",
+  docsUrl: "https://docs.runtype.com"
+};
+var BRAND_CONFIGS = {
+  travrse: travrseConfig,
+  runtype: runtypeConfig
+  // Add more brand configs here:
+  // mybrand: myBrandConfig,
+};
+var DEFAULT_BRAND_NAME = "runtype";
+function loadBrandConfig(env) {
+  let configName = DEFAULT_BRAND_NAME;
+  try {
+    if (env) {
+      configName = env.NEXT_PUBLIC_BRAND_CONFIG_NAME || env.BRAND_CONFIG_NAME || DEFAULT_BRAND_NAME;
+    } else {
+      configName = process.env.NEXT_PUBLIC_BRAND_CONFIG_NAME || process.env.BRAND_CONFIG_NAME || DEFAULT_BRAND_NAME;
+    }
+  } catch (error51) {
+    configName = DEFAULT_BRAND_NAME;
+  }
+  const config3 = BRAND_CONFIGS[configName];
+  if (!config3) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        `Brand config "${configName}" not found. Available configs: ${Object.keys(BRAND_CONFIGS).join(", ")}. Falling back to "${DEFAULT_BRAND_NAME}".`
+      );
+    }
+    return BRAND_CONFIGS[DEFAULT_BRAND_NAME];
+  }
+  return config3;
+}
+var BRAND = loadBrandConfig();
+var DEFAULT_BRAND_CONFIG = BRAND_CONFIGS[DEFAULT_BRAND_NAME];
+
+// ../shared/dist/chunk-3BMGMHHD.mjs
+function getNestedValue(obj, path16) {
+  let normalizedPath = path16;
+  normalizedPath = normalizedPath.replace(/^\$\.?/, "");
+  normalizedPath = normalizedPath.replace(/\[(\d+)\]/g, ".$1");
+  normalizedPath = normalizedPath.replace(/\[['"]([^'"\]]+)['"]\]/g, ".$1");
+  normalizedPath = normalizedPath.replace(/\[([^'"\]]+)\]/g, ".$1");
+  normalizedPath = normalizedPath.replace(/^\./, "");
+  const keys = normalizedPath.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (current === null || current === void 0 || key === void 0) {
+      return void 0;
+    }
+    if (Array.isArray(current)) {
+      if (/^\d+$/.test(key)) {
+        const index = parseInt(key, 10);
+        if (index >= 0 && index < current.length) {
+          current = current[index];
+        } else {
+          return void 0;
+        }
+      } else {
+        return void 0;
+      }
+    } else if (current && typeof current === "object") {
+      if (DANGEROUS_KEYS.has(key)) return void 0;
+      current = current[key];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var TEMPLATE_EXPRESSION_PATTERN = /\{\{([^{}]+)\}\}/g;
+function parseTemplateExpression(expr) {
+  const tokens = tokenizeFallbackExpression(expr);
+  if (tokens) {
+    return {
+      kind: "fallback",
+      operator: tokens.operator,
+      operands: tokens.rawOperands.map(parseOperand)
+    };
+  }
+  const trimmed = expr.trim();
+  const pipeIndex = trimmed.indexOf("|");
+  if (pipeIndex === -1) {
+    return { kind: "legacy", variable: trimmed };
+  }
+  return {
+    kind: "legacy",
+    variable: trimmed.slice(0, pipeIndex).trim(),
+    defaultValue: trimmed.slice(pipeIndex + 1).trim()
+  };
+}
+function tokenizeFallbackExpression(expr) {
+  const operands = [];
+  let current = "";
+  let quote = null;
+  let operator = null;
+  for (let i = 0; i < expr.length; i++) {
+    const ch = expr[i];
+    if (quote) {
+      current += ch;
+      if (ch === quote && countTrailingBackslashes(expr, i) % 2 === 0) {
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "|" && expr[i + 1] === "|") {
+      if (operator === "??") {
+        throw new Error(
+          `Cannot mix '||' and '??' in template expression: "${expr}". Use one operator or wrap branches in separate {{...}} blocks.`
+        );
+      }
+      operator = "||";
+      operands.push(current);
+      current = "";
+      i++;
+      continue;
+    }
+    if (ch === "?" && expr[i + 1] === "?") {
+      if (operator === "||") {
+        throw new Error(
+          `Cannot mix '||' and '??' in template expression: "${expr}". Use one operator or wrap branches in separate {{...}} blocks.`
+        );
+      }
+      operator = "??";
+      operands.push(current);
+      current = "";
+      i++;
+      continue;
+    }
+    current += ch;
+  }
+  if (operator === null) return null;
+  operands.push(current);
+  return { rawOperands: operands, operator };
+}
+function parseOperand(raw) {
+  const t = raw.trim();
+  if (t.startsWith('"') && t.endsWith('"') && t.length >= 2 || t.startsWith("'") && t.endsWith("'") && t.length >= 2) {
+    const inner = t.slice(1, -1);
+    return { kind: "literal", value: inner.replace(/\\(.)/g, "$1") };
+  }
+  if (/^-?\d+(\.\d+)?$/.test(t)) {
+    return { kind: "literal", value: Number(t) };
+  }
+  if (t === "true") return { kind: "literal", value: true };
+  if (t === "false") return { kind: "literal", value: false };
+  if (t === "null") return { kind: "literal", value: null };
+  return { kind: "path", path: t };
+}
+function evaluateOperand(operand, context) {
+  if (operand.kind === "literal") return operand.value;
+  return getNestedValue(context, operand.path);
+}
+function countTrailingBackslashes(s, i) {
+  let n = 0;
+  let j = i - 1;
+  while (j >= 0 && s[j] === "\\") {
+    n++;
+    j--;
+  }
+  return n;
+}
+function passesOperator(value, operator) {
+  if (operator === "||") return Boolean(value);
+  return value !== null && value !== void 0;
+}
+function stringifyValue(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+var _SimpleTemplateEngine = class _SimpleTemplateEngine2 {
+  substitute(template, context = {}) {
+    const usedVariables = [];
+    const usedDefaults = [];
+    const missingVariables = [];
+    const result = template.replace(_SimpleTemplateEngine2.EXPRESSION_PATTERN, (match, expr) => {
+      let parsed;
+      try {
+        parsed = parseTemplateExpression(expr);
+      } catch {
+        return match;
+      }
+      if (parsed.kind === "legacy") {
+        return resolveLegacy(parsed, context, {
+          usedVariables,
+          usedDefaults,
+          missingVariables,
+          match
+        });
+      }
+      return resolveFallback(parsed, context, {
+        usedVariables,
+        missingVariables,
+        match
+      });
+    });
+    return {
+      result,
+      usedVariables,
+      usedDefaults,
+      missingVariables
+    };
+  }
+  /**
+   * Extract all variable references from a template.
+   * Each `{{ ... }}` produces one entry; for fallback expressions the entry
+   * carries every path operand under `paths`, and `hasDefault: true` whenever
+   * the chain has any non-path terminal (literal) the user can fall back to.
+   */
+  extractVariables(template) {
+    const out = [];
+    const pattern = new RegExp(_SimpleTemplateEngine2.EXPRESSION_PATTERN.source, "g");
+    let match;
+    while (match = pattern.exec(template)) {
+      const expr = match[1];
+      if (!expr) continue;
+      let parsed;
+      try {
+        parsed = parseTemplateExpression(expr);
+      } catch {
+        continue;
+      }
+      if (parsed.kind === "legacy") {
+        if (!parsed.variable) continue;
+        out.push({
+          variable: parsed.variable,
+          hasDefault: parsed.defaultValue !== void 0,
+          defaultValue: parsed.defaultValue
+        });
+        continue;
+      }
+      const paths = parsed.operands.filter((o) => o.kind === "path").map((o) => o.path);
+      const hasLiteralFallback = parsed.operands.some((o) => o.kind === "literal");
+      const primary = paths[0] ?? "";
+      out.push({
+        variable: primary,
+        hasDefault: hasLiteralFallback,
+        paths
+      });
+    }
+    return out;
+  }
+  /**
+   * Validate that a template can be processed with given context.
+   * Returns warnings and errors.
+   */
+  validate(template, context = {}) {
+    const warnings = [];
+    const errors = [];
+    try {
+      const result = this.substitute(template, context);
+      if (result.usedDefaults.length > 0) {
+        warnings.push(
+          `Used ${result.usedDefaults.length} default values: ${result.usedDefaults.map((d) => d.variable).join(", ")}`
+        );
+      }
+      if (result.missingVariables.length > 0) {
+        errors.push(`Missing variables without defaults: ${result.missingVariables.join(", ")}`);
+      }
+      return {
+        isValid: errors.length === 0,
+        warnings,
+        errors
+      };
+    } catch (error51) {
+      return {
+        isValid: false,
+        warnings,
+        errors: [`Template parsing error: ${error51}`]
+      };
+    }
+  }
+};
+_SimpleTemplateEngine.EXPRESSION_PATTERN = TEMPLATE_EXPRESSION_PATTERN;
+var SimpleTemplateEngine = _SimpleTemplateEngine;
+function resolveLegacy(parsed, context, tracking) {
+  const value = getNestedValue(context, parsed.variable);
+  if (value !== void 0 && value !== null) {
+    tracking.usedVariables.push(parsed.variable);
+    return stringifyValue(value);
+  }
+  if (parsed.defaultValue !== void 0) {
+    tracking.usedDefaults.push({
+      variable: parsed.variable,
+      defaultValue: parsed.defaultValue
+    });
+    return parsed.defaultValue;
+  }
+  tracking.missingVariables.push(parsed.variable);
+  return tracking.match;
+}
+function resolveFallback(parsed, context, tracking) {
+  let chosen = null;
+  for (const operand of parsed.operands) {
+    const value = evaluateOperand(operand, context);
+    if (operand.kind === "path" && value !== void 0) {
+      tracking.usedVariables.push(operand.path);
+    }
+    if (chosen === null && passesOperator(value, parsed.operator)) {
+      chosen = { value, isPath: operand.kind === "path" };
+    }
+  }
+  if (chosen) return stringifyValue(chosen.value);
+  const last = parsed.operands[parsed.operands.length - 1];
+  if (last && last.kind === "literal") {
+    return stringifyValue(last.value);
+  }
+  for (const operand of parsed.operands) {
+    if (operand.kind === "path") tracking.missingVariables.push(operand.path);
+  }
+  return tracking.match;
+}
+var templateEngine = new SimpleTemplateEngine();
+
 // ../../node_modules/.pnpm/zod@4.4.2/node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -17069,6 +17426,15 @@ var PROVIDER_SECRET_SPECS = [
     matches: (m) => m.startsWith("generic-openai/") || m.startsWith("generic-openai:"),
     secretNames: ["GENERIC_OPENAI_API_KEY", "GENERIC_OPENAI_BASE_URL"]
   },
+  {
+    providerId: "general-compute",
+    // General Compute (https://api.generalcompute.com/v1) is an OpenAI-compatible
+    // host. Models are addressed only with the explicit `general-compute/` prefix
+    // (e.g. `general-compute/minimax-m2.7`) so they never collide with the same
+    // bare model id served by another gateway (Vercel already routes `minimax-m2.7`).
+    matches: (m) => m.startsWith("general-compute/") || m.startsWith("general-compute:"),
+    secretNames: ["GENERAL_COMPUTE_API_KEY"]
+  },
   {
     providerId: "workers-ai",
     // Uses a CF platform binding, not a secret — secretNames is intentionally empty.
@@ -32786,6 +33152,8 @@ var DEFAULT_MODELS_FOR_NEW_ACCOUNTS = [
   // Mixlayer models
   { provider: "runtype", modelId: "qwen/qwen3.5-9b", isDefault: true },
   { provider: "runtype", modelId: "qwen3.5-plus", isDefault: false },
+  // General Compute (platform key) - explicit provider prefix, single-provider model
+  { provider: "runtype", modelId: "general-compute/minimax-m2.7", isDefault: false },
   // Routed models - benefit from automatic provider optimization
   // OpenAI models (routed via OpenAI direct, with Vercel fallback)
   { provider: "runtype", modelId: "gpt-5.4", isDefault: false },
@@ -34061,6 +34429,7 @@ var PLATFORM_KEY_PROVIDER_MAP = {
   "vertex-anthropic": false,
   "tinfoil": false,
   "generic-openai": false,
+  "general-compute": true,
   "workers-ai": false,
   "mock": false
 };
@@ -34104,6 +34473,15 @@ var MANUAL_PROVIDER_MAP_OVERRIDES = {
   },
   "gpt-oss-120b": {
     "workers-ai": "@cf/openai/gpt-oss-120b"
+  },
+  // MiniMax M2.7: explicit provider IDs for the GC-primary / Vercel-fallback route.
+  // `general-compute` is NOT in PROVIDERS_WITHOUT_PREFIX, so resolveRoutedFamily
+  // prepends `general-compute/` itself — store the BARE id here to avoid a double
+  // prefix (`general-compute/general-compute/...`). Vercel IS prefixless, so its
+  // value is the gateway-form `minimax/minimax-m2.7` used as-is.
+  "minimax-m2.7": {
+    "general-compute": "minimax-m2.7",
+    "vercel": "minimax/minimax-m2.7"
   }
 };
 var BASE_MODEL_PROVIDER_MAP = (() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/cli",
-  "version": "2.16.7",
+  "version": "2.16.8",
   "description": "Command-line interface for Runtype AI platform",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "rosie-skills": "0.8.1",
     "yaml": "^2.9.0",
     "@runtypelabs/ink-components": "0.3.2",
-    "@runtypelabs/sdk": "4.1.0",
+    "@runtypelabs/sdk": "4.2.0",
     "@runtypelabs/terminal-animations": "0.2.1"
   },
   "devDependencies": {
@@ -36,7 +36,7 @@
     "tsx": "^4.7.1",
     "typescript": "^5.3.3",
     "vitest": "^4.1.0",
-    "@runtypelabs/shared": "1.12.0"
+    "@runtypelabs/shared": "1.13.2"
   },
   "engines": {
     "node": ">=22.0.0"