llms-py 3.0.0__py3-none-any.whl → 3.0.0b1__py3-none-any.whl

{llms_py-3.0.0.dist-info → llms_py-3.0.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llms-py
-Version: 3.0.0
+Version: 3.0.0b1
 Summary: A lightweight CLI tool and OpenAI-compatible server for querying multiple Large Language Model (LLM) providers
 Home-page: https://github.com/ServiceStack/llms
 Author: ServiceStack

llms_py-3.0.0b1.dist-info/RECORD

@@ -0,0 +1,49 @@
+llms/__init__.py,sha256=DKwTZDsyYL_wHe7yvLw49Nf8PSgPSyWaeVdotUqSvrQ,84
+llms/__main__.py,sha256=hrBulHIt3lmPm1BCyAEVtB6DQ0Hvc3gnIddhHCmJasg,151
+llms/index.html,sha256=_pkjdzCX95HTf19LgE4gMh6tLittcnf7M_jL2hSEbbM,3250
+llms/llms.json,sha256=Y_J3Usw0tt96fc7Dp_fY41wjHrIRKbx0gS0-gk2Uoqk,9697
+llms/main.py,sha256=knAHWd0WZO_nSLrAqDVTziPa0CjQfS8Ahsk9vuw510M,117476
+llms/providers.json,sha256=meE6G2vyzfKYmwdml9-O8Pm_uGc520bj891SUjQmsLY,215127
+llms/ui.json,sha256=iBOmpNeD5-o8AgUa51ymS-KemovJ7bm9J1fnL0nf8jk,134025
+llms/ui/Analytics.mjs,sha256=LfWbUlpb__0EEYtHu6e4r8AeyhsNQeAxrg44RuNSR0M,73261
+llms/ui/App.mjs,sha256=L8Zn7b7YVqR5jgVQKvo_txijSd1T7jq6QOQEt7Q0eB0,3811
+llms/ui/Avatar.mjs,sha256=TgouwV9bN-Ou1Tf2zCDtVaRiUB21TXZZPFCTlFL-xxQ,3387
+llms/ui/Brand.mjs,sha256=JLN_lPirNXqS332g0B_WVOlFRVg3lNe1Q56TRnpj0zQ,3411
+llms/ui/ChatPrompt.mjs,sha256=vu05EC_mHdiEBYRHUNMJrmyupfhHVo-MZh4QgvNhrsM,26892
+llms/ui/Main.mjs,sha256=Z5RQfFF7AaXZ-SSMHBnWeiKnXbZP6po1HY28mBGH9Ro,45867
+llms/ui/ModelSelector.mjs,sha256=8WoPrlWXr_kSJN6TFJfGjk6M_GzoEm-trswvprDCwK0,37507
+llms/ui/OAuthSignIn.mjs,sha256=IdA9Tbswlh74a_-9e9YulOpqLfRpodRLGfCZ9sTZ5jU,4879
+llms/ui/ProviderIcon.mjs,sha256=XdEJRm90Zaeu7AlcxfLTXqh_jj2F5JvFkug0XexZeQc,22900
+llms/ui/ProviderStatus.mjs,sha256=Dsr_kzjdYuXNLNIwpcQe3URB4nmBdEEFeU8DgOfWu20,6144
+llms/ui/Recents.mjs,sha256=sRoesSktUvBZ7UjfFJwp0btCQj5eQvnTDjSUDzN8ySU,8864
+llms/ui/SettingsDialog.mjs,sha256=vyqLOrACBICwT8qQ10oJAMOYeA1phrAyz93mZygn-9Y,19956
+llms/ui/Sidebar.mjs,sha256=93wCzrbY4F9VBFGiWujNIj5ynxP_9bmv5pJQOGdybIc,11183
+llms/ui/SignIn.mjs,sha256=df3b-7L3ZIneDGbJWUk93K9RGo40gVeuR5StzT1ZH9g,2324
+llms/ui/SystemPromptEditor.mjs,sha256=PffkNPV6hGbm1QZBKPI7yvWPZSBL7qla0d-JEJ4mxYo,1466
+llms/ui/SystemPromptSelector.mjs,sha256=UgoeuscFes0B1oFkx74dFwC0JgRib37VM4Gy3-kCVDQ,3769
+llms/ui/Welcome.mjs,sha256=r9j7unF9CF3k7gEQBMRMVsa2oSjgHGNn46Oa5l5BwlY,950
+llms/ui/ai.mjs,sha256=GpYD7np2mFb4FX49dzHZCUUrB9-Aj676zf_1ejVp4tA,4839
+llms/ui/app.css,sha256=WrCjd6lJTS6DWuQKUMGPwmrIYCTfauDS_m-ghkoR2qA,119287
+llms/ui/fav.svg,sha256=_R6MFeXl6wBFT0lqcUxYQIDWgm246YH_3hSTW0oO8qw,734
+llms/ui/markdown.mjs,sha256=0LUF2Tyvpv88ic-MjdUjAAdd1Rt8LYA_d7VRA-kBFuM,6518
+llms/ui/tailwind.input.css,sha256=QInTVDpCR89OTzRo9AePdAa-MX3i66RkhNOfa4_7UAg,12086
+llms/ui/threadStore.mjs,sha256=CL-dTxnMJsk9ORDiN80FSgdsdDQEmKsZDKI5fAGCr-o,16706
+llms/ui/typography.css,sha256=6o7pbMIamRVlm2GfzSStpcOG4T5eFCK_WcQ3RIHKAsU,19587
+llms/ui/utils.mjs,sha256=dzBBhltx8bUPasFAM3VRsobbDOesBd2M3mjuYdwAExA,7283
+llms/ui/lib/chart.js,sha256=dx8FdDX0Rv6OZtZjr9FQh5h-twFsKjfnb-FvFlQ--cU,196176
+llms/ui/lib/charts.mjs,sha256=MNym9qE_2eoH6M7_8Gj9i6e6-Y3b7zw9UQWCUHRF6x0,1088
+llms/ui/lib/color.js,sha256=DDG7Pr-qzJHTPISZNSqP_qJR8UflKHEc_56n6xrBugQ,8273
+llms/ui/lib/highlight.min.mjs,sha256=sG7wq8bF-IKkfie7S4QSyh5DdHBRf0NqQxMOEH8-MT0,127458
+llms/ui/lib/idb.min.mjs,sha256=CeTXyV4I_pB5vnibvJuyXdMs0iVF2ZL0Z7cdm3w_QaI,3853
+llms/ui/lib/marked.min.mjs,sha256=QRHb_VZugcBJRD2EP6gYlVFEsJw5C2fQ8ImMf_pA2_s,39488
+llms/ui/lib/servicestack-client.mjs,sha256=UVafVbzhJ_0N2lzv7rlzIbzwnWpoqXxGk3N3FSKgOOc,54534
+llms/ui/lib/servicestack-vue.mjs,sha256=unTA8lM0tKy2PwZiJ8UEvrTuGmei8jNZnmmuQ5MKyV4,216753
+llms/ui/lib/vue-router.min.mjs,sha256=fR30GHoXI1u81zyZ26YEU105pZgbbAKSXbpnzFKIxls,30418
+llms/ui/lib/vue.min.mjs,sha256=iXh97m5hotl0eFllb3aoasQTImvp7mQoRJ_0HoxmZkw,163811
+llms/ui/lib/vue.mjs,sha256=dS8LKOG01t9CvZ04i0tbFXHqFXOO_Ha4NmM3BytjQAs,537071
+llms_py-3.0.0b1.dist-info/licenses/LICENSE,sha256=bus9cuAOWeYqBk2OuhSABVV1P4z7hgrEFISpyda_H5w,1532
+llms_py-3.0.0b1.dist-info/METADATA,sha256=jS7M9B8ThKrqFC_Uzuk_fYmbzo3eNNDqiAj6aJY7cZw,2193
+llms_py-3.0.0b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+llms_py-3.0.0b1.dist-info/entry_points.txt,sha256=WswyE7PfnkZMIxboC-MS6flBD6wm-CYU7JSUnMhqMfM,40
+llms_py-3.0.0b1.dist-info/top_level.txt,sha256=gC7hk9BKSeog8gyg-EM_g2gxm1mKHwFRfK-10BxOsa4,5
+llms_py-3.0.0b1.dist-info/RECORD,,

llms/extensions/app/README.md

@@ -1,20 +0,0 @@
-# App Extension
-
-This extension provides the core application logic and data persistence for the LLMs platform.
-
-## Data Storage & Architecture
-
-### Server-Side SQLite Migration
-The application has migrated from client-side IndexedDB storage to a robust server-side SQLite solution. This architectural shift ensures better data consistency, improved performance, and enables multi-device access to your chat history.
-
-### Asset Management
-To keep the database efficient and portable, binary assets (images, audio, etc.) are not stored directly in the SQLite database. Instead:
-- All generated assets are stored in the local file system cache at `~/.llms/cache`.
-- The database stores only **relative URLs** pointing to these assets.
-- This approach allows for efficient caching and serving of static media.
-
-### Concurrency Model
-To ensure data integrity and high performance without complex locking mechanisms, the system utilizes a **single background thread** for managing all write operations to the database. This design improves concurrency handling and eliminates database locking issues during high-load scenarios.
-
-### Multi-Tenancy & Security
-When authentication is enabled, data isolation is automatically enforced. All core tables, including `threads` and `requests`, are scoped to the authenticated user, ensuring that users can only access their own data.

llms/extensions/app/__init__.py

@@ -1,530 +0,0 @@
-import asyncio
-import json
-import os
-import time
-from datetime import datetime
-from typing import Any
-
-from aiohttp import web
-
-g_db = None
-
-try:
-    from llms.extensions.app.db import AppDB
-except ImportError as e:
-    print(f"Failed to import AppDB: {e}")
-    AppDB = None
-
-
-def install(ctx):
-    def get_db():
-        global g_db
-        if g_db is None and AppDB:
-            try:
-                db_path = os.path.join(ctx.get_user_path(), "app", "app.sqlite")
-                g_db = AppDB(ctx, db_path)
-                ctx.register_shutdown_handler(g_db.close)
-
-                threads_json = "/home/mythz/src/ServiceStack/llms/llms/extensions/app/threads.json"
-                requests_json = "/home/mythz/src/ServiceStack/llms/llms/extensions/app/requests.json"
-                with open(threads_json) as f:
-                    threads = json.load(f)["threads"]
-                    threads.reverse()
-                with open(requests_json) as f:
-                    requests = json.load(f)["requests"]
-                    requests.reverse()
-                # g_db.import_db(threads, requests)
-
-            except Exception as e:
-                ctx.err("Failed to init AppDB", e)
-        return g_db
-
-    if not get_db():
-        return
-
-    def to_dto(row, json_columns):
-        # as=column -> [0,1,2]
-        if not isinstance(row, dict):
-            return row
-
-        to = {}
-        for k, v in row.items():
-            if k in json_columns and v is not None and isinstance(v, str):
-                try:
-                    to[k] = json.loads(v)
-                except Exception as e:
-                    ctx.err(f"Failed to parse JSON for {k}: {v} ({type(v)})", e)
-                    to[k] = v
-            else:
-                to[k] = v
-        return to
-
-    def thread_dto(row):
-        return row and to_dto(row, ["messages", "modalities", "args", "modelInfo", "stats", "metadata"])
-
-    def request_dto(row):
-        return row and to_dto(row, ["usage"])
-
-    def prompt_to_title(prompt):
-        return prompt[:100] + ("..." if len(prompt) > 100 else "") if prompt else None
-
-    def timestamp_messages(messages):
-        timestamp = int(time.time() * 1000)
-        for message in messages:
-            if "timestamp" not in message:
-                message["timestamp"] = timestamp
-                timestamp += 1  # make unique
-        return messages
-
-    async def query_threads(request):
-        rows = g_db.query_threads(request.query, user=ctx.get_username(request))
-        dtos = [thread_dto(row) for row in rows]
-        return web.json_response(dtos)
-
-    ctx.add_get("threads", query_threads)
-
-    async def create_thread(request):
-        thread = await request.json()
-        id = await g_db.create_thread_async(thread, user=ctx.get_username(request))
-        row = g_db.get_thread(id, user=ctx.get_username(request))
-        return web.json_response(thread_dto(row) if row else "")
-
-    ctx.add_post("threads", create_thread)
-
-    async def update_thread(request):
-        thread = await request.json()
-        id = request.match_info["id"]
-        update_count = await g_db.update_thread_async(id, thread, user=ctx.get_username(request))
-        if update_count == 0:
-            raise Exception("Thread not found")
-        row = g_db.get_thread(id, user=ctx.get_username(request))
-        return web.json_response(thread_dto(row) if row else "")
-
-    ctx.add_patch("threads/{id}", update_thread)
-
-    async def delete_thread(request):
-        id = request.match_info["id"]
-        g_db.delete_thread(id, user=ctx.get_username(request))
-        return web.json_response({})
-
-    ctx.add_delete("threads/{id}", delete_thread)
-
-    async def queue_chat_handler(request):
-        # Check authentication if enabled
-        is_authenticated, user_data = ctx.check_auth(request)
-        if not is_authenticated:
-            return web.json_response(ctx.error_auth_required, status=401)
-
-        if not request.body_exists:
-            raise Exception("messages required")
-
-        chat = await request.json()
-
-        messages = timestamp_messages(chat.get("messages", []))
-        if len(messages) == 0:
-            raise Exception("messages required")
-
-        id = request.match_info["id"]
-        thread = thread_dto(g_db.get_thread(id, user=ctx.get_username(request)))
-        if not thread:
-            raise Exception("Thread not found")
-
-        update_thread = {
-            "messages": messages,
-            "startedAt": datetime.now(),
-            "completedAt": None,
-            "error": None,
-        }
-
-        model = chat.get("model", None)
-        if model:
-            update_thread["model"] = model
-        metadata = chat.get("metadata", {})
-        if len(metadata) > 0:
-            update_thread["metadata"] = metadata
-        if chat.get("modalities") or not thread.get("modalities"):
-            update_thread["modalities"] = chat.get("modalities", ["text"])
-        system_prompt = ctx.chat_to_system_prompt(chat)
-        if system_prompt:
-            update_thread["systemPrompt"] = system_prompt
-
-        args = thread.get("args") or {}
-        for k, v in chat.items():
-            if k in ctx.request_args:
-                args[k] = v
-        update_thread["args"] = args
-
-        # allow chat to override thread title
-        title = chat.get("title")
-        if title:
-            update_thread["title"] = title
-        else:
-            # only update thread title if it's not already set
-            title = thread.get("title")
-            if not title:
-                update_thread["title"] = title = prompt_to_title(ctx.last_user_prompt(chat))
-
-        user = ctx.get_username(request)
-        await g_db.update_thread_async(
-            id,
-            update_thread,
-            user=user,
-        )
-        thread = thread_dto(g_db.get_thread(id, user=user))
-        if not thread:
-            raise Exception("Thread not found")
-
-        metadata = thread.get("metadata", {})
-        chat = {
-            "model": thread.get("model"),
-            "messages": thread.get("messages"),
-            "modalities": thread.get("modalities"),
-            "systemPrompt": thread.get("systemPrompt"),
-            "metadata": metadata,
-        }
-        for k, v in thread.get("args", {}).items():
-            if k in ctx.request_args:
-                chat[k] = v
-
-        context = {
-            "chat": chat,
-            "user": user,
-            "threadId": id,
-            "metadata": metadata,
-            "tools": metadata.get("tools", "all"),
-        }
-
-        # execute chat in background thread
-        async def run_chat(chat_req, context_req):
-            try:
-                await ctx.chat_completion(chat_req, context=context_req)
-            except Exception as ex:
-                ctx.err("run_chat", ex)
-                # not necessary to update thread in db with error as it's done in chat_error filter
-
-        asyncio.create_task(run_chat(chat, context))
-
-        return web.json_response(thread_dto(thread))
-
-    ctx.add_post("threads/{id}/chat", queue_chat_handler)
-
-    async def get_thread_updates(request):
-        id = request.match_info["id"]
-        after = request.query.get("after", None)
-        user = ctx.get_username(request)
-        thread = g_db.get_thread(id, user=user)
-        if not thread:
-            raise Exception("Thread not found")
-        if after:
-            started = time.time()
-            thread_id = thread.get("id")
-            thread_updated_at = thread.get("updatedAt")
-
-            while thread_updated_at <= after:
-                thread_updated_at = g_db.get_thread_column(thread_id, "updatedAt", user=user)
-                # if thread is not updated in 30 seconds, break
-                if time.time() - started > 10:
-                    break
-                await asyncio.sleep(1)
-            ctx.dbg(f"get_thread_updates: {thread_id} / {thread_updated_at} < {after} / {thread_updated_at < after}")
-            thread = g_db.get_thread(thread_id, user=user)
-        return web.json_response(thread_dto(thread))
-
-    ctx.add_get("threads/{id}/updates", get_thread_updates)
-
-    async def cancel_thread(request):
-        id = request.match_info["id"]
-        await g_db.update_thread_async(
-            id, {"completedAt": datetime.now(), "error": "Request was canceled"}, user=ctx.get_username(request)
-        )
-        thread = g_db.get_thread(id, user=ctx.get_username(request))
-        ctx.dbg(f"cancel_thread: {id} / {thread.get('error')} / {thread.get('completedAt')}")
-        return web.json_response(thread_dto(thread))
-
-    ctx.add_post("threads/{id}/cancel", cancel_thread)
-
-    async def query_requests(request):
-        rows = g_db.query_requests(request.query, user=ctx.get_username(request))
-        dtos = [request_dto(row) for row in rows]
-        return web.json_response(dtos)
-
-    ctx.add_get("requests", query_requests)
-
-    async def delete_request(request):
-        id = request.match_info["id"]
-        g_db.delete_request(id, user=ctx.get_username(request))
-        return web.json_response({})
-
-    ctx.add_delete("requests/{id}", delete_request)
-
-    async def requests_summary(request):
-        rows = g_db.get_request_summary(user=ctx.get_username(request))
-        stats = {
-            "dailyData": {},
-            "years": [],
-            "totalCost": 0,
-            "totalRequests": 0,
-            "totalInputTokens": 0,
-            "totalOutputTokens": 0,
-        }
-        years = set()
-        for row in rows:
-            date = row["date"]
-            year = int(date[:4])
-            years.add(year)
-            stats["dailyData"][date] = {
-                "cost": row["cost"],
-                "requests": row["requests"],
-                "inputTokens": row["inputTokens"],
-                "outputTokens": row["outputTokens"],
-            }
-            stats["totalCost"] += row["cost"] or 0
-            stats["totalRequests"] += row["requests"] or 0
-            stats["totalInputTokens"] += row["inputTokens"] or 0
-            stats["totalOutputTokens"] += row["outputTokens"] or 0
-
-        stats["years"] = sorted(years)
-        return web.json_response(stats)
-
-    ctx.add_get("requests/summary", requests_summary)
-
-    async def daily_requests_summary(request):
-        day = request.match_info["day"]
-        summary = g_db.get_daily_request_summary(day, user=ctx.get_username(request))
-        return web.json_response(summary)
-
-    ctx.add_get("requests/summary/{day}", daily_requests_summary)
-
-    async def chat_request(openai_request, context):
-        chat = openai_request
-        user = context.get("user", None)
-        provider = context.get("provider", None)
-        thread_id = context.get("threadId", None)
-        model_info = context.get("modelInfo", None)
-
-        metadata = chat.get("metadata", {})
-        model = chat.get("model", None)
-        messages = timestamp_messages(chat.get("messages", []))
-        title = context.get("title") or prompt_to_title(ctx.last_user_prompt(chat) if chat else None)
-        started_at = context.get("startedAt")
-        if not started_at:
-            context["startedAt"] = started_at = datetime.now()
-        if thread_id is None:
-            thread = {
-                "user": user,
-                "model": model,
-                "provider": provider,
-                "modelInfo": model_info,
-                "title": title,
-                "messages": messages,
-                "systemPrompt": ctx.chat_to_system_prompt(chat),
-                "modalities": chat.get("modalities", ["text"]),
-                "startedAt": started_at,
-                "metadata": metadata,
-            }
-            thread_id = await g_db.create_thread_async(thread, user=user)
-            context["threadId"] = thread_id
-        else:
-            update_thread = {
-                "model": model,
-                "provider": provider,
-                "modelInfo": model_info,
-                "startedAt": started_at,
-                "messages": messages,
-                "completedAt": None,
-                "error": None,
-                "metadata": metadata,
-            }
-            await g_db.update_thread_async(thread_id, update_thread, user=user)
-
-        completed_at = g_db.get_thread_column(thread_id, "completedAt", user=user)
-        if completed_at:
-            context["completed"] = True
-
-    ctx.register_chat_request_filter(chat_request)
-
-    async def tool_request(chat_request, context):
-        messages = chat_request.get("messages", [])
-        ctx.dbg(f"tool_request: messages {len(messages)}")
-        thread_id = context.get("threadId", None)
-        if not thread_id:
-            ctx.dbg("Missing threadId")
-            return
-        user = context.get("user", None)
-        await g_db.update_thread_async(
-            thread_id,
-            {
-                "messages": messages,
-            },
-            user=user,
-        )
-
-        completed_at = g_db.get_thread_column(thread_id, "completedAt", user=user)
-        if completed_at:
-            context["completed"] = True
-
-    ctx.register_chat_tool_filter(tool_request)
-
-    async def chat_response(openai_response, context):
-        ctx.dbg("create_response")
-        o = openai_response
-        chat = context.get("chat")
-        usage = o.get("usage", None)
-        if not usage and not chat:
-            ctx.dbg("Missing chat and usage")
-            return
-
-        user = context.get("user", None)
-        thread_id = context.get("threadId", None)
-        provider = context.get("provider", None)
-        model_info = context.get("modelInfo", None)
-        model_cost = context.get("modelCost", model_info.get("cost", None)) or {"input": 0, "output": 0}
-        duration = context.get("duration", 0)
-
-        metadata = o.get("metadata", {})
-        choices = o.get("choices", [])
-        tasks = []
-        title = context.get("title") or prompt_to_title(ctx.last_user_prompt(chat) if chat else None)
-        completed_at = datetime.now()
-
-        model = model_info.get("name") or model_info.get("id")
-        finish_reason = choices[0].get("finish_reason", None) if len(choices) > 0 else None
-        input_price = model_cost.get("input", 0)
-        output_price = model_cost.get("output", 0)
-        input_tokens = usage.get("prompt_tokens", 0)
-        output_tokens = usage.get("completion_tokens", 0)
-        total_tokens = usage.get("total_tokens", input_tokens + output_tokens)
-        cost = o.get("cost", ((input_price * input_tokens) + (output_price * output_tokens)) / 1000000)
-
-        request = {
-            "user": user,
-            "model": model,
-            "duration": duration,
-            "cost": cost,
-            "inputPrice": input_price,
-            "inputTokens": input_tokens,
-            "inputCachedTokens": usage.get("inputCachedTokens", 0),
-            "outputPrice": output_price,
-            "outputTokens": output_tokens,
-            "finishReason": finish_reason,
-            "provider": provider,
-            "providerModel": o.get("model", None),
-            "providerRef": o.get("provider", None),
-            "threadId": thread_id,
-            "title": title,
-            "startedAt": context.get("startedAt"),
-            "totalTokens": total_tokens,
-            "usage": usage,
-            "completedAt": completed_at,
-            "toolHistory": o.get("tool_history", None),
-            "ref": o.get("id", None),
-        }
-        tasks.append(g_db.create_request_async(request, user=user))
-
-        if thread_id:
-            messages = chat.get("messages", [])
-            last_role = messages[-1].get("role", None) if len(messages) > 0 else None
-            if last_role == "user" or last_role == "tool":
-                user_message = messages[-1]
-                user_message["model"] = model
-                user_message["usage"] = {
-                    "tokens": input_tokens,
-                    "price": input_price,
-                    "cost": (input_price * input_tokens) / 1000000,
-                }
-            else:
-                ctx.dbg(
-                    f"Missing user message for thread {thread_id}, {len(messages)} messages, last role: {last_role}"
-                )
-            assistant_message = ctx.chat_response_to_message(o)
-            assistant_message["model"] = model
-            assistant_message["usage"] = {
-                "tokens": output_tokens,
-                "price": output_price,
-                "cost": (output_price * output_tokens) / 1000000,
-                "duration": duration,
-            }
-            messages.append(assistant_message)
-
-            update_thread = {
-                "model": model,
-                "providerModel": o.get("model"),
-                "modelInfo": model_info,
-                "messages": messages,
-                "completedAt": completed_at,
-            }
-            if "error" in metadata:
-                update_thread["error"] = metadata["error"]
-            tasks.append(g_db.update_thread_async(thread_id, update_thread, user=user))
-        else:
-            ctx.dbg("Missing thread_id")
-
-        await asyncio.gather(*tasks)
-
-        # Update thread costs from all thread requests
-        thread_requests = g_db.query_requests({"threadId": thread_id}, user=user)
-        total_costs = 0
-        total_input = 0
-        total_output = 0
-        for request in thread_requests:
-            total_costs += request.get("cost", 0) or 0
-            total_input += request.get("inputTokens", 0) or 0
-            total_output += request.get("outputTokens", 0) or 0
-        stats = {
-            "inputTokens": total_input,
-            "outputTokens": total_output,
-            "cost": total_costs,
-            "duration": duration,
-            "requests": len(thread_requests),
-        }
-        g_db.update_thread(
-            thread_id,
-            {
-                "inputTokens": total_input,
-                "outputTokens": total_output,
-                "cost": total_costs,
-                "stats": stats,
-            },
-            user=user,
-        )
-
-    ctx.register_chat_response_filter(chat_response)
-
-    async def chat_error(e: Exception, context: Any):
-        error = ctx.error_message(e)
-        ctx.dbg(f"Chat error: {error}")
-        chat = context.get("chat")
-        if not chat:
-            ctx.dbg("Missing chat")
-            return
-
-        title = context.get("title") or prompt_to_title(ctx.last_user_prompt(chat) if chat else None)
-        completed_at = datetime.now()
-        user = context.get("user", None)
-
-        thread_id = context.get("threadId", None)
-        tasks = []
-        if thread_id:
-            tasks.append(g_db.update_thread_async(thread_id, {"completedAt": completed_at, "error": error}, user=user))
-        else:
-            ctx.dbg("Missing threadId")
-
-        request = {
-            "user": user,
-            "model": chat.get("model", None),
-            "title": title,
-            "threadId": thread_id,
-            "startedAt": context.get("startedAt"),
-            "completedAt": completed_at,
-            "error": error,
-            "stackTrace": context.get("stackTrace", None),
-        }
-        tasks.append(g_db.create_request_async(request, user=user))
-
-        if len(tasks) > 0:
-            await asyncio.gather(*tasks)
-
-    ctx.register_chat_error_filter(chat_error)
-
-
-__install__ = install