minor issues and update to library

tysonthomas9 · tysonthomas9 · commit 98837c45fc03 · 2025-11-23T22:56:00.000-08:00
diff --git a/front_end/panels/ai_chat/LLM/AnthropicProvider.ts b/front_end/panels/ai_chat/LLM/AnthropicProvider.ts
@@ -17,6 +17,7 @@ const logger = createLogger('AnthropicProvider');
 export class AnthropicProvider extends LLMBaseProvider {
   private static readonly API_BASE_URL = 'https://api.anthropic.com/v1';
   private static readonly MESSAGES_PATH = '/messages';
+  private static readonly MODELS_PATH = '/models';
   private static readonly API_VERSION = '2023-06-01';
 
   readonly name: LLMProvider = 'anthropic';
@@ -32,6 +33,13 @@ export class AnthropicProvider extends LLMBaseProvider {
     return `${AnthropicProvider.API_BASE_URL}${AnthropicProvider.MESSAGES_PATH}`;
   }
 
+  /**
+   * Get the models endpoint URL
+   */
+  private getModelsEndpoint(): string {
+    return `${AnthropicProvider.API_BASE_URL}${AnthropicProvider.MODELS_PATH}`;
+  }
+
   /**
    * Convert MessageContent to Anthropic format
    */
@@ -165,6 +173,7 @@ export class AnthropicProvider extends LLMBaseProvider {
         'Content-Type': 'application/json',
         'x-api-key': this.apiKey,
         'anthropic-version': AnthropicProvider.API_VERSION,
+        'anthropic-dangerous-direct-browser-access': 'true',
       };
 
       // Add beta headers if provided
@@ -322,13 +331,95 @@ export class AnthropicProvider extends LLMBaseProvider {
     return LLMResponseParser.parseResponse(response);
   }
 
+  /**
+   * Fetch available models from Anthropic API
+   */
+  async fetchModels(apiKey?: string, endpoint?: string): Promise<AnthropicModel[]> {
+    logger.debug('Fetching available Anthropic models...');
+
+    // Use provided apiKey if available, otherwise fall back to instance apiKey
+    const keyToUse = apiKey || this.apiKey;
+
+    try {
+      const response = await fetch(this.getModelsEndpoint(), {
+        method: 'GET',
+        headers: {
+          'x-api-key': keyToUse,
+          'anthropic-version': AnthropicProvider.API_VERSION,
+          'anthropic-dangerous-direct-browser-access': 'true',
+        },
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({ error: { message: 'Unknown error' } }));
+        logger.error('Anthropic models API error:', JSON.stringify(errorData, null, 2));
+        throw new Error(`Anthropic models API error: ${response.statusText} - ${errorData?.error?.message || 'Unknown error'}`);
+      }
+
+      const data: AnthropicModelsResponse = await response.json();
+      logger.debug('Anthropic Models Response:', data);
+
+      if (!data?.data || !Array.isArray(data.data)) {
+        throw new Error('Invalid models response format');
+      }
+
+      return data.data;
+    } catch (error) {
+      logger.error('Failed to fetch Anthropic models:', error);
+      throw error;
+    }
+  }
+
   /**
    * Get all models supported by this provider
    */
   async getModels(): Promise<ModelInfo[]> {
-    // Anthropic doesn't provide a public models API endpoint
-    // Return hardcoded list of known models
-    return this.getDefaultModels();
+    try {
+      // Fetch models from Anthropic API
+      const anthropicModels = await this.fetchModels();
+
+      return anthropicModels.map(model => ({
+        id: model.id,
+        name: model.display_name || model.id,
+        provider: 'anthropic' as LLMProvider,
+        capabilities: {
+          functionCalling: this.modelSupportsFunctionCalling(model.id),
+          reasoning: this.modelSupportsReasoning(model.id),
+          vision: this.modelSupportsVision(model.id),
+          structured: true, // All Anthropic models support structured outputs
+        }
+      }));
+    } catch (error) {
+      logger.warn('Failed to fetch models from API, falling back to default list:', error);
+      // Fallback to hardcoded list if API call fails
+      return this.getDefaultModels();
+    }
+  }
+
+  /**
+   * Check if a model supports function calling
+   */
+  private modelSupportsFunctionCalling(modelId: string): boolean {
+    // All Claude 3+ models support function calling
+    return modelId.includes('claude-3') || modelId.includes('claude-sonnet-4');
+  }
+
+  /**
+   * Check if a model supports extended thinking/reasoning
+   */
+  private modelSupportsReasoning(modelId: string): boolean {
+    // Claude Sonnet 4.5 and newer support extended thinking
+    return modelId.includes('claude-sonnet-4.5') || modelId.includes('claude-sonnet-4-');
+  }
+
+  /**
+   * Check if a model supports vision/image inputs
+   */
+  private modelSupportsVision(modelId: string): boolean {
+    // Claude 3 Opus, Sonnet, and Haiku support vision
+    // Claude Sonnet 4+ also supports vision
+    return (modelId.includes('claude-3') && !modelId.includes('haiku')) ||
+           modelId.includes('claude-sonnet-4');
   }
 
   /**
@@ -467,3 +558,23 @@ export class AnthropicProvider extends LLMBaseProvider {
     };
   }
 }
+
+/**
+ * Anthropic model object from the /v1/models API
+ */
+interface AnthropicModel {
+  id: string;
+  display_name: string;
+  created_at: string;
+  type: 'model';
+}
+
+/**
+ * Response from Anthropic /v1/models endpoint
+ */
+interface AnthropicModelsResponse {
+  data: AnthropicModel[];
+  first_id: string;
+  last_id: string;
+  has_more: boolean;
+}
diff --git a/front_end/panels/ai_chat/LLM/GoogleAIProvider.ts b/front_end/panels/ai_chat/LLM/GoogleAIProvider.ts
@@ -344,11 +344,17 @@ export class GoogleAIProvider extends LLMBaseProvider {
   /**
    * Fetch available models from Google AI API
    */
-  async fetchModels(): Promise<GoogleAIModel[]> {
+  async fetchModels(apiKey?: string, endpoint?: string): Promise<GoogleAIModel[]> {
     logger.debug('Fetching available Google AI models...');
 
+    // Use provided apiKey if available, otherwise fall back to instance apiKey
+    const keyToUse = apiKey || this.apiKey;
+
+    // Build endpoint URL with API key
+    const modelsUrl = `${GoogleAIProvider.API_BASE_URL}/models?key=${keyToUse}`;
+
     try {
-      const response = await fetch(this.getModelsEndpoint(), {
+      const response = await fetch(modelsUrl, {
         method: 'GET',
       });
 
diff --git a/front_end/panels/ai_chat/ui/CustomProviderDialog.ts b/front_end/panels/ai_chat/ui/CustomProviderDialog.ts
@@ -4,8 +4,7 @@
 
 import * as UI from '../../../ui/legacy/legacy.js';
 import * as Geometry from '../../../models/geometry/geometry.js';
-import { CustomProviderManager } from '../core/CustomProviderManager.js';
-import type { CustomProviderConfig } from '../core/CustomProviderManager.js';
+import { CustomProviderManager, type CustomProviderConfig } from '../core/CustomProviderManager.js';
 import { LLMClient } from '../LLM/LLMClient.js';
 import { createLogger } from '../core/Logger.js';
 import { PROVIDER_SELECTION_KEY } from './settings/constants.js';
diff --git a/front_end/panels/ai_chat/vendor/readability-source.ts b/front_end/panels/ai_chat/vendor/readability-source.ts
@@ -3,14 +3,14 @@
 // found in the LICENSE file.
 
 /**
- * Mozilla Readability library bundled as a string for runtime injection.
- * Version: 0.6.0
+ * Bundled Mozilla Readability library (main branch)
  * Source: https://github.com/mozilla/readability
- * License: Apache-2.0
+ * This file contains the Readability.js source code as a string constant
+ * for injection into web pages for content extraction.
  */
 
-// @ts-nocheck - Large bundled library source
-export const READABILITY_SOURCE = `/*
+export const READABILITY_SOURCE = `
+/*
  * Copyright (c) 2010 Arc90 Inc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -151,7 +151,8 @@ Readability.prototype = {
     // Readability-readerable.js. Please keep both copies in sync.
     unlikelyCandidates:
       /-ad-|ai2html|banner|breadcrumbs|combx|comment|community|cover-wrap|disqus|extra|footer|gdpr|header|legends|menu|related|remark|replies|rss|shoutbox|sidebar|skyscraper|social|sponsor|supplemental|ad-break|agegate|pagination|pager|popup|yom-remote/i,
-    okMaybeItsACandidate: /and|article|body|column|content|main|shadow/i,
+    okMaybeItsACandidate:
+      /and|article|body|column|content|main|mathjax|shadow/i,
 
     positive:
       /article|body|content|entry|hentry|h-entry|main|page|pagination|post|text|blog|story/i,
@@ -163,7 +164,7 @@ Readability.prototype = {
     replaceFonts: /<(\\/?)font[^>]*>/gi,
     normalize: /\\s{2,}/g,
     videos:
-      /\\/\\/(www\\.)?((dailymotion|youtube|youtube-nocookie|player\\.vimeo|v\\.qq)\\.com|(archive|upload\\.wikimedia)\\.org|player\\.twitch\\.tv)/i,
+      /\\/\\/(www\\.)?((dailymotion|youtube|youtube-nocookie|player\\.vimeo|v\\.qq|bilibili|live.bilibili)\\.com|(archive|upload\\.wikimedia)\\.org|player\\.twitch\\.tv)/i,
     shareElements: /(\\b|_)(share|sharedaddy)(\\b|_)/i,
     nextLink: /(next|weiter|continue|>([^\\|]|$)|»([^\\|]|$))/i,
     prevLink: /(prev|earl|old|new|<|«)/i,
@@ -605,14 +606,20 @@ Readability.prototype = {
     }
 
     // If there's a separator in the title, first remove the final part
-    if (/ [\\|\\-\\\\\\/>»] /.test(curTitle)) {
-      titleHadHierarchicalSeparators = / [\\\\\\/>»] /.test(curTitle);
-      let allSeparators = Array.from(origTitle.matchAll(/ [\\|\\-\\\\\\/>»] /gi));
+    const titleSeparators = /\\|\\-–—\\\\\\/>»/.source;
+    if (new RegExp(\`\\\\s[\${titleSeparators}]\\\\s\`).test(curTitle)) {
+      titleHadHierarchicalSeparators = /\\s[\\\\\\/>»]\\s/.test(curTitle);
+      let allSeparators = Array.from(
+        origTitle.matchAll(new RegExp(\`\\\\s[\${titleSeparators}]\\\\s\`, "gi"))
+      );
       curTitle = origTitle.substring(0, allSeparators.pop().index);
 
       // If the resulting title is too short, remove the first part instead:
       if (wordCount(curTitle) < 3) {
-        curTitle = origTitle.replace(/^[^\\|\\-\\\\\\/>»]*[\\|\\-\\\\\\/>»]/gi, "");
+        curTitle = origTitle.replace(
+          new RegExp(\`^[^\${titleSeparators}]*[\${titleSeparators}]\`, "gi"),
+          ""
+        );
       }
     } else if (curTitle.includes(": ")) {
       // Check if we have an heading containing this exact string, so we
@@ -654,7 +661,10 @@ Readability.prototype = {
       curTitleWordCount <= 4 &&
       (!titleHadHierarchicalSeparators ||
         curTitleWordCount !=
-          wordCount(origTitle.replace(/[\\|\\-\\\\\\/>»]+/g, "")) - 1)
+          wordCount(
+            origTitle.replace(new RegExp(\`\\\\s[\${titleSeparators}]\\\\s\`, "g"), "")
+          ) -
+            1)
     ) {
       curTitle = origTitle;
     }
@@ -1176,23 +1186,39 @@ Readability.prototype = {
         // Turn all divs that don't have children block level elements into p's
         if (node.tagName === "DIV") {
           // Put phrasing content into paragraphs.
-          var p = null;
           var childNode = node.firstChild;
           while (childNode) {
             var nextSibling = childNode.nextSibling;
             if (this._isPhrasingContent(childNode)) {
-              if (p !== null) {
-                p.appendChild(childNode);
-              } else if (!this._isWhitespace(childNode)) {
-                p = doc.createElement("p");
-                node.replaceChild(p, childNode);
-                p.appendChild(childNode);
+              var fragment = doc.createDocumentFragment();
+              // Collect all consecutive phrasing content into a fragment.
+              do {
+                nextSibling = childNode.nextSibling;
+                fragment.appendChild(childNode);
+                childNode = nextSibling;
+              } while (childNode && this._isPhrasingContent(childNode));
+
+              // Trim leading and trailing whitespace from the fragment.
+              while (
+                fragment.firstChild &&
+                this._isWhitespace(fragment.firstChild)
+              ) {
+                fragment.firstChild.remove();
               }
-            } else if (p !== null) {
-              while (p.lastChild && this._isWhitespace(p.lastChild)) {
-                p.lastChild.remove();
+              while (
+                fragment.lastChild &&
+                this._isWhitespace(fragment.lastChild)
+              ) {
+                fragment.lastChild.remove();
+              }
+
+              // If the fragment contains anything, wrap it in a paragraph and
+              // insert it before the next non-phrasing node.
+              if (fragment.firstChild) {
+                var p = doc.createElement("p");
+                p.appendChild(fragment);
+                node.insertBefore(p, nextSibling);
               }
-              p = null;
             }
             childNode = nextSibling;
           }
@@ -2796,4 +2822,5 @@ if (typeof module === "object") {
   /* global module */
   module.exports = Readability;
 }
+
 `;
