@inneranimalmedia/agentsam-sdk 2.6.0 → 2.6.1

package/src/commands/merkle.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { buildMerkleTree, saveSnapshot, readSnapshot, diffTrees, normalizePolicy } from '../lib/merkle/index.js';
+import { buildMerkleTree, saveSnapshot, readSnapshot, diffTrees, normalizePolicy } from '../../packages/agentsam-repository/src/merkle/index.js';
 import { renderSummary, safeText } from '../ui/merkle/render.js';
 import { runMerkleExplorer } from '../ui/merkle/explorer.js';
 import { runMerklePersist } from './merkle-persist.js';

package/src/commands/models.js

@@ -1,32 +1,58 @@
 import pc from 'picocolors';
 import { probeOllama, resolveOllamaConfig } from './ollama.js';
 import { listModelCatalog } from '../models/index.js';
+import { discoverProviderModels } from '../models/discovery.js';
 import { resolveProviderCredential } from '../lib/provider-credentials.js';
 
-const API_PROVIDERS = Object.freeze([
+export const API_PROVIDERS = Object.freeze([
   { id: 'openai', label: 'OpenAI', credential: 'OPENAI_API_KEY' },
-  { id: 'gemini', label: 'Gemini', credential: 'GEMINI_API_KEY' },
-  { id: 'grok', label: 'Grok', credential: 'XAI_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: 'cloudflare', label: 'Cloudflare', credential: 'CLOUDFLARE_API_TOKEN' },
 ]);
 
 function clean(value) { return value == null ? '' : String(value).trim(); }
-function configured(value) { return Boolean(clean(value)); }
-
-async function discoverOpenAIModels(apiKey, fetchImpl) {
-  if (!apiKey) return { attempted: false, ok: false, models: [], error: null };
-  try {
-    const response = await fetchImpl('https://api.openai.com/v1/models', {
-      headers: { authorization: `Bearer ${apiKey}` },
-      signal: typeof AbortSignal?.timeout === 'function' ? AbortSignal.timeout(8_000) : undefined,
+
+function emptyDiscovery() {
+  return { attempted: false, ok: false, models: [], error: null };
+}
+
+function providerSummary(result = {}) {
+  return {
+    attempted: result.attempted === true,
+    ok: result.ok === true,
+    error: result.error || null,
+    returnedModelCount: Array.isArray(result.models) ? result.models.length : 0,
+  };
+}
+
+function mergeStaticFallbacks(discovered = []) {
+  const byKey = new Map(discovered.map((row) => [row.model_key, row]));
+  const out = [...discovered];
+  for (const record of listModelCatalog()) {
+    if (byKey.has(record.model_key)) continue;
+    out.push({
+      model_key: record.model_key,
+      provider: record.provider,
+      provider_model_id: record.provider_model_id,
+      label: record.label,
+      availability: 'unverified',
+      availability_source: 'sdk_reference',
+      context_window: record.context_window,
+      context_window_source: 'sdk_reference',
+      max_output_tokens: record.max_output_tokens,
+      max_output_tokens_source: 'sdk_reference',
+      reasoning_efforts: [...record.reasoning_efforts],
+      service_tiers: [...record.service_tiers],
+      capabilities: { ...record.capabilities },
+      pricing: record.pricing || null,
+      context_policy: record.context_policy || null,
+      batch: record.batch || null,
+      source: record.source || null,
     });
-    if (!response.ok) return { attempted: true, ok: false, models: [], error: `HTTP ${response.status}` };
-    const body = await response.json();
-    const models = Array.isArray(body?.data) ? body.data.map((row) => clean(row?.id)).filter(Boolean) : [];
-    return { attempted: true, ok: true, models, error: null };
-  } catch (error) {
-    return { attempted: true, ok: false, models: [], error: error?.message || String(error) };
   }
+  return out;
 }
 
 export async function collectModelsStatus(options = {}) {
@@ -35,7 +61,13 @@ export async function collectModelsStatus(options = {}) {
   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 credentials = new Map(
+    API_PROVIDERS.map((provider) => [
+      provider.id,
+      resolveProviderCredential(provider.id, { env, home: options.home }),
+    ]),
+  );
+
   const providers = API_PROVIDERS.map((provider) => {
     const credential = credentials.get(provider.id);
     return {
@@ -46,36 +78,32 @@ export async function collectModelsStatus(options = {}) {
     };
   });
 
-  const openaiCredential = credentials.get('openai');
-  const shouldDiscover = options.discoverRemote !== false && Boolean(openaiCredential?.configured);
-  const openai = shouldDiscover
-    ? await discoverOpenAIModels(clean(openaiCredential?.value), providerFetchImpl)
-    : { attempted: false, ok: false, models: [], error: null };
-  const availableIds = new Set(openai.models);
-  const catalogModels = listModelCatalog().map((record) => ({
-    model_key: record.model_key,
-    provider: record.provider,
-    provider_model_id: record.provider_model_id,
-    label: record.label,
-    availability: record.provider === 'openai' && openai.ok
-      ? (availableIds.has(record.provider_model_id) ? 'available' : 'unavailable')
-      : 'unverified',
-    source: record.source,
+  const shouldDiscover = options.discoverRemote !== false;
+  const discovery = {};
+  const providerModels = {};
+
+  await Promise.all(API_PROVIDERS.map(async (provider) => {
+    const credential = credentials.get(provider.id);
+    const result = shouldDiscover && credential?.configured
+      ? await discoverProviderModels(provider.id, credential, { fetchImpl: providerFetchImpl })
+      : emptyDiscovery();
+    discovery[provider.id] = providerSummary(result);
+    providerModels[provider.id] = result.models || [];
   }));
 
+  const discovered = Object.values(providerModels).flat();
+  const exactAvailable = discovered.filter((row) => row.availability === 'available');
+  const catalogModels = mergeStaticFallbacks(discovered);
+
   return {
-    schemaVersion: 'agentsam-model-inventory-v2',
+    schemaVersion: 'agentsam-model-inventory-v3',
+    generatedAt: new Date().toISOString(),
+    authority: 'per_credential_provider_discovery',
     providers,
-    discovery: {
-      openai: {
-        attempted: openai.attempted,
-        ok: openai.ok,
-        error: openai.error,
-        returnedModelCount: openai.models.length,
-      },
-    },
+    discovery,
+    providerModels,
     catalogModels,
-    availableModels: catalogModels.filter((row) => row.availability === 'available'),
+    availableModels: exactAvailable,
     local: {
       provider: 'ollama',
       configured: ollama.online,
@@ -91,60 +119,90 @@ export async function collectModelsStatus(options = {}) {
 
 function statusMark(ok) { return ok ? pc.green('●') : pc.dim('○'); }
 function writeLine(write, value = '') { write(`${value}\n`); }
+function contextLabel(model) {
+  const value = Number(model?.context_window);
+  if (!Number.isFinite(value) || value <= 0) return 'ctx unknown';
+  return `ctx ${Math.round(value / 1000).toLocaleString('en-US')}k`;
+}
 
 export function renderModelsStatus(status) {
   const lines = [];
   lines.push('');
   lines.push(`  ${pc.bold('Agent Sam · models')}`);
-  lines.push(`  ${pc.dim('Credential presence is local evidence; exact hosted-model availability is provider-verified when discovery succeeds.')}`);
+  lines.push(`  ${pc.dim('Availability is verified with this machine\'s own provider credentials. Limits are provider-derived when exposed; otherwise marked unknown/reference.')}`);
   lines.push('');
 
   for (const provider of status.providers) {
-    const state = provider.configured ? pc.green('configured') : pc.dim(provider.credentialError ? 'blocked' : 'not configured');
-    const detail = provider.configured ? `credential available · ${provider.source || 'runtime'}` : provider.credentialError ? `${provider.credential} · ${provider.credentialError}` : provider.credential;
-    lines.push(`  ${statusMark(provider.configured)}  ${pc.cyan(provider.label.padEnd(10))} ${state.padEnd(20)} ${pc.dim(detail)}`);
+    const state = provider.configured
+      ? pc.green('configured')
+      : pc.dim(provider.credentialError ? 'blocked' : 'not configured');
+    const discovery = status.discovery?.[provider.id];
+    const detail = provider.configured
+      ? discovery?.attempted
+        ? discovery.ok
+          ? `${discovery.returnedModelCount} account-visible models`
+          : `discovery failed · ${discovery.error || 'unknown error'}`
+        : `credential available · ${provider.source || 'runtime'}`
+      : provider.credentialError
+        ? `${provider.credential} · ${provider.credentialError}`
+        : provider.credential;
+    lines.push(`  ${statusMark(provider.configured)}  ${pc.cyan(provider.label.padEnd(12))} ${state.padEnd(20)} ${pc.dim(detail)}`);
   }
 
-  const exact = status.availableModels || [];
-  if (exact.length) {
-    lines.push('');
-    lines.push(`  ${pc.dim('provider-verified selectable models')}`);
-    for (const model of exact) lines.push(`    ${pc.green('•')} ${model.provider_model_id}`);
-  } else if (status.discovery?.openai?.attempted) {
+  for (const provider of API_PROVIDERS) {
+    const models = status.providerModels?.[provider.id] || [];
+    if (!models.length) continue;
     lines.push('');
-    lines.push(`  ${pc.dim(`OpenAI discovery ${status.discovery.openai.ok ? 'completed; no catalog models matched' : `failed: ${status.discovery.openai.error || 'unknown error'}`}`)}`);
+    lines.push(`  ${pc.dim(`${provider.label} · provider-verified for this credential`)}`);
+    const visible = models.slice(0, 30);
+    for (const model of visible) {
+      const source = model.context_window_source === 'provider_api'
+        ? contextLabel(model)
+        : model.context_window_source === 'sdk_reference'
+          ? `${contextLabel(model)} · reference`
+          : 'ctx unknown';
+      lines.push(`    ${pc.green('•')} ${model.provider_model_id} ${pc.dim('· ' + source)}`);
+    }
+    if (models.length > visible.length) lines.push(`    ${pc.dim(`… ${models.length - visible.length} more`)}`);
   }
 
   const local = status.local;
   const localState = local.online ? pc.green('online') : pc.dim('offline');
-  lines.push(`  ${statusMark(local.online)}  ${pc.cyan('Ollama'.padEnd(10))} ${localState.padEnd(20)} ${pc.dim('local only')}`);
+  lines.push('');
+  lines.push(`  ${statusMark(local.online)}  ${pc.cyan('Ollama'.padEnd(12))} ${localState.padEnd(20)} ${pc.dim('local only')}`);
   if (local.online) {
     const names = local.models.map((row) => row.name).filter(Boolean);
-    lines.push('');
-    lines.push(`  ${pc.dim('local models')}`);
-    if (names.length) for (const name of names) lines.push(`    ${pc.green('•')} ${name}`);
-    else lines.push(`    ${pc.dim('no models reported')}`);
-    lines.push('');
-    lines.push(`  ${pc.dim('chat default')}   ${local.chatModel}`);
-    lines.push(`  ${pc.dim('embed default')}  ${local.embedModel}`);
+    for (const name of names.slice(0, 30)) lines.push(`    ${pc.green('•')} ${name}`);
+    if (names.length > 30) lines.push(`    ${pc.dim(`… ${names.length - 30} more`)}`);
   }
+
   lines.push('');
-  lines.push(`  ${pc.dim('Use /model inside Agent Sam to choose an exact verified model, reasoning effort, and processing tier.')}`);
+  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('');
   return lines.join('\n');
 }
 
 export async function runModels(argv = [], options = {}) {
   if (argv.some((arg) => arg === '--help' || arg === '-h')) {
-    const text = 'agentsam models [--json] [--no-discover]\n\nShow configured providers, provider-verified known models when available, and local Ollama inventory.\n';
+    const text = [
+      'agentsam models [--json] [--no-discover]',
+      '',
+      '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.',
+      '',
+    ].join('\n');
     (options.write || process.stdout.write.bind(process.stdout))(text);
     return;
   }
+
   const allowed = new Set(['--json', '--no-discover']);
   const unknown = argv.filter((arg) => !allowed.has(arg));
   if (unknown.length) throw new Error(`unknown models option: ${unknown[0]}`);
 
-  const status = await collectModelsStatus({ ...options, discoverRemote: !argv.includes('--no-discover') });
+  const status = await collectModelsStatus({
+    ...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));

package/src/commands/ollama.js

@@ -148,6 +148,32 @@ function hasModel(models, desired) {
   return models.some((row) => normalizeModelName(row.name || row.model) === want);
 }
 
+export async function probeOllamaModel(model, config, fetchImpl = fetch) {
+  const endpoint = `${config.baseUrl}/api/show`;
+  try {
+    const response = await fetchImpl(endpoint, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ model }),
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!response.ok) return { ok: false, model, context_window: null, error: `HTTP ${response.status}` };
+    const body = await response.json();
+    const info = body?.model_info && typeof body.model_info === 'object' ? body.model_info : {};
+    const contextEntry = Object.entries(info).find(([key, value]) => key.endsWith('.context_length') && Number(value) > 0);
+    return {
+      ok: true,
+      model,
+      context_window: contextEntry ? Math.floor(Number(contextEntry[1])) : null,
+      context_window_source: contextEntry ? 'local_runtime' : 'unknown',
+      capabilities: Array.isArray(body?.capabilities) ? body.capabilities : [],
+      details: body?.details || null,
+    };
+  } catch (error) {
+    return { ok: false, model, context_window: null, error: error?.message || String(error) };
+  }
+}
+
 export async function probeOllama(config, fetchImpl = fetch) {
   const endpoint = `${config.baseUrl}/api/tags`;
   try {

package/src/commands/preferences.js

@@ -5,6 +5,7 @@ import { cancel, confirm, intro, isCancel, outro, select, text } from '@clack/pr
 import { collectModelsStatus } from './models.js';
 import { getModelRecord } from '../models/index.js';
 import { detectCliProject, readCliPreferences, writeCliPreferences } from '../lib/cli-preferences.js';
+import { readAccountSession } from '../lib/account-session.js';
 
 function stopIfCancelled(value) {
   if (!isCancel(value)) return value;
@@ -19,6 +20,17 @@ function commandExists(command) {
   return spawnSync(probe[0], probe[1], { stdio: 'ignore' }).status === 0;
 }
 
+export function runtimeOptions({ accountConnected = false } = {}) {
+  const rows = [{ value: 'local', label: 'Local machine', hint: 'standalone · real shell + filesystem' }];
+  if (accountConnected) {
+    rows.push(
+      { value: 'remote', label: 'Remote', hint: 'IAM-connected enrolled runtime' },
+      { value: 'sandbox', label: 'Sandbox', hint: 'IAM-connected isolated runtime' },
+    );
+  }
+  return rows;
+}
+
 export function availableShells(env = process.env) {
   const values = [];
   const detected = path.basename(env.SHELL || env.ComSpec || '').trim();
@@ -28,23 +40,38 @@ export function availableShells(env = process.env) {
 }
 
 export function modelOptions(status) {
-  const options = [{ value: 'auto', label: 'Automatic', hint: 'runtime chooses; exact economics unavailable until resolved' }];
+  const options = [{ value: 'auto', label: 'Automatic', hint: 'runtime chooses from this credential\'s verified inventory', model: null }];
   for (const model of status.availableModels || []) {
-    options.push({ value: model.model_key, label: model.label, hint: `${model.provider_model_id} · provider verified` });
+    const context = Number(model.context_window) > 0 ? ` · ctx ${Math.round(Number(model.context_window) / 1000)}k` : ' · ctx unknown';
+    options.push({
+      value: model.model_key,
+      label: `${model.provider} · ${model.label}`,
+      hint: `${model.provider_model_id}${context} · provider verified`,
+      model,
+    });
   }
   if (status.local?.online) {
-    for (const row of status.local.models || []) if (row?.name) options.push({ value: `ollama:${row.name}`, label: `Ollama · ${row.name}`, hint: 'local' });
-  }
-  for (const provider of status.providers || []) {
-    if (provider.configured && !options.some((row) => row.value.startsWith(`${provider.id}:`) && row.value !== `${provider.id}:auto`)) {
-      options.push({ value: `${provider.id}:auto`, label: `${provider.label} · automatic`, hint: 'credential proven; exact model not verified' });
-    }
+    for (const row of status.local.models || []) if (row?.name) options.push({
+      value: `ollama:${row.name}`,
+      label: `Ollama · ${row.name}`,
+      hint: 'local',
+      model: {
+        model_key: `ollama:${row.name}`, provider: 'ollama', provider_model_id: row.name, label: row.name,
+        availability: 'available', availability_source: 'local_runtime', context_window: null, context_window_source: 'unknown',
+        max_output_tokens: null, max_output_tokens_source: 'unknown', reasoning_efforts: ['auto'], service_tiers: ['default'], capabilities: { chat: true },
+      },
+    });
   }
   return options;
 }
 
-function reasoningOptions(modelPreference) {
-  const record = getModelRecord(modelPreference);
+function resolvedModel(modelPreference, modelSnapshot) {
+  if (modelSnapshot?.model_key === modelPreference) return modelSnapshot;
+  return getModelRecord(modelPreference);
+}
+
+function reasoningOptions(modelPreference, modelSnapshot) {
+  const record = resolvedModel(modelPreference, modelSnapshot);
   if (!record) return [{ value: 'auto', label: 'Automatic', hint: 'runtime/provider default' }];
   return record.reasoning_efforts.map((value) => ({
     value,
@@ -53,8 +80,8 @@ function reasoningOptions(modelPreference) {
   }));
 }
 
-function serviceTierOptions(modelPreference) {
-  const record = getModelRecord(modelPreference);
+function serviceTierOptions(modelPreference, modelSnapshot) {
+  const record = resolvedModel(modelPreference, modelSnapshot);
   if (!record) return [{ value: 'default', label: 'Standard', hint: 'default provider processing' }];
   return record.service_tiers.map((value) => {
     if (value === 'fast') return { value, label: 'Fast', hint: 'lower latency · 2× applicable token rates for Astra' };
@@ -68,20 +95,22 @@ async function promptModelPreferences(identity, existing, options = {}) {
   try { status = await collectModelsStatus(options.modelStatusOptions || {}); } catch { /* inventory remains best-effort */ }
   const models = modelOptions(status);
   const initialModel = models.some((row) => row.value === existing.modelPreference) ? existing.modelPreference : 'auto';
-  const modelPreference = stopIfCancelled(await select({ message: 'Model', initialValue: initialModel, options: models }));
+  const modelPreference = stopIfCancelled(await select({ message: 'Model', initialValue: initialModel, options: models.map(({ model, ...row }) => row) }));
+  const selected = models.find((row) => row.value === modelPreference)?.model || null;
+  const modelSnapshot = selected || (existing.modelSnapshot?.model_key === modelPreference ? existing.modelSnapshot : null);
 
-  const reasoning = reasoningOptions(modelPreference);
+  const reasoning = reasoningOptions(modelPreference, modelSnapshot);
   const initialReasoning = reasoning.some((row) => row.value === existing.reasoningEffort) ? existing.reasoningEffort : reasoning[0].value;
   const reasoningEffort = stopIfCancelled(await select({ message: 'Reasoning level', initialValue: initialReasoning, options: reasoning }));
 
-  const tiers = serviceTierOptions(modelPreference);
+  const tiers = serviceTierOptions(modelPreference, modelSnapshot);
   const initialTier = tiers.some((row) => row.value === existing.serviceTier) ? existing.serviceTier : tiers[0].value;
   const serviceTier = stopIfCancelled(await select({ message: 'Processing', initialValue: initialTier, options: tiers }));
 
-  return { modelPreference, reasoningEffort, serviceTier };
+  return { modelPreference, modelSnapshot, reasoningEffort, serviceTier };
 }
 
-export async function configureCliPreferences({ cwd = process.cwd(), firstRun = false, section = 'all', modelStatusOptions } = {}) {
+export async function configureCliPreferences({ cwd = process.cwd(), firstRun = false, section = 'all', modelStatusOptions, home, env = process.env } = {}) {
   let identity = detectCliProject(cwd);
   const existing = readCliPreferences(identity.root) || {};
   intro(firstRun ? `You are in ${identity.root}` : section === 'model' ? 'Agent Sam model' : 'Agent Sam settings');
@@ -100,8 +129,10 @@ export async function configureCliPreferences({ cwd = process.cwd(), firstRun =
     }
   }
 
-  let runtime = existing.runtime || 'local';
-  let terminal = existing.terminal || availableShells()[0];
+  const accountConnected = Boolean(readAccountSession({ home, env })?.account_id);
+  const runtimes = runtimeOptions({ accountConnected });
+  let runtime = runtimes.some((row) => row.value === existing.runtime) ? existing.runtime : 'local';
+  let terminal = existing.terminal || availableShells(env)[0];
   if (!firstRun && section === 'all') {
     const projectChoice = stopIfCancelled(await select({
       message: 'Where should Agent Sam work?',
@@ -124,20 +155,16 @@ export async function configureCliPreferences({ cwd = process.cwd(), firstRun =
     }
     runtime = stopIfCancelled(await select({
       message: 'Runtime', initialValue: runtime,
-      options: [
-        { value: 'local', label: 'Local machine', hint: 'real shell + filesystem' },
-        { value: 'remote', label: 'Remote', hint: 'connected remote runtime' },
-        { value: 'sandbox', label: 'Sandbox', hint: 'isolated disposable runtime' },
-      ],
+      options: runtimes,
     }));
-    const shells = availableShells();
+    const shells = availableShells(env);
     terminal = stopIfCancelled(await select({
       message: 'Terminal', initialValue: terminal && shells.includes(terminal) ? terminal : shells[0],
       options: shells.map((shell) => ({ value: shell, label: shell, hint: shell === shells[0] ? 'detected/default' : undefined })),
     }));
   }
 
-  const model = await promptModelPreferences(identity, existing, { modelStatusOptions });
+  const model = await promptModelPreferences(identity, existing, { modelStatusOptions: { home, env, ...(modelStatusOptions || {}) } });
   const preferences = writeCliPreferences(identity.root, { trustedDirectory, runtime, terminal, ...model });
   outro(`Ready · ${identity.project}`);
   return { identity, preferences };