Route HuggingFace calls through backend proxy via huggingface_hub

- Frontend HF calls now use /api/proxy/hf backend endpoint
- Backend uses huggingface_hub.InferenceClient with internal routing
(bypasses api-inference.huggingface.co DNS issue on HF infra)
- Removed browser-direct HF fetch (hfFetch + CORS proxies)

app.py

@@ -8,6 +8,13 @@ import sys
 app = Flask(__name__)
 STATIC_DIR = os.path.dirname(os.path.abspath(__file__))
 
+# Import huggingface_hub if available (pre-installed on HF Spaces)
+try:
+    from huggingface_hub import InferenceClient
+    HAS_HF_HUB = True
+except ImportError:
+    HAS_HF_HUB = False
+
 @app.route('/')
 def index():
     return send_from_directory(STATIC_DIR, 'index.html')
@@ -24,7 +31,6 @@ def proxy():
 
     method = data.get('method', 'POST').upper()
     headers = data.get('headers', {})
-    # Filter out hop-by-hop / browser-only headers
     filtered_headers = {}
     skip = {'origin', 'referer', 'host', 'cookie', 'set-cookie', 'cf-connecting-ip', 'cf-ray', 'cf-worker', 'x-forwarded-for', 'x-forwarded-proto', 'x-real-ip'}
     for k, v in headers.items():
@@ -89,6 +95,95 @@ def proxy():
         )
 
 
+@app.route('/api/proxy/hf', methods=['POST', 'OPTIONS'])
+def proxy_hf():
+    """Proxy HuggingFace Inference API via huggingface_hub internal routing."""
+    if request.method == 'OPTIONS':
+        return Response(headers={'Access-Control-Allow-Origin': '*'})
+
+    data = request.get_json(force=True)
+    model = data.get('model', '')
+    body = data.get('body', {})
+    token = data.get('token', '')
+    is_chat = data.get('is_chat', False)
+    stream = data.get('stream', False)
+
+    if not model:
+        return {'error': 'Missing model'}, 400
+
+    if not HAS_HF_HUB:
+        return {'error': 'huggingface_hub not available on server'}, 500
+
+    try:
+        client = InferenceClient(token=token)
+
+        if is_chat and not stream:
+            messages = body.get('messages', [])
+            temperature = body.get('temperature', 0.7)
+            max_tokens = body.get('max_tokens', 2048)
+
+            result = client.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=False,
+            )
+            return Response(
+                json.dumps(result.to_dict()),
+                status=200,
+                headers={'Content-Type': 'application/json'}
+            )
+
+        elif stream:
+            messages = body.get('messages', [])
+            temperature = body.get('temperature', 0.7)
+            max_tokens = body.get('max_tokens', 2048)
+
+            result = client.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=True,
+            )
+
+            def generate():
+                try:
+                    for chunk in result:
+                        yield f'data: {json.dumps(chunk.to_dict())}\n\n'
+                    yield 'data: [DONE]\n\n'
+                except Exception as e:
+                    print(f'HF stream error: {e}', file=sys.stderr, flush=True)
+            return Response(
+                stream_with_context(generate()),
+                status=200,
+                headers={'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'}
+            )
+
+        else:
+            # Text generation via _post to bypass model metadata lookup
+            resp = client._post(
+                path=f"/models/{model}",
+                json=body,
+                stream=False,
+            )
+            return Response(
+                resp.content,
+                status=resp.status_code,
+                headers={k: v for k, v in resp.headers.items() if k.lower() not in {'content-encoding', 'transfer-encoding', 'content-length'}},
+                content_type=resp.headers.get('Content-Type', 'application/json'),
+            )
+
+    except ImportError:
+        return {'error': 'huggingface_hub library not found'}, 500
+    except Exception as e:
+        tb = traceback.format_exc()
+        print(f'HF proxy error for {model}: {e}\n{tb}', file=sys.stderr, flush=True)
+        error_msg = f'{type(e).__name__}: {e}'
+        return {'error': error_msg}, 500
+
+
 if __name__ == '__main__':
     port = int(os.environ.get('PORT', 7860))
     app.run(host='0.0.0.0', port=port, debug=False)

index.html

@@ -1962,41 +1962,24 @@ async function streamPollinations(messages, systemPrompt, signal, onChunk) {
 async function callHuggingFace(messages, systemPrompt, signal, onChunk) {
   const apiKey = state.apiKeys['huggingface'] || '';
   const model = state.currentModel;
-  const headers = {'Content-Type':'application/json'};
-  if (apiKey) headers['Authorization'] = `Bearer ${apiKey}`;
   console.log('callHuggingFace: model=%s hasKey=%s', model, !!apiKey);
 
-  // Try chat completions endpoint first (direct fetch + CORS proxies, no backend proxy - DNS doesn't resolve server-side)
+  // Try chat completions via backend proxy (uses huggingface_hub internal routing)
   try {
-    return await hfChatCompletionsBrowser(model, messages, systemPrompt, headers, signal, onChunk);
+    return await hfChatCompletionsBackend(model, messages, systemPrompt, apiKey, signal, onChunk);
   } catch(e) {
-    if (e.message?.includes('HTTP 404') || e.message?.includes('HTTP 400')) {
+    if (e.message?.includes('HTTP 404') || e.message?.includes('HTTP 400') || e.message?.includes('model_not_supported')) {
       console.warn('Chat completions not supported for', model, 'trying text-generation');
     } else {
       throw e;
     }
   }
 
-  // Fallback: text-generation endpoint (also via browser)
-  return await hfTextGenerationBrowser(model, messages, systemPrompt, headers, signal, onChunk);
-}
-
-async function hfFetch(url, options = {}) {
-  // Try direct browser fetch first, then CORS proxies
-  try {
-    return await fetch(url, options);
-  } catch(e) {
-    if (!isNetworkError(e)) throw e;
-    const proxies = ['https://corsproxy.io/?url=', 'https://api.allorigins.win/raw?url=', 'https://thingproxy.freeboard.io/fetch/'];
-    for (const proxy of proxies) {
-      try { return await fetch(proxy + encodeURIComponent(url), options); } catch(e2) { if (!isNetworkError(e2)) throw e2; }
-    }
-    throw new Error('Ne mogu dosegnuti HuggingFace. Provjeri internet konekciju ili probaj Pollinations provider.');
-  }
+  // Fallback: text-generation via backend proxy
+  return await hfTextGenerationBackend(model, messages, systemPrompt, apiKey, signal, onChunk);
 }
 
-async function hfChatCompletionsBrowser(model, messages, systemPrompt, headers, signal, onChunk) {
-  const url = `https://api-inference.huggingface.co/models/${model}/v1/chat/completions`;
+async function hfChatCompletionsBackend(model, messages, systemPrompt, apiKey, signal, onChunk) {
   const body = {
     model,
     messages: [
@@ -2005,26 +1988,31 @@ async function hfChatCompletionsBrowser(model, messages, systemPrompt, headers,
     ],
     temperature: state.settings.temperature,
     max_tokens: state.settings.maxTokens,
-    stream: false, // non-streaming for reliability
   };
 
-  const res = await hfFetch(url, {method:'POST', headers, body:JSON.stringify(body), signal});
+  const res = await fetch('/api/proxy/hf', {
+    method: 'POST',
+    headers: {'Content-Type':'application/json'},
+    body: JSON.stringify({model, token: apiKey, is_chat: true, stream: false, body}),
+    signal,
+  });
+
   if (!res.ok) {
     let err = '';
     try { err = await res.text(); } catch(_) {}
     let msg = `HuggingFace HTTP ${res.status}`;
-    try { const j = JSON.parse(err); msg += ': ' + (j.error?.message || err.slice(0,300)); } catch(_) { if (err) msg += ': ' + err.slice(0,300); }
+    try { const j = JSON.parse(err); msg += ': ' + (j.error || err.slice(0,300)); } catch(_) { if (err) msg += ': ' + err.slice(0,300); }
     throw new Error(msg);
   }
+
   const json = await res.json();
   const fullText = json.choices?.[0]?.message?.content || '';
   if (fullText) onChunk(fullText);
   return fullText;
 }
 
-async function hfTextGenerationBrowser(model, messages, systemPrompt, headers, signal, onChunk) {
+async function hfTextGenerationBackend(model, messages, systemPrompt, apiKey, signal, onChunk) {
   const prompt = buildPrompt(messages, systemPrompt);
-  const url = `https://api-inference.huggingface.co/models/${model}`;
   const body = {
     inputs: prompt,
     parameters: {
@@ -2034,7 +2022,13 @@ async function hfTextGenerationBrowser(model, messages, systemPrompt, headers, s
     }
   };
 
-  const res = await hfFetch(url, {method:'POST', headers, body:JSON.stringify(body), signal});
+  const res = await fetch('/api/proxy/hf', {
+    method: 'POST',
+    headers: {'Content-Type':'application/json'},
+    body: JSON.stringify({model, token: apiKey, is_chat: false, stream: false, body}),
+    signal,
+  });
+
   if (!res.ok) {
     let err = '';
     try { err = await res.text(); } catch(_) {}
@@ -2042,44 +2036,13 @@ async function hfTextGenerationBrowser(model, messages, systemPrompt, headers, s
     try { const j = JSON.parse(err); msg += ': ' + (j.error || err.slice(0,300)); } catch(_) { if (err) msg += ': ' + err.slice(0,300); }
     throw new Error(msg);
   }
+
   const arr = await res.json();
   const fullText = Array.isArray(arr) ? (arr[0]?.generated_text || '') : '';
   if (fullText) onChunk(fullText);
   return fullText;
 }
 
-async function hfChatCompletions(model, messages, systemPrompt, headers, signal, onChunk) {
-  const url = `https://api-inference.huggingface.co/models/${model}/v1/chat/completions`;
-  const body = {
-    model,
-    messages: [
-      {role:'system', content: systemPrompt},
-      ...messages
-    ],
-    temperature: state.settings.temperature,
-    max_tokens: state.settings.maxTokens,
-  };
-
-  let res;
-  try {
-    res = await apiFetch(url, {method:'POST',headers,body:JSON.stringify(body),signal});
-  } catch(e) {
-    if (signal?.aborted) throw e;
-    throw new Error('Ne mogu dosegnuti HuggingFace.');
-  }
-  if (!res.ok) {
-    let err = '';
-    try { err = await res.text(); } catch(_) {}
-    let msg = `HuggingFace HTTP ${res.status}`;
-    try { const j = JSON.parse(err); msg += ': ' + (j.error?.message || err.slice(0,300)); } catch(_) { if (err) msg += ': ' + err.slice(0,300); }
-    throw new Error(msg);
-  }
-  const json = await res.json();
-  const fullText = json.choices?.[0]?.message?.content || '';
-  if (fullText) onChunk(fullText);
-  return fullText;
-}
-
 function buildPrompt(messages, systemPrompt) {
   let prompt = `System: ${systemPrompt}\n\n`;
   for (const m of messages) {

requirements.txt

@@ -1,3 +1,4 @@
 flask>=3.0
 requests>=2.31
 gunicorn>=21.2
+huggingface_hub>=0.26