@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.4

package/src/commands/mcp.js

@@ -0,0 +1,341 @@
+import {
+  deleteMcpServer,
+  detectInstalledClients,
+  inspectClientAdapter,
+  isClientRegistered,
+  listKnownServers,
+  listMcpServers,
+  listMcpTools,
+  listRegisteredClients,
+  pingMcpServer,
+  readMcpServer,
+  removeServerFromClient,
+  resolveServerPreset,
+  syncServerToClient,
+  writeMcpServer,
+} from '../mcp/index.js';
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+export function parseMcpArgs(argv = []) {
+  let subcommand = clean(argv[0]);
+  let help = false;
+  if (subcommand === '--help' || subcommand === '-h') {
+    help = true;
+    subcommand = '';
+  }
+  const target = clean(argv[1]);
+  let client = '';
+  let url = '';
+  let token = '';
+  let json = false;
+  let catalog = false;
+
+  for (let i = 1; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--client') client = argv[++i] || '';
+    else if (arg === '--url') url = argv[++i] || '';
+    else if (arg === '--token') token = argv[++i] || '';
+    else if (arg === '--json') json = true;
+    else if (arg === '--catalog' || arg === '--all') catalog = true;
+    else if (arg === '--help' || arg === '-h') help = true;
+  }
+
+  return {
+    subcommand,
+    target: target.startsWith('--') ? '' : target,
+    client: client.toLowerCase(),
+    url,
+    token,
+    json,
+    catalog,
+    help,
+  };
+}
+
+function renderHelp(options = {}) {
+  const clients = listRegisteredClients(options);
+  const servers = listKnownServers(options);
+
+  const presetRows = servers.map((s) => {
+    const key = (s.name || s.server_key || '').padEnd(24);
+    const desc = s.description || s.display_name || s.health_status || '';
+    return `    ${key} ${s.url} (${desc})`;
+  }).join('\n');
+
+  const clientRows = clients.map((c) => {
+    const key = c.client_key.padEnd(24);
+    const note = c.notes || c.display_name;
+    return `    ${key} ${c.display_name} (${note})`;
+  }).join('\n');
+
+  return `
+  AgentSam · MCP Client Management
+
+  Usage:
+    agentsam mcp add <name> [--client <client>|all] [--url <url>] [--token <token>]
+    agentsam mcp list [--catalog|--all] [--json]
+    agentsam mcp status [<name>] [--json]
+    agentsam mcp doctor [<name>] [--json]
+    agentsam mcp remove <name> [--client <client>|all]
+
+  Known server presets:
+${presetRows}
+
+  Recognized client adapters:
+${clientRows}
+`;
+}
+
+export async function runMcp(argv = [], options = {}) {
+  const args = parseMcpArgs(argv);
+  const write = options.write || ((text) => process.stdout.write(text));
+
+  if (args.help || !args.subcommand) {
+    write(renderHelp(options));
+    return null;
+  }
+
+  const { subcommand, target } = args;
+
+  if (subcommand === 'list') {
+    if (args.catalog) {
+      const catalog = listKnownServers(options);
+      if (args.json) {
+        write(JSON.stringify({ catalog }, null, 2) + '\n');
+        return catalog;
+      }
+      write('\n  Known MCP Server Catalog (Registry: agentsam_mcp_servers)\n\n');
+      for (const s of catalog) {
+        write(`  • ${s.name || s.server_key} (${s.display_name || s.name})\n`);
+        write(`      url:       ${s.url}\n`);
+        write(`      auth_type: ${s.auth_type || 'none'}\n`);
+        write(`      health:    ${s.health_status || 'unknown'}${s.avg_latency_ms != null ? ` · ${s.avg_latency_ms}ms` : ''}\n\n`);
+      }
+      return catalog;
+    }
+
+    const servers = listMcpServers(options);
+    if (args.json) {
+      write(JSON.stringify({ servers }, null, 2) + '\n');
+      return servers;
+    }
+    if (servers.length === 0) {
+      write('  No MCP servers configured yet. Add one with: agentsam mcp add inneranimalmedia\n');
+      return servers;
+    }
+    write('\n  Configured MCP Servers (Authority: ~/.agentsam/mcp/)\n\n');
+    for (const s of servers) {
+      write(`  • ${s.name}\n`);
+      write(`      url:     ${s.url}\n`);
+      write(`      clients: ${(s.clients || []).join(', ') || 'none'}\n`);
+      write(`      auth:    ${s.auth?.token ? 'bearer token configured' : 'none'}\n`);
+      write(`      updated: ${s.updated_at || s.created_at || 'unknown'}\n\n`);
+    }
+    return servers;
+  }
+
+  if (subcommand === 'add') {
+    const name = target || 'inneranimalmedia';
+    const preset = resolveServerPreset(name, options);
+    const url = args.url || preset?.url;
+
+    if (!url) {
+      throw new Error(`missing_url: specify --url for custom MCP server "${name}"`);
+    }
+
+    let requestedClients = ['cursor'];
+    if (args.client) {
+      if (args.client === 'all') {
+        const detected = detectInstalledClients(options);
+        requestedClients = detected.length > 0 ? detected : ['cursor', 'claude'];
+      } else {
+        requestedClients = [args.client];
+      }
+    } else if (preset?.defaultClients?.length) {
+      requestedClients = preset.defaultClients;
+    }
+
+    const serverConfig = {
+      name,
+      url,
+      protocol: preset?.protocol || 'sse',
+      auth: args.token ? { type: preset?.auth_type || 'bearer', token: args.token } : null,
+      clients: requestedClients,
+      metadata: preset ? { preset: name, description: preset.description, health_status: preset.health_status } : {},
+    };
+
+    // Store in AgentSam authority
+    const written = writeMcpServer(name, serverConfig, options);
+
+    // Materialize client adapters
+    const syncedAdapters = [];
+    for (const c of requestedClients) {
+      const res = syncServerToClient(c, name, serverConfig, options);
+      syncedAdapters.push(res);
+    }
+
+    // Ping to verify connectivity
+    const ping = await pingMcpServer(serverConfig, options);
+
+    if (args.json) {
+      const payload = { ok: true, server: written, syncedAdapters, ping };
+      write(JSON.stringify(payload, null, 2) + '\n');
+      return payload;
+    }
+
+    write(`\n  ✓ Configured MCP server: ${name}\n`);
+    write(`      Authority:   ~/.agentsam/mcp/${name}.json\n`);
+    write(`      URL:         ${url}\n`);
+    for (const a of syncedAdapters) {
+      write(`      Adapter:     ${a.client} -> ${a.configPath}\n`);
+    }
+    if (ping.ok) {
+      write(`      Ping:        ✓ Connected (${ping.latencyMs}ms)\n`);
+    } else {
+      write(`      Ping:        ⚠ Warning (${ping.error || 'unreachable'})\n`);
+    }
+    write('\n');
+    return { server: written, syncedAdapters, ping };
+  }
+
+  if (subcommand === 'status') {
+    const name = target || 'inneranimalmedia';
+    const server = readMcpServer(name, options);
+    if (!server) {
+      if (args.json) {
+        write(JSON.stringify({ ok: false, error: 'server_not_configured', name }) + '\n');
+        return null;
+      }
+      write(`  MCP server "${name}" is not configured. Run: agentsam mcp add ${name}\n`);
+      return null;
+    }
+
+    const ping = await pingMcpServer(server, options);
+    const clientStatuses = (server.clients || ['cursor']).map((c) =>
+      inspectClientAdapter(c, name, options),
+    );
+
+    const report = {
+      name,
+      url: server.url,
+      ping,
+      clients: clientStatuses,
+      hasAuth: Boolean(server.auth?.token),
+    };
+
+    if (args.json) {
+      write(JSON.stringify(report, null, 2) + '\n');
+      return report;
+    }
+
+    write(`\n  MCP Server Status: ${name}\n`);
+    write(`      URL:       ${server.url}\n`);
+    write(`      Ping:      ${ping.ok ? `✓ Active (${ping.latencyMs}ms)` : `✗ Error: ${ping.error}`}\n`);
+    write(`      Auth:      ${report.hasAuth ? '✓ Bearer token present' : '○ No auth token'}\n`);
+    for (const c of clientStatuses) {
+      write(`      ${c.client}:    ${c.configured ? '✓ Configured' : '○ Not configured'} (${c.path})\n`);
+    }
+    write('\n');
+    return report;
+  }
+
+  if (subcommand === 'doctor') {
+    const name = target || 'inneranimalmedia';
+    const server = readMcpServer(name, options);
+
+    if (!server) {
+      const errPayload = { ok: false, error: 'server_not_configured', name };
+      if (args.json) write(JSON.stringify(errPayload, null, 2) + '\n');
+      else write(`  MCP server "${name}" is not configured.\n`);
+      return errPayload;
+    }
+
+    const preset = resolveServerPreset(name, options);
+    const ping = await pingMcpServer(server, options);
+    const clientStatuses = (server.clients || ['cursor']).map((c) =>
+      inspectClientAdapter(c, name, options),
+    );
+    const toolsProbe = ping.ok ? await listMcpTools(server, options) : { count: 0, tools: [] };
+
+    const detectedClients = detectInstalledClients(options);
+    const diagnostics = {
+      name,
+      authorityPath: `~/.agentsam/mcp/${name}.json`,
+      url: server.url,
+      connectivity: ping.ok ? 'pass' : 'fail',
+      latencyMs: ping.latencyMs,
+      authConfigured: Boolean(server.auth?.token),
+      discoveredTools: toolsProbe.count,
+      clients: clientStatuses,
+      detectedHostClients: detectedClients,
+      catalogHealth: preset ? {
+        health_status: preset.health_status,
+        avg_latency_ms: preset.avg_latency_ms,
+        error_rate: preset.error_rate,
+      } : null,
+    };
+
+    if (args.json) {
+      write(JSON.stringify(diagnostics, null, 2) + '\n');
+      return diagnostics;
+    }
+
+    write(`\n  AgentSam MCP Doctor · ${name}\n\n`);
+    write(`  [1] Authority state:   ✓ Valid (~/.agentsam/mcp/${name}.json)\n`);
+    write(`  [2] Endpoint ping:     ${ping.ok ? `✓ Reachable (${ping.latencyMs}ms)` : `✗ Unreachable (${ping.error})`}\n`);
+    if (preset?.health_status) {
+      write(`  [3] Live health data:  ${preset.health_status} (avg latency: ${preset.avg_latency_ms ?? 0}ms, error rate: ${preset.error_rate ?? 0}%)\n`);
+    }
+    write(`  [4] Auth credential:   ${diagnostics.authConfigured ? '✓ Token configured' : '○ Unauthenticated / public'}\n`);
+    write(`  [5] Tool discovery:    ${toolsProbe.count > 0 ? `✓ Found ${toolsProbe.count} tools` : '○ 0 tools discovered'}\n`);
+    write(`  [6] Client adapters:\n`);
+    for (const c of clientStatuses) {
+      write(`        • ${c.client}: ${c.configured ? '✓ Synced' : '✗ Desynced'} (${c.path})\n`);
+    }
+    write('\n');
+    return diagnostics;
+  }
+
+  if (subcommand === 'remove') {
+    const name = target;
+    if (!name) throw new Error('mcp_server_name_required');
+
+    const server = readMcpServer(name, options);
+    const targetClients = args.client
+      ? (args.client === 'all' ? (server?.clients || ['cursor', 'claude']) : [args.client])
+      : (server?.clients || ['cursor', 'claude']);
+
+    const removedAdapters = [];
+    for (const c of targetClients) {
+      const res = removeServerFromClient(c, name, options);
+      removedAdapters.push(res);
+    }
+
+    let deletedAuthority = false;
+    if (!args.client || args.client === 'all') {
+      deletedAuthority = deleteMcpServer(name, options);
+    }
+
+    const result = { name, removedAdapters, deletedAuthority };
+    if (args.json) {
+      write(JSON.stringify(result, null, 2) + '\n');
+      return result;
+    }
+
+    write(`\n  ✓ Removed MCP server: ${name}\n`);
+    for (const r of removedAdapters) {
+      if (r.removed) write(`      Removed from client adapter: ${r.client} (${r.configPath})\n`);
+    }
+    if (deletedAuthority) {
+      write(`      Deleted authority: ~/.agentsam/mcp/${name}.json\n`);
+    }
+    write('\n');
+    return result;
+  }
+
+  write(`  Unknown mcp subcommand: "${subcommand}". Use "agentsam mcp --help" for guidance.\n`);
+  return null;
+}

package/src/commands/merkle-persist.js

@@ -74,7 +74,9 @@ function parse(args) {
 }
 
 export function resolveMerklePersistenceIdentity(root, options = {}) {
-  const session = options.session ?? readAccountSession(options.sessionOptions || {});
+  const session = Object.hasOwn(options, 'session')
+    ? options.session
+    : readAccountSession(options.sessionOptions || {});
   const accountId = String(session?.account_id || '').trim();
   if (!accountId) throw new Error('agentsam_login_required_for_merkle_persistence');
 

package/src/commands/merkle.js

@@ -51,11 +51,15 @@ function parse(argv) {
     if (arg === '--' && !positionalOnly) { positionalOnly = true; continue; }
     if (positionalOnly || !arg.startsWith('-')) opts.paths.push(arg);
     else if (arg === '--interactive' || arg === '--tui') opts.tui = true;
-    else if (['--json', '--force', '--semantic'].includes(arg)) opts[arg.slice(2)] = true;
-    else if (['--out', '--root', '--include', '--exclude'].includes(arg)) {
+    else if (['--json', '--force', '--semantic', '--persist'].includes(arg)) opts[arg.slice(2)] = true;
+    else if (['--out', '--root', '--include', '--exclude', '--connection-id', '--runtime-lease-id', '--capture-kind', '--wrangler-config'].includes(arg)) {
       const value = args[++i];
       if (!value || value.startsWith('--')) throw new Error(`Missing value for ${arg}`);
       if (['--include', '--exclude'].includes(arg)) opts[arg.slice(2)].push(value);
+      else if (arg === '--connection-id') opts.connectionId = value;
+      else if (arg === '--runtime-lease-id') opts.runtimeLeaseId = value;
+      else if (arg === '--capture-kind') opts.captureKind = value;
+      else if (arg === '--wrangler-config') opts.wranglerConfig = value;
       else opts[arg.slice(2)] = value;
     } else throw new Error(`Unknown option: ${arg}`);
   }
@@ -106,7 +110,18 @@ export async function runMerkle(argv = []) {
       if (opts.command === 'diff') return comparison(opts, progress);
       if (opts.command === 'snapshot') {
         const { snapshot: tree, output } = await saveSnapshot(target, { ...progress, policy: opts.policy, out: opts.out, force: opts.force, semantic: opts.semantic });
-        return { title: 'Merkle snapshot', tree, output };
+        let persisted = null;
+        if (opts.persist || opts.connectionId || opts.runtimeLeaseId) {
+          const persistArgs = [output];
+          if (opts.wranglerConfig) persistArgs.push('--wrangler-config', opts.wranglerConfig);
+          if (opts.captureKind) persistArgs.push('--capture-kind', opts.captureKind);
+          else if (opts.connectionId || opts.runtimeLeaseId) persistArgs.push('--capture-kind', 'agent');
+          if (opts.connectionId) persistArgs.push('--connection-id', opts.connectionId);
+          if (opts.runtimeLeaseId) persistArgs.push('--runtime-lease-id', opts.runtimeLeaseId);
+          if (opts.json) persistArgs.push('--json');
+          persisted = await runMerklePersist(persistArgs);
+        }
+        return { title: 'Merkle snapshot', tree, output, persisted };
       }
       const isSnapshot = ['inspect', 'explore'].includes(opts.command) && !(await fs.stat(target)).isDirectory();
       if (isSnapshot && (opts.include.length || opts.exclude.length)) throw new Error('Snapshot inspection uses saved ignore rules.');

package/src/commands/models.js

@@ -1,14 +1,24 @@
 import pc from 'picocolors';
+import { isCancel, select } from '@clack/prompts';
 import { probeOllama, resolveOllamaConfig } from './ollama.js';
-import { listModelCatalog } from '../models/index.js';
+import { listModelCatalog } from '../models/catalog.js';
 import { discoverProviderModels } from '../models/discovery.js';
 import { resolveProviderCredential } from '../lib/provider-credentials.js';
+import { providerChoices, promptAndConfigureProvider } from './providers.js';
+import {
+  WORKERS_AI_CURATED_MODEL_IDS,
+  filterWorkersAiCurated,
+  sanitizeInventoryForClient,
+} from '../models/inventory-core.js';
+
+export { WORKERS_AI_CURATED_MODEL_IDS, filterWorkersAiCurated, sanitizeInventoryForClient };
 
 export const API_PROVIDERS = Object.freeze([
   { id: 'openai', label: 'OpenAI', credential: 'OPENAI_API_KEY' },
   { id: 'anthropic', label: 'Anthropic', credential: 'ANTHROPIC_API_KEY' },
   { id: 'gemini', label: 'Gemini', credential: 'GEMINI_API_KEY' },
   { id: 'grok', label: 'Grok / xAI', credential: 'XAI_API_KEY' },
+  { id: 'cursor', label: 'Cursor', credential: 'CURSOR_API_KEY' },
   { id: 'cloudflare', label: 'Cloudflare', credential: 'CLOUDFLARE_API_TOKEN' },
 ]);
 
@@ -55,18 +65,34 @@ function mergeStaticFallbacks(discovered = []) {
   return out;
 }
 
+/**
+ * Build credential-scoped model inventory.
+ *
+ * @param {object} [options]
+ * @param {Record<string, string>} [options.env]
+ * @param {string} [options.home]
+ * @param {boolean} [options.discoverRemote]
+ * @param {'machine'|'studio_vault'|'mixed'} [options.credentialPlane]
+ * @param {(providerId: string) => Promise<object|null>|object|null} [options.resolveCredential]
+ *   Injected resolver (Studio vault). When omitted, uses machine env.d / process env.
+ * @param {boolean} [options.curateWorkersAi] default true — intersect Cloudflare models with curated allowlist
+ * @param {boolean} [options.includeLocal] default true — probe Ollama (machine plane only by default)
+ */
 export async function collectModelsStatus(options = {}) {
   const env = options.env || process.env;
   const ollamaFetchImpl = options.fetchImpl || fetch;
   const providerFetchImpl = options.providerFetchImpl || fetch;
-  const ollamaConfig = resolveOllamaConfig({}, env);
-  const ollama = await probeOllama(ollamaConfig, ollamaFetchImpl);
-  const credentials = new Map(
-    API_PROVIDERS.map((provider) => [
-      provider.id,
-      resolveProviderCredential(provider.id, { env, home: options.home }),
-    ]),
-  );
+  const credentialPlane = options.credentialPlane || (options.resolveCredential ? 'studio_vault' : 'machine');
+  const includeLocal = options.includeLocal ?? credentialPlane === 'machine';
+  const curateWorkersAi = options.curateWorkersAi !== false;
+
+  const resolveCredential = options.resolveCredential
+    || ((providerId) => resolveProviderCredential(providerId, { env, home: options.home }));
+
+  const credentials = new Map();
+  for (const provider of API_PROVIDERS) {
+    credentials.set(provider.id, await resolveCredential(provider.id));
+  }
 
   const providers = API_PROVIDERS.map((provider) => {
     const credential = credentials.get(provider.id);
@@ -84,10 +110,20 @@ export async function collectModelsStatus(options = {}) {
 
   await Promise.all(API_PROVIDERS.map(async (provider) => {
     const credential = credentials.get(provider.id);
-    const result = shouldDiscover && credential?.configured
+    let result = shouldDiscover && credential?.configured
       ? await discoverProviderModels(provider.id, credential, { fetchImpl: providerFetchImpl })
       : emptyDiscovery();
+    if (provider.id === 'cloudflare' && result.ok && curateWorkersAi) {
+      const curated = filterWorkersAiCurated(result.models || [], { curated: true });
+      result = {
+        ...result,
+        models: curated,
+        returnedModelCount: curated.length,
+        curation: 'agentsam_workers_ai_allowlist',
+      };
+    }
     discovery[provider.id] = providerSummary(result);
+    if (result.curation) discovery[provider.id].curation = result.curation;
     providerModels[provider.id] = result.models || [];
   }));
 
@@ -95,25 +131,42 @@ export async function collectModelsStatus(options = {}) {
   const exactAvailable = discovered.filter((row) => row.availability === 'available');
   const catalogModels = mergeStaticFallbacks(discovered);
 
+  let local = {
+    provider: 'ollama',
+    configured: false,
+    online: false,
+    endpoint: null,
+    chatModel: null,
+    embedModel: null,
+    models: [],
+    error: null,
+  };
+  if (includeLocal) {
+    const ollamaConfig = resolveOllamaConfig({}, env);
+    const ollama = await probeOllama(ollamaConfig, ollamaFetchImpl);
+    local = {
+      provider: 'ollama',
+      configured: ollama.online,
+      online: ollama.online,
+      endpoint: ollama.endpoint,
+      chatModel: ollamaConfig.model,
+      embedModel: ollamaConfig.embedModel,
+      models: ollama.models || [],
+      error: ollama.error || null,
+    };
+  }
+
   return {
     schemaVersion: 'agentsam-model-inventory-v3',
     generatedAt: new Date().toISOString(),
     authority: 'per_credential_provider_discovery',
+    credential_plane: credentialPlane,
     providers,
     discovery,
     providerModels,
     catalogModels,
     availableModels: exactAvailable,
-    local: {
-      provider: 'ollama',
-      configured: ollama.online,
-      online: ollama.online,
-      endpoint: ollama.endpoint,
-      chatModel: ollamaConfig.model,
-      embedModel: ollamaConfig.embedModel,
-      models: ollama.models || [],
-      error: ollama.error || null,
-    },
+    local,
   };
 }
 
@@ -176,6 +229,10 @@ export function renderModelsStatus(status) {
     if (names.length > 30) lines.push(`    ${pc.dim(`… ${names.length - 30} more`)}`);
   }
 
+  const unconfiguredCount = status.providers.filter((p) => !p.configured).length;
+  if (unconfiguredCount > 0) {
+    lines.push(`  ${pc.yellow('Tip:')} Select your preferred provider to continue, or run 'agentsam providers'.`);
+  }
   lines.push('');
   lines.push(`  ${pc.dim('Use /model inside Agent Sam. The picker is built from the models visible to your own connected provider credentials.')}`);
   lines.push('');
@@ -185,7 +242,7 @@ export function renderModelsStatus(status) {
 export async function runModels(argv = [], options = {}) {
   if (argv.some((arg) => arg === '--help' || arg === '-h')) {
     const text = [
-      'agentsam models [--json] [--no-discover]',
+      'agentsam models [--json] [--no-discover] [--setup]',
       '',
       'Probe the provider accounts configured on this machine and list the models visible to those exact credentials.',
       'Context/output limits are taken from provider metadata when available; otherwise Agent Sam reports unknown or a clearly-labeled SDK reference.',
@@ -195,7 +252,7 @@ export async function runModels(argv = [], options = {}) {
     return;
   }
 
-  const allowed = new Set(['--json', '--no-discover']);
+  const allowed = new Set(['--json', '--no-discover', '--setup']);
   const unknown = argv.filter((arg) => !allowed.has(arg));
   if (unknown.length) throw new Error(`unknown models option: ${unknown[0]}`);
 
@@ -204,7 +261,36 @@ export async function runModels(argv = [], options = {}) {
     discoverRemote: !argv.includes('--no-discover'),
   });
   const write = options.write || ((text) => process.stdout.write(text));
-  if (argv.includes('--json')) writeLine(write, JSON.stringify(status, null, 2));
-  else write(renderModelsStatus(status));
+  if (argv.includes('--json')) {
+    writeLine(write, JSON.stringify(status, null, 2));
+    return status;
+  }
+  write(renderModelsStatus(status));
+
+  const allUnconfigured = status.providers.every((p) => !p.configured);
+  const interactive = options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (interactive && (argv.includes('--setup') || allUnconfigured)) {
+    const promptSelect = options.selectImpl || select;
+    const choices = [
+      ...providerChoices(options),
+      { value: '__skip__', label: 'Skip / Continue', hint: 'set up provider credentials later' },
+    ];
+    const choice = await promptSelect({
+      message: 'Tip: Select your preferred provider to continue',
+      options: choices,
+    });
+    if (!isCancel(choice) && choice !== '__skip__') {
+      const result = await promptAndConfigureProvider(choice, options);
+      if (result?.saved) {
+        const updated = await collectModelsStatus({
+          ...options,
+          discoverRemote: !argv.includes('--no-discover'),
+        });
+        write(renderModelsStatus(updated));
+        return updated;
+      }
+    }
+  }
+
   return status;
 }