@runtypelabs/cli 2.16.6 → 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, {
@@ -16591,6 +16948,173 @@ var promptConfigSchema = external_exports.object({
   mode: external_exports.string().optional()
   // UI mode (task, agent, etc.)
 });
+var conditionalConfigSchema = external_exports.object({
+  condition: external_exports.string().min(1, "Condition is required"),
+  trueSteps: external_exports.array(external_exports.lazy(() => contextStepSchema)),
+  falseSteps: external_exports.array(external_exports.lazy(() => contextStepSchema)).optional()
+});
+var saveMemoryConfigSchema = external_exports.object({
+  profileTemplate: external_exports.string().min(1, "Profile template is required"),
+  contentVariable: external_exports.string().min(1, "Content variable is required"),
+  sessionId: external_exports.string().nullable().optional(),
+  outputVariable: external_exports.string().optional(),
+  errorHandling: contextErrorHandlingConfigSchema.optional(),
+  defaultValue: external_exports.any().optional()
+});
+var recallMemoryConfigSchema = external_exports.object({
+  profileTemplate: external_exports.string().min(1, "Profile template is required"),
+  queryTemplate: external_exports.string().min(1, "Query template is required"),
+  thinkingLevel: external_exports.enum(["low", "medium", "high"]).optional(),
+  responseLength: external_exports.enum(["short", "medium", "long"]).optional(),
+  outputVariable: external_exports.string().min(1, "Output variable is required"),
+  errorHandling: contextErrorHandlingConfigSchema.optional(),
+  defaultValue: external_exports.any().optional()
+});
+var memorySummaryConfigSchema = external_exports.object({
+  profileTemplate: external_exports.string().min(1, "Profile template is required"),
+  sessionId: external_exports.string().nullable().optional(),
+  outputVariable: external_exports.string().min(1, "Output variable is required"),
+  errorHandling: contextErrorHandlingConfigSchema.optional(),
+  defaultValue: external_exports.any().optional()
+});
+var sharedStepConfigSchemas = {
+  "set-variable": setVariableConfigSchema,
+  "send-stream": sendStreamConfigSchema,
+  "fetch-github": fetchGithubConfigSchema,
+  "api-call": apiCallConfigSchema,
+  "execute-agent": executeAgentConfigSchema,
+  "fetch-url": fetchUrlConfigSchema,
+  crawl: crawlConfigSchema,
+  search: searchConfigSchema,
+  "send-text": sendTextConfigSchema,
+  "send-event": sendEventConfigSchema,
+  "store-asset": storeAssetConfigSchema,
+  "generate-pdf": generatePdfConfigSchema,
+  template: templateConfigSchema,
+  "wait-until": waitUntilConfigSchema,
+  "generate-embedding": generateEmbeddingConfigSchema,
+  "vector-search": vectorSearchConfigSchema,
+  "tool-call": toolCallConfigSchema,
+  "store-vector": storeVectorConfigSchema,
+  "upsert-record": upsertRecordConfigSchema,
+  "send-email": sendEmailConfigSchema,
+  "paginate-api": paginateApiConfigSchema,
+  "retrieve-record": retrieveRecordConfigSchema,
+  "update-record": updateRecordConfigSchema,
+  "transform-data": transformDataConfigSchema,
+  prompt: promptConfigSchema,
+  conditional: conditionalConfigSchema,
+  "save-memory": saveMemoryConfigSchema,
+  "recall-memory": recallMemoryConfigSchema,
+  "memory-summary": memorySummaryConfigSchema
+};
+var makeNestedStepEnvelope = (type, configSchema) => external_exports.object({
+  type: external_exports.literal(type),
+  config: configSchema,
+  id: external_exports.string().optional(),
+  name: external_exports.string().optional(),
+  order: external_exports.number().optional(),
+  enabled: external_exports.boolean().optional(),
+  when: external_exports.string().optional()
+}).passthrough();
+var contextStepSchema = external_exports.discriminatedUnion(
+  "type",
+  Object.entries(sharedStepConfigSchemas).map(
+    ([type, configSchema]) => makeNestedStepEnvelope(type, configSchema)
+  )
+);
+var CONTEXT_STEP_TYPES = [
+  "crawl",
+  "fetch-url",
+  "retrieve-record",
+  "fetch-github",
+  "api-call",
+  "transform-data",
+  "template",
+  "conditional",
+  "set-variable",
+  "upsert-record",
+  "send-email",
+  "send-text",
+  "send-event",
+  "send-stream",
+  "update-record",
+  "search",
+  "generate-embedding",
+  "vector-search",
+  "tool-call",
+  "wait-until",
+  "paginate-api",
+  "store-vector",
+  "execute-agent",
+  "store-asset",
+  "generate-pdf",
+  "save-memory",
+  "recall-memory",
+  "memory-summary"
+];
+var FLOW_STEP_TYPES = ["prompt", ...CONTEXT_STEP_TYPES];
+var flowStepValidationSchema = external_exports.object({
+  // Optional stable client-supplied identifier. Preserved across saves so that
+  // `flow_step_results.stepId` references stay valid and dashboard UI state
+  // (test-step modal, deeplinks, in-flight requests) doesn't go stale after a
+  // save. When omitted the server mints one.
+  id: external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9_\-:.]+$/, "Step id must be alphanumeric with _ - : . only").optional(),
+  type: external_exports.enum(FLOW_STEP_TYPES),
+  name: external_exports.string().min(1, "Step name is required"),
+  order: external_exports.number().int().min(0).optional(),
+  enabled: external_exports.boolean().default(true),
+  when: external_exports.string().max(500).optional(),
+  config: external_exports.any()
+});
+var createFlowValidationSchema = external_exports.object({
+  name: external_exports.string().min(1, "Flow name is required"),
+  flowSteps: external_exports.array(flowStepValidationSchema).optional(),
+  // Backward compatibility: some clients still send `steps` instead of `flowSteps`.
+  steps: external_exports.array(flowStepValidationSchema).optional()
+}).refine((data) => !(data.flowSteps && data.steps), {
+  message: "Provide either 'flowSteps' or 'steps', not both.",
+  path: ["flowSteps"]
+}).transform((data) => ({
+  name: data.name,
+  flowSteps: data.flowSteps ?? data.steps ?? []
+}));
+var updateFlowValidationSchema = external_exports.object({
+  name: external_exports.string().min(1, "Flow name is required").optional(),
+  flowSteps: external_exports.array(flowStepValidationSchema).optional()
+});
+var CAMEL_CASE_TOOL_KEYS = {
+  toolIds: true,
+  toolConfigs: true,
+  runtimeTools: true,
+  mcpServers: true,
+  maxToolCalls: true,
+  toolCallStrategy: true,
+  parallelCalls: true,
+  perToolLimits: true,
+  approval: true,
+  subagentConfig: true,
+  codeModeConfig: true,
+  toolSearch: true
+};
+var SNAKE_CASE_TOOL_KEYS = {
+  tool_ids: true,
+  tool_configs: true,
+  runtime_tools: true,
+  mcp_servers: true,
+  max_tool_calls: true,
+  tool_call_strategy: true,
+  parallel_calls: true,
+  per_tool_limits: true,
+  approval: true,
+  subagent_config: true,
+  code_mode_config: true,
+  tool_search: true
+};
+var KNOWN_TOOL_KEYS = /* @__PURE__ */ new Set([
+  ...Object.keys(CAMEL_CASE_TOOL_KEYS),
+  ...Object.keys(SNAKE_CASE_TOOL_KEYS)
+]);
 var SERIALIZED_HELPERS_SOURCE = `
 // Transform helper functions (from packages/shared/src/transform-helpers.ts)
 const helpers = (function createHelpers() {
@@ -16860,34 +17384,6 @@ const helpers = (function createHelpers() {
   }
 })()
 `.trim();
-var CONTEXT_STEP_TYPES = [
-  "crawl",
-  "fetch-url",
-  "retrieve-record",
-  "fetch-github",
-  "api-call",
-  "transform-data",
-  "template",
-  "conditional",
-  "set-variable",
-  "upsert-record",
-  "send-email",
-  "send-text",
-  "send-event",
-  "send-stream",
-  "update-record",
-  "search",
-  "generate-embedding",
-  "vector-search",
-  "tool-call",
-  "wait-until",
-  "paginate-api",
-  "store-vector",
-  "execute-agent",
-  "store-asset",
-  "generate-pdf"
-];
-var FLOW_STEP_TYPES = ["prompt", ...CONTEXT_STEP_TYPES];
 var PROVIDER_SECRET_SPECS = [
   // ----- Explicit-prefix providers -----
   {
@@ -16930,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.
@@ -31165,6 +31670,87 @@ var CORE_BUILTIN_TOOLS_REGISTRY = [
     requiresApiKey: false,
     executionHint: "platform",
     platformKeySupport: true
+  },
+  // -----------------------------------------------------------------------
+  // Memory tools — require agent.config.memory.enabled (resolved per turn by
+  // the agent loop; absent until then, so these fail closed with
+  // `memory_not_enabled`). Semantics mirror the non-destructive session API:
+  // save, recall, and summary only — no destructive per-memory delete.
+  // -----------------------------------------------------------------------
+  {
+    id: "save_memory",
+    name: "Save to Memory",
+    description: "Save a fact, preference, or observation to long-term memory. Use when the user tells you something worth remembering across sessions \u2014 preferences, names, decisions, rules they want enforced. Pass the information as a plain sentence. Returns { success, memoryId, type, summary }.",
+    category: BuiltInToolCategory.DATA_MANAGEMENT,
+    providers: [BuiltInToolProvider.MULTI],
+    parametersSchema: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: 'Natural-language statement to remember. Example: "User prefers dark mode" or "Meeting with Acme is rescheduled to Friday."',
+          minLength: 1
+        },
+        sessionId: {
+          type: "string",
+          description: "Optional session scope for the memory. Omit to store against the profile default."
+        }
+      },
+      required: ["content"]
+    },
+    executionHint: "platform",
+    requiresApiKey: false,
+    platformKeySupport: false
+  },
+  {
+    id: "recall_memory",
+    name: "Recall from Memory",
+    description: "Search long-term memory for information relevant to a query. Returns a synthesized answer plus scored candidate memories with IDs. Call this whenever the user refers to past conversations, prior decisions, or things you should already know. Returns { answer, count, candidates: [{ id, summary, score }] }.",
+    category: BuiltInToolCategory.DATA_MANAGEMENT,
+    providers: [BuiltInToolProvider.MULTI],
+    parametersSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: 'Natural-language query. Example: "What are the user preferences?"',
+          minLength: 1
+        },
+        thinkingLevel: {
+          type: "string",
+          enum: ["low", "medium", "high"],
+          description: 'Controls search breadth. Default "low" is usually sufficient; raise to "medium" or "high" for ambiguous questions.'
+        },
+        responseLength: {
+          type: "string",
+          enum: ["short", "medium", "long"],
+          description: 'Controls how detailed the synthesized answer is. Default "medium"; use "short" for a quick fact lookup or "long" for a thorough recall.'
+        }
+      },
+      required: ["query"]
+    },
+    executionHint: "platform",
+    requiresApiKey: false,
+    platformKeySupport: false
+  },
+  {
+    id: "memory_summary",
+    name: "Get Memory Summary",
+    description: "Fetch a Markdown summary of what you know \u2014 key facts, recent events, active tasks, last session, and standing instructions. Useful at the start of a session to orient yourself. Returns { summary }.",
+    category: BuiltInToolCategory.DATA_MANAGEMENT,
+    providers: [BuiltInToolProvider.MULTI],
+    parametersSchema: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Optional session scope. When provided, the summary covers that session; omit for a profile-wide summary."
+        }
+      }
+    },
+    executionHint: "platform",
+    requiresApiKey: false,
+    platformKeySupport: false
   }
 ];
 var BUILTIN_TOOLS_REGISTRY = [
@@ -32566,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 },
@@ -33841,6 +34429,7 @@ var PLATFORM_KEY_PROVIDER_MAP = {
   "vertex-anthropic": false,
   "tinfoil": false,
   "generic-openai": false,
+  "general-compute": true,
   "workers-ai": false,
   "mock": false
 };
@@ -33884,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 = (() => {
@@ -34740,6 +35338,18 @@ var temporalConfigSchema = external_exports.object({
   groundNow: external_exports.boolean().optional(),
   timezone: external_exports.string().optional()
 });
+var memoryConfigSchema = external_exports.object({
+  enabled: external_exports.boolean(),
+  profileTemplate: external_exports.string().optional(),
+  // When omitted and `enabled` is true, treated as `true` (smart default): a
+  // Markdown memory summary is woven into the agent's system prompt on each
+  // turn so the agent always has the user in context — without the model having
+  // to call `recall_memory` first. (The summary is cached per profile so the
+  // synthesis cost is paid once, not on every turn.) Set false to skip
+  // injection (focused task agents that don't benefit from a profile overview).
+  // Resolved via `shouldInjectMemorySummary` so the default lives in one place.
+  injectSummary: external_exports.boolean().optional()
+});
 var agentRuntimeConfigSchema = external_exports.object({
   model: external_exports.string().optional(),
   systemPrompt: external_exports.string().optional(),
@@ -34854,7 +35464,12 @@ var agentRuntimeConfigSchema = external_exports.object({
   // `elapsedThresholdSeconds`). `groundNow` additionally surfaces the current
   // datetime in that block. `timezone` is the agent's DEFAULT IANA zone —
   // the layered tool/decorator resolution overrides it per-conversation.
-  temporal: temporalConfigSchema.optional()
+  temporal: temporalConfigSchema.optional(),
+  // Long-term memory (Cloudflare Agent Memory). Single-sourced as
+  // `memoryConfigSchema` (below) and reused by the update-agent, dispatch
+  // inline-agent, and FPO agent schemas so the four surfaces never drift —
+  // mirroring how `temporalConfigSchema` is shared.
+  memory: memoryConfigSchema.optional()
 });
 var SECRET_REF_PATTERN = /\{\{secret:([A-Z][A-Z0-9_]*[A-Z0-9])\}\}/g;
 function extractSecretReferences(template) {
@@ -35067,6 +35682,7 @@ var agentDefinitionSchema = external_exports.object({
   // External / managed agent configs
   externalConfig: agentExternalConfigSchema.optional(),
   claudeManagedConfig: agentClaudeManagedConfigSchema.optional(),
+  memory: memoryConfigSchema.optional(),
   createPolicy: createPolicySchema
 });
 var agentDefinitionSchemaV2 = external_exports.object({
@@ -35277,6 +35893,18 @@ var fullProductObjectSchema = external_exports.object({
     }
   }
 });
+var FLAT_ADVANCED_CONFIG_KEYS = {
+  loopConfig: true,
+  reasoning: true,
+  voice: true,
+  errorHandling: true,
+  artifacts: true,
+  advisor: true,
+  memory: true
+};
+var FLAT_ADVANCED_CONFIG_KEY_LIST = Object.keys(
+  FLAT_ADVANCED_CONFIG_KEYS
+);
 function createIssue(severity, code, message, path16, suggestedFix) {
   return { code, message, path: path16, severity, ...suggestedFix ? { suggestedFix } : {} };
 }
@@ -36453,6 +37081,24 @@ var FLOW_STEP_TYPE_METADATA = {
     category: "document",
     isPrompt: false,
     configHints: "html OR markdown, filename, visibility (public|private), pdfOptions (format, landscape, margin), outputVariable"
+  },
+  "save-memory": {
+    description: "Ingest text from a variable into a Cloudflare Agent Memory profile so future recall-memory / memory-summary steps can synthesize from it.",
+    category: "integration",
+    isPrompt: false,
+    configHints: "profileTemplate (template), contentVariable (variable path), sessionId (optional), outputVariable (optional), errorHandling"
+  },
+  "recall-memory": {
+    description: "Recall a synthesized natural-language answer from a Cloudflare Agent Memory profile, given a query.",
+    category: "integration",
+    isPrompt: false,
+    configHints: "profileTemplate (template), queryTemplate (template), outputVariable, thinkingLevel (low|medium|high), responseLength (short|medium|long), errorHandling"
+  },
+  "memory-summary": {
+    description: "Fetch a markdown summary (Key Facts / Recent Events / Active Tasks) of a Cloudflare Agent Memory profile.",
+    category: "integration",
+    isPrompt: false,
+    configHints: "profileTemplate (template), outputVariable, sessionId (optional), errorHandling"
   }
 };
 var platformCatalogSchema = external_exports.object({
@@ -37063,6 +37709,7 @@ ${orthogonalLines.join("\n")}
 - **Speech-to-text** \u2192 \`builtin:elevenlabs-stt\`
 - **Emit rich content** \u2192 \`builtin:emit_artifact_markdown\`, \`builtin:emit_artifact_component\`
 - **Record CRUD** \u2192 \`builtin:runtype_record_upsert\`, \`builtin:runtype_record_get\`, \`builtin:runtype_record_list\`, \`builtin:runtype_record_delete\`
+- **Agent memory (persist facts and recall them across sessions)** \u2192 \`builtin:save_memory\`, \`builtin:recall_memory\`, \`builtin:memory_summary\` \u2014 the memory bundle, attached together when memory is enabled on the agent
 - **E-commerce checkout** \u2192 \`builtin:ucp_discover\`, \`builtin:ucp_search_catalog\`, \`builtin:ucp_create_checkout\`
 
 ### Custom MCP Servers (saved by the user)
@@ -37788,7 +38435,8 @@ var AgentInputSchema = external_exports.object({
   advisor: external_exports.object({
     model: external_exports.string(),
     systemPrompt: external_exports.string().optional()
-  }).optional().nullable()
+  }).optional().nullable(),
+  memory: memoryConfigSchema.optional()
 });
 var TextContentPartSchema = external_exports.object({
   type: external_exports.literal("text"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/cli",
-  "version": "2.16.6",
+  "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.0.4",
+    "@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.10.2"
+    "@runtypelabs/shared": "1.13.2"
   },
   "engines": {
     "node": ">=22.0.0"