@yeaft/webchat-agent 0.1.1024 → 0.1.1026

package/cli.js

@@ -24,6 +24,11 @@ import {
   useOpenAICompatible,
   writeLocalLlmConfig,
 } from './llm-config-cli.js';
+import {
+  discoverGitHubCopilotModels,
+  discoverOpenAICompatibleModels,
+  GITHUB_COPILOT_PROVIDER,
+} from './llm-model-discovery.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf-8'));
@@ -97,6 +102,7 @@ function printLlmHelp() {
 
   Usage:
     yeaft-agent llm show [--reveal]
+    yeaft-agent llm list-models [<provider-name>]
     yeaft-agent llm setup
     yeaft-agent llm use github-copilot --model <modelId> [--fast <modelId>] [--allow-unknown-model]
     yeaft-agent llm use openai-compatible --name <name> --base-url <url> --api-key-env <ENV> --model <modelId> [--fast <modelId>]
@@ -112,6 +118,8 @@ function printLlmHelp() {
     add-provider updates/replaces an existing provider with the same --name.
     --api-key-env reads the environment variable value and writes it as apiKey.
     set-model requires full provider/model references.
+    list-models with no provider lists the local config offline; with 'github-copilot'
+      or a configured provider name, it queries the live '/models' catalog.
     --config <path> can target a config file for tests or scripted setup.
 
   Examples:
@@ -127,7 +135,14 @@ async function handleLlmCommand(args) {
   const subcommand = args[0];
 
   try {
-    const options = parseLlmArgs(args.slice(subcommand === 'use' ? 2 : 1));
+    // `use <preset>` and `list-models <provider-name>` both put a positional
+    // arg right after the subcommand; trim it off before flag parsing so
+    // parseLlmArgs sees only flags.
+    const positionalAfterSub =
+      subcommand === 'use' ? 2
+      : (subcommand === 'list-models' && args[1] && !args[1].startsWith('--')) ? 2
+      : 1;
+    const options = parseLlmArgs(args.slice(positionalAfterSub));
     const configPath = options.config || getDefaultYeaftConfigPath();
     if (!subcommand || subcommand === '--help' || subcommand === '-h' || subcommand === 'help') {
       printLlmHelp();
@@ -140,6 +155,19 @@ async function handleLlmCommand(args) {
       return;
     }
 
+    if (subcommand === 'list-models') {
+      // `yeaft-agent llm list-models` (no provider) — list models declared in
+      //   the local config (offline; no network call).
+      // `yeaft-agent llm list-models <provider-name>` — live-discover models:
+      //   - "github-copilot" uses the local Copilot credential
+      //   - any other name must already exist in config.json (uses its
+      //     baseUrl + apiKey for OpenAI-compatible /models discovery)
+      const providerName = (args[1] && !args[1].startsWith('--')) ? args[1] : null;
+      const config = readLocalLlmConfig(configPath);
+      await handleListModels(config, { providerName });
+      return;
+    }
+
     const current = readLocalLlmConfig(configPath);
     let result;
     if (subcommand === 'setup') {
@@ -204,6 +232,95 @@ async function handleLlmCommand(args) {
   }
 }
 
+/**
+ * `yeaft-agent llm list-models [<provider-name>]` handler.
+ *
+ * Three modes:
+ *  - No provider — list all models declared in the local config (offline,
+ *    no network call). Annotates `← primary` / `← fast` for clarity.
+ *  - "github-copilot" — live-discover Copilot's model catalog using the
+ *    local device credential. Missing/invalid credential prints an
+ *    actionable hint ("Run `gh auth login` ...") and exits non-zero so
+ *    scripts can detect the failure.
+ *  - Any other name — must already exist in config.json; uses its
+ *    baseUrl + apiKey for OpenAI-compatible `/models` discovery.
+ */
+export async function handleListModels(
+  config,
+  { providerName = null, deps = {} } = {}
+) {
+  const discoverCopilot = deps.discoverCopilot || discoverGitHubCopilotModels;
+  const discoverOpenAI = deps.discoverOpenAI || discoverOpenAICompatibleModels;
+
+  if (providerName === GITHUB_COPILOT_PROVIDER.name) {
+    try {
+      const result = await discoverCopilot();
+      console.log(`Available models from GitHub Copilot (source: ${result.source}):`);
+      for (const id of result.models) console.log(`  ${id}`);
+      if (result.warning) console.log(`\nNote: ${result.warning}`);
+      return;
+    } catch (err) {
+      console.error(`GitHub Copilot model discovery failed: ${err.message}`);
+      if (err.code === 'COPILOT_CREDENTIAL_MISSING' || err.code === 'COPILOT_AUTH_INVALID') {
+        console.error('Tip: run `gh auth login` (or complete the Copilot device login) and re-run this command.');
+      }
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  if (providerName) {
+    const providers = Array.isArray(config.providers) ? config.providers : [];
+    const target = providers.find(p => p && p.name === providerName);
+    if (!target) {
+      console.error(`Provider "${providerName}" not found in config.json.`);
+      if (providers.length === 0) {
+        console.error('No providers are configured. Run `yeaft-agent llm setup` or `yeaft-agent llm use github-copilot ...`.');
+      } else {
+        console.error('Configured providers:');
+        for (const p of providers) console.error(`  ${p.name}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const result = await discoverOpenAI({
+        baseUrl: target.baseUrl,
+        apiKey: target.apiKey,
+      });
+      console.log(`Available models from "${providerName}" (${target.baseUrl}, source: ${result.source}):`);
+      for (const id of result.models) console.log(`  ${providerName}/${id}`);
+      return;
+    } catch (err) {
+      console.error(`Model discovery for "${providerName}" failed: ${err.message}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  // Default: list configured providers' declared models (no network call).
+  const providers = Array.isArray(config.providers) ? config.providers : [];
+  if (providers.length === 0) {
+    console.log('No providers configured in config.json.');
+    console.log('Run `yeaft-agent llm setup`, or `yeaft-agent llm list-models github-copilot` to discover the Copilot catalog.');
+    return;
+  }
+  console.log('Configured models:');
+  for (const provider of providers) {
+    const tag = provider.managed || provider.credentialProvider ? ' (managed)' : '';
+    console.log(`  [${provider.name}]${tag} ${provider.baseUrl || ''}`.trimEnd());
+    if (!Array.isArray(provider.models)) continue;
+    for (const m of provider.models) {
+      const id = typeof m === 'string' ? m : m?.id;
+      if (!id) continue;
+      const ref = `${provider.name}/${id}`;
+      const annot = ref === config.primaryModel ? ' ← primary'
+        : ref === config.fastModel ? ' ← fast'
+        : '';
+      console.log(`    ${ref}${annot}`);
+    }
+  }
+}
 
 async function runLlmSetup(current, configPath) {
   if (!process.stdin.isTTY || !process.stdout.isTTY) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.1024",
+  "version": "0.1.1026",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/yeaft/models.js

@@ -428,6 +428,13 @@ export const OPENAI_REASONING_EFFORT_OPTIONS = ['minimal', 'low', 'medium', 'hig
 export const ANTHROPIC_MANUAL_EFFORT_OPTIONS = ['low', 'medium', 'high'];
 export const ANTHROPIC_ADAPTIVE_EFFORT_OPTIONS = ['low', 'medium', 'high', 'xhigh', 'max'];
 export const ANTHROPIC_ADAPTIVE_MAX_EFFORT_OPTIONS = ['low', 'medium', 'high', 'max'];
+// DeepSeek reasoning models (deepseek-reasoner / deepseek-r1) expose a simple
+// low/medium/high effort scale. DeepSeek's OpenAI-compatible surface accepts a
+// reasoning effort hint; we send it through the standard openai-reasoning
+// `reasoning.effort` path (relay/proxy adapts to DeepSeek's wire format). No
+// `minimal` tier — DeepSeek documents only a high/max effort distinction, so we
+// keep the user-facing scale to the three levels the user expects.
+export const DEEPSEEK_REASONING_EFFORT_OPTIONS = ['low', 'medium', 'high'];
 
 function inferThinkingCapability(model) {
   const id = parseModelRef(model).modelId.toLowerCase();
@@ -468,6 +475,20 @@ function inferThinkingCapability(model) {
     return { supportsThinking: true, thinkingProtocol: 'anthropic', defaultEffort: null, maxBudgetTokens };
   }
 
+  // DeepSeek reasoning models expose a thinking effort hint. Only the reasoner
+  // family (deepseek-reasoner / deepseek-r1*) is a reasoning model — plain
+  // deepseek-chat stays effort-less. Effort travels over the openai-reasoning
+  // `reasoning.effort` path; user-facing scale is low/medium/high.
+  if (/^deepseek-(reasoner|r1)/.test(id)) {
+    return {
+      supportsThinking: true,
+      thinkingProtocol: 'openai-reasoning',
+      defaultEffort: null,
+      maxBudgetTokens: null,
+      effortOptions: DEEPSEEK_REASONING_EFFORT_OPTIONS,
+    };
+  }
+
   return null;
 }
 

package/yeaft/web-bridge.js

@@ -3481,6 +3481,17 @@ function removeQueuedVpTurn(turnId) {
   return removed;
 }
 
+function findTurnIdsForVp({ sessionId = null, vpId = null } = {}) {
+  if (!vpId) return [];
+  const ids = [];
+  for (const [turnId, meta] of turnAbortMeta.entries()) {
+    if (!meta || meta.vpId !== vpId) continue;
+    if (sessionId && meta.sessionId !== sessionId) continue;
+    ids.push(turnId);
+  }
+  return ids;
+}
+
 function emitQueuedTurnAbort(meta, turnId) {
   if (!meta?.vpId) return;
   const sessionId = meta.sessionId || null;
@@ -3621,31 +3632,55 @@ export function handleYeaftAbortAll(msg = {}) {
 }
 
 /**
- * Per-VP abort: stops a single VP turn by turnId without affecting siblings.
- * Frontend sends `{ type: 'yeaft_abort_turn', turnId }`.
- * @param {{ turnId?: string }} msg
+ * Per-VP abort: stops a single VP turn without affecting siblings.
+ * New clients send `{ sessionId, vpId }`; `turnId` is kept for legacy buttons.
+ * @param {{ turnId?: string, sessionId?: string, vpId?: string }} msg
  */
 export function handleYeaftAbortTurn(msg = {}) {
-  const { turnId } = msg;
-  if (!turnId) {
-    sendSessionEvent({ type: 'yeaft_turn_aborted', turnId: null, success: false });
+  const sessionId = msg.sessionId || null;
+  const vpId = msg.vpId || null;
+  const turnIds = msg.turnId ? [msg.turnId] : findTurnIdsForVp({ sessionId, vpId });
+
+  if (turnIds.length === 0) {
+    sendSessionEvent({ type: 'yeaft_turn_aborted', turnId: null, turnIds: [], success: false, sessionId, vpId }, sessionId ? { sessionId } : undefined);
     return;
   }
 
-  const meta = turnAbortMeta.get(turnId);
-  const ctrl = turnAbortCtrls.get(turnId);
   let success = false;
+  const abortedTurnIds = [];
+  let ackSessionId = sessionId;
+  let ackVpId = vpId;
+
+  for (const turnId of turnIds) {
+    const meta = turnAbortMeta.get(turnId);
+    const ctrl = turnAbortCtrls.get(turnId);
+    if (!ackSessionId && meta?.sessionId) ackSessionId = meta.sessionId;
+    if (!ackVpId && meta?.vpId) ackVpId = meta.vpId;
+
+    let turnAborted = false;
+    if (ctrl && !ctrl.signal.aborted) {
+      try { ctrl.abort(); turnAborted = true; } catch { /* best-effort */ }
+    } else if (removeQueuedVpTurn(turnId)) {
+      turnAborted = true;
+      emitQueuedTurnAbort(meta, turnId);
+    }
 
-  if (ctrl && !ctrl.signal.aborted) {
-    try { ctrl.abort(); success = true; } catch { /* best-effort */ }
-  } else if (removeQueuedVpTurn(turnId)) {
-    success = true;
-    emitQueuedTurnAbort(meta, turnId);
+    if (turnAborted) {
+      success = true;
+      abortedTurnIds.push(turnId);
+    }
+    turnAbortCtrls.delete(turnId);
+    turnAbortMeta.delete(turnId);
   }
 
-  turnAbortCtrls.delete(turnId);
-  turnAbortMeta.delete(turnId);
-  sendSessionEvent({ type: 'yeaft_turn_aborted', turnId, success, sessionId: meta?.sessionId || null }, meta?.sessionId ? { sessionId: meta.sessionId } : undefined);
+  sendSessionEvent({
+    type: 'yeaft_turn_aborted',
+    turnId: abortedTurnIds[0] || turnIds[0] || null,
+    turnIds: abortedTurnIds.length > 0 ? abortedTurnIds : turnIds,
+    success,
+    sessionId: ackSessionId || null,
+    vpId: ackVpId || null,
+  }, ackSessionId ? { sessionId: ackSessionId } : undefined);
 }
 
 /**