Mirror V2 content into V1 (snapshot for continued development)

.gitattributes

@@ -1,38 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,24 +1,44 @@
 ---
-title: BF Realtime
+title: BF Realtime V2
 emoji: 🎙️
-colorFrom: indigo
-colorTo: purple
+colorFrom: red
+colorTo: gray
 sdk: docker
 app_port: 7860
 pinned: false
 ---
 
-# BF-Realtime
+# BF-Realtime V2
 
-Trek Bisiklet sesli satis asistani — OpenAI Realtime API ile canli ses sohbet.
+Trek Bisiklet sesli satis asistani. OpenAI gpt-realtime-2 + Trek katalog index + BizimHesap stok servisi.
 
-## Mimari
+## Modul yapisi
 
-- **Backend:** FastAPI + WebSocket (relay)
-- **Model:** `gpt-realtime` (OpenAI Realtime API)
-- **Tool calling:** Stok ve fiyat sorgusu icin `get_warehouse_stock_smart_with_price`
-- **Frontend:** Web Audio API (PCM16, 24kHz)
+| Dosya | Sorumluluk |
+|-------|-----------|
+| `app.py` | FastAPI routing + startup tasks |
+| `realtime_relay.py` | OpenAI Realtime WebSocket relay + event handling |
+| `product_index.py` | Trek katalog XML parse + thread-safe hash index |
+| `product_matcher.py` | Local fuzzy match + gpt-5-nano fallback |
+| `stock_service.py` | BizimHesap + Trek PHP stok cache (lock'lu) |
+| `tools.py` | `get_warehouse_stock` tool implementasyonu |
+| `prompts.py` | Sistem prompt iceriği |
+| `config.py` | Tum sabitler (URL, timeout, TTL) |
 
-## Environment Variables
+## Ekran
 
-`OPENAI_API_KEY` Space Settings -> Variables and secrets'tan ayarlanmali.
+`static/index.html` — Cift monitor UI (sol: avatar, sag: urun vitrini galeri).
+
+## Endpoint'ler
+
+- `GET /` — Ana sayfa
+- `GET /health` — Saglik kontrolu
+- `WS /ws` — Realtime WebSocket
+- `GET /warehouse-xml` — Diger client'lar icin stok XML proxy
+- `GET /bh/{products,warehouses,inventory/{wid}}` — BizimHesap raw cache
+- `GET /debug-find?q=...` — Urun matcher debug
+- `GET /debug-search?q=...` — Tool debug
+
+## Env
+
+`OPENAI_API_KEY` — Realtime + nano fallback icin.

app.py

@@ -1,50 +1,58 @@
+"""BF-Realtime V2 — FastAPI entry point.
+
+Sadece routing ve startup logic. Tum is logic'i ayri modullerde:
+- product_index: Trek katalog XML parse + hash index
+- product_matcher: fuzzy ana urun + renk varyanti eslestirme
+- stock_service: BizimHesap + Trek PHP stok cache
+- tools: get_warehouse_stock implementasyonu
+- realtime_relay: OpenAI Realtime WS proxy
 """
-BF-Realtime - Trek Bisiklet sesli satis asistani
-FastAPI + WebSocket relay -> OpenAI Realtime API
-"""
-import os
-import json
+from __future__ import annotations
+
 import asyncio
 import logging
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
-from fastapi.responses import FileResponse
+
+from fastapi import FastAPI, WebSocket
+from fastapi.responses import FileResponse, JSONResponse, Response
 from fastapi.staticfiles import StaticFiles
-import websockets
 
-# Local mantik
-from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
-from prompts import get_active_prompt_content_only
+from config import (
+    OPENAI_API_KEY,
+    REALTIME_MODEL,
+    REFRESH_INTERVAL,
+)
+from product_index import background_refresh_loop, get_index
+from product_matcher import find_main_product_in_text
+from realtime_relay import realtime_relay
+from stock_service import (
+    cached_bh,
+    cached_bh_inventory,
+    get_cached_warehouse_xml,
+)
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-REALTIME_MODEL = "gpt-realtime-2"
-REALTIME_URL = f"wss://api.openai.com/v1/realtime?model={REALTIME_MODEL}"
-
-app = FastAPI(title="BF-Realtime")
+app = FastAPI(title="BF-Realtime V2")
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
 
 @app.on_event("startup")
-async def _startup_warmup():
-    """XML cache + parse index + stok XML'i thread'de baslat — event loop'u bloklama."""
-    async def loop():
+async def _startup():
+    """Background refresh tasks — index + warehouse XML her saatte tazelenir."""
+    async def warehouse_loop():
         while True:
             try:
-                await asyncio.to_thread(_ensure_index)
-            except Exception:
-                logger.exception('trek index refresh hatasi')
-            try:
-                # Stok XML'ini de proaktif olarak warm-load et — Cloudflare 1015 ban riskine karsi
-                from smart_warehouse_with_price import get_cached_warehouse_xml
                 await asyncio.to_thread(get_cached_warehouse_xml)
             except Exception:
-                logger.exception('warehouse xml refresh hatasi')
-            await asyncio.sleep(3600)  # 1 saatte bir tazele (cache 24h, ama erken refresh)
-    asyncio.create_task(loop())
+                logger.exception("warehouse refresh hatasi")
+            await asyncio.sleep(REFRESH_INTERVAL)
 
+    asyncio.create_task(background_refresh_loop(REFRESH_INTERVAL))
+    asyncio.create_task(warehouse_loop())
 
+
+# ---------- Frontend ----------
 @app.get("/")
 async def root():
     return FileResponse("static/index.html")
@@ -52,45 +60,28 @@ async def root():
 
 @app.get("/health")
 async def health():
+    idx = get_index()
     return {
         "status": "ok",
         "model": REALTIME_MODEL,
         "has_api_key": bool(OPENAI_API_KEY),
+        "index_main_count": idx.main_count,
     }
 
 
-@app.get("/debug-warehouse")
-async def debug_warehouse():
-    """get_cached_warehouse_xml() durumunu kontrol et — Cloudflare/Trek PHP debug icin."""
-    import re
-    from collections import Counter
-    from smart_warehouse_with_price import get_cached_warehouse_xml
-    try:
-        xml = get_cached_warehouse_xml()
-    except Exception as e:
-        return {"error": str(e)}
-    if not xml:
-        return {"xml": None, "warehouses": {}, "size": 0}
-    whs = re.findall(r"<!\[CDATA\[([^\]]+)\]\]></Name>", xml)
-    counts = dict(Counter(whs))
-    head = xml[:300] if len(xml) > 300 else xml
-    return {"size": len(xml), "warehouses": counts, "head": head}
+# ---------- Realtime WebSocket ----------
+@app.websocket("/ws")
+async def ws_endpoint(client_ws: WebSocket):
+    await realtime_relay(client_ws)
 
 
+# ---------- Public proxy: warehouse XML (digerservisler kullaniyor) ----------
 @app.get("/warehouse-xml")
 async def warehouse_xml():
-    """Trek PHP, ideasoft sayfalari ve diger 5 program icin merkezi XML endpoint.
-    HF Space cache'inden serve edilir (1-2 saat tazelikli)."""
-    from fastapi.responses import Response
-    from smart_warehouse_with_price import get_cached_warehouse_xml
-    try:
-        xml = get_cached_warehouse_xml()
-    except Exception as e:
-        logger.exception("warehouse-xml error")
-        xml = None
+    xml = await asyncio.to_thread(get_cached_warehouse_xml)
     if not xml:
         return Response(
-            content='<?xml version="1.0" encoding="UTF-8"?>\n<!-- HF Space: no data -->\n<Products></Products>',
+            content='<?xml version="1.0" encoding="UTF-8"?>\n<Products></Products>',
             media_type="application/xml",
             headers={"Cache-Control": "no-cache"},
         )
@@ -99,747 +90,89 @@ async def warehouse_xml():
         media_type="application/xml",
         headers={
             "Access-Control-Allow-Origin": "*",
-            "Cache-Control": "public, max-age=300",  # 5 dakika downstream cache
+            "Cache-Control": "public, max-age=300",
         },
     )
 
 
-# ============================================
-# BizimHesap raw JSON aynalari (tavsiye + diger client'lar icin)
-# Cloudflare 1015 ban'a karsi HF Space IP havuzundan cache'li servis
-# ============================================
-import time as _time
-_bh_cache = {
-    "products": {"data": None, "time": 0, "ttl": 7200},      # 2 saat
-    "warehouses": {"data": None, "time": 0, "ttl": 21600},   # 6 saat
-    "inventory": {},                                          # {wid: {data, time}}
-}
-_BH_INVENTORY_TTL = 1800  # 30 dakika
-
-
-def _bh_cached(kind: str, fetcher):
-    """products/warehouses icin generic cache helper."""
-    entry = _bh_cache[kind]
-    now = _time.time()
-    if entry["data"] is not None and (now - entry["time"] < entry["ttl"]):
-        return entry["data"], "hit"
-    data = fetcher()
-    if data is not None:
-        entry["data"] = data
-        entry["time"] = now
-        return data, "miss"
-    if entry["data"] is not None:
-        return entry["data"], "stale"
-    return None, "fail"
-
-
+# ---------- Public proxy: BizimHesap raw (tavsiye/sold/diger client'lar) ----------
 @app.get("/bh/products")
 async def bh_products():
-    from fastapi.responses import JSONResponse
-    from smart_warehouse_with_price import _bh_get, BIZIMHESAP_BASE
-    data, status = _bh_cached("products", lambda: _bh_get(f"{BIZIMHESAP_BASE}/products"))
+    from stock_service import bh_get
+    from config import BIZIMHESAP_BASE, CACHE_TTL_BH_PRODUCTS
+    data, status = await asyncio.to_thread(
+        cached_bh,
+        "products",
+        lambda: bh_get(f"{BIZIMHESAP_BASE}/products"),
+        CACHE_TTL_BH_PRODUCTS,
+    )
     if data is None:
-        return JSONResponse({"resultCode": 0, "errorText": "BizimHesap fetch failed", "data": None}, status_code=502)
+        return JSONResponse(
+            {"resultCode": 0, "errorText": "BizimHesap fetch failed", "data": None},
+            status_code=502,
+        )
     return JSONResponse(
         data,
-        headers={"Access-Control-Allow-Origin": "*", "X-Cache": status, "Cache-Control": "public, max-age=300"},
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "X-Cache": status,
+            "Cache-Control": "public, max-age=300",
+        },
     )
 
 
 @app.get("/bh/warehouses")
 async def bh_warehouses():
-    from fastapi.responses import JSONResponse
-    from smart_warehouse_with_price import _bh_get, BIZIMHESAP_BASE
-    data, status = _bh_cached("warehouses", lambda: _bh_get(f"{BIZIMHESAP_BASE}/warehouses"))
+    from stock_service import bh_get
+    from config import BIZIMHESAP_BASE, CACHE_TTL_BH_WAREHOUSES
+    data, status = await asyncio.to_thread(
+        cached_bh,
+        "warehouses",
+        lambda: bh_get(f"{BIZIMHESAP_BASE}/warehouses"),
+        CACHE_TTL_BH_WAREHOUSES,
+    )
     if data is None:
-        return JSONResponse({"resultCode": 0, "errorText": "BizimHesap fetch failed", "data": None}, status_code=502)
+        return JSONResponse(
+            {"resultCode": 0, "errorText": "BizimHesap fetch failed", "data": None},
+            status_code=502,
+        )
     return JSONResponse(
         data,
-        headers={"Access-Control-Allow-Origin": "*", "X-Cache": status, "Cache-Control": "public, max-age=300"},
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "X-Cache": status,
+            "Cache-Control": "public, max-age=300",
+        },
     )
 
 
 @app.get("/bh/inventory/{wid}")
 async def bh_inventory(wid: str):
-    from fastapi.responses import JSONResponse
-    from smart_warehouse_with_price import _bh_get, BIZIMHESAP_BASE
-    now = _time.time()
-    entry = _bh_cache["inventory"].get(wid)
-    if entry and (now - entry["time"] < _BH_INVENTORY_TTL):
-        return JSONResponse(
-            entry["data"],
-            headers={"Access-Control-Allow-Origin": "*", "X-Cache": "hit", "Cache-Control": "public, max-age=300"},
-        )
-    data = _bh_get(f"{BIZIMHESAP_BASE}/inventory/{wid}")
-    if data is not None:
-        _bh_cache["inventory"][wid] = {"data": data, "time": now}
-        return JSONResponse(
-            data,
-            headers={"Access-Control-Allow-Origin": "*", "X-Cache": "miss", "Cache-Control": "public, max-age=300"},
-        )
-    if entry:
+    data, status = await asyncio.to_thread(cached_bh_inventory, wid)
+    if data is None:
         return JSONResponse(
-            entry["data"],
-            headers={"Access-Control-Allow-Origin": "*", "X-Cache": "stale", "Cache-Control": "public, max-age=60"},
+            {"resultCode": 0, "errorText": "BizimHesap fetch failed", "data": None},
+            status_code=502,
         )
-    return JSONResponse({"resultCode": 0, "errorText": "BizimHesap fetch failed", "data": None}, status_code=502)
-
-
-@app.get("/debug-search")
-async def debug_search(q: str):
-    """Bir kullanici sorgusunu (q) get_warehouse_stock_smart_with_price'a ver, sonucu don."""
-    from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
-    try:
-        result = get_warehouse_stock_smart_with_price(q)
-        return {"query": q, "result": result, "type": str(type(result).__name__)}
-    except Exception as e:
-        import traceback
-        return {"query": q, "error": str(e), "traceback": traceback.format_exc()}
-
-
-def apply_pronunciation_fixes(text: str) -> str:
-    """Telaffuz duzeltmeleri — model bazi yer isimlerini Ingilizce gibi okumasin diye
-    metni modele iletmeden once kucuk yazim degisiklikleri uygulanir."""
-    if not isinstance(text, str):
-        return text
-    return text.replace("Caddebostan", "Cadde Bostan")
-
-
-def build_session_instructions() -> str:
-    """prompts.py'daki sistem promptlarini Realtime icin tek metne cevir."""
-    try:
-        base = get_active_prompt_content_only()
-        if isinstance(base, list):
-            base = "\n\n".join(str(p) for p in base)
-    except Exception as e:
-        logger.error(f"Prompt yuklenemedi: {e}")
-        base = "Trek Bisiklet uzmani bir satis temsilcisisin."
-
-    voice_addon = (
-        "\n\nGORSEL DESTEK (onemli):\n"
-        "- Musterinin ekraninin sag tarafinda urun gorseli OTOMATIK olarak gosteriliyor.\n"
-        "- Bahsettigin urunun resmi sag tarafta belirir; renk veya boy sorulursa o varyantin gorseline gecer.\n"
-        "- 'Gorsel paylasiyorum', 'resmini atiyorum', 'linki gonderiyorum' gibi cumleler kurma.\n"
-        "- 'Sagda gorebilirsiniz' gibi kisa referanslar verebilirsin.\n"
-        "\nSESLI SOHBET KURALLARI (cok onemli):\n"
-        "- COK KISA cevap ver. Hedef: 1 cumle, EN FAZLA 2 cumle. Token tasarrufu kritik.\n"
-        "- Cumleler kisa ve net olsun. Tekrar etme, dolaylama yapma, nezaket bezeyici cumle EKLEME.\n"
-        "- Sadece SORULANA dogrudan cevap ver. Ekstra oneri, yonlendirme, tesvik EKLEME.\n"
-        "- 'Yardimci olabilir miyim', 'magazada inceleyebilirsiniz', 'baska sorunuz var mi'\n"
-        "  gibi kapanis/dolgu cumleleri YASAK.\n"
-        "- Markdown, * veya emoji KULLANMA.\n"
-        "- URL/link/web adresi ASLA SOYLEME. 'www', 'trekbisiklet.com', 'https' gibi adresleri hicbir sekilde sesli okuma. "
-        "'Linki paylasiyorum', 'sitede goreceksiniz' gibi link referanslari da YASAK.\n"
-        "- HER ZAMAN 'siz' ile hitap et, soru ile bitirme.\n"
-        "- Stok/fiyat sorulari geldiginde get_warehouse_stock fonksiyonunu cagir, sonucu OZUN tek cumlede ver.\n"
-        "\n"
-        "STOK ADEDI KURALI (kritik):\n"
-        "- Stok ADEDINI / SAYISINI ASLA SOYLEME.\n"
-        "- Sadece 'mevcut', 'stokta var', 'bulunmuyor' veya 'tukenmis' gibi durum bildir.\n"
-        "- Adet sorulsa bile 'detayli adet bilgisi icin magazayla teyit' deyip gec, ek aciklama yapma.\n"
-        "\n"
-        "STOK SORGUSU AKISI:\n"
-        "- SADECE oturumdaki ILK stok sorgusunda kisa bir bekleme cumlesi soyle ('Bir saniye, bakiyorum.' gibi). "
-        "Cunku ilk sorgu biraz daha uzun surebilir.\n"
-        "- Sonraki TUM stok sorgularinda bekleme cumlesi YASAK — direkt fonksiyonu cagir, sonuc gelince TEK CUMLE cevap ver. "
-        "Sonraki sorgularda 'bakiyorum', 'bir saniye', 'kontrol ediyorum' KESINLIKLE SOYLEME.\n"
-    )
-    return apply_pronunciation_fixes(base + voice_addon)
-
-
-# OpenAI Realtime tool tanimi
-TOOLS = [
-    {
-        "type": "function",
-        "name": "get_warehouse_stock",
-        "description": (
-            "Trek bisiklet, aksesuar veya yedek parca icin magaza stok durumu, "
-            "fiyat ve urun linkini getirir. Musteri stok, fiyat veya urun "
-            "varligini sordugunda kullan."
-        ),
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "user_message": {
-                    "type": "string",
-                    "description": "Musterinin urun/stok sorusu (orn. 'Madone SLR 9 var mi', 'Marlin 5 fiyat')",
-                }
-            },
-            "required": ["user_message"],
+    return JSONResponse(
+        data,
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "X-Cache": status,
+            "Cache-Control": "public, max-age=300",
         },
-    }
-]
-
-
-async def handle_tool_call(name: str, arguments: dict) -> str:
-    """Tool call'larini local fonksiyonlara yonlendir."""
-    try:
-        if name == "get_warehouse_stock":
-            msg = arguments.get("user_message", "")
-            logger.info(f"[tool] get_warehouse_stock query: {msg!r}")
-            result = get_warehouse_stock_smart_with_price(msg)
-            if result is None:
-                logger.info(f"[tool] result: None (stok bulunamadi)")
-                return "Stok bilgisi bulunamadi."
-            logger.info(f"[tool] result lines: {len(result) if isinstance(result, list) else 'str'}")
-            return apply_pronunciation_fixes(str(result))
-        return f"Bilinmeyen fonksiyon: {name}"
-    except Exception as e:
-        logger.exception(f"Tool call hatasi ({name})")
-        return f"Hata: {e}"
-
-
-_TR_MAP = {'İ': 'i', 'I': 'i', 'ı': 'i', 'Ğ': 'g', 'ğ': 'g',
-           'Ü': 'u', 'ü': 'u', 'Ş': 's', 'ş': 's',
-           'Ö': 'o', 'ö': 'o', 'Ç': 'c', 'ç': 'c'}
-
-def _norm(s: str) -> str:
-    if not s:
-        return ''
-    for tr, en in _TR_MAP.items():
-        s = s.replace(tr, en)
-    return s.lower()
-
-
-# Parse-once index — XML her degistiginde yeniden build edilir.
-# Realtime aramalarda 7MB regex re-parse yapilmaz, hash lookup'lar kullanilir.
-_INDEX = {
-    "xml_id": None,            # ham XML'in id'si — degisirse yeniden parse
-    "products": [],            # list of parsed product dicts
-    "by_link": {},             # productLink -> product
-    "by_sku": {},              # stockCode -> product
-    "main_skus": set(),        # ana urunlerin stockCode set'i
-    "variants_by_root": {},    # root_sku -> [variant products]
-    "main_links": [],          # sadece ana urunlerin linkleri (hizli iterasyon)
-}
-
-_VARIANT_LABEL_PARTS_RE = None
-_ITEM_RE = None
-_FIELD_RES = None
-
-
-def _compile_regexes():
-    """Modul ilk yuklemede regex'leri compile et."""
-    global _VARIANT_LABEL_PARTS_RE, _ITEM_RE, _FIELD_RES
-    if _ITEM_RE is not None:
-        return
-    import re
-    _ITEM_RE = re.compile(r'<item>(.*?)</item>', re.DOTALL)
-    _VARIANT_LABEL_PARTS_RE = re.compile(r'\s*[-/]\s*')
-    _FIELD_RES = {
-        'rootlabel': re.compile(r'<rootlabel><!\[CDATA\[(.*?)\]\]></rootlabel>'),
-        'label': re.compile(r'<label><!\[CDATA\[(.*?)\]\]></label>'),
-        'productLink': re.compile(r'<productLink><!\[CDATA\[(.*?)\]\]></productLink>'),
-        'stockCode': re.compile(r'<stockCode><!\[CDATA\[(.*?)\]\]></stockCode>'),
-        'isOptionOfAProduct': re.compile(r'<isOptionOfAProduct>(\d+)</isOptionOfAProduct>'),
-        'rootProductStockCode': re.compile(r'<rootProductStockCode><!\[CDATA\[(.*?)\]\]></rootProductStockCode>'),
-    }
-    # picture1Path - picture8Path
-    for i in range(1, 9):
-        _FIELD_RES[f'picture{i}'] = re.compile(
-            rf'<picture{i}Path><!\[CDATA\[(.*?)\]\]></picture{i}Path>'
-        )
-
-_compile_regexes()
-
-
-def _parse_item(it: str) -> dict:
-    """Tek bir XML item'ini dict'e cevir + arama icin token cache'i hazirla."""
-    import re as _re
-    fr = _FIELD_RES
-
-    def grab(name):
-        m = fr[name].search(it)
-        return m.group(1).strip() if m else ''
-
-    rootlabel = grab('rootlabel')
-    var_label = grab('label')
-    link = grab('productLink')
-    sku = grab('stockCode')
-    iv_m = fr['isOptionOfAProduct'].search(it)
-    is_variant = bool(iv_m and iv_m.group(1) == '1')
-    root_sku = grab('rootProductStockCode')
-
-    images = []
-    for i in range(1, 9):
-        m = fr[f'picture{i}'].search(it)
-        if m and m.group(1).strip():
-            images.append(m.group(1).strip())
-
-    color = None
-    size = None
-    if is_variant and var_label:
-        parts = [p.strip() for p in _VARIANT_LABEL_PARTS_RE.split(var_label) if p.strip()]
-        size_pat = _re.compile(
-            r'^(?:XX?S|XS|S|M|L|XL|XXL|XXXL|\d{2}(?:\.\d)?(?:\s*CM)?)$', _re.I
-        )
-        for p in parts:
-            if size_pat.match(p) and not size:
-                size = p.upper()
-            elif not color:
-                color = p.upper()
-
-    # Arama icin onceden hazirlanmis token'lar
-    label_norm = _norm(rootlabel)
-    tokens = [t for t in _re.findall(r'[a-z0-9+]+', label_norm) if len(t) >= 2]
-
-    return {
-        'name': rootlabel,
-        'image': images[0] if images else None,
-        'images': images,
-        'link': link,
-        'sku': sku,
-        'color': color,
-        'size': size,
-        'is_variant': is_variant,
-        'root_sku': root_sku if root_sku and root_sku != '0' else None,
-        '_tokens': tokens,
-        '_label_norm': label_norm,
-    }
-
-
-def _build_index(xml_text: str) -> dict:
-    """7MB XML'i bir kez parse et, lookup index'leri hazirla."""
-    products = []
-    by_link = {}
-    by_sku = {}
-    main_skus = set()
-    variants_by_root = {}
-    main_links = []
-
-    items = _ITEM_RE.findall(xml_text)
-    for it in items:
-        p = _parse_item(it)
-        products.append(p)
-        if p['link']:
-            by_link[p['link']] = p
-        if p['sku']:
-            by_sku[p['sku']] = p
-        if not p['is_variant']:
-            if p['sku']:
-                main_skus.add(p['sku'])
-            if p['link']:
-                main_links.append(p['link'])
-        else:
-            if p['root_sku']:
-                variants_by_root.setdefault(p['root_sku'], []).append(p)
-
-    logger.info(f"[index] parsed {len(products)} items, {len(main_skus)} main, "
-                f"{sum(len(v) for v in variants_by_root.values())} variants")
-    return {
-        "products": products,
-        "by_link": by_link,
-        "by_sku": by_sku,
-        "main_skus": main_skus,
-        "variants_by_root": variants_by_root,
-        "main_links": main_links,
-    }
-
-
-def _ensure_index() -> dict | None:
-    """Cache'deki XML icin (id() degisirse) index'i guncelle."""
-    try:
-        from smart_warehouse_with_price import get_cached_trek_xml
-        xml = get_cached_trek_xml()
-        if not xml:
-            return None
-        xml_id = id(xml)
-        if _INDEX["xml_id"] != xml_id:
-            text = xml.decode('utf-8', errors='replace') if isinstance(xml, bytes) else str(xml)
-            built = _build_index(text)
-            _INDEX["xml_id"] = xml_id
-            _INDEX["products"] = built["products"]
-            _INDEX["by_link"] = built["by_link"]
-            _INDEX["by_sku"] = built["by_sku"]
-            _INDEX["main_skus"] = built["main_skus"]
-            _INDEX["variants_by_root"] = built["variants_by_root"]
-            _INDEX["main_links"] = built["main_links"]
-        return _INDEX
-    except Exception:
-        logger.exception('_ensure_index hatasi')
-        return None
-
-
-def _public_view(p: dict | None) -> dict | None:
-    """Index'teki internal field'lari (_tokens, _label_norm) cikar — client'a gonderilebilir."""
-    if not p:
-        return None
-    return {k: v for k, v in p.items() if not k.startswith('_')}
-
-
-def find_product_by_link(product_link: str) -> dict | None:
-    """O(1) lookup. Varyant ise ana urune cik."""
-    idx = _ensure_index()
-    if not idx:
-        return None
-    p = idx["by_link"].get(product_link.strip())
-    if not p:
-        return None
-    if p['is_variant'] and p['root_sku']:
-        main = idx["by_sku"].get(p['root_sku'])
-        if main and not main['is_variant']:
-            return _public_view(main)
-    return _public_view(p)
-
-
-def find_variants_of_product(main_link: str) -> list[dict]:
-    """Bir ana urunun tum varyantlari (hash lookup)."""
-    idx = _ensure_index()
-    if not idx:
-        return []
-    main = idx["by_link"].get(main_link.strip())
-    if not main or main['is_variant'] or not main['sku']:
-        return []
-    return [_public_view(v) for v in idx["variants_by_root"].get(main['sku'], [])]
-
-
-def extract_product_link_from_result(result: str) -> str | None:
-    """Tool sonucu string'inden ilk productLink URL'sini cikar."""
-    import re
-    if not result:
-        return None
-    m = re.search(r'https?://(?:www\.)?trekbisiklet\.com\.tr/urun/[^\s)\]\'"]+', result)
-    return m.group(0) if m else None
-
-
-# Renk eşanlam haritası (TR söylüyorlar, XML'de TR/EN karışık olabilir)
-_COLOR_SYNONYMS = {
-    'siyah': ['siyah', 'black', 'noir', 'negro'],
-    'beyaz': ['beyaz', 'white', 'blanco'],
-    'mavi': ['mavi', 'blue', 'azul', 'navy', 'lacivert'],
-    'kirmizi': ['kirmizi', 'kırmızı', 'red', 'rojo'],
-    'yesil': ['yesil', 'yeşil', 'green', 'verde'],
-    'sari': ['sari', 'sarı', 'yellow', 'amarillo'],
-    'turuncu': ['turuncu', 'orange', 'naranja'],
-    'mor': ['mor', 'purple'],
-    'pembe': ['pembe', 'pink', 'rosa'],
-    'gri': ['gri', 'grey', 'gray', 'gris'],
-    'kahverengi': ['kahverengi', 'brown', 'marron'],
-    'altin': ['altin', 'altın', 'gold'],
-    'gumus': ['gumus', 'gümüş', 'silver'],
-    'bordo': ['bordo', 'burgundy'],
-}
-
-def _detect_colors_in_text(text_norm: str) -> set[str]:
-    """Metinde geçen renkleri normalized form'da dondur."""
-    found = set()
-    for key, syns in _COLOR_SYNONYMS.items():
-        for s in syns:
-            if _norm(s) in text_norm:
-                found.add(key)
-                break
-    return found
-
-def find_main_product_in_text(text: str) -> dict | None:
-    """Metinde gecen ANA urunu bul. ZORUNLU tokenlar:
-    - 4+ karakter kelimeler (marlin, domane, emonda)
-    - 1-2 basamakli sayilar (model numaralari: 4, 5, 6)
-    Birden fazla urun gecerse, METINDE EN SON gecen kazanir
-    (asistan konustukca son bahsedilen urune gecisin)."""
-    try:
-        idx = _ensure_index()
-        if not idx:
-            return None
-        text_norm = _norm(text)
-
-        best = None
-        best_last_pos = -1
-        for p in idx["products"]:
-            if p['is_variant']:
-                continue
-            tokens = p.get('_tokens') or []
-            mandatory = [
-                t for t in tokens
-                if len(t) >= 4 or (t.isdigit() and 1 <= len(t) <= 2)
-            ]
-            if not mandatory:
-                continue
-            # Tum mandatory tokenlar metinde olmali
-            positions = []
-            ok = True
-            for t in mandatory:
-                pos = text_norm.rfind(t)
-                if pos < 0:
-                    ok = False
-                    break
-                positions.append(pos)
-            if not ok:
-                continue
-            last_pos = max(positions)
-            if last_pos > best_last_pos:
-                best_last_pos = last_pos
-                best = p
-        return _public_view(best)
-    except Exception:
-        logger.exception('find_main_product_in_text hatasi')
-        return None
-
-
-def find_color_variant(main_link: str, text: str) -> dict | None:
-    """Verilen ana urunun, metinde gecen renge ait varyantini dondur.
-    DONUS: variant'in resmi/galeri'si + ANA URUN'un ismi ve linki (boy bilgisi yok).
-    Metinde renk yoksa None doner."""
-    try:
-        idx = _ensure_index()
-        if not idx:
-            return None
-        text_colors = _detect_colors_in_text(_norm(text))
-        if not text_colors:
-            return None
-        main = idx["by_link"].get(main_link.strip())
-        if not main or main['is_variant'] or not main['sku']:
-            return None
-        variants = idx["variants_by_root"].get(main['sku'], [])
-        for v in variants:
-            v_color = (v.get('color') or '').lower()
-            if not v_color:
-                continue
-            for key, syns in _COLOR_SYNONYMS.items():
-                if key in text_colors and any(_norm(s) in _norm(v_color) for s in syns):
-                    # Resim varyanttan, isim/link ana urunden — boy ve renk ismi ayiklanir
-                    return {
-                        'name': main['name'],
-                        'image': v.get('image'),
-                        'images': v.get('images') or [],
-                        'link': main['link'],
-                        'sku': main['sku'],
-                        'color': (v.get('color') or '').upper(),
-                        'size': None,
-                        'is_variant': False,
-                    }
-        return None
-    except Exception:
-        logger.exception('find_color_variant hatasi')
-        return None
-
-
-@app.websocket("/ws")
-async def realtime_relay(client_ws: WebSocket):
-    """Browser <-> OpenAI Realtime API arasinda WebSocket relay."""
-    await client_ws.accept()
-
-    if not OPENAI_API_KEY:
-        await client_ws.send_text(json.dumps({
-            "type": "error",
-            "error": {"message": "OPENAI_API_KEY tanimli degil."}
-        }))
-        await client_ws.close()
-        return
-
-    headers = {
-        "Authorization": f"Bearer {OPENAI_API_KEY}",
-    }
-
-    try:
-        async with websockets.connect(REALTIME_URL, additional_headers=headers) as openai_ws:
-            logger.info("OpenAI Realtime baglantisi kuruldu")
-
-            # Initial session config (GA API format)
-            await openai_ws.send(json.dumps({
-                "type": "session.update",
-                "session": {
-                    "type": "realtime",
-                    "model": REALTIME_MODEL,
-                    "instructions": build_session_instructions(),
-                    "output_modalities": ["audio"],
-                    "audio": {
-                        "input": {
-                            "format": {"type": "audio/pcm", "rate": 24000},
-                            "transcription": {"model": "whisper-1"},
-                            "turn_detection": {
-                                "type": "server_vad",
-                                "threshold": 0.5,
-                                "prefix_padding_ms": 300,
-                                "silence_duration_ms": 700,
-                                "interrupt_response": False,
-                                "create_response": True,
-                            },
-                        },
-                        "output": {
-                            "format": {"type": "audio/pcm", "rate": 24000},
-                        },
-                    },
-                    "tools": TOOLS,
-                    "tool_choice": "auto",
-                }
-            }))
-
-            async def client_to_openai():
-                try:
-                    while True:
-                        msg = await client_ws.receive_text()
-                        await openai_ws.send(msg)
-                except WebSocketDisconnect:
-                    logger.info("Client disconnected")
-                except Exception as e:
-                    logger.error(f"client_to_openai error: {e}")
-
-            # Asistan transkripti per-response birikir, response.done'da urun aramasi yapilir
-            # current_main_link: en son gosterilen ana urun (varyant aramasi icin scope)
-            transcript_buf = {
-                "text": "",
-                "tool_link": None,
-                "current_main_link": None,
-                "last_shown_in_response": None,
-                "last_check_len": 0,
-            }
-
-            async def openai_to_client():
-                try:
-                    async for raw in openai_ws:
-                        try:
-                            data = json.loads(raw)
-                        except Exception:
-                            await client_ws.send_text(raw)
-                            continue
-
-                        evt_type = data.get("type", "")
-
-                        # Debug: onemli event'leri logla
-                        if evt_type in ("session.created", "session.updated"):
-                            logger.info(f"[Realtime] {evt_type}")
-                        elif evt_type == "error":
-                            logger.error(f"[Realtime] ERROR: {json.dumps(data)[:500]}")
-                        elif evt_type == "response.done":
-                            status = data.get("response", {}).get("status")
-                            details = data.get("response", {}).get("status_details")
-                            logger.info(f"[Realtime] response.done status={status} details={details}")
-                        elif evt_type in ("input_audio_buffer.speech_started", "input_audio_buffer.speech_stopped", "input_audio_buffer.committed", "response.created"):
-                            logger.info(f"[Realtime] {evt_type}")
-
-                        # Yeni response basladiginda transkript ve live state sifirla
-                        # tool_link KULLANICI YENI TURNE GECINCE sifirlanir (asagida)
-                        if evt_type == "response.created":
-                            transcript_buf["text"] = ""
-                            transcript_buf["last_shown_in_response"] = None
-                            transcript_buf["last_check_len"] = 0
-
-                        # Kullanici yeni soru sormaya basladi — yeni turn
-                        if evt_type == "input_audio_buffer.speech_started":
-                            transcript_buf["tool_link"] = None
-
-                        # Asistan ses transkripti — fragmanlari biriktir + LIVE urun tespiti
-                        if evt_type in ("response.audio_transcript.delta",
-                                        "response.output_audio_transcript.delta",
-                                        "response.output_text.delta"):
-                            d = data.get("delta", "")
-                            if isinstance(d, str):
-                                transcript_buf["text"] += d
-                                # Her ~80 char'da bir tara (perf icin throttle)
-                                if len(transcript_buf["text"]) - transcript_buf["last_check_len"] >= 80:
-                                    transcript_buf["last_check_len"] = len(transcript_buf["text"])
-                                    live_p = find_main_product_in_text(transcript_buf["text"])
-                                    if live_p and live_p.get("image"):
-                                        live_link = live_p.get("link")
-                                        if live_link != transcript_buf["last_shown_in_response"]:
-                                            transcript_buf["last_shown_in_response"] = live_link
-                                            transcript_buf["current_main_link"] = live_link
-                                            logger.info(f"[product/live] {live_p['name']}")
-                                            try:
-                                                await client_ws.send_text(json.dumps({
-                                                    "type": "product.show",
-                                                    "product": live_p,
-                                                }))
-                                            except Exception:
-                                                pass
-
-                        # response.done — sadece RENK OVERRIDE icin transkript kullanilir.
-                        # Yeni ana urun gosterimi tamamen TOOL CAGRISINA birakilir (GPT'ye guven).
-                        # Boylece "Marlin 4'e donme" tahmin bug'i tamamen ortadan kalkar.
-                        if evt_type == "response.done":
-                            text = transcript_buf["text"]
-                            active_main = transcript_buf["current_main_link"]
-                            if text and active_main:
-                                color_v = find_color_variant(active_main, text)
-                                if color_v and color_v.get("image"):
-                                    logger.info(f"[product/color-override] {color_v['name']}")
-                                    try:
-                                        await client_ws.send_text(json.dumps({
-                                            "type": "product.show",
-                                            "product": color_v,
-                                        }))
-                                    except Exception:
-                                        pass
-
-                        # Tool call yakala
-                        if evt_type == "response.function_call_arguments.done":
-                            call_id = data.get("call_id")
-                            fn_name = data.get("name")
-                            try:
-                                args = json.loads(data.get("arguments", "{}"))
-                            except Exception:
-                                args = {}
-
-                            logger.info(f"Tool call: {fn_name}({args})")
-                            result = await handle_tool_call(fn_name, args)
-
-                            # Urun resmi bul ve client'a gonder (split-screen display icin)
-                            # Tool result'taki gercek productLink'i kullan — garanti dogru urun
-                            if fn_name == "get_warehouse_stock":
-                                product = None
-                                product_link = extract_product_link_from_result(result)
-                                if product_link:
-                                    product = find_product_by_link(product_link)
-                                # Stok XML duser veya tool urun bulamazsa — Trek katalog index'inden
-                                # kullanici sorgusuna gore arama yap, en azindan resmi gosterelim
-                                if not product or not product.get("image"):
-                                    query = args.get("user_message", "")
-                                    fallback = find_main_product_in_text(query)
-                                    if fallback and fallback.get("image"):
-                                        product = fallback
-                                if product and product.get("image"):
-                                    logger.info(f"[product/tool] {product['name']} ({product.get('link')})")
-                                    transcript_buf["tool_link"] = product.get("link") or product_link
-                                    if product.get("link"):
-                                        transcript_buf["current_main_link"] = product["link"]
-                                        transcript_buf["last_shown_in_response"] = product["link"]
-                                    try:
-                                        await client_ws.send_text(json.dumps({
-                                            "type": "product.show",
-                                            "product": product,
-                                        }))
-                                    except Exception:
-                                        pass
-
-                                # Modelin URL'i sesli okumamasi icin tool sonucundan linkleri temizle
-                                import re as _re
-                                result = _re.sub(r'(?im)^\s*(?:Link|URL|Url|🔗.*?):.*$', '', result)
-                                result = _re.sub(r'https?://\S+', '', result)
-                                result = _re.sub(r'\n{3,}', '\n\n', result).strip()
-
-                            # Tool sonucunu OpenAI'ye geri gonder
-                            await openai_ws.send(json.dumps({
-                                "type": "conversation.item.create",
-                                "item": {
-                                    "type": "function_call_output",
-                                    "call_id": call_id,
-                                    "output": result,
-                                }
-                            }))
-                            # Yeni response istegi
-                            await openai_ws.send(json.dumps({"type": "response.create"}))
+    )
 
-                        # Tum mesajlari client'a forward et
-                        await client_ws.send_text(raw)
 
-                except websockets.exceptions.ConnectionClosed:
-                    logger.info("OpenAI WebSocket kapandi")
-                except Exception as e:
-                    logger.error(f"openai_to_client error: {e}")
+# ---------- Debug ----------
+@app.get("/debug-find")
+async def debug_find(q: str):
+    p = find_main_product_in_text(q)
+    return {"query": q, "matched": (p.get("name") if p else None), "result": p}
 
-            await asyncio.gather(client_to_openai(), openai_to_client())
 
-    except Exception as e:
-        logger.exception("Realtime relay hatasi")
-        try:
-            await client_ws.send_text(json.dumps({
-                "type": "error",
-                "error": {"message": str(e)}
-            }))
-        except Exception:
-            pass
-    finally:
-        try:
-            await client_ws.close()
-        except Exception:
-            pass
+@app.get("/debug-search")
+async def debug_search(q: str):
+    from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
+    result = await asyncio.to_thread(get_warehouse_stock_smart_with_price, q)
+    return {"query": q, "result": result}

config.py

@@ -0,0 +1,42 @@
+"""BF-Realtime V2 — merkezi konfigurasyon."""
+import os
+
+# OpenAI
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+REALTIME_MODEL = "gpt-realtime-2"
+REALTIME_URL = f"wss://api.openai.com/v1/realtime?model={REALTIME_MODEL}"
+
+# Tool icindeki fuzzy matching modeli (primary)
+MATCHER_MODEL = "gpt-5.5"
+MATCHER_TIMEOUT = 12
+
+# Fallback model (matcher fail ederse)
+NANO_MODEL = "gpt-5-nano"
+NANO_TIMEOUT = 6
+
+# Trek katalog XML (urun resmi, link, isim, varyant bilgisi)
+TREK_XML_URL = "https://www.trekbisiklet.com.tr/output/2688003925"
+TREK_XML_TIMEOUT = 8
+
+# Stok kaynaklari
+BIZIMHESAP_TOKEN = "6F4BAF303FA240608A39653824B6C495"
+BIZIMHESAP_BASE = "https://bizimhesap.com/api/b2b"
+BIZIMHESAP_TIMEOUT = 12
+BIZIMHESAP_HEADERS = {"token": BIZIMHESAP_TOKEN, "Accept": "application/json"}
+
+TREK_PHP_URL = "https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php"
+TREK_PHP_TIMEOUT = 30  # PHP icinde 15dk cache — proxy'nin upstream cevabi 30s'ye kadar surebilir
+
+# Cache TTL'leri (saniye)
+CACHE_TTL_TREK_XML = 86400          # 24 saat
+CACHE_TTL_WAREHOUSE = 86400         # 24 saat
+CACHE_TTL_BH_PRODUCTS = 7200        # 2 saat
+CACHE_TTL_BH_WAREHOUSES = 21600     # 6 saat
+CACHE_TTL_BH_INVENTORY = 1800       # 30 dakika
+CACHE_TTL_SEARCH = 3600             # 1 saat
+
+# Background refresh interval
+REFRESH_INTERVAL = 3600  # 1 saat
+
+# 2'den fazla kritik magaza bossa stok cache'ini guncelleme
+CRITICAL_WAREHOUSES = {"BAHCEKOY", "CADDEBOSTAN", "ALSANCAK"}

conversation_tracker.py

@@ -1,68 +0,0 @@
-"""Conversation tracking for BF chatbot"""
-
-import json
-import os
-from datetime import datetime
-from typing import List, Dict, Any
-
-# Konuşma geçmişini saklamak için
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-CONVERSATIONS_FILE = os.path.join(BASE_DIR, "conversations.json")
-PUBLIC_FILE = os.path.join(BASE_DIR, "public", "conversations.json")
-MAX_CONVERSATIONS = 100  # Son 100 konuşmayı sakla
-
-def load_conversations():
-    """Load conversation history from file"""
-    if os.path.exists(CONVERSATIONS_FILE):
-        try:
-            with open(CONVERSATIONS_FILE, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except:
-            return []
-    return []
-
-def save_conversations(conversations):
-    """Save conversations to file"""
-    try:
-        # Keep only last MAX_CONVERSATIONS
-        if len(conversations) > MAX_CONVERSATIONS:
-            conversations = conversations[-MAX_CONVERSATIONS:]
-        
-        # Try to save to file
-        with open(CONVERSATIONS_FILE, 'w', encoding='utf-8') as f:
-            json.dump(conversations, f, ensure_ascii=False, indent=2)
-        print(f"✅ Saved {len(conversations)} conversations to {CONVERSATIONS_FILE}")
-        
-        # Also save to a backup location that Gradio can access
-        try:
-            # Create a directory if it doesn't exist
-            os.makedirs(os.path.dirname(PUBLIC_FILE), exist_ok=True)
-            with open(PUBLIC_FILE, 'w', encoding='utf-8') as f:
-                json.dump(conversations, f, ensure_ascii=False, indent=2)
-            print(f"✅ Also saved to {PUBLIC_FILE}")
-        except:
-            pass
-            
-    except Exception as e:
-        print(f"❌ Error saving conversations: {e}")
-        # If file write fails, at least keep in memory
-        global _memory_conversations
-        _memory_conversations = conversations
-
-# Keep a memory backup
-_memory_conversations = []
-
-def add_conversation(user_message, bot_response):
-    """Add a new conversation to history"""
-    conversations = load_conversations()
-    
-    conversation = {
-        "timestamp": datetime.now().isoformat(),
-        "user": user_message,
-        "bot": bot_response
-    }
-    
-    conversations.append(conversation)
-    save_conversations(conversations)
-    
-    return conversation

enhanced_features.py

@@ -1,563 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Trek Chatbot Enhanced Features
-1. Görsel AI Entegrasyonu
-2. Kişiselleştirilmiş Öneri Motoru  
-3. Gelişmiş Ürün Karşılaştırma
-"""
-
-import os
-import json
-import base64
-import requests
-from datetime import datetime
-import pandas as pd
-from PIL import Image
-import random
-
-# Kullanıcı profili dosyası
-USER_PROFILES_FILE = "user_profiles.json"
-
-class UserProfileManager:
-    """Kullanıcı profili yönetimi"""
-    
-    def __init__(self):
-        self.profiles = self.load_profiles()
-    
-    def load_profiles(self):
-        """Kullanıcı profillerini yükle"""
-        if os.path.exists(USER_PROFILES_FILE):
-            with open(USER_PROFILES_FILE, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        return {}
-    
-    def save_profiles(self):
-        """Kullanıcı profillerini kaydet"""
-        with open(USER_PROFILES_FILE, 'w', encoding='utf-8') as f:
-            json.dump(self.profiles, f, ensure_ascii=False, indent=2)
-    
-    def get_or_create_profile(self, user_id="default_user"):
-        """Kullanıcı profili al veya oluştur"""
-        if user_id not in self.profiles:
-            self.profiles[user_id] = {
-                "created_at": datetime.now().isoformat(),
-                "preferences": {
-                    "budget_range": None,
-                    "bike_category": None,
-                    "size": None,
-                    "usage_purpose": None
-                },
-                "interaction_history": [],
-                "favorite_products": [],
-                "viewed_products": []
-            }
-        return self.profiles[user_id]
-    
-    def update_user_preference(self, user_id, key, value):
-        """Kullanıcı tercihini güncelle"""
-        profile = self.get_or_create_profile(user_id)
-        profile["preferences"][key] = value
-        self.save_profiles()
-    
-    def add_interaction(self, user_id, interaction_type, data):
-        """Kullanıcı etkileşimi ekle"""
-        profile = self.get_or_create_profile(user_id)
-        interaction = {
-            "timestamp": datetime.now().isoformat(),
-            "type": interaction_type,
-            "data": data
-        }
-        profile["interaction_history"].append(interaction)
-        # Son 50 etkileşimi tut
-        profile["interaction_history"] = profile["interaction_history"][-50:]
-        
-        # Otomatik tercih çıkarımı
-        self._extract_preferences_from_interaction(user_id, interaction_type, data)
-        
-        self.save_profiles()
-    
-    def _extract_preferences_from_interaction(self, user_id, interaction_type, data):
-        """Etkileşimden otomatik tercih çıkarımı"""
-        profile = self.get_or_create_profile(user_id)
-        
-        if interaction_type == "chat_message":
-            user_message = data.get("user_message", "").lower()
-            
-            # Bütçe tespiti
-            import re
-            if "bütçe" in user_message or "budget" in user_message:
-                numbers = re.findall(r'\d+', user_message)
-                if len(numbers) >= 1:
-                    try:
-                        budget_value = int(numbers[0]) * 1000  # K TL formatı için
-                        if budget_value > 10000:  # Makul bütçe aralığı
-                            current_budget = profile["preferences"].get("budget_range")
-                            if not current_budget:
-                                # Bütçe aralığını tahmin et
-                                budget_max = budget_value * 1.5
-                                profile["preferences"]["budget_range"] = [budget_value, budget_max]
-                    except ValueError:
-                        pass
-            
-            # Bisiklet kategorisi tespiti
-            bike_categories = {
-                "dağ": "dağ bisikleti",
-                "mountain": "dağ bisikleti", 
-                "mtb": "dağ bisikleti",
-                "yol": "yol bisikleti",
-                "road": "yol bisikleti",
-                "şehir": "şehir bisikleti",
-                "city": "şehir bisikleti",
-                "urban": "şehir bisikleti",
-                "elektrikli": "elektrikli bisiklet",
-                "electric": "elektrikli bisiklet",
-                "e-bike": "elektrikli bisiklet",
-                "gravel": "gravel bisiklet"
-            }
-            
-            for keyword, category in bike_categories.items():
-                if keyword in user_message:
-                    profile["preferences"]["bike_category"] = category
-                    break
-            
-            # Kullanım amacı tespiti
-            usage_purposes = {
-                "işe": "günlük ulaşım",
-                "work": "günlük ulaşım",
-                "spor": "spor ve egzersiz",
-                "sport": "spor ve egzersiz",
-                "egzersiz": "spor ve egzersiz",
-                "fitness": "spor ve egzersiz",
-                "tur": "tur ve gezi",
-                "tour": "tur ve gezi",
-                "gezi": "tur ve gezi",
-                "yarış": "yarış ve performans",
-                "race": "yarış ve performans",
-                "performance": "yarış ve performans"
-            }
-            
-            for keyword, purpose in usage_purposes.items():
-                if keyword in user_message:
-                    profile["preferences"]["usage_purpose"] = purpose
-                    break
-
-class VisualAI:
-    """Görsel AI işlemleri"""
-    
-    def __init__(self, openai_api_key):
-        self.api_key = openai_api_key
-    
-    def analyze_bike_image(self, image_path):
-        """Bisiklet görselini analiz et"""
-        if not self.api_key:
-            # Yerel görsel analiz (demo amaçlı)
-            return self.local_image_analysis(image_path)
-        
-        return self.openai_image_analysis(image_path)
-    
-    def local_image_analysis(self, image_path):
-        """Yerel görsel analiz (demo)"""
-        try:
-            # Görseli yükle ve temel bilgileri al
-            img = Image.open(image_path)
-            width, height = img.size
-            
-            # Basit analiz mantığı (demo amaçlı)
-            bike_types = ["Yol Bisikleti", "Dağ Bisikleti", "Şehir Bisikleti", "Elektrikli Bisiklet"]
-            trek_models = ["Madone", "Émonda", "Domane", "Marlin", "Fuel EX", "FX", "Powerfly"]
-            colors = ["Siyah", "Beyaz", "Kırmızı", "Mavi", "Gri", "Yeşil"]
-            
-            # Rastgele ama mantıklı analiz
-            detected_type = random.choice(bike_types)
-            detected_model = random.choice(trek_models)
-            detected_color = random.choice(colors)
-            
-            return f"""🖼️ **Görsel Analiz Sonucu**
-
-📊 **Görsel Bilgileri:**
-• Boyut: {width}x{height} piksel
-• Format: {img.format if img.format else 'Bilinmiyor'}
-
-🚲 **Bisiklet Analizi:**
-• **Tip:** {detected_type}
-• **Tahmini Model:** Trek {detected_model}
-• **Renk:** {detected_color}
-
-🔍 **Tespit Edilen Özellikler:**
-• Karbon kadro yapısı görünüyor
-• Profesyonel seviye ekipman
-• Aerodinamik tasarım elementleri
-
-💡 **Önerilerim:**
-Bu bisiklet {detected_type.lower()} kategorisinde. Eğer {detected_model} modeli ilginizi çekiyorsa, 
-stoklarımızda bu seriyle ilgili güncel modelleri gösterebilirim.
-
-*Not: Bu yerel analiz sistemidir. Daha detaylı analiz için Vision API entegrasyonu önerilir.*"""
-            
-        except Exception as e:
-            return f"🖼️ Görsel analiz hatası: {str(e)}"
-    
-    def openai_image_analysis(self, image_path):
-        """OpenAI Vision API ile analiz"""
-        
-        try:
-            # Görseli base64'e çevir
-            with open(image_path, "rb") as image_file:
-                base64_image = base64.b64encode(image_file.read()).decode('utf-8')
-            
-            headers = {
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {self.api_key}"
-            }
-            
-            payload = {
-                "model": "gpt-4-vision-preview",
-                "messages": [
-                    {
-                        "role": "user",
-                        "content": [
-                            {
-                                "type": "text",
-                                "text": "Bu bisiklet görselini analiz et. Hangi tip bisiklet? Marka, model tahmininde bulun. Trek bisikletleri hakkında uzmanısın."
-                            },
-                            {
-                                "type": "image_url",
-                                "image_url": {
-                                    "url": f"data:image/jpeg;base64,{base64_image}"
-                                }
-                            }
-                        ]
-                    }
-                ],
-                "max_tokens": 300
-            }
-            
-            response = requests.post("https://api.openai.com/v1/chat/completions", 
-                                   headers=headers, json=payload)
-            
-            if response.status_code == 200:
-                result = response.json()
-                return result["choices"][0]["message"]["content"]
-            else:
-                return f"Görsel analiz hatası: {response.status_code}"
-                
-        except Exception as e:
-            return f"Görsel analiz hatası: {str(e)}"
-
-class ProductComparison:
-    """Ürün karşılaştırma sistemi"""
-    
-    def __init__(self, products_data):
-        self.products = products_data
-    
-    def round_price(self, price_str):
-        """Fiyatı yuvarlama formülüne göre yuvarla"""
-        try:
-            price_float = float(price_str)
-            # Fiyat 200000 üzerindeyse en yakın 5000'lik basamağa yuvarla
-            if price_float > 200000:
-                return str(round(price_float / 5000) * 5000)
-            # Fiyat 30000 üzerindeyse en yakın 1000'lik basamağa yuvarla
-            elif price_float > 30000:
-                return str(round(price_float / 1000) * 1000)
-            # Fiyat 10000 üzerindeyse en yakın 100'lük basamağa yuvarla
-            elif price_float > 10000:
-                return str(round(price_float / 100) * 100)
-            # Diğer durumlarda en yakın 10'luk basamağa yuvarla
-            else:
-                return str(round(price_float / 10) * 10)
-        except (ValueError, TypeError):
-            return price_str
-    
-    def find_products_by_name(self, product_names):
-        """İsimlere göre ürünleri bul"""
-        found_products = []
-        for name in product_names:
-            for product in self.products:
-                if name.lower() in product[2].lower():  # product[2] = full_name
-                    found_products.append(product)
-                    break
-        return found_products
-    
-    def create_comparison_table(self, product_names):
-        """Karşılaştırma tablosu oluştur"""
-        products = self.find_products_by_name(product_names)
-        
-        if len(products) < 2:
-            return "Karşılaştırma için en az 2 ürün gerekli."
-        
-        # Tablo verilerini hazırla
-        comparison_data = []
-        for product in products:
-            name, item_info, full_name = product
-            
-            # Ürün bilgilerini parse et
-            stock_status = item_info[0] if len(item_info) > 0 else "Bilgi yok"
-            price_raw = item_info[1] if len(item_info) > 1 and item_info[1] else "Fiyat yok"
-            product_link = item_info[2] if len(item_info) > 2 else ""
-            image_url = item_info[6] if len(item_info) > 6 and item_info[6] else ""
-            
-            # Fiyatı yuvarlama formülüne göre yuvarla
-            if price_raw != "Fiyat yok":
-                price = self.round_price(price_raw)
-                price_display = f"{price} TL"
-            else:
-                price_display = price_raw
-            
-            comparison_data.append({
-                "Ürün": full_name,
-                "Stok": stock_status,
-                "Fiyat": price_display,
-                "Link": product_link,
-                "Resim": image_url if image_url else "Resim yok"
-            })
-        
-        # DataFrame oluştur
-        df = pd.DataFrame(comparison_data)
-        
-        # Markdown tablosu olarak döndür
-        return df.to_markdown(index=False)
-    
-    def get_similar_products(self, product_name, category_filter=None):
-        """Benzer ürünleri bul"""
-        similar_products = []
-        base_name = product_name.lower().split()[0]  # İlk kelimeyi al
-        
-        for product in self.products:
-            product_full_name = product[2].lower()
-            if base_name in product_full_name and product_name.lower() != product_full_name:
-                if category_filter:
-                    if category_filter.lower() in product_full_name:
-                        similar_products.append(product)
-                else:
-                    similar_products.append(product)
-        
-        return similar_products[:5]  # İlk 5 benzer ürün
-
-class PersonalizedRecommendations:
-    """Kişiselleştirilmiş öneriler"""
-    
-    def __init__(self, profile_manager, products_data):
-        self.profile_manager = profile_manager
-        self.products = products_data
-    
-    def get_budget_recommendations(self, user_id, budget_min, budget_max):
-        """Bütçeye uygun öneriler"""
-        suitable_products = []
-        
-        for product in self.products:
-            if product[1][0] == "stokta" and product[1][1]:  # Stokta ve fiyatı var
-                try:
-                    price = float(product[1][1])
-                    if budget_min <= price <= budget_max:
-                        suitable_products.append(product)
-                except (ValueError, TypeError):
-                    continue
-        
-        # Kullanıcı tercihlerini kaydet
-        self.profile_manager.update_user_preference(user_id, "budget_range", [budget_min, budget_max])
-        
-        return suitable_products[:5]  # İlk 5 öneri
-    
-    def get_personalized_suggestions(self, user_id):
-        """Geçmiş davranışlara göre öneriler"""
-        profile = self.profile_manager.get_or_create_profile(user_id)
-        preferences = profile["preferences"]
-        
-        suggestions = []
-        
-        # Bütçe tercihi varsa ona göre filtrele
-        if preferences.get("budget_range"):
-            budget_min, budget_max = preferences["budget_range"]
-            suggestions.extend(self.get_budget_recommendations(user_id, budget_min, budget_max))
-        
-        # Kategori tercihi varsa ona göre filtrele  
-        if preferences.get("bike_category"):
-            category = preferences["bike_category"]
-            for product in self.products:
-                if category.lower() in product[2].lower() and product[1][0] == "stokta":
-                    suggestions.append(product)
-        
-        return list(set(suggestions))[:3]  # Duplicate'ları kaldır ve ilk 3'ü al
-
-# Global instance'lar
-profile_manager = UserProfileManager()
-visual_ai = None  # OpenAI key ile başlatılacak
-product_comparison = None  # Products data ile başlatılacak
-personalized_recommendations = None  # Profile manager ve products ile başlatılacak
-
-def initialize_enhanced_features(openai_api_key, products_data):
-    """Enhanced özellikleri başlat"""
-    global visual_ai, product_comparison, personalized_recommendations
-    
-    visual_ai = VisualAI(openai_api_key)
-    product_comparison = ProductComparison(products_data)
-    personalized_recommendations = PersonalizedRecommendations(profile_manager, products_data)
-
-def process_image_message(image_path, user_message):
-    """Görsel mesajını işle"""
-    if visual_ai and image_path:
-        image_analysis = visual_ai.analyze_bike_image(image_path)
-        return f"Görsel Analiz: {image_analysis}\n\nSoru: {user_message}"
-    return user_message
-
-def handle_comparison_request(user_message):
-    """Karşılaştırma talebini işle"""
-    try:
-        if "karşılaştır" in user_message.lower() or "compare" in user_message.lower():
-            # Ürün isimlerini çıkarmaya çalış
-            words = user_message.lower().split()
-            potential_products = []
-            
-            # Bilinen model isimlerini ara
-            known_models = ["émonda", "madone", "domane", "marlin", "fuel", "powerfly", "fx"]
-            for word in words:
-                for model in known_models:
-                    if model in word:
-                        potential_products.append(model)
-            
-            if len(potential_products) >= 2 and product_comparison:
-                comparison_table = product_comparison.create_comparison_table(potential_products)
-                return f"Ürün Karşılaştırması:\n\n{comparison_table}"
-        
-        return None
-    except Exception as e:
-        print(f"Comparison error: {e}")
-        return None
-
-def get_user_chat_context(user_id, limit=5):
-    """Son sohbet geçmişini kontekst için al"""
-    try:
-        profile = profile_manager.get_or_create_profile(user_id)
-        interactions = profile.get("interaction_history", [])
-        
-        # Son chat mesajlarını al
-        chat_messages = []
-        for interaction in reversed(interactions):
-            if interaction['type'] == 'chat_message' and len(chat_messages) < limit:
-                data = interaction['data']
-                chat_messages.append({
-                    "user": data.get('user_message', ''),
-                    "assistant": data.get('bot_response', ''),
-                    "timestamp": data.get('timestamp', '')
-                })
-        
-        return list(reversed(chat_messages))  # Kronolojik sıra
-        
-    except Exception as e:
-        print(f"Chat context error: {e}")
-        return []
-
-def get_user_profile_summary(user_id):
-    """Kullanıcı profil özetini döndür"""
-    try:
-        profile = profile_manager.get_or_create_profile(user_id)
-        preferences = profile.get("preferences", {})
-        
-        if not any(preferences.values()):
-            return "Henüz tercihleriniz kaydedilmemiş. Bisiklet arayışınız hakkında konuşarak size daha iyi öneriler verebilirim."
-        
-        summary = "🔄 **Kaydedilen Tercihleriniz:**\n\n"
-        
-        if preferences.get("bike_category"):
-            summary += f"🚲 **Bisiklet Kategorisi:** {preferences['bike_category']}\n"
-        
-        if preferences.get("budget_range"):
-            budget_min, budget_max = preferences['budget_range']
-            summary += f"💰 **Bütçe Aralığı:** {budget_min:,.0f} - {budget_max:,.0f} TL\n"
-        
-        if preferences.get("usage_purpose"):
-            summary += f"🎯 **Kullanım Amacı:** {preferences['usage_purpose']}\n"
-        
-        if preferences.get("size"):
-            summary += f"📏 **Boyut:** {preferences['size']}\n"
-        
-        # Son etkileşimler
-        interactions = profile.get("interaction_history", [])
-        if interactions:
-            recent_chats = [i for i in interactions[-5:] if i['type'] == 'chat_message']
-            if recent_chats:
-                summary += f"\n📝 **Son {len(recent_chats)} Sohbet:**\n"
-                for chat in recent_chats:
-                    timestamp = chat['data'].get('timestamp', 'Bilinmiyor')
-                    summary += f"• {timestamp}: Sohbet\n"
-        
-        summary += "\n*Bu tercihler sohbetlerimizden otomatik olarak çıkarıldı.*"
-        return summary
-        
-    except Exception as e:
-        print(f"Profile summary error: {e}")
-        return "Profil bilgilerine şu anda erişilemiyor."
-
-def get_user_recommendations(user_id, user_message):
-    """Kullanıcıya özel öneriler al"""
-    try:
-        # Kullanıcı etkileşimini kaydet (tercih çıkarımı için)
-        profile_manager.add_interaction(user_id, "recommendation_query", {
-            "message": user_message,
-            "timestamp": datetime.now().isoformat()
-        })
-        
-        # Bütçe sorgusu varsa
-        if "bütçe" in user_message.lower() or "budget" in user_message.lower():
-            # Rakamları çıkarmaya çalış
-            import re
-            numbers = re.findall(r'\d+', user_message)
-            if len(numbers) >= 2 and personalized_recommendations:
-                budget_min = int(numbers[0]) * 1000  # K TL formatı için
-                budget_max = int(numbers[1]) * 1000
-                recommendations = personalized_recommendations.get_budget_recommendations(
-                    user_id, budget_min, budget_max
-                )
-                
-                if recommendations:
-                    rec_text = "Bütçenize uygun öneriler:\n\n"
-                    for product in recommendations[:3]:
-                        rec_text += f"• {product[2]} - {product[1][1]} TL\n"
-                    return rec_text
-            elif len(numbers) >= 1 and personalized_recommendations:
-                # Tek sayı varsa aralık oluştur
-                budget_center = int(numbers[0]) * 1000
-                budget_min = int(budget_center * 0.8)
-                budget_max = int(budget_center * 1.2)
-                recommendations = personalized_recommendations.get_budget_recommendations(
-                    user_id, budget_min, budget_max
-                )
-                
-                if recommendations:
-                    rec_text = f"{numbers[0]}K TL bütçenize uygun öneriler:\n\n"
-                    for product in recommendations[:3]:
-                        rec_text += f"• {product[2]} - {product[1][1]} TL\n"
-                    return rec_text
-        
-        # Kullanıcı profili tercihleri varsa öneri ver
-        if personalized_recommendations:
-            profile = profile_manager.get_or_create_profile(user_id)
-            preferences = profile.get("preferences", {})
-            
-            # Eğer kullanıcının kaydedilmiş tercihleri varsa
-            if any(preferences.values()):
-                suggestions = personalized_recommendations.get_personalized_suggestions(user_id)
-                if suggestions:
-                    sug_text = "Tercihlerinize göre önerilerimiz:\n\n"
-                    for product in suggestions[:3]:
-                        sug_text += f"• {product[2]} - {product[1][1]} TL\n"
-                    
-                    # Tercih özetini ekle
-                    pref_summary = []
-                    if preferences.get("bike_category"):
-                        pref_summary.append(f"Kategori: {preferences['bike_category']}")
-                    if preferences.get("budget_range"):
-                        pref_summary.append(f"Bütçe: {preferences['budget_range'][0]:,.0f}-{preferences['budget_range'][1]:,.0f} TL")
-                    if preferences.get("usage_purpose"):
-                        pref_summary.append(f"Kullanım: {preferences['usage_purpose']}")
-                    
-                    if pref_summary:
-                        sug_text += f"\n*Kaydedilen tercihleriniz: {', '.join(pref_summary)}*"
-                    
-                    return sug_text
-        
-        return None
-    except Exception as e:
-        print(f"Recommendations error: {e}")
-        return None

get_warehouse_fast.py

@@ -1,130 +0,0 @@
-"""Ultra fast warehouse stock getter using regex"""
-
-def get_warehouse_stock(product_name):
-    """Super fast warehouse stock finder using regex instead of XML parsing"""
-    try:
-        import re
-        import requests
-        
-        # Fetch XML
-        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
-        response = requests.get(warehouse_url, verify=False, timeout=7)
-        
-        if response.status_code != 200:
-            return None
-        
-        xml_text = response.text
-        
-        # Turkish normalization
-        turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
-        
-        def normalize_turkish(text):
-            text = text.lower()
-            for tr_char, en_char in turkish_map.items():
-                text = text.replace(tr_char, en_char)
-            return text
-        
-        # Normalize search
-        search_name = normalize_turkish(product_name.strip())
-        search_name = search_name.replace('(2026)', '').replace('(2025)', '').strip()
-        search_words = search_name.split()
-        
-        # Separate size from product words
-        size_words = ['s', 'm', 'l', 'xl', 'xs', 'xxl', 'ml']
-        size_indicators = ['beden', 'size', 'boy']
-        
-        variant_filter = [w for w in search_words if w in size_words]
-        product_words = [w for w in search_words if w not in size_words and w not in size_indicators]
-        
-        print(f"DEBUG - Looking for: {' '.join(product_words)}")
-        print(f"DEBUG - Size filter: {variant_filter}")
-        
-        # Build exact pattern for common products
-        search_pattern = ' '.join(product_words).upper()
-        
-        # Handle specific products
-        if 'madone' in product_words and 'sl' in product_words and '6' in product_words and 'gen' in product_words and '8' in product_words:
-            search_pattern = 'MADONE SL 6 GEN 8'
-        elif 'madone' in product_words and 'slr' in product_words and '7' in product_words:
-            search_pattern = 'MADONE SLR 7 GEN 8'
-        else:
-            # Generic pattern
-            search_pattern = search_pattern.replace('İ', 'I')
-        
-        # Find all Product blocks with this name
-        # Using lazy quantifier .*? for efficiency
-        product_pattern = f'<Product>.*?<ProductName><!\\[CDATA\\[{re.escape(search_pattern)}\\]\\]></ProductName>.*?</Product>'
-        matches = re.findall(product_pattern, xml_text, re.DOTALL)
-        
-        print(f"DEBUG - Found {len(matches)} products matching '{search_pattern}'")
-        
-        # Process matches
-        warehouse_stock_map = {}
-        
-        for match in matches:
-            # Extract variant if we need to filter by size
-            should_process = True
-            
-            if variant_filter:
-                variant_match = re.search(r'<ProductVariant><!\\[CDATA\\[(.*?)\\]\\]></ProductVariant>', match)
-                if variant_match:
-                    variant = variant_match.group(1)
-                    size_wanted = variant_filter[0].upper()
-                    
-                    # Check if variant starts with desired size
-                    if variant.startswith(f'{size_wanted}-'):
-                        print(f"DEBUG - Found matching variant: {variant}")
-                        should_process = True
-                    else:
-                        should_process = False
-                else:
-                    should_process = False
-            
-            if should_process:
-                # Extract all warehouses with stock
-                warehouse_pattern = r'<Warehouse>.*?<Name><!\\[CDATA\\[(.*?)\\]\\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
-                warehouses = re.findall(warehouse_pattern, match, re.DOTALL)
-                
-                for wh_name, wh_stock in warehouses:
-                    try:
-                        stock = int(wh_stock.strip())
-                        if stock > 0:
-                            if wh_name in warehouse_stock_map:
-                                warehouse_stock_map[wh_name] += stock
-                            else:
-                                warehouse_stock_map[wh_name] = stock
-                    except:
-                        pass
-                
-                # If we found a variant match, stop looking
-                if variant_filter and should_process:
-                    break
-        
-        print(f"DEBUG - Warehouse stock: {warehouse_stock_map}")
-        
-        # Format results
-        if warehouse_stock_map:
-            all_warehouse_info = []
-            for warehouse_name, total_stock in warehouse_stock_map.items():
-                # Make store names more readable
-                if "Caddebostan" in warehouse_name or "CADDEBOSTAN" in warehouse_name:
-                    display_name = "Caddebostan mağazası"
-                elif "Ortaköy" in warehouse_name or "ORTAKÖY" in warehouse_name:
-                    display_name = "Ortaköy mağazası"
-                elif "Sarıyer" in warehouse_name:
-                    display_name = "Sarıyer mağazası"
-                elif "Alsancak" in warehouse_name or "ALSANCAK" in warehouse_name or "İzmir" in warehouse_name:
-                    display_name = "İzmir Alsancak mağazası"
-                elif "BAHCEKOY" in warehouse_name or "Bahçeköy" in warehouse_name:
-                    display_name = "Bahçeköy mağazası"
-                else:
-                    display_name = warehouse_name
-                
-                all_warehouse_info.append(f"{display_name}: Mevcut")
-            return all_warehouse_info
-        else:
-            return ["Hiçbir mağazada mevcut değil"]
-    
-    except Exception as e:
-        print(f"Warehouse stock error: {e}")
-        return None

image_renderer.py

@@ -1,143 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Ürün Resimlerini Sohbette Gösterme Sistemi
-"""
-
-def round_price(price_str):
-    """Fiyatı yuvarlama formülüne göre yuvarla"""
-    try:
-        # TL ve diğer karakterleri temizle
-        price_clean = price_str.replace(' TL', '').replace(',', '.')
-        price_float = float(price_clean)
-        
-        # Fiyat 200000 üzerindeyse en yakın 5000'lik basamağa yuvarla
-        if price_float > 200000:
-            return str(round(price_float / 5000) * 5000)
-        # Fiyat 30000 üzerindeyse en yakın 1000'lik basamağa yuvarla
-        elif price_float > 30000:
-            return str(round(price_float / 1000) * 1000)
-        # Fiyat 10000 üzerindeyse en yakın 100'lük basamağa yuvarla
-        elif price_float > 10000:
-            return str(round(price_float / 100) * 100)
-        # Diğer durumlarda en yakın 10'luk basamağa yuvarla
-        else:
-            return str(round(price_float / 10) * 10)
-    except (ValueError, TypeError):
-        return price_str
-
-def format_message_with_images(message):
-    """Mesajdaki resim URL'lerini HTML formatına çevir"""
-    if "Ürün resmi:" not in message:
-        return message
-    
-    lines = message.split('\n')
-    formatted_lines = []
-    
-    for line in lines:
-        if line.startswith("Ürün resmi:"):
-            image_url = line.replace("Ürün resmi:", "").strip()
-            if image_url:
-                # HTML img tag'i oluştur
-                img_html = f"""
-<div style="margin: 10px 0;">
-    <img src="{image_url}" 
-         alt="Ürün Resmi" 
-         style="max-width: 300px; max-height: 200px; border-radius: 8px; border: 1px solid #ddd; box-shadow: 0 2px 4px rgba(0,0,0,0.1);"
-         onerror="this.style.display='none'">
-</div>"""
-                formatted_lines.append(img_html)
-            else:
-                formatted_lines.append(line)
-        else:
-            formatted_lines.append(line)
-    
-    return '\n'.join(formatted_lines)
-
-def create_product_gallery(products_with_images):
-    """Birden fazla ürün için galeri oluştur"""
-    if not products_with_images:
-        return ""
-    
-    gallery_html = """
-<div style="display: flex; flex-wrap: wrap; gap: 15px; margin: 15px 0;">
-"""
-    
-    for product in products_with_images:
-        name = product.get('name', 'Bilinmeyen')
-        price = product.get('price', 'Fiyat yok')
-        image_url = product.get('image_url', '')
-        product_url = product.get('product_url', '')
-        
-        if image_url:
-            card_html = f"""
-<div style="border: 1px solid #ddd; border-radius: 8px; padding: 10px; max-width: 200px; text-align: center; background: white; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-    <img src="{image_url}" 
-         alt="{name}" 
-         style="max-width: 180px; max-height: 120px; border-radius: 4px; margin-bottom: 8px;"
-         onerror="this.style.display='none'">
-    <div style="font-size: 12px; font-weight: bold; margin-bottom: 4px;">{name}</div>
-    <div style="font-size: 11px; color: #666; margin-bottom: 8px;">{price}</div>
-    {f'<a href="{product_url}" target="_blank" style="font-size: 10px; color: #007bff; text-decoration: none;">Detaylı Bilgi</a>' if product_url else ''}
-</div>"""
-            gallery_html += card_html
-    
-    gallery_html += "</div>"
-    return gallery_html
-
-def extract_product_info_for_gallery(message):
-    """Mesajdan ürün bilgilerini çıkarıp galeri formatına çevir"""
-    if "karşılaştır" in message.lower() or "öneri" in message.lower():
-        # Bu durumda galeri formatı kullan
-        lines = message.split('\n')
-        products = []
-        
-        current_product = {}
-        for line in lines:
-            line = line.strip()
-            if line.startswith('•') and any(keyword in line.lower() for keyword in ['marlin', 'émonda', 'madone', 'domane', 'fuel', 'powerfly', 'fx']):
-                # Yeni ürün başladı
-                if current_product:
-                    products.append(current_product)
-                
-                # Ürün adı ve fiyatı parse et
-                parts = line.split(' - ')
-                name = parts[0].replace('•', '').strip()
-                price_raw = parts[1] if len(parts) > 1 else 'Fiyat yok'
-                
-                # Fiyatı yuvarlama formülüne göre yuvarla
-                if price_raw != 'Fiyat yok':
-                    price = round_price(price_raw) + ' TL'
-                else:
-                    price = price_raw
-                
-                current_product = {
-                    'name': name,
-                    'price': price,
-                    'image_url': '',
-                    'product_url': ''
-                }
-            elif "Ürün resmi:" in line and current_product:
-                current_product['image_url'] = line.replace("Ürün resmi:", "").strip()
-            elif "Ürün linki:" in line and current_product:
-                current_product['product_url'] = line.replace("Ür��n linki:", "").strip()
-        
-        # Son ürünü ekle
-        if current_product:
-            products.append(current_product)
-        
-        if products:
-            gallery = create_product_gallery(products)
-            # Orijinal mesajdaki resim linklerini temizle
-            cleaned_message = message
-            for line in message.split('\n'):
-                if line.startswith("Ürün resmi:") or line.startswith("Ürün linki:"):
-                    cleaned_message = cleaned_message.replace(line, "")
-            
-            return cleaned_message.strip() + "\n\n" + gallery
-    
-    return format_message_with_images(message)
-
-def should_use_gallery_format(message):
-    """Mesajın galeri formatı kullanması gerekip gerekmediğini kontrol et"""
-    gallery_keywords = ["karşılaştır", "öneri", "seçenek", "alternatif", "bütçe"]
-    return any(keyword in message.lower() for keyword in gallery_keywords)

product_index.py

@@ -0,0 +1,244 @@
+"""Trek katalog XML'ini bir kez parse edip hash index halinde tutar.
+Tum lookup'lar O(1) — re-parse yok. Background refresh ve fetch lock'u var."""
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+import threading
+import time
+
+import requests
+import urllib3
+
+from config import TREK_XML_URL, TREK_XML_TIMEOUT, CACHE_TTL_TREK_XML
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+logger = logging.getLogger(__name__)
+
+
+# Turkce -> ASCII normalizasyon
+_TR_MAP = {
+    "İ": "i", "I": "i", "ı": "i",
+    "Ğ": "g", "ğ": "g",
+    "Ü": "u", "ü": "u",
+    "Ş": "s", "ş": "s",
+    "Ö": "o", "ö": "o",
+    "Ç": "c", "ç": "c",
+}
+
+
+def normalize(s: str) -> str:
+    if not s:
+        return ""
+    for tr, en in _TR_MAP.items():
+        s = s.replace(tr, en)
+    return s.lower()
+
+
+# Pre-compiled regex'ler (modul yuklemesinde bir kez)
+_ITEM_RE = re.compile(r"<item>(.*?)</item>", re.DOTALL)
+_VARIANT_LABEL_SEP = re.compile(r"\s*[-/]\s*")
+_TOKEN_RE = re.compile(r"[a-z0-9]+")
+_SIZE_PAT = re.compile(
+    r"^(?:XX?S|XS|S|M|L|XL|XXL|XXXL|\d{2}(?:\.\d)?(?:\s*CM)?)$", re.I
+)
+
+_FIELD_RES = {
+    "rootlabel": re.compile(r"<rootlabel><!\[CDATA\[(.*?)\]\]></rootlabel>"),
+    "label": re.compile(r"<label><!\[CDATA\[(.*?)\]\]></label>"),
+    "productLink": re.compile(r"<productLink><!\[CDATA\[(.*?)\]\]></productLink>"),
+    "stockCode": re.compile(r"<stockCode><!\[CDATA\[(.*?)\]\]></stockCode>"),
+    "isOptionOfAProduct": re.compile(r"<isOptionOfAProduct>(\d+)</isOptionOfAProduct>"),
+    "rootProductStockCode": re.compile(
+        r"<rootProductStockCode><!\[CDATA\[(.*?)\]\]></rootProductStockCode>"
+    ),
+}
+for i in range(1, 9):
+    _FIELD_RES[f"picture{i}"] = re.compile(
+        rf"<picture{i}Path><!\[CDATA\[(.*?)\]\]></picture{i}Path>"
+    )
+
+
+def _parse_item(it: str) -> dict:
+    """Tek bir <item> blogunu dict'e cevir + arama icin token cache'i ekle."""
+    def grab(name: str) -> str:
+        m = _FIELD_RES[name].search(it)
+        return m.group(1).strip() if m else ""
+
+    rootlabel = grab("rootlabel")
+    var_label = grab("label")
+    link = grab("productLink")
+    sku = grab("stockCode")
+    iv_m = _FIELD_RES["isOptionOfAProduct"].search(it)
+    is_variant = bool(iv_m and iv_m.group(1) == "1")
+    root_sku_raw = grab("rootProductStockCode")
+    root_sku = root_sku_raw if root_sku_raw and root_sku_raw != "0" else None
+
+    images: list[str] = []
+    for i in range(1, 9):
+        m = _FIELD_RES[f"picture{i}"].search(it)
+        if m and m.group(1).strip():
+            images.append(m.group(1).strip())
+
+    color: str | None = None
+    size: str | None = None
+    if is_variant and var_label:
+        parts = [p.strip() for p in _VARIANT_LABEL_SEP.split(var_label) if p.strip()]
+        for p in parts:
+            if _SIZE_PAT.match(p) and not size:
+                size = p.upper()
+            elif not color:
+                color = p.upper()
+
+    label_norm = normalize(rootlabel)
+    tokens = [t for t in _TOKEN_RE.findall(label_norm) if len(t) >= 1]
+
+    return {
+        "name": rootlabel,
+        "image": images[0] if images else None,
+        "images": images,
+        "link": link,
+        "sku": sku,
+        "color": color,
+        "size": size,
+        "is_variant": is_variant,
+        "root_sku": root_sku,
+        "_tokens": tokens,
+        "_label_norm": label_norm,
+    }
+
+
+def public_view(p: dict | None) -> dict | None:
+    """Internal field'lari (_tokens, _label_norm) cikar — client'a gonderilebilir."""
+    if not p:
+        return None
+    return {k: v for k, v in p.items() if not k.startswith("_")}
+
+
+class ProductIndex:
+    """Thread-safe parse-once index. Re-parse sadece XML degisirse."""
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._fetch_lock = threading.Lock()
+        self._xml_data: bytes | None = None
+        self._xml_time: float = 0
+        self._xml_id: int | None = None
+        self.products: list[dict] = []
+        self.by_link: dict[str, dict] = {}
+        self.by_sku: dict[str, dict] = {}
+        self.variants_by_root: dict[str, list[dict]] = {}
+        self.main_count: int = 0
+
+    # ---------- XML fetch (lock'lu, thundering herd onleyici) ----------
+    def _fetch_xml(self) -> bytes | None:
+        with self._fetch_lock:
+            now = time.time()
+            # Lock alindiginda baska bir thread fetch yapmis olabilir
+            if self._xml_data and (now - self._xml_time < CACHE_TTL_TREK_XML):
+                return self._xml_data
+            try:
+                r = requests.get(TREK_XML_URL, verify=False, timeout=TREK_XML_TIMEOUT)
+                if r.status_code == 200 and r.content:
+                    self._xml_data = r.content
+                    self._xml_time = now
+                    logger.info(f"[index] fetched Trek XML ({len(r.content)} bytes)")
+                    return r.content
+            except Exception:
+                logger.exception("[index] Trek XML fetch hatasi")
+            # Eski (stale) data varsa onu kullan
+            return self._xml_data
+
+    # ---------- Index build ----------
+    def _build(self, xml_bytes: bytes) -> None:
+        text = xml_bytes.decode("utf-8", errors="replace")
+        products: list[dict] = []
+        by_link: dict[str, dict] = {}
+        by_sku: dict[str, dict] = {}
+        variants_by_root: dict[str, list[dict]] = {}
+        main_count = 0
+
+        for it in _ITEM_RE.findall(text):
+            p = _parse_item(it)
+            products.append(p)
+            if p["link"]:
+                by_link[p["link"]] = p
+            if p["sku"]:
+                by_sku[p["sku"]] = p
+            if not p["is_variant"]:
+                main_count += 1
+            else:
+                if p["root_sku"]:
+                    variants_by_root.setdefault(p["root_sku"], []).append(p)
+
+        with self._lock:
+            self.products = products
+            self.by_link = by_link
+            self.by_sku = by_sku
+            self.variants_by_root = variants_by_root
+            self.main_count = main_count
+            self._xml_id = id(xml_bytes)
+
+        logger.info(
+            f"[index] built: {len(products)} items, {main_count} main, "
+            f"{sum(len(v) for v in variants_by_root.values())} variants"
+        )
+
+    def ensure(self) -> bool:
+        """XML cache'ini guncelle ve index'i (gerekirse) yeniden build et.
+        True donerse data hazir. Sync, thread-safe."""
+        xml = self._fetch_xml()
+        if not xml:
+            return False
+        if id(xml) != self._xml_id:
+            self._build(xml)
+        return True
+
+    # ---------- Public lookups (sync, hizli) ----------
+    def find_by_link(self, link: str) -> dict | None:
+        """productLink ile eslesen urun. Varyant ise ana urune cikar."""
+        if not link:
+            return None
+        with self._lock:
+            p = self.by_link.get(link.strip())
+            if not p:
+                return None
+            if p["is_variant"] and p["root_sku"]:
+                main = self.by_sku.get(p["root_sku"])
+                if main and not main["is_variant"]:
+                    return public_view(main)
+            return public_view(p)
+
+    def variants_of(self, main_link: str) -> list[dict]:
+        """Verilen ana urunun tum varyantlari."""
+        if not main_link:
+            return []
+        with self._lock:
+            main = self.by_link.get(main_link.strip())
+            if not main or main["is_variant"] or not main["sku"]:
+                return []
+            return [public_view(v) for v in self.variants_by_root.get(main["sku"], [])]
+
+    def snapshot(self) -> list[dict]:
+        """Tum urunlerin internal-field'li listesi (matcher icin)."""
+        with self._lock:
+            return list(self.products)
+
+
+# Singleton
+_index = ProductIndex()
+
+
+def get_index() -> ProductIndex:
+    return _index
+
+
+async def background_refresh_loop(interval: int):
+    """Periodic XML refresh in thread executor."""
+    while True:
+        try:
+            await asyncio.to_thread(_index.ensure)
+        except Exception:
+            logger.exception("background_refresh_loop hatasi")
+        await asyncio.sleep(interval)

product_matcher.py

@@ -0,0 +1,257 @@
+"""Urun eslestirme: local fuzzy matcher + opsiyonel gpt-5-nano fallback.
+
+Tasarim:
+- find_main_product_in_text(text): Metinde gecen ANA urunu bul.
+  ZORUNLU tokenlar (hepsi metinde olmalı):
+    * 4+ karakter alfa kelimeler (marlin, domane, emonda)
+    * 1-2 basamakli sayilar (model numaralari: 4, 5, 6)
+  Birden fazla urun gecerse: METINDE EN SON gecen kazanir.
+- find_color_variant(main_link, text): Aktif ana urunun, kullanicinin metnindeki
+  renge uyan varyantini dondur. Resim variant'in, isim/link ana urunun.
+"""
+from __future__ import annotations
+
+import logging
+
+import requests
+
+from config import OPENAI_API_KEY, MATCHER_MODEL, MATCHER_TIMEOUT, NANO_MODEL, NANO_TIMEOUT
+from product_index import get_index, normalize, public_view
+
+logger = logging.getLogger(__name__)
+
+
+# Renk eşanlam haritası (TR/EN)
+COLOR_SYNONYMS = {
+    "siyah":     ["siyah", "black", "noir", "negro"],
+    "beyaz":     ["beyaz", "white", "blanco"],
+    "mavi":      ["mavi", "blue", "azul"],
+    "lacivert":  ["lacivert", "navy"],
+    "kirmizi":   ["kirmizi", "kırmızı", "red", "rojo"],
+    "yesil":     ["yesil", "yeşil", "green", "verde"],
+    "sari":      ["sari", "sarı", "yellow", "amarillo"],
+    "turuncu":   ["turuncu", "orange", "naranja"],
+    "mor":       ["mor", "purple"],
+    "pembe":     ["pembe", "pink", "rosa"],
+    "gri":       ["gri", "grey", "gray", "gris"],
+    "kahverengi": ["kahverengi", "brown", "marron"],
+    "altin":     ["altin", "altın", "gold"],
+    "gumus":     ["gumus", "gümüş", "silver"],
+    "bordo":     ["bordo", "burgundy"],
+    "turkuaz":   ["turkuaz", "turquoise"],
+}
+
+
+def _detect_colors(text_norm: str) -> set[str]:
+    found: set[str] = set()
+    for key, syns in COLOR_SYNONYMS.items():
+        for s in syns:
+            if normalize(s) in text_norm:
+                found.add(key)
+                break
+    return found
+
+
+def _is_distinctive(t: str) -> bool:
+    """Token ZORUNLU mu? 4+ char alfa veya 1-2 basamakli sayi."""
+    return len(t) >= 4 or (t.isdigit() and 1 <= len(t) <= 2)
+
+
+def find_main_product_in_text(text: str) -> dict | None:
+    """Metinde gecen ANA urunu bul (varyantlar dahil edilmez).
+    Birden fazla aday varsa en son gecen secilir."""
+    if not text:
+        return None
+    idx = get_index()
+    if not idx.ensure():
+        return None
+    text_norm = normalize(text)
+
+    best = None
+    best_last_pos = -1
+    for p in idx.snapshot():
+        if p["is_variant"]:
+            continue
+        tokens = p.get("_tokens") or []
+        mandatory = [t for t in tokens if _is_distinctive(t)]
+        if not mandatory:
+            continue
+        positions = []
+        ok = True
+        for t in mandatory:
+            pos = text_norm.rfind(t)
+            if pos < 0:
+                ok = False
+                break
+            positions.append(pos)
+        if not ok:
+            continue
+        last_pos = max(positions)
+        if last_pos > best_last_pos:
+            best_last_pos = last_pos
+            best = p
+    return public_view(best)
+
+
+def find_color_variant(main_link: str, text: str) -> dict | None:
+    """Aktif ana urunun, metinde gecen renge uyan varyantini bul.
+    DONUS: variant resmi/galeri'si + ana urunun ismi/linki (boy bilgisi yok)."""
+    if not main_link or not text:
+        return None
+    idx = get_index()
+    if not idx.ensure():
+        return None
+    text_norm = normalize(text)
+    text_colors = _detect_colors(text_norm)
+    if not text_colors:
+        return None
+
+    # Ana urunu bul
+    main_view = idx.find_by_link(main_link)
+    if not main_view:
+        return None
+    variants = idx.variants_of(main_link)
+    if not variants:
+        return None
+
+    for v in variants:
+        v_color = (v.get("color") or "").lower()
+        if not v_color:
+            continue
+        v_color_norm = normalize(v_color)
+        for key, syns in COLOR_SYNONYMS.items():
+            if key in text_colors and any(normalize(s) in v_color_norm for s in syns):
+                # Resim variant'tan, isim/link ana urunden
+                return {
+                    "name": main_view["name"],
+                    "image": v.get("image"),
+                    "images": v.get("images") or [],
+                    "link": main_view["link"],
+                    "sku": main_view["sku"],
+                    "color": (v.get("color") or "").upper(),
+                    "size": None,
+                    "is_variant": False,
+                }
+    return None
+
+
+def extract_product_link_from_text(text: str) -> str | None:
+    """Tool sonucundan veya başka metinden ilk Trek productLink URL'sini cikar."""
+    if not text:
+        return None
+    import re
+    m = re.search(r"https?://(?:www\.)?trekbisiklet\.com\.tr/urun/[^\s)\]\'\"]+", text)
+    return m.group(0) if m else None
+
+
+def gpt_match(query: str, products_summary: list[dict], asked_warehouse: str | None = None) -> str:
+    """V1'deki gpt-5.5 fuzzy matcher (primary). Yazim hatasi, sira farki, semantik
+    eslesme yapar. Donus: virgulle ayrilmis index string'i ('5,12') veya '-1'."""
+    import json as _json
+    if not OPENAI_API_KEY or not products_summary:
+        return "-1"
+
+    warehouse_filter = ""
+    if asked_warehouse:
+        warehouse_filter = (
+            f"\nIMPORTANT: User is asking specifically about {asked_warehouse} warehouse. "
+            f"Only return products available in that warehouse."
+        )
+
+    smart_prompt = f"""User is asking: "{query}"
+
+FIRST CHECK: Is this actually a product search?
+- If the message is a question about the system, service, or a general inquiry, return: -1
+- If the message contains "musun", "misin", "neden", "nasıl", etc. it's likely NOT a product search
+- Only proceed if this looks like a genuine product name or model
+
+Find ALL products that match this query from the list below.
+If user asks about specific size (S, M, L, XL, XXL, SMALL, MEDIUM, LARGE, X-LARGE), return only that size.
+If user asks generally (without size), return ALL variants of the product.
+{warehouse_filter}
+
+CRITICAL TURKISH CHARACTER RULES:
+- "MARLIN" and "MARLİN" are the SAME product (Turkish İ vs I)
+- Treat these as equivalent: I/İ/ı, Ö/ö, Ü/ü, Ş/ş, Ğ/ğ, Ç/ç
+
+IMPORTANT BRAND AND PRODUCT TYPE RULES:
+- GOBIK: Spanish textile brand we import. When user asks about "gobik", return ALL products with "GOBIK" in the name.
+- Product names contain type information: FORMA (jersey/cycling shirt), TAYT (tights), İÇLİK (base layer), YAĞMURLUK (raincoat), etc.
+- Understand Turkish/English terms:
+  * "erkek forma" / "men's jersey" -> Find products with FORMA in name
+  * "tayt" / "tights" -> Find products with TAYT in name
+  * "içlik" / "base layer" -> Find products with İÇLİK in name
+  * "yağmurluk" / "raincoat" -> Find products with YAĞMURLUK in name
+- Gender: UNISEX means for both men and women.
+
+Products list (with warehouse availability):
+{_json.dumps(products_summary, ensure_ascii=False, indent=2)}
+
+Return ONLY index numbers of ALL matching products as comma-separated list (e.g., "5,8,12,15").
+If no products found, return ONLY: -1
+DO NOT return empty string or any explanation, ONLY numbers or -1
+"""
+
+    try:
+        r = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {OPENAI_API_KEY}",
+            },
+            json={
+                "model": MATCHER_MODEL,
+                "messages": [
+                    {"role": "system", "content": "You are a product matcher. Find ALL matching products. Return only index numbers."},
+                    {"role": "user", "content": smart_prompt},
+                ],
+            },
+            timeout=MATCHER_TIMEOUT,
+        )
+        if r.status_code == 200:
+            return r.json()["choices"][0]["message"]["content"].strip()
+        logger.warning(f"[matcher/gpt] HTTP {r.status_code}: {r.text[:200]}")
+    except Exception as e:
+        logger.warning(f"[matcher/gpt] fail: {e}")
+    return "-1"
+
+
+def nano_fallback_match(query: str, products_summary: list[dict]) -> str:
+    """Local matcher hicbir sey bulamazsa, gpt-5-nano'ya kucuk bir liste gonder.
+    products_summary: [{i: int, n: name, v: variant}, ...]
+    Donus: virgulle ayrilmis index string'i ('5,12') veya '-1'."""
+    if not OPENAI_API_KEY or not products_summary:
+        return "-1"
+    import json as _json
+    try:
+        items_min = [
+            {"i": p.get("i", p.get("index")), "n": p.get("n", p.get("name", "")),
+             "v": p.get("v", p.get("variant", ""))}
+            for p in products_summary
+        ]
+        prompt = (
+            f'Soru: "{query}"\n'
+            'Asagidaki listeden eslesen tum urunlerin "i" indekslerini '
+            'virgulle ayrilmis sekilde dondur (orn. "5,12"). Eslesme yoksa "-1".\n'
+            f"Liste: {_json.dumps(items_min, ensure_ascii=False)}"
+        )
+        r = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {OPENAI_API_KEY}",
+            },
+            json={
+                "model": NANO_MODEL,
+                "messages": [
+                    {"role": "system", "content": "Sadece sayi listesi don, baska hicbir sey yazma."},
+                    {"role": "user", "content": prompt},
+                ],
+            },
+            timeout=NANO_TIMEOUT,
+        )
+        if r.status_code == 200:
+            return r.json()["choices"][0]["message"]["content"].strip()
+    except Exception as e:
+        logger.warning(f"[matcher/nano] fail: {e}")
+    return "-1"

prompts.py

@@ -114,6 +114,66 @@ SYSTEM_PROMPTS = [
         "content": "EKİM KAMPANYASI (1-31 Ekim 2025):\nTrek Bicycle Turkey, Ekim ayı boyunca seçili bisiklet modellerinde vade farksız 8 taksit imkanı sunmaktadır.\n\nKAPSAMDAKİ MODELLER:\n✅ MADONE Serisi (Tüm varyantlar): SLR 9, SLR 7, SL 7, SL 6, SL 5\n✅ MARLIN Serisi (Tüm varyantlar): Marlin 9, 8, 7, 6, 5, 4\n✅ FX Serisi (Tüm varyantlar): FX Sport 6, Sport 5, FX 3 Disc, FX 2 Disc, FX 1 Disc\n✅ TÜM ELEKTRİKLİ BİSİKLETLER: Rail, Powerfly, Fuel EXe, Domane+, FX+, DS+, Verve+, Townie+, Allant+\n\nKAMPANYA KOŞULLARI:\n• Minimum alışveriş: 10.000 TL\n• Tüm kredi kartları geçerli (Visa, Mastercard, Amex)\n• Vade farkı YOK - Peşin fiyatına 8 taksit\n• Online ve mağaza alışverişlerinde geçerli\n• Ücretsiz kargo dahil\n• Ücretsiz ilk servis dahil\n• İndirimli ürünlerle birleştirilebilir\n• Eski bisiklet takası ile birleştirilebilir\n\nKAPSAM DIŞI MODELLER:\n❌ Émonda, Domane (elektriksiz), Fuel EX (elektriksiz), Top Fuel, Slash, Remedy, Supercaliber, X-Caliber, Roscoe, Procaliber, Dual Sport (elektriksiz), District, Checkpoint, Verve (elektriksiz)\n\nÖNEMLİ NOTLAR:\n• Émonda isteyen müşteriye → Madone önerin (kampanyada)\n• Fuel EX isteyen müşteriye → Marlin 9 veya Rail (e-MTB) önerin\n• X-Caliber isteyen müşteriye → Marlin serisi önerin\n• Checkpoint isteyen müşteriye → FX serisi önerin\n\nÖRNEK CEVAPLAR:\n'Evet! Ekim ayında Madone, Marlin, FX serileri ve tüm elektrikli bisikletlerde vade farksız 8 taksit kampanyamız var!'\n'Madone SL 6 kampanyaya dahil! Vade farksız 8 taksit ile alabilirsiniz.'\n'Maalesef Fuel EX kampanyada değil, ancak Marlin 9 veya elektrikli Rail modellerimiz kampanyada!'\n'Tüm elektrikli bisikletlerimiz kampanya kapsamında - Rail, Powerfly, Domane+ ve daha fazlası!'"
     },
 
+    # 19. JANT FİYAT KURALI
+    {
+        "role": "system",
+        "category": "rim_pricing",
+        "content": (
+            "JANT FİYAT KURALI:\n"
+            "Bontrager jantları ÖN ve ARKA olarak AYRI AYRI satılır ve fiyatlanır. "
+            "Listeden gelen fiyat TEK JANT fiyatıdır (çift değil).\n"
+            "\n"
+            "Müşteriye fiyat verirken DAİMA ön mü arka mı belirt:\n"
+            "• Doğru: 'Aeolus Pro 51 ön jant 18.000 TL, arka jant 22.000 TL.'\n"
+            "• Doğru: 'Tek jant fiyatı 20.000 TL — ön ve arkayı ayrı satıyoruz.'\n"
+            "• Yanlış: 'Aeolus Pro 51 jant 20.000 TL.' (eksik bilgi, müşteri çift sanır)\n"
+            "\n"
+            "Eğer ürün adında ön/arka belirtilmediyse, müşteriye 'ön mü arka mı?' "
+            "diye sormak yerine ikisinin de fiyatını ver."
+        )
+    },
+
+    # 17. ÜRÜN ARAMA / TOOL ÇAĞRI KURALLARI (kritik)
+    {
+        "role": "system",
+        "category": "tool_search_rules",
+        "content": (
+            "ÜRÜN ARAMA KURALI (her sorguda uyulacak):\n"
+            "Bir ürünün adını söyleyeceğin/önereceğin/sorgulayacağın zaman, "
+            "DAİMA tam ürün adını kullan ve mutlaka KATEGORİ ekle.\n"
+            "\n"
+            "• 'Comp' DEĞİL → 'Bontrager Comp sele'\n"
+            "• 'Pro' DEĞİL → 'Bontrager Aeolus Pro sele'\n"
+            "• 'XR4' DEĞİL → 'Bontrager XR4 Team Issue lastik'\n"
+            "• 'Elite' DEĞİL → 'Bontrager Elite Aero gidon'\n"
+            "• 'Aeolus 51' DEĞİL → 'Bontrager Aeolus Pro 51 jant'\n"
+            "• 'Line' DEĞİL → 'Bontrager Line Elite pedal'\n"
+            "\n"
+            "Format: MARKA + MODEL + KATEGORİ\n"
+            "Geçerli kategoriler: bisiklet, sele, kask, far, gidon, jant, pedal, "
+            "lastik, fren, vites, zincir, eldiven, jersey, forma, tayt, içlik, "
+            "şort, ayakkabı, çanta, suluk, gözlük.\n"
+            "\n"
+            "Bu kurala ASLA istisna yapma. Kısa adla sorgu yaparsan yanlış ürün "
+            "bulunur ve müşteriye yanlış bilgi/görsel gösterilir."
+        )
+    },
+
+    # 18. TELAFFUZ KURALLARI (kritik — sesli asistan icin)
+    {
+        "role": "system",
+        "category": "pronunciation",
+        "content": (
+            "Pronunciation rules:\n"
+            "- The store name \"Caddebostan\" is Turkish.\n"
+            "- Always pronounce it as \"Jad-de-bos-tan\".\n"
+            "- Never pronounce the first C as K.\n"
+            "- In Turkish, the letter C sounds like the English \"J\" in \"jam\".\n"
+            "- If speaking Turkish, say: \"Caddebostan mağazamız\" naturally as "
+            "\"Jadde-bostan mağazamız\"."
+        )
+    },
+
     # 16. HATA ÖNLEMLERİ VE KONUŞMA REHBERİ
     {
         "role": "system",

realtime_relay.py

@@ -0,0 +1,330 @@
+"""OpenAI Realtime API <-> Browser WebSocket relay.
+
+Akis:
+1. Browser baglanir
+2. OpenAI Realtime'a baglanip session config gonderir
+3. Iki yonlu mesaj relay'i:
+   - Browser -> OpenAI: PCM audio + control
+   - OpenAI -> Browser: audio chunks + transcript + tool calls + custom events
+4. Tool call'lari yakala, thread'de calistir, sonucu OpenAI'ye geri gonder
+5. Asistan transkripti + kullanici intent'iyle urun gorsellerini live update et
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+
+import websockets
+from websockets.asyncio.client import connect as ws_connect
+from fastapi import WebSocket, WebSocketDisconnect
+
+from config import OPENAI_API_KEY, REALTIME_MODEL, REALTIME_URL
+from product_matcher import (
+    extract_product_link_from_text,
+    find_color_variant,
+    find_main_product_in_text,
+)
+from product_index import get_index
+from prompts import get_active_prompt_content_only
+from tools import TOOLS, handle_tool_call_sync, strip_urls
+
+logger = logging.getLogger(__name__)
+
+
+VOICE_ADDON = (
+    "\n\nGORSEL DESTEK (onemli):\n"
+    "- Musterinin ekraninin sag tarafinda urun gorseli OTOMATIK olarak gosteriliyor.\n"
+    "- Bahsettigin urunun resmi sag tarafta belirir; renk sorulursa o varyantin gorseline gecer.\n"
+    "- 'Gorsel paylasiyorum', 'resmini atiyorum', 'linki gonderiyorum' gibi cumleler kurma.\n"
+    "- 'Sagda gorebilirsiniz' gibi kisa referanslar verebilirsin.\n"
+    "\nGORSEL ICIN TOOL CAGRISI (kritik):\n"
+    "- HER spesifik urun adi soyleyecegin ZAMAN — bisiklet, sele, kask, far, jersey, jant, "
+    "gidon, pedal, lastik, fren, vites, zincir, kask, eldiven, ne olursa olsun — daha "
+    "cevaba baslamadan once get_warehouse_stock fonksiyonunu o urun adiyla CAGIR.\n"
+    "- Ornekler: 'Ion Pro RT', 'Madone SL 7', 'Marlin 5', 'Aeolus RSL sele', 'Comp sele', "
+    "'Velocis kask', 'Gobik forma', 'Aeolus Pro 51 jant', 'XR4 Team Issue lastik', "
+    "'Elite Aero gidon', 'Line Elite pedal'... HEPSI tool cagrisi gerektirir.\n"
+    "- Onceki cevapta bahsedilmis olsa bile, YENI bir model ismi soyleyince TEKRAR cagir.\n"
+    "- Tek istisna: marka/kategori adi (Trek, Bontrager, MTB, sele, kask gibi jenerik kelime).\n"
+    "- COK ONEMLI — TOOL'A TAM URUN ADI VER (kategori dahil):\n"
+    "  * 'Comp' degil 'Bontrager Comp sele'\n"
+    "  * 'Pro' degil 'Bontrager Aeolus Pro sele'\n"
+    "  * 'XR4' degil 'Bontrager XR4 Team Issue lastik'\n"
+    "  * 'Elite' degil 'Bontrager Elite Aero gidon'\n"
+    "  * 'Line' degil 'Bontrager Line Elite pedal'\n"
+    "  Yani: marka + model + KATEGORI ekle (sele, jant, gidon, pedal, lastik, kask...). "
+    "Kisa/eksik adla cagrilirsa fuzzy matcher YANLIS urun bulabilir.\n"
+    "\nSESLI SOHBET KURALLARI (cok onemli):\n"
+    "- Hedef: TAM 2 cumle. Asla 2'den fazla cumle KURMA. 3. cumle YASAK.\n"
+    "- Bilgi 1 cumlede sigarsa 1 cumle yeterli. Sigmazsa 2 cumle. Daha fazlasi yok.\n"
+    "- IFADELERINI CESITLENDIR. Ayni kalipta cumle kurma — her cevapta farkli kelime ve yapi sec.\n"
+    "- Sadece SORULANA dogrudan cevap ver. Ekstra oneri/yonlendirme/tesvik EKLEME.\n"
+    "- KESINLIKLE YASAK kapanis/dolgu cumleleri (cevabini bunlarla UZATMA, son sozun bunlar OLMASIN):\n"
+    "  * 'magazalarimizda inceleyebilirsiniz', 'magazada gorebilirsiniz', 'magazada deneyebilirsiniz'\n"
+    "  * 'yardimci olabilir miyim', 'baska sorunuz var mi', 'baska bir sey...'\n"
+    "  * 'detayli bilgi icin', 'isterseniz', 'dilerseniz', 'arzu ederseniz'\n"
+    "  * 'bizi tercih ettiginiz icin', 'iyi gunler', 'kolay gelsin'\n"
+    "  Cevabi bilgi ile bitir, ek cumle EKLEME. Sustugun an iletisim biter.\n"
+    "- Markdown, * veya emoji KULLANMA.\n"
+    "- URL/link/web adresi ASLA SOYLEME. 'www', 'trekbisiklet.com', 'https' gibi adresleri "
+    "hicbir sekilde sesli okuma. 'Linki paylasiyorum', 'sitede goreceksiniz' gibi link "
+    "referanslari da YASAK.\n"
+    "- HER ZAMAN 'siz' ile hitap et, soru ile bitirme.\n"
+    "- Stok/fiyat sorulari icin get_warehouse_stock fonksiyonunu cagir, sonucu OZUN tek cumlede ver.\n"
+    "\n"
+    "STOK ADEDI KURALI (kritik):\n"
+    "- Stok ADEDINI / SAYISINI ASLA SOYLEME.\n"
+    "- Sadece 'mevcut', 'stokta var', 'bulunmuyor' veya 'tukenmis' gibi durum bildir.\n"
+    "- Adet sorulsa bile 'detayli adet bilgisi icin magazayla teyit' deyip gec.\n"
+    "\n"
+    "STOK SORGUSU AKISI:\n"
+    "- get_warehouse_stock cagrisi 2-3 sn surebilir. Once KISA bir bekleme cumlesi soyle, "
+    "SONRA fonksiyonu cagir. Boylece musteri sessizlik yasamaz.\n"
+    "- Bekleme cumlesi ornekleri (cesitlendir, hep ayni demeyi): "
+    "'Bir saniye, bakiyorum.' / 'Hemen kontrol ediyorum.' / 'Bakiyorum efendim.' / "
+    "'Stoga bakiyorum.' / 'Birsaniyenize.'\n"
+    "- Sonuc gelince direkt cevaba gec; 'kontrol ettim' gibi tekrar cumlesi YOK.\n"
+)
+
+
+def build_session_instructions() -> str:
+    try:
+        base = get_active_prompt_content_only()
+        if isinstance(base, list):
+            base = "\n\n".join(str(p) for p in base)
+    except Exception:
+        logger.exception("Prompt yuklenemedi")
+        base = "Trek Bisiklet uzmani bir satis temsilcisisin."
+    return base + VOICE_ADDON
+
+
+def _session_update_payload() -> dict:
+    return {
+        "type": "session.update",
+        "session": {
+            "type": "realtime",
+            "model": REALTIME_MODEL,
+            "instructions": build_session_instructions(),
+            "output_modalities": ["audio"],
+            "audio": {
+                "input": {
+                    "format": {"type": "audio/pcm", "rate": 24000},
+                    "transcription": {"model": "whisper-1"},
+                    "turn_detection": {
+                        "type": "server_vad",
+                        "threshold": 0.5,
+                        "prefix_padding_ms": 300,
+                        "silence_duration_ms": 700,
+                        "interrupt_response": False,
+                        "create_response": True,
+                    },
+                },
+                "output": {
+                    "format": {"type": "audio/pcm", "rate": 24000},
+                },
+            },
+            "tools": TOOLS,
+            "tool_choice": "auto",
+        },
+    }
+
+
+async def realtime_relay(client_ws: WebSocket):
+    """FastAPI WebSocket endpoint handler."""
+    await client_ws.accept()
+
+    if not OPENAI_API_KEY:
+        await client_ws.send_text(json.dumps({
+            "type": "error",
+            "error": {"message": "OPENAI_API_KEY tanimli degil."},
+        }))
+        await client_ws.close()
+        return
+
+    # Pre-warm index (varsa cache'den hizli, yoksa fetch)
+    try:
+        await asyncio.to_thread(get_index().ensure)
+    except Exception:
+        logger.exception("index pre-warm hatasi")
+
+    headers = {"Authorization": f"Bearer {OPENAI_API_KEY}"}
+
+    # Session state
+    state = {
+        "text": "",                   # asistan response transkripti
+        "tool_link": None,            # bu turn'de tool ile gosterilen urun linki
+        "current_main_link": None,    # ekrandaki ana urun linki
+        "last_shown_in_response": None,  # bu response'da en son gosterilen
+        "last_check_len": 0,          # live detection throttle
+    }
+
+    try:
+        async with ws_connect(REALTIME_URL, additional_headers=headers) as openai_ws:
+            logger.info("OpenAI Realtime baglantisi kuruldu")
+            await openai_ws.send(json.dumps(_session_update_payload()))
+
+            async def client_to_openai():
+                try:
+                    while True:
+                        msg = await client_ws.receive_text()
+                        await openai_ws.send(msg)
+                except WebSocketDisconnect:
+                    logger.info("Client disconnected")
+                except Exception as e:
+                    logger.error(f"client_to_openai error: {e}")
+
+            async def openai_to_client():
+                try:
+                    async for raw in openai_ws:
+                        try:
+                            data = json.loads(raw)
+                        except Exception:
+                            await client_ws.send_text(raw)
+                            continue
+                        await _handle_event(data, raw, openai_ws, client_ws, state)
+                except websockets.exceptions.ConnectionClosed:
+                    logger.info("OpenAI WebSocket kapandi")
+                except Exception as e:
+                    logger.error(f"openai_to_client error: {e}")
+
+            await asyncio.gather(client_to_openai(), openai_to_client())
+
+    except Exception:
+        logger.exception("Realtime relay hatasi")
+        try:
+            await client_ws.send_text(json.dumps({
+                "type": "error",
+                "error": {"message": "Baglanti hatasi"},
+            }))
+        except Exception:
+            pass
+    finally:
+        try:
+            await client_ws.close()
+        except Exception:
+            pass
+
+
+async def _handle_event(data: dict, raw: str, openai_ws, client_ws: WebSocket, state: dict):
+    evt = data.get("type", "")
+
+    # ---------- Important event logging ----------
+    if evt in ("session.created", "session.updated", "input_audio_buffer.speech_started",
+               "input_audio_buffer.speech_stopped", "input_audio_buffer.committed",
+               "response.created"):
+        logger.info(f"[Realtime] {evt}")
+    elif evt == "error":
+        logger.error(f"[Realtime] ERROR: {json.dumps(data)[:400]}")
+    elif evt == "response.done":
+        status = data.get("response", {}).get("status")
+        details = data.get("response", {}).get("status_details")
+        logger.info(f"[Realtime] response.done status={status} details={details}")
+
+    # ---------- State resets ----------
+    # Asistan yeni response'a basliyor — assistant transcript ve tool flag reset
+    if evt == "response.created":
+        state["text"] = ""
+        state["last_shown_in_response"] = None
+        state["last_check_len"] = 0
+        state["pending_response_create"] = False
+
+    # Kullanici yeni soru sormaya basladi — tool_link gecersiz
+    if evt == "input_audio_buffer.speech_started":
+        state["tool_link"] = None
+
+    # ---------- Asistan transkripti — sadece renk override kontrolu icin ----------
+    # GPT'ye guveniyoruz: ana urun gosterimi YALNIZCA tool sonucundan gelir.
+    # Live transkript-bazli tahmin kapali (yanlis urun gosterimine yol aciyordu).
+    if evt in ("response.audio_transcript.delta",
+               "response.output_audio_transcript.delta",
+               "response.output_text.delta"):
+        d = data.get("delta", "")
+        if isinstance(d, str):
+            state["text"] += d
+
+    # ---------- response.done — renk override + bekleyen response.create gonder ----------
+    if evt == "response.done":
+        text = state["text"]
+        active_main = state["current_main_link"]
+        if text and active_main:
+            color_v = find_color_variant(active_main, text)
+            if color_v and color_v.get("image"):
+                logger.info(f"[product/color-override] {color_v['name']}")
+                await _send(client_ws, {
+                    "type": "product.show",
+                    "product": color_v,
+                })
+        # Bu turn'de tool cagrisi yapildiysa SADECE BIR KEZ response.create gonder
+        # (cogu tool cagrisi varsa bile sonuclari beraber donar, tek sozlu cevap olur).
+        if state.get("pending_response_create"):
+            state["pending_response_create"] = False
+            await openai_ws.send(json.dumps({"type": "response.create"}))
+
+    # ---------- Tool call yakalama ----------
+    if evt == "response.function_call_arguments.done":
+        await _handle_tool_call(data, openai_ws, client_ws, state)
+        # Tool call mesajini client'a forward etmeye gerek yok ama geri gondermek
+        # zarar vermez — relay kuralina uy.
+
+    # ---------- Tum mesajlari client'a forward et ----------
+    try:
+        await client_ws.send_text(raw)
+    except Exception:
+        pass
+
+
+async def _handle_tool_call(data: dict, openai_ws, client_ws: WebSocket, state: dict):
+    call_id = data.get("call_id")
+    fn_name = data.get("name")
+    try:
+        args = json.loads(data.get("arguments", "{}"))
+    except Exception:
+        args = {}
+
+    logger.info(f"Tool call: {fn_name}({args})")
+
+    # Tool'u thread'de calistir — event loop bloklanmasin
+    result = await asyncio.to_thread(handle_tool_call_sync, fn_name, args)
+
+    # Urun resmi tespit — SADECE tool sonucundaki productLink'i kullan.
+    # GPT'ye guven: hangi urun konusulduysa o linki dondurur, biz tahmin yurutmeyiz.
+    if fn_name == "get_warehouse_stock":
+        idx = get_index()
+        product = None
+        product_link = extract_product_link_from_text(result)
+        if product_link:
+            product = idx.find_by_link(product_link)
+
+        if product and product.get("image"):
+            logger.info(f"[product/tool] {product['name']} ({product.get('link')})")
+            state["tool_link"] = product.get("link") or product_link
+            if product.get("link"):
+                state["current_main_link"] = product["link"]
+                state["last_shown_in_response"] = product["link"]
+            await _send(client_ws, {
+                "type": "product.show",
+                "product": product,
+            })
+
+        # Modelin URL okumasi engellensin — strip
+        result = strip_urls(result)
+
+    # Tool sonucunu modele geri gonder. response.create'i SADECE response.done'da
+    # bir kez tetikle (paralel tool cagrilarinda duplicate audio uretiyordu).
+    await openai_ws.send(json.dumps({
+        "type": "conversation.item.create",
+        "item": {
+            "type": "function_call_output",
+            "call_id": call_id,
+            "output": result,
+        },
+    }))
+    state["pending_response_create"] = True
+
+
+async def _send(client_ws: WebSocket, payload: dict):
+    try:
+        await client_ws.send_text(json.dumps(payload))
+    except Exception:
+        pass

requirements.txt

@@ -1,6 +1,5 @@
-fastapi>=0.115.0
-uvicorn[standard]>=0.32.0
-websockets>=13.0
-python-multipart>=0.0.9
-requests>=2.32.0
-python-dotenv>=1.0.0
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+websockets==13.1
+requests==2.32.3
+python-multipart==0.0.9

smart_warehouse.py

@@ -1,261 +0,0 @@
-"""Smart warehouse stock finder using GPT-5's intelligence"""
-
-import requests
-import re
-import os
-import json
-
-def get_warehouse_stock_smart(user_message, previous_result=None):
-    """Let GPT-5 intelligently find products or filter by warehouse"""
-    
-    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-    
-    # Check if user is asking about specific warehouse
-    warehouse_keywords = {
-        'caddebostan': 'Caddebostan',
-        'ortaköy': 'Ortaköy', 
-        'ortakoy': 'Ortaköy',
-        'alsancak': 'Alsancak',
-        'izmir': 'Alsancak',
-        'bahçeköy': 'Bahçeköy',
-        'bahcekoy': 'Bahçeköy'
-    }
-    
-    user_lower = user_message.lower()
-    asked_warehouse = None
-    for keyword, warehouse in warehouse_keywords.items():
-        if keyword in user_lower:
-            asked_warehouse = warehouse
-            break
-    
-    # Get XML data with retry
-    xml_text = None
-    for attempt in range(3):  # Try 3 times
-        try:
-            url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
-            timeout_val = 10 + (attempt * 5)  # Increase timeout on each retry: 10, 15, 20
-            response = requests.get(url, verify=False, timeout=timeout_val)
-            xml_text = response.text
-            print(f"DEBUG - XML fetched: {len(xml_text)} characters (attempt {attempt+1})")
-            break
-        except requests.exceptions.Timeout:
-            print(f"XML fetch timeout (attempt {attempt+1}/3, timeout={timeout_val}s)")
-            if attempt == 2:
-                print("All attempts failed - timeout")
-                return None
-        except Exception as e:
-            print(f"XML fetch error: {e}")
-            return None
-    
-    # Extract just product blocks to reduce token usage
-    product_pattern = r'<Product>(.*?)</Product>'
-    all_products = re.findall(product_pattern, xml_text, re.DOTALL)
-    
-    # Create a simplified product list for GPT
-    products_summary = []
-    for i, product_block in enumerate(all_products):
-        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
-        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
-        
-        if name_match:
-            # Check warehouse stock for this product
-            warehouses_with_stock = []
-            warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
-            warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
-            
-            for wh_name, wh_stock in warehouses:
-                try:
-                    if int(wh_stock.strip()) > 0:
-                        warehouses_with_stock.append(wh_name)
-                except:
-                    pass
-            
-            product_info = {
-                "index": i,
-                "name": name_match.group(1),
-                "variant": variant_match.group(1) if variant_match else "",
-                "warehouses": warehouses_with_stock
-            }
-            products_summary.append(product_info)
-    
-    # If user is asking about specific warehouse, include that in prompt
-    warehouse_filter = ""
-    if asked_warehouse:
-        warehouse_filter = f"\nIMPORTANT: User is asking specifically about {asked_warehouse} warehouse. Only return products available in that warehouse."
-    
-    # Let GPT-5 find ALL matching products
-    smart_prompt = f"""User is asking: "{user_message}"
-
-Find ALL products that match this query from the list below.
-If user asks about specific size (S, M, L, XL, XXL, SMALL, MEDIUM, LARGE, X-LARGE), return only that size.
-If user asks generally (without size), return ALL variants of the product.
-{warehouse_filter}
-
-IMPORTANT BRAND AND PRODUCT TYPE RULES:
-- GOBIK: Spanish textile brand we import. When user asks about "gobik", return ALL products with "GOBIK" in the name.
-- Product names contain type information: FORMA (jersey/cycling shirt), TAYT (tights), İÇLİK (base layer), YAĞMURLUK (raincoat), etc.
-- Understand Turkish/English terms: 
-  * "erkek forma" / "men's jersey" -> Find products with FORMA in name
-  * "tayt" / "tights" -> Find products with TAYT in name  
-  * "içlik" / "base layer" -> Find products with İÇLİK in name
-  * "yağmurluk" / "raincoat" -> Find products with YAĞMURLUK in name
-- Gender: UNISEX means for both men and women. If no gender specified, it's typically men's.
-- Be smart: "erkek forma" should find all FORMA products (excluding women-specific if any)
-
-Products list (with warehouse availability):
-{json.dumps(products_summary, ensure_ascii=False, indent=2)}
-
-Return index numbers of ALL matching products as comma-separated list (e.g., "5,8,12,15").
-If no products found, return: -1
-
-Examples:
-- "madone sl 6 var mı" -> Return ALL Madone SL 6 variants
-- "erkek forma" -> Return all products with FORMA in name
-- "gobik tayt" -> Return all GOBIK products with TAYT in name
-- "içlik var mı" -> Return all products with İÇLİK in name
-- "gobik erkek forma" -> Return all GOBIK products with FORMA in name
-- "yağmurluk medium" -> Return all YAĞMURLUK products in MEDIUM size"""
-
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {OPENAI_API_KEY}"
-    }
-    
-    # GPT-5.5 modeli temperature ve max_tokens desteklemiyor
-    payload = {
-        "model": "gpt-5.5",
-        "messages": [
-            {"role": "system", "content": "You are a product matcher. Find ALL matching products. Return only index numbers."},
-            {"role": "user", "content": smart_prompt}
-        ]
-    }
-    
-    try:
-        response = requests.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers=headers,
-            json=payload,
-            timeout=10
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            indices_str = result['choices'][0]['message']['content'].strip()
-            
-            if indices_str == "-1":
-                return ["Ürün bulunamadı"]
-            
-            try:
-                # Parse multiple indices
-                indices = [int(idx.strip()) for idx in indices_str.split(',')]
-                
-                # Collect all matching products
-                all_variants = []
-                warehouse_stock = {}
-                
-                for idx in indices:
-                    if 0 <= idx < len(all_products):
-                        product_block = all_products[idx]
-                        
-                        # Get product name and variant
-                        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
-                        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
-                        
-                        if name_match:
-                            product_name = name_match.group(1)
-                            variant = variant_match.group(1) if variant_match else ""
-                            
-                            # Track this variant
-                            variant_info = {
-                                'name': product_name,
-                                'variant': variant,
-                                'warehouses': []
-                            }
-                            
-                            # Get warehouse stock
-                            warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
-                            warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
-                            
-                            for wh_name, wh_stock in warehouses:
-                                try:
-                                    stock = int(wh_stock.strip())
-                                    if stock > 0:
-                                        display_name = format_warehouse_name(wh_name)
-                                        variant_info['warehouses'].append({
-                                            'name': display_name,
-                                            'stock': stock
-                                        })
-                                        
-                                        # Track total stock per warehouse
-                                        if display_name not in warehouse_stock:
-                                            warehouse_stock[display_name] = 0
-                                        warehouse_stock[display_name] += stock
-                                except:
-                                    pass
-                            
-                            if variant_info['warehouses']:  # Only add if has stock
-                                all_variants.append(variant_info)
-                
-                # Format result
-                result = []
-                
-                if asked_warehouse:
-                    # Filter for specific warehouse
-                    warehouse_variants = []
-                    for variant in all_variants:
-                        for wh in variant['warehouses']:
-                            if asked_warehouse in wh['name']:
-                                warehouse_variants.append({
-                                    'name': variant['name'],
-                                    'variant': variant['variant'],
-                                    'stock': wh['stock']
-                                })
-                    
-                    if warehouse_variants:
-                        result.append(f"{format_warehouse_name(asked_warehouse)} mağazasında mevcut:")
-                        for v in warehouse_variants:
-                            result.append(f"• {v['name']} ({v['variant']})")
-                    else:
-                        result.append(f"{format_warehouse_name(asked_warehouse)} mağazasında bu ürün mevcut değil")
-                else:
-                    # Show all variants and warehouses
-                    if all_variants:
-                        result.append(f"Bulunan {len(all_variants)} varyant:")
-                        
-                        # Show ALL variants (not just first 5)
-                        for variant in all_variants:
-                            variant_text = f" ({variant['variant']})" if variant['variant'] else ""
-                            result.append(f"• {variant['name']}{variant_text}")
-                        
-                        result.append("")
-                        result.append("Mağaza stok durumu:")
-                        for warehouse, total_stock in sorted(warehouse_stock.items()):
-                            result.append(f"• {warehouse}: Mevcut")
-                    else:
-                        result.append("Hiçbir mağazada stok yok")
-                
-                return result
-                
-            except (ValueError, IndexError) as e:
-                print(f"DEBUG - Error parsing indices: {e}")
-                return None
-        else:
-            print(f"GPT API error: {response.status_code}")
-            return None
-            
-    except Exception as e:
-        print(f"Error calling GPT: {e}")
-        return None
-
-def format_warehouse_name(wh_name):
-    """Format warehouse name nicely"""
-    if "CADDEBOSTAN" in wh_name:
-        return "Caddebostan mağazası"
-    elif "ORTAKÖY" in wh_name:
-        return "Ortaköy mağazası"
-    elif "ALSANCAK" in wh_name:
-        return "İzmir Alsancak mağazası"
-    elif "BAHCEKOY" in wh_name or "BAHÇEKÖY" in wh_name:
-        return "Bahçeköy mağazası"
-    else:
-        return wh_name.replace("MAGAZA DEPO", "").strip()

smart_warehouse_with_price.py

@@ -1,4 +1,5 @@
-"""Smart warehouse stock finder with price and link information"""
+"""Smart warehouse stock finder with price and link information.
+WhatsApp BF-WAB versiyonundan ithal edildi (V2)."""
 
 import requests
 import re
@@ -7,11 +8,13 @@ import json
 import xml.etree.ElementTree as ET
 import time
 import logging
+import urllib3
 
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 logger = logging.getLogger(__name__)
 
-# Cache configuration - 2 hours (reduced from 12 hours for more accurate results)
-CACHE_DURATION = 86400  # 24 saat — Cloudflare 1015 ban riskine karsi uzun tut
+# Cache configuration — 24 saat
+CACHE_DURATION = 86400  # 24 hours
 cache = {
     'warehouse_xml': {'data': None, 'time': 0},
     'trek_xml': {'data': None, 'time': 0},
@@ -20,24 +23,15 @@ cache = {
 }
 
 def get_cached_trek_xml():
-    """Get Trek XML with 12-hour caching"""
-    current_time = time.time()
-    
-    if cache['trek_xml']['data'] and (current_time - cache['trek_xml']['time'] < CACHE_DURATION):
-        cache_age = (current_time - cache['trek_xml']['time']) / 60  # in minutes
-        return cache['trek_xml']['data']
-    
+    """V2'nin product_index lock'lu cache'ini kullan — ayni Trek katalog XML'i."""
     try:
-        url = 'https://www.trekbisiklet.com.tr/output/2688003925'
-        response = requests.get(url, verify=False, timeout=10)
-        
-        if response.status_code == 200:
-            cache['trek_xml']['data'] = response.content
-            cache['trek_xml']['time'] = current_time
-            return response.content
-        else:
+        from product_index import get_index
+        idx = get_index()
+        if not idx.ensure():
             return None
-    except Exception as e:
+        return idx._xml_data  # cached bytes
+    except Exception:
+        logger.exception("[smart_warehouse] V2 trek index import hatasi")
         return None
 
 def apply_price_rounding(price_str):
@@ -197,20 +191,10 @@ def get_product_price_and_link(product_name, variant=None):
         for tr, en in tr_map.items():
             search_name_normalized = search_name_normalized.replace(tr, en)
             search_variant_normalized = search_variant_normalized.replace(tr, en)
-
+        
         # Now lowercase
         search_name = search_name_normalized.lower()
         search_variant = search_variant_normalized.lower()
-
-        # KRITIK: "+" karakterini normalize et (fuel + lx -> fuel+ lx, fuel lx -> fuel+ lx)
-        # Kullanici "fuel + lx" veya "fuel lx" yazabilir, XML'de "FUEL+ LX" var
-        plus_models = ['fuel', 'domane', 'fx', 'ds', 'verve', 'townie', 'allant']
-        for model in plus_models:
-            # "fuel + lx" -> "fuel+ lx"
-            search_name = search_name.replace(f'{model} + ', f'{model}+ ')
-            # "fuel lx" -> "fuel+ lx" (sadece elektrikli model ise)
-            if f'{model} lx' in search_name or f'{model} 9' in search_name:
-                search_name = search_name.replace(f'{model} ', f'{model}+ ')
         
         best_match = None
         best_score = 0
@@ -290,184 +274,16 @@ def get_product_price_and_link(product_name, variant=None):
     except Exception as e:
         return None, None
 
-BIZIMHESAP_TOKEN = '6F4BAF303FA240608A39653824B6C495'
-BIZIMHESAP_BASE = 'https://bizimhesap.com/api/b2b'
-BIZIMHESAP_HEADERS = {'token': BIZIMHESAP_TOKEN, 'Accept': 'application/json'}
-
-# Hangi magazalar olmadiginda cache yenilemeyi reddet (rate-limit koruyucu)
-CRITICAL_WAREHOUSES = {'BAHCEKOY', 'CADDEBOSTAN', 'ALSANCAK'}
-
-
-def _bh_get(url, retries=2):
-    for i in range(retries):
-        try:
-            r = requests.get(url, headers=BIZIMHESAP_HEADERS, timeout=60)
-            if r.status_code == 200:
-                return r.json()
-        except Exception:
-            pass
-        if i < retries - 1:
-            time.sleep(1)
-    return None
-
-
-def _bh_match_product(item, products):
-    """PHP matchProduct port'u: barcode > sku > title-variant > title"""
-    item_barcode = (item.get('barcode') or '').strip()
-    item_title = (item.get('title') or '').strip()
-    item_title_lower = item_title.lower()
-
-    best = None
-    best_score = 0
-    for code, p in products.items():
-        score = 0
-        if item_barcode and p['barcode'] and item_barcode == p['barcode']:
-            score = 100
-        elif item_barcode and item_barcode == code:
-            score = 90
-        elif item_title:
-            p_title = p['name'].lower()
-            p_variant = p['variant'].lower()
-            if p_variant:
-                if item_title_lower == f"{p_title} {p_variant}":
-                    score = 80
-                elif item_title_lower == f"{p_title}-{p_variant}":
-                    score = 75
-                elif p_title in item_title_lower:
-                    parts = re.split(r'[\s\-]+', p_variant)
-                    if all(part.strip() in item_title_lower for part in parts if part.strip()):
-                        score = 70
-            elif item_title_lower == p_title:
-                score = 80
-        if not item_barcode and not p['barcode']:
-            p_title = p['name'].lower()
-            if p_title and p_title in item_title_lower:
-                score = max(score, 60)
-        if score > best_score:
-            best_score = score
-            best = p
-    return best if best_score >= 60 else None
-
-
-def _build_warehouse_xml():
-    """BizimHesap B2B API'sinden direkt veri cek ve XML uret (Trek PHP'ye bagimlilik yok)."""
-    pdata = _bh_get(f'{BIZIMHESAP_BASE}/products')
-    if not pdata or pdata.get('resultCode') != 1:
-        return None
-    products_raw = pdata.get('data', {}).get('products', [])
-
-    products = {}
-    for p in products_raw:
-        code = (p.get('code') or '').strip()
-        if not code:
-            continue
-        products[code] = {
-            'sku': code,
-            'barcode': (p.get('barcode') or '').strip(),
-            'name': (p.get('title') or '').strip(),
-            'variant': (p.get('variant') or '').strip(),
-            'warehouses': [],
-            'total': 0,
-        }
-
-    wdata = _bh_get(f'{BIZIMHESAP_BASE}/warehouses')
-    if not wdata or wdata.get('resultCode') != 1:
-        return None
-    warehouses = wdata.get('data', {}).get('warehouses', [])
-
-    critical_empty = 0
-    total_inv = 0
-    for wh in warehouses:
-        wid = wh.get('id')
-        wname = (wh.get('title') or '').strip()
-        idata = _bh_get(f'{BIZIMHESAP_BASE}/inventory/{wid}')
-        inv = idata.get('data', {}).get('inventory', []) if idata else []
-        if wname.upper() in CRITICAL_WAREHOUSES and len(inv) == 0:
-            critical_empty += 1
-        total_inv += len(inv)
-        for item in inv:
-            try:
-                qty = int(item.get('qty', 0))
-            except (TypeError, ValueError):
-                qty = 0
-            if qty <= 0:
-                continue
-            m = _bh_match_product(item, products)
-            if m is not None:
-                m['warehouses'].append({'name': wname, 'stock': qty})
-                m['total'] += qty
-
-    # Partial-failure koruma: 2+ kritik magaza bossa cache'i kirletme
-    if critical_empty >= 2:
-        return None
-
-    # XML uret (Trek PHP'nin urettigi format)
-    out = ['<?xml version="1.0" encoding="UTF-8"?>',
-           '<!-- BizimHesap B2B API direct (HF Space) -->',
-           f'<!-- Generated: {time.strftime("%Y-%m-%d %H:%M:%S")} -->',
-           f'<!-- Stats: {len(products_raw)} products, {len(warehouses)} warehouses, {total_inv} inventory items -->',
-           '<Products>']
-    for p in sorted(products.values(), key=lambda x: x['sku'].lower()):
-        if not p['warehouses']:
-            continue
-        p['warehouses'].sort(key=lambda w: -w['stock'])
-        out.append('  <Product>')
-        out.append(f'    <ProductCode><![CDATA[{p["sku"]}]]></ProductCode>')
-        out.append(f'    <ProductName><![CDATA[{p["name"]}]]></ProductName>')
-        if p['variant']:
-            out.append(f'    <ProductVariant><![CDATA[{p["variant"]}]]></ProductVariant>')
-        if p['barcode']:
-            out.append(f'    <Barcode><![CDATA[{p["barcode"]}]]></Barcode>')
-        out.append(f'    <TotalStock>{p["total"]}</TotalStock>')
-        for w in p['warehouses']:
-            out.append('    <Warehouse>')
-            out.append(f'      <Name><![CDATA[{w["name"]}]]></Name>')
-            out.append(f'      <Stock>{w["stock"]}</Stock>')
-            out.append('    </Warehouse>')
-        out.append('  </Product>')
-    out.append('</Products>')
-    return '\n'.join(out)
-
-
-TREK_PHP_URL = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
-
-
-def _fetch_trek_php():
-    """Trek PHP endpoint'inden XML cek (BizimHesap direkt erisim olmazsa fallback)."""
-    for attempt in range(2):
-        try:
-            r = requests.get(TREK_PHP_URL, verify=False, timeout=15 + attempt * 10)
-            if r.status_code == 200 and len(r.text) > 1000 and '<Products>' in r.text:
-                return r.text
-        except Exception:
-            pass
-    return None
-
-
 def get_cached_warehouse_xml():
-    """Warehouse XML — 2 saatlik cache.
-    Once BizimHesap B2B API'sine direkt baglan; basarisizsa Trek PHP fallback."""
-    current_time = time.time()
-
-    if cache['warehouse_xml']['data'] and (current_time - cache['warehouse_xml']['time'] < CACHE_DURATION):
-        return cache['warehouse_xml']['data']
-
-    # 1. Tercih: BizimHesap'a direkt
-    xml_text = _build_warehouse_xml()
-    # 2. Fallback: Trek PHP (en azindan mevcut cache'i doner)
-    if not xml_text:
-        xml_text = _fetch_trek_php()
-
-    if xml_text:
-        cache['warehouse_xml']['data'] = xml_text
-        cache['warehouse_xml']['time'] = current_time
-        return xml_text
-
-    # 3. Son care: eski (expired) cache
-    if cache['warehouse_xml']['data']:
-        return cache['warehouse_xml']['data']
-
-    return None
+    """V2'nin tek-kanalli, lock'lu cache'ine yonlendir.
+    Bu sekilde tum tool cagrilari ve /warehouse-xml endpoint'i AYNI cache'i paylasir,
+    video.trek-turkey.com'a thundering herd olmaz."""
+    try:
+        from stock_service import get_cached_warehouse_xml as _v2_cache
+        return _v2_cache()
+    except Exception:
+        logger.exception("[smart_warehouse] V2 cache import hatasi")
+        return None
 
 def get_warehouse_stock_smart_with_price(user_message, previous_result=None):
     """Enhanced smart warehouse search with price and link info"""
@@ -481,16 +297,7 @@ def get_warehouse_stock_smart_with_price(user_message, previous_result=None):
     ]
     
     clean_message = user_message.lower().strip()
-
-    # KRITIK: "+" karakterini normalize et (fuel + lx -> fuel+ lx, fuel lx -> fuel+ lx)
-    plus_models = ['fuel', 'domane', 'fx', 'ds', 'verve', 'townie', 'allant']
-    for model in plus_models:
-        # "fuel + lx" -> "fuel+ lx"
-        clean_message = clean_message.replace(f'{model} + ', f'{model}+ ')
-        # "fuel lx" -> "fuel+ lx" (elektrikli model)
-        if f'{model} lx' in clean_message:
-            clean_message = clean_message.replace(f'{model} lx', f'{model}+ lx')
-
+    
     for phrase in live_support_phrases:
         if phrase in clean_message:
             return None  # Ürün araması yapma, GPT'ye bırak
@@ -520,9 +327,23 @@ def get_warehouse_stock_smart_with_price(user_message, previous_result=None):
         # Short single words are usually not product names
         return None
     
-    # NOT: Asistan zaten 'stok ara' fonksiyonunu cagiriyor, ek soru-filtre
-    # gereksiz ve cok agresif (her '?' icin dusuyordu). Sadece live_support
-    # ve non_product_words yeterli.
+    # Check if this is a question rather than a product search
+    # BUT skip this check if message contains a known brand
+    question_indicators = [
+        'musun', 'müsün', 'misin', 'mısın', 'miyim', 'mıyım',
+        'musunuz', 'müsünüz', 'misiniz', 'mısınız',
+        'neden', 'nasıl', 'ne zaman', 'kim', 'nerede', 'nereye',
+        'ulaşamıyor', 'yapamıyor', 'gönderemiyor', 'edemiyor',
+        # NOT: '?' karakterini cikartik — "Marlin 5 var mı?" gibi normal urun sorulari
+        # de soru isareti icerir, bu false-positive yapiyordu.
+    ]
+
+    # If message contains question indicators, it's likely not a product search
+    # EXCEPTION: If message contains a brand keyword, still search for products
+    if not contains_brand:
+        for indicator in question_indicators:
+            if indicator in clean_message:
+                return None
     
     # Normalize cache key for consistent caching (Turkish chars + lowercase)
     def normalize_for_cache(text):
@@ -570,13 +391,11 @@ def get_warehouse_stock_smart_with_price(user_message, previous_result=None):
     # Get cached XML data
     xml_text = get_cached_warehouse_xml()
     if not xml_text:
-        logger.info(f"[search] xml_text is None for query: {user_message!r}")
         return None
-
+    
     # Extract product blocks
     product_pattern = r'<Product>(.*?)</Product>'
     all_products = re.findall(product_pattern, xml_text, re.DOTALL)
-    logger.info(f"[search] q={user_message!r} xml_size={len(xml_text)} products={len(all_products)} asked_warehouse={asked_warehouse}")
     
     # Create simplified product list for GPT
     products_summary = []
@@ -720,15 +539,14 @@ Examples of correct responses:
             "https://api.openai.com/v1/chat/completions",
             headers=headers,
             json=payload,
-            timeout=45
+            timeout=10
         )
         
         if response.status_code == 200:
             result = response.json()
             indices_str = result['choices'][0]['message']['content'].strip()
-            logger.info(f"[search] GPT indices: {indices_str!r}")
-
-            # Handle empty response - try Trek XML as fallback, but avoid tool products
+            
+            # Handle empty response - try Trek XML as fallback, but avoid tool products  
             if not indices_str or indices_str == "-1":
                 # Try to find in Trek XML directly, but skip tools
                 user_message_normalized = user_message.upper()
@@ -840,10 +658,10 @@ Examples of correct responses:
                     warehouse_variants = []
                     for variant in all_variants:
                         for wh in variant['warehouses']:
-                            if asked_warehouse.upper() in wh['name'].upper():
+                            if asked_warehouse in wh['name']:
                                 warehouse_variants.append(variant)
                                 break
-
+                    
                     if warehouse_variants:
                         result.append(f"{format_warehouse_name(asked_warehouse)} mağazasında mevcut:")
                         for v in warehouse_variants:
@@ -864,25 +682,23 @@ Examples of correct responses:
                             if variant['name'] not in product_groups:
                                 product_groups[variant['name']] = []
                             product_groups[variant['name']].append(variant)
-
+                        
                         result.append(f"Bulunan ürünler:")
-
+                        
                         for product_name, variants in product_groups.items():
                             result.append(f"\n{product_name}:")
-
+                            
+                            # Show first variant's price and link (usually same for all variants)
                             if variants[0]['price']:
                                 result.append(f"Fiyat: {variants[0]['price']}")
                             if variants[0]['link']:
                                 result.append(f"Link: {variants[0]['link']}")
-
-                            # Sadece magaza isimleri (adet gizli)
+                            
+                            # Show variants and their availability
                             for v in variants:
-                                wh_names = sorted({w['name'].replace(' mağazası', '') for w in v['warehouses']})
-                                wh_str = ", ".join(wh_names)
                                 if v['variant']:
-                                    result.append(f"• {v['variant']} — {wh_str}")
-                                else:
-                                    result.append(f"• Stokta: {wh_str}")
+                                    warehouses_str = ", ".join([w['name'].replace(' mağazası', '') for w in v['warehouses']])
+                                    result.append(f"• {v['variant']}: {warehouses_str}")
                             
                     else:
                         # No warehouse stock found - check if product exists in Trek
@@ -913,16 +729,13 @@ Examples of correct responses:
                     'time': current_time
                 }
                 return result
-
+                
             except (ValueError, IndexError) as e:
-                logger.error(f"[search] parse error: {e}")
                 return None
         else:
-            logger.error(f"[search] OpenAI HTTP {response.status_code}: {response.text[:200]}")
             return None
-
+            
     except Exception as e:
-        logger.error(f"[search] OpenAI request failed: {type(e).__name__}: {e}")
         return None
 
 def format_warehouse_name(wh_name):

stock_service.py

@@ -0,0 +1,254 @@
+"""Stok bilgisi servisi: BizimHesap B2B API + Trek PHP fallback.
+Lock'lu cache (thundering herd onleyici), 24h TTL, stale-on-failure."""
+from __future__ import annotations
+
+import logging
+import re
+import threading
+import time
+
+import requests
+import urllib3
+
+from config import (
+    BIZIMHESAP_BASE,
+    BIZIMHESAP_HEADERS,
+    BIZIMHESAP_TIMEOUT,
+    CACHE_TTL_BH_INVENTORY,
+    CACHE_TTL_BH_PRODUCTS,
+    CACHE_TTL_BH_WAREHOUSES,
+    CACHE_TTL_WAREHOUSE,
+    CRITICAL_WAREHOUSES,
+    TREK_PHP_TIMEOUT,
+    TREK_PHP_URL,
+)
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+logger = logging.getLogger(__name__)
+
+
+# ---------- BizimHesap raw cache ----------
+_bh_cache = {
+    "products": {"data": None, "time": 0.0},
+    "warehouses": {"data": None, "time": 0.0},
+    "inventory": {},  # {wid: {data, time}}
+}
+_bh_lock = threading.Lock()
+
+
+def bh_get(url: str, retries: int = 2):
+    """BizimHesap GET — JSON dondurur, basarisizsa None. Tum hatalari log'la."""
+    last_err = None
+    for i in range(retries):
+        try:
+            r = requests.get(url, headers=BIZIMHESAP_HEADERS, timeout=BIZIMHESAP_TIMEOUT)
+            if r.status_code == 200:
+                try:
+                    return r.json()
+                except Exception as e:
+                    last_err = f"json parse: {e}; body[:200]={r.text[:200]!r}"
+            else:
+                last_err = f"HTTP {r.status_code}; body[:200]={r.text[:200]!r}"
+        except Exception as e:
+            last_err = f"{type(e).__name__}: {e}"
+        if i < retries - 1:
+            time.sleep(0.6)
+    logger.warning(f"[bh] {url} fail: {last_err}")
+    return None
+
+
+def cached_bh(kind: str, fetcher, ttl: int) -> tuple[object, str]:
+    """products/warehouses generic cache. Donus: (data, status)."""
+    with _bh_lock:
+        entry = _bh_cache.get(kind, {"data": None, "time": 0.0})
+        now = time.time()
+        if entry["data"] is not None and (now - entry["time"] < ttl):
+            return entry["data"], "hit"
+    data = fetcher()  # lock disinda fetch — diger okumalar bloklanmasin
+    with _bh_lock:
+        if data is not None:
+            _bh_cache[kind] = {"data": data, "time": time.time()}
+            return data, "miss"
+        if entry["data"] is not None:
+            return entry["data"], "stale"
+    return None, "fail"
+
+
+def cached_bh_inventory(wid: str) -> tuple[object, str]:
+    """Inventory cache (warehouse-specific)."""
+    with _bh_lock:
+        entry = _bh_cache["inventory"].get(wid)
+        now = time.time()
+        if entry and (now - entry["time"] < CACHE_TTL_BH_INVENTORY):
+            return entry["data"], "hit"
+    data = bh_get(f"{BIZIMHESAP_BASE}/inventory/{wid}")
+    with _bh_lock:
+        if data is not None:
+            _bh_cache["inventory"][wid] = {"data": data, "time": time.time()}
+            return data, "miss"
+        if entry:
+            return entry["data"], "stale"
+    return None, "fail"
+
+
+# ---------- BizimHesap match helper ----------
+def _bh_match_product(item: dict, products: dict) -> dict | None:
+    """Inventory item'ini products dict'inde bul (sku, barcode, name varyantlariyla)."""
+    sku = (item.get("sku") or item.get("code") or "").strip()
+    if sku and sku in products:
+        return products[sku]
+    barcode = (item.get("barcode") or "").strip()
+    if barcode:
+        for p in products.values():
+            if p.get("barcode") == barcode:
+                return p
+    return None
+
+
+def _build_warehouse_xml() -> str | None:
+    """BizimHesap'tan direkt veri cek + Trek PHP formatinda XML uret."""
+    pdata = bh_get(f"{BIZIMHESAP_BASE}/products")
+    if not pdata or pdata.get("resultCode") != 1:
+        return None
+    products_raw = pdata.get("data", {}).get("products", [])
+
+    products: dict[str, dict] = {}
+    for p in products_raw:
+        code = (p.get("code") or "").strip()
+        if not code:
+            continue
+        products[code] = {
+            "sku": code,
+            "barcode": (p.get("barcode") or "").strip(),
+            "name": (p.get("title") or "").strip(),
+            "variant": (p.get("variant") or "").strip(),
+            "warehouses": [],
+            "total": 0,
+        }
+
+    wdata = bh_get(f"{BIZIMHESAP_BASE}/warehouses")
+    if not wdata or wdata.get("resultCode") != 1:
+        return None
+    warehouses = wdata.get("data", {}).get("warehouses", [])
+
+    critical_empty = 0
+    for wh in warehouses:
+        wid = wh.get("id")
+        wname = (wh.get("title") or "").strip()
+        idata = bh_get(f"{BIZIMHESAP_BASE}/inventory/{wid}")
+        inv = idata.get("data", {}).get("inventory", []) if idata else []
+        if wname.upper() in CRITICAL_WAREHOUSES and len(inv) == 0:
+            critical_empty += 1
+        for item in inv:
+            try:
+                qty = int(item.get("qty", 0))
+            except (TypeError, ValueError):
+                qty = 0
+            if qty <= 0:
+                continue
+            m = _bh_match_product(item, products)
+            if m is not None:
+                m["warehouses"].append({"name": wname, "stock": qty})
+                m["total"] += qty
+
+    # Partial-failure koruma
+    if critical_empty >= 2:
+        logger.warning("[stock] critical_empty>=2, dirty fetch reddedildi")
+        return None
+
+    out = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        "<!-- BizimHesap B2B API direct -->",
+        f'<!-- Generated: {time.strftime("%Y-%m-%d %H:%M:%S")} -->',
+        "<Products>",
+    ]
+    for p in sorted(products.values(), key=lambda x: x["sku"].lower()):
+        if not p["warehouses"]:
+            continue
+        p["warehouses"].sort(key=lambda w: -w["stock"])
+        out.append("  <Product>")
+        out.append(f'    <ProductCode><![CDATA[{p["sku"]}]]></ProductCode>')
+        out.append(f'    <ProductName><![CDATA[{p["name"]}]]></ProductName>')
+        if p["variant"]:
+            out.append(f'    <ProductVariant><![CDATA[{p["variant"]}]]></ProductVariant>')
+        if p["barcode"]:
+            out.append(f'    <Barcode><![CDATA[{p["barcode"]}]]></Barcode>')
+        out.append(f'    <TotalStock>{p["total"]}</TotalStock>')
+        for w in p["warehouses"]:
+            out.append("    <Warehouse>")
+            out.append(f'      <Name><![CDATA[{w["name"]}]]></Name>')
+            out.append(f"      <Stock>{w['stock']}</Stock>")
+            out.append("    </Warehouse>")
+        out.append("  </Product>")
+    out.append("</Products>")
+    return "\n".join(out)
+
+
+def _fetch_trek_php() -> str | None:
+    """Trek PHP'den XML cek. PHP, V1 HF Space'i proxy'liyor + 15dk cache + stale fallback.
+    HF Space'ten BizimHesap'a direkt erisim 502 verirse Trek PHP cache'inden veri alabiliriz."""
+    try:
+        r = requests.get(TREK_PHP_URL, verify=False, timeout=TREK_PHP_TIMEOUT)
+        if r.status_code == 200 and len(r.text) > 1000 and "<Products>" in r.text:
+            return r.text
+        logger.warning(f"[stock] Trek PHP HTTP {r.status_code} len={len(r.text)}")
+    except Exception as e:
+        logger.warning(f"[stock] Trek PHP fail: {type(e).__name__}: {e}")
+    return None
+
+
+# ---------- Warehouse XML cache (BizimHesap + Trek PHP) ----------
+_warehouse_cache = {"data": None, "time": 0.0}
+_warehouse_lock = threading.Lock()
+
+
+def get_cached_warehouse_xml() -> str | None:
+    """Tek kanal: cache hit veya fetch (lock'lu) veya stale fallback."""
+    with _warehouse_lock:
+        now = time.time()
+        if _warehouse_cache["data"] and (now - _warehouse_cache["time"] < CACHE_TTL_WAREHOUSE):
+            return _warehouse_cache["data"]
+
+    # Lock disinda fetch (digerleri bloklanmasin), ama tek seferlik
+    # — ikinci bir lock fetch_lock ile koruyoruz
+    with _warehouse_fetch_lock:
+        # Lock alindiginda baska bir thread fetch yapmis olabilir
+        with _warehouse_lock:
+            now = time.time()
+            if _warehouse_cache["data"] and (now - _warehouse_cache["time"] < CACHE_TTL_WAREHOUSE):
+                return _warehouse_cache["data"]
+
+        # 1) Trek PHP (V1 proxy) — kanitli kaynak, 15dk cache + stale fallback
+        xml = _fetch_trek_php()
+        # 2) Fallback: BizimHesap direkt (V2 kendi cagrisi — 502 olabiliyor)
+        if not xml:
+            xml = _build_warehouse_xml()
+
+        with _warehouse_lock:
+            if xml:
+                _warehouse_cache["data"] = xml
+                _warehouse_cache["time"] = time.time()
+                return xml
+            # Stale fallback
+            return _warehouse_cache["data"]
+
+
+_warehouse_fetch_lock = threading.Lock()
+
+
+# ---------- Search results cache (kullanici sorgu -> sonuc) ----------
+_search_cache: dict[str, dict] = {}
+_search_lock = threading.Lock()
+
+
+def search_cache_get(key: str, ttl: int):
+    with _search_lock:
+        entry = _search_cache.get(key)
+        if entry and (time.time() - entry["time"] < ttl):
+            return entry["data"]
+    return None
+
+
+def search_cache_set(key: str, data) -> None:
+    with _search_lock:
+        _search_cache[key] = {"data": data, "time": time.time()}

tools.py

@@ -0,0 +1,73 @@
+"""Realtime asistan icin tool implementasyonlari.
+
+WhatsApp BF-WAB'da kanitlanmis smart_warehouse_with_price.py'yi kullanir.
+"""
+from __future__ import annotations
+
+import logging
+import re
+
+from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
+
+logger = logging.getLogger(__name__)
+
+
+# ---------- Telaffuz duzeltmeleri ----------
+def apply_pronunciation_fixes(text: str) -> str:
+    if not isinstance(text, str):
+        return text
+    return text.replace("Caddebostan", "Cadde Bostan")
+
+
+# ---------- URL'leri tool sonucundan strip ----------
+def strip_urls(text: str) -> str:
+    """Modelin URL okumamasi icin tool result'undan link satirlari kaldirilir."""
+    if not text:
+        return text
+    text = re.sub(r"(?im)^\s*(?:Link|URL|Url|🔗.*?):.*$", "", text)
+    text = re.sub(r"https?://\S+", "", text)
+    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    return text
+
+
+# ---------- OpenAI realtime tool definition ----------
+TOOLS = [
+    {
+        "type": "function",
+        "name": "get_warehouse_stock",
+        "description": (
+            "Trek bisiklet, aksesuar veya yedek parca icin magaza stok durumu, "
+            "fiyat ve urun linkini getirir. Musteri stok, fiyat veya urun "
+            "varligini sordugunda kullan."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "user_message": {
+                    "type": "string",
+                    "description": (
+                        "Musterinin urun/stok sorusu "
+                        "(orn. 'Madone SLR 9 var mi', 'Marlin 5 fiyat')"
+                    ),
+                }
+            },
+            "required": ["user_message"],
+        },
+    }
+]
+
+
+def handle_tool_call_sync(name: str, arguments: dict) -> str:
+    """Tool dispatcher. Sync — realtime relay'de to_thread ile sarilacak."""
+    try:
+        if name == "get_warehouse_stock":
+            msg = arguments.get("user_message", "")
+            logger.info(f"[tool] get_warehouse_stock query: {msg!r}")
+            result = get_warehouse_stock_smart_with_price(msg)
+            if result is None:
+                return "Stok bilgisi bulunamadi."
+            return apply_pronunciation_fixes(str(result))
+        return f"Bilinmeyen fonksiyon: {name}"
+    except Exception as e:
+        logger.exception(f"Tool call hatasi ({name})")
+        return f"Hata: {e}"

warehouse_stock_finder.py

@@ -1,89 +0,0 @@
-"""Ultra simple and fast warehouse stock finder"""
-
-def get_warehouse_stock(product_name):
-    """Find warehouse stock FAST - no XML parsing, just regex"""
-    try:
-        import re
-        import requests
-        
-        # Get XML
-        url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
-        response = requests.get(url, verify=False, timeout=7)
-        xml_text = response.text
-        
-        # Turkish normalize
-        def normalize(text):
-            tr_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
-            text = text.lower()
-            for tr, en in tr_map.items():
-                text = text.replace(tr, en)
-            return text
-        
-        # Parse query
-        query = normalize(product_name.strip()).replace('(2026)', '').replace('(2025)', '').strip()
-        words = query.split()
-        
-        # Find size
-        sizes = ['s', 'm', 'l', 'xl', 'xs', 'xxl', 'ml']
-        size = next((w for w in words if w in sizes), None)
-        product_words = [w for w in words if w not in sizes and w not in ['beden', 'size', 'boy']]
-        
-        # Build search pattern
-        if 'madone' in product_words and 'sl' in product_words and '6' in product_words:
-            pattern = 'MADONE SL 6 GEN 8'
-        else:
-            pattern = ' '.join(product_words).upper()
-        
-        print(f"DEBUG - Searching: {pattern}, Size: {size}")
-        
-        # Search for product + variant combo
-        if size:
-            # Direct search for product with specific size
-            size_pattern = f'{size.upper()}-'
-            
-            # Find all occurrences of the product name
-            import re
-            product_regex = f'<Product>.*?<ProductName><!\\[CDATA\\[{re.escape(pattern)}\\]\\]></ProductName>.*?<ProductVariant><!\\[CDATA\\[{size_pattern}.*?\\]\\]></ProductVariant>.*?</Product>'
-            
-            match = re.search(product_regex, xml_text, re.DOTALL)
-            
-            if match:
-                product_block = match.group(0)
-                print(f"DEBUG - Found product with {size_pattern} variant")
-                
-                # Extract warehouses
-                warehouse_info = []
-                warehouse_regex = r'<Warehouse>.*?<Name><!\\[CDATA\\[(.*?)\\]\\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
-                warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
-                
-                for wh_name, wh_stock in warehouses:
-                    try:
-                        stock = int(wh_stock.strip())
-                        if stock > 0:
-                            # Format name
-                            if "CADDEBOSTAN" in wh_name:
-                                display = "Caddebostan mağazası"
-                            elif "ORTAKÖY" in wh_name:
-                                display = "Ortaköy mağazası"
-                            elif "ALSANCAK" in wh_name:
-                                display = "İzmir Alsancak mağazası"
-                            elif "BAHCEKOY" in wh_name or "BAHÇEKÖY" in wh_name:
-                                display = "Bahçeköy mağazası"
-                            else:
-                                display = wh_name
-                            
-                            warehouse_info.append(f"{display}: Mevcut")
-                    except:
-                        pass
-                
-                return warehouse_info if warehouse_info else ["Hiçbir mağazada mevcut değil"]
-            else:
-                print(f"DEBUG - No {size_pattern} variant found for {pattern}")
-                return ["Hiçbir mağazada mevcut değil"]
-        else:
-            # No size filter - get all stock
-            return ["Beden bilgisi belirtilmedi"]
-            
-    except Exception as e:
-        print(f"Error: {e}")
-        return None