llms-py 2.0.14__py3-none-any.whl → 2.0.16__py3-none-any.whl

{llms_py-2.0.14.data/data → llms}/ui/tailwind.input.css

@@ -1,6 +1,6 @@
 /* tailwindcss -i ./tailwind.input.css -o ./ui/app.css --watch */
 @import "tailwindcss";
-@source "./lib/servicestack-vue.min.mjs";
+@source "./lib/servicestack-vue.mjs";
 
 @custom-variant dark (&:where(.dark, .dark *));
 

llms/ui/threadStore.mjs

@@ -0,0 +1,524 @@
+import { ref, computed, unref } from 'vue'
+import { openDB } from 'idb'
+import { nextId, toModelInfo } from './utils.mjs'
+
+// Thread store for managing chat threads with IndexedDB
+const threads = ref([])
+const currentThread = ref(null)
+const isLoading = ref(false)
+
+let db = null
+
+// Initialize IndexedDB
+async function initDB() {
+    if (db) return db
+    
+    db = await openDB('LlmsThreads', 3, {
+        upgrade(db, _oldVersion, _newVersion, transaction) {
+            if (!db.objectStoreNames.contains('threads')) {
+                // Create threads store
+                const threadStore = db.createObjectStore('threads', {
+                    keyPath: 'id',
+                    autoIncrement: false
+                })
+
+                // Create indexes for efficient querying
+                threadStore.createIndex('createdAt', 'createdAt')
+                threadStore.createIndex('updatedAt', 'updatedAt')
+                threadStore.createIndex('title', 'title')
+            }
+            if (!db.objectStoreNames.contains('requests')) {
+                // Create requests store
+                const requestStore = db.createObjectStore('requests', {
+                    keyPath: 'id',
+                    autoIncrement: false
+                })
+                requestStore.createIndex('threadId', 'threadId')
+                requestStore.createIndex('model', 'model')
+                requestStore.createIndex('provider', 'provider')
+                requestStore.createIndex('inputTokens', 'inputTokens')
+                requestStore.createIndex('outputTokens', 'outputTokens')
+                requestStore.createIndex('cost', 'cost')
+                requestStore.createIndex('duration', 'duration')
+                requestStore.createIndex('created', 'created')
+            }
+        }
+    })
+    
+    return db
+}
+
+// Generate unique thread ID
+function generateThreadId() {
+    return Date.now().toString()
+}
+
+async function logRequest(threadId, model, request, response) {
+    await initDB()
+    const metadata = response.metadata || {}
+    const usage = response.usage || {}
+    const [inputPrice, outputPrice] = metadata.pricing ? metadata.pricing.split('/') : [0, 0]
+    const lastUserContent = request.messages?.slice().reverse().find(m => m.role === 'user')?.content
+    const content = Array.isArray(lastUserContent) 
+        ? lastUserContent.filter(c => c?.text).map(c => c.text).join(' ') 
+        : lastUserContent
+    const title = content.slice(0, 100) + (content.length > 100 ? '...' : '')
+    const inputTokens = usage?.prompt_tokens ?? 0
+    const outputTokens = usage?.completion_tokens ?? 0
+    const inputCachedTokens = usage?.prompt_token_details?.cached_tokens ?? 0
+    const finishReason = response.choices[0]?.finish_reason || 'unknown'
+
+    const subtractDays = (date, days) => {
+        const result = new Date(date * 1000)
+        result.setDate(result.getDate() - days)
+        return parseInt(result.valueOf() / 1000)
+    }
+
+    const log = {
+        id: nextId(),
+        threadId: threadId,
+        model: model.id,
+        provider: model.provider,
+        providerModel: response.model || model.provider_model,
+        title,
+        inputTokens,
+        outputTokens,
+        inputCachedTokens,
+        totalTokens: usage.total_tokens ?? (inputTokens + outputTokens),
+        inputPrice,
+        outputPrice,
+        cost: (parseFloat(inputPrice) * inputTokens) + (parseFloat(outputPrice) * outputTokens),
+        duration: metadata.duration ?? 0,
+        created: subtractDays(response.created ?? Math.floor(Date.now() / 1000), 1),
+        finishReason,
+        providerRef: response.provider,
+        ref: response.id || undefined,
+        usage: usage,
+    }
+    console.debug('logRequest', log)
+    const tx = db.transaction(['requests'], 'readwrite')
+    await tx.objectStore('requests').add(log)
+    await tx.complete
+    return log
+}
+
+// Create a new thread
+async function createThread(title = 'New Chat', model = null, systemPrompt = '') {
+    await initDB()
+
+    const thread = {
+        id: generateThreadId(),
+        title: title,
+        model: model?.id ?? '',
+        info: toModelInfo(model),
+        systemPrompt: systemPrompt,
+        messages: [],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+    }
+    
+    const tx = db.transaction(['threads'], 'readwrite')
+    await tx.objectStore('threads').add(thread)
+    await tx.complete
+    
+    threads.value.unshift(thread)
+    // Note: currentThread will be set by router navigation
+
+    return thread
+}
+
+// Update thread
+async function updateThread(threadId, updates) {
+    await initDB()
+    
+    const tx = db.transaction(['threads'], 'readwrite')
+    const store = tx.objectStore('threads')
+    
+    const thread = await store.get(threadId)
+    if (!thread) throw new Error('Thread not found')
+    
+    const updatedThread = {
+        ...thread,
+        ...updates,
+        updatedAt: new Date().toISOString()
+    }
+    
+    await store.put(updatedThread)
+    await tx.complete
+    
+    // Update in memory
+    const index = threads.value.findIndex(t => t.id === threadId)
+    if (index !== -1) {
+        threads.value[index] = updatedThread
+    }
+    
+    if (currentThread.value?.id === threadId) {
+        currentThread.value = updatedThread
+    }
+    
+    return updatedThread
+}
+
+async function calculateThreadStats(threadId) {
+    await initDB()
+    
+    const tx = db.transaction(['requests'], 'readonly')
+    const store = tx.objectStore('requests')
+    const index = store.index('threadId')
+    
+    const requests = await index.getAll(threadId)
+    
+    let inputTokens = 0
+    let outputTokens = 0
+    let cost = 0.0
+    let duration = 0
+    
+    requests.forEach(req => {
+        inputTokens += req.inputTokens || 0
+        outputTokens += req.outputTokens || 0
+        cost += req.cost || 0.0
+        duration += req.duration || 0
+    })
+    
+    return {
+        inputTokens,
+        outputTokens,
+        cost,
+        duration,
+        requests: requests.length
+    }
+}
+
+// Add message to thread
+async function addMessageToThread(threadId, message, usage) {
+    const thread = await getThread(threadId)
+    if (!thread) throw new Error('Thread not found')
+    
+    const newMessage = {
+        id: nextId(),
+        timestamp: new Date().toISOString(),
+        ...message
+    }
+    
+    // Add input and output token usage to previous 'input' message
+    if (usage?.prompt_tokens != null) {
+        const lastMessage = thread.messages[thread.messages.length - 1]
+        if (lastMessage && lastMessage.role === 'user') {
+            lastMessage.usage = {
+                tokens: parseInt(usage.prompt_tokens),
+                price: usage.input || '0',
+            }
+        }
+    }
+    if (usage?.completion_tokens != null) {
+        newMessage.usage = {
+            tokens: parseInt(usage.completion_tokens),
+            price: usage.output || '0',
+            duration: usage.duration || undefined,
+        }
+    }
+
+    const updatedMessages = [...thread.messages, newMessage]
+    
+    // Auto-generate title from first user message if still "New Chat"
+    let title = thread.title
+    if (title === 'New Chat' && message.role === 'user' && updatedMessages.length <= 2) {
+        title = message.content.slice(0, 200) + (message.content.length > 200 ? '...' : '')
+    }
+
+    const stats = await calculateThreadStats(threadId)
+    
+    await updateThread(threadId, {
+        messages: updatedMessages,
+        title: title,
+        stats,
+    })
+    
+    return newMessage
+}
+
+async function deleteMessageFromThread(threadId, messageId) {
+    const thread = await getThread(threadId)
+    if (!thread) throw new Error('Thread not found')
+    const updatedMessages = thread.messages.filter(m => m.id !== messageId)
+    await updateThread(threadId, { messages: updatedMessages })
+}
+
+async function updateMessageInThread(threadId, messageId, updates) {
+    const thread = await getThread(threadId)
+    if (!thread) throw new Error('Thread not found')
+
+    const messageIndex = thread.messages.findIndex(m => m.id === messageId)
+    if (messageIndex === -1) throw new Error('Message not found')
+
+    const updatedMessages = [...thread.messages]
+    updatedMessages[messageIndex] = {
+        ...updatedMessages[messageIndex],
+        ...updates
+    }
+
+    await updateThread(threadId, { messages: updatedMessages })
+}
+
+async function redoMessageFromThread(threadId, messageId) {
+    const thread = await getThread(threadId)
+    if (!thread) throw new Error('Thread not found')
+
+    // Find the index of the message to redo
+    const messageIndex = thread.messages.findIndex(m => m.id === messageId)
+    if (messageIndex === -1) throw new Error('Message not found')
+
+    // Keep only messages up to and including the target message
+    const updatedMessages = thread.messages.slice(0, messageIndex + 1)
+
+    // Update the thread with the new messages
+    await updateThread(threadId, { messages: updatedMessages })
+}
+
+// Get all threads
+async function loadThreads() {
+    await initDB()
+    isLoading.value = true
+    
+    try {
+        const tx = db.transaction(['threads'], 'readonly')
+        const store = tx.objectStore('threads')
+        const index = store.index('updatedAt')
+        
+        const allThreads = await index.getAll()
+        threads.value = allThreads.reverse() // Most recent first
+        
+        return threads.value
+    } finally {
+        isLoading.value = false
+    }
+}
+
+// Get single thread
+async function getThread(threadId) {
+    await initDB()
+    
+    const tx = db.transaction(['threads'], 'readonly')
+    const thread = await tx.objectStore('threads').get(threadId)
+    
+    return thread
+}
+
+// Delete thread
+async function deleteThread(threadId) {
+    await initDB()
+    
+    const tx = db.transaction(['threads'], 'readwrite')
+    await tx.objectStore('threads').delete(threadId)
+    await tx.complete
+    
+    threads.value = threads.value.filter(t => t.id !== threadId)
+    
+    if (currentThread.value?.id === threadId) {
+        currentThread.value = null
+    }
+}
+
+// Set current thread
+async function setCurrentThread(threadId) {
+    const thread = await getThread(threadId)
+    if (thread) {
+        currentThread.value = thread
+    }
+    return thread
+}
+
+// Set current thread from router params (router-aware version)
+async function setCurrentThreadFromRoute(threadId, router) {
+    if (!threadId) {
+        currentThread.value = null
+        return null
+    }
+
+    const thread = await getThread(threadId)
+    if (thread) {
+        currentThread.value = thread
+        return thread
+    } else {
+        // Thread not found, redirect to home
+        if (router) {
+            router.push((globalThis.ai?.base || '') + '/')
+        }
+        currentThread.value = null
+        return null
+    }
+}
+
+// Clear current thread (go back to initial state)
+function clearCurrentThread() {
+    currentThread.value = null
+}
+
+function getGroupedThreads(total) {
+    const now = new Date()
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
+    const lastWeek = new Date(today.getTime() - 7 * 24 * 60 * 60 * 1000)
+    const lastMonth = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1000)
+    
+    const groups = {
+        today: [],
+        lastWeek: [],
+        lastMonth: [],
+        older: {}
+    }
+    
+    const takeThreads = threads.value.slice(0, total)
+
+    takeThreads.forEach(thread => {
+        const threadDate = new Date(thread.updatedAt)
+        
+        if (threadDate >= today) {
+            groups.today.push(thread)
+        } else if (threadDate >= lastWeek) {
+            groups.lastWeek.push(thread)
+        } else if (threadDate >= lastMonth) {
+            groups.lastMonth.push(thread)
+        } else {
+            const year = threadDate.getFullYear()
+            const month = threadDate.toLocaleString('default', { month: 'long' })
+            const key = `${month} ${year}`
+            
+            if (!groups.older[key]) {
+                groups.older[key] = []
+            }
+            groups.older[key].push(thread)
+        }
+    })
+    
+    return groups
+}
+
+// Group threads by time periods
+const groupedThreads = computed(() => getGroupedThreads(threads.value.length))
+
+// Query requests with pagination and filtering
+async function getRequests(filters = {}, limit = 20, offset = 0) {
+    try {
+        await initDB()
+
+        const {
+            model = null,
+            provider = null,
+            threadId = null,
+            sortBy = 'created',
+            sortOrder = 'desc',
+            startDate = null,
+            endDate = null
+        } = filters
+
+        const tx = db.transaction(['requests'], 'readonly')
+        const store = tx.objectStore('requests')
+
+        // Get all requests and filter in memory (IndexedDB limitations)
+        const allRequests = await store.getAll()
+
+        // Apply filters
+        let results = allRequests.filter(req => {
+            if (model && req.model !== model) return false
+            if (provider && req.provider !== provider) return false
+            if (threadId && req.threadId !== threadId) return false
+            if (startDate && req.created < startDate) return false
+            if (endDate && req.created > endDate) return false
+            return true
+        })
+
+        // Sort
+        results.sort((a, b) => {
+            let aVal = a[sortBy]
+            let bVal = b[sortBy]
+
+            if (sortOrder === 'desc') {
+                return bVal - aVal
+            } else {
+                return aVal - bVal
+            }
+        })
+
+        // Paginate
+        const total = results.length
+        const paginatedResults = results.slice(offset, offset + limit)
+
+        return {
+            requests: paginatedResults,
+            total,
+            hasMore: offset + limit < total
+        }
+    } catch (error) {
+        console.error('Error in getRequests:', error)
+        return {
+            requests: [],
+            total: 0,
+            hasMore: false
+        }
+    }
+}
+
+// Get unique values for filter options
+async function getFilterOptions() {
+    try {
+        await initDB()
+
+        const tx = db.transaction(['requests'], 'readonly')
+        const store = tx.objectStore('requests')
+        const allRequests = await store.getAll()
+
+        const models = [...new Set(allRequests.map(r => r.model).filter(m => m))].sort()
+        const providers = [...new Set(allRequests.map(r => r.provider).filter(p => p))].sort()
+
+        return {
+            models,
+            providers
+        }
+    } catch (error) {
+        console.error('Error in getFilterOptions:', error)
+        return {
+            models: [],
+            providers: []
+        }
+    }
+}
+
+// Delete a request by ID
+async function deleteRequest(requestId) {
+    await initDB()
+
+    const tx = db.transaction(['requests'], 'readwrite')
+    await tx.objectStore('requests').delete(requestId)
+    await tx.complete
+}
+
+// Export the store
+export function useThreadStore() {
+    return {
+        // State
+        threads,
+        currentThread,
+        isLoading,
+        groupedThreads,
+
+        // Actions
+        initDB,
+        logRequest,
+        createThread,
+        updateThread,
+        addMessageToThread,
+        deleteMessageFromThread,
+        updateMessageInThread,
+        redoMessageFromThread,
+        loadThreads,
+        getThread,
+        deleteThread,
+        setCurrentThread,
+        setCurrentThreadFromRoute,
+        clearCurrentThread,
+        getGroupedThreads,
+        getRequests,
+        getFilterOptions,
+        deleteRequest,
+    }
+}

{llms_py-2.0.14.data/data → llms}/ui/utils.mjs

@@ -54,6 +54,42 @@ export function fileToDataUri(file) {
   })
 }
 
+export function toModelInfo(model) {
+    if (!model) return undefined
+    return Object.assign({}, model, { pricing: Object.assign({}, model.pricing) || undefined })
+}
+
+const numFmt = new Intl.NumberFormat(undefined,{style:'currency',currency:'USD', maximumFractionDigits:6})
+export function tokenCost(price) {
+    if (!price) return ''
+    var ret = numFmt.format(parseFloat(price))
+    return ret.endsWith('.00') ? ret.slice(0, -3) : ret
+}
+export function formatCost(cost) {
+    if (!cost) return ''
+    return numFmt.format(parseFloat(cost))
+}
+export function statsTitle(stats) {
+    let title = []
+    // Each stat on its own line
+    if (stats.cost) {
+        title.push(`Total Cost: ${formatCost(stats.cost)}`)
+    }
+    if (stats.inputTokens) {
+        title.push(`Input Tokens: ${stats.inputTokens}`)
+    }
+    if (stats.outputTokens) {
+        title.push(`Output Tokens: ${stats.outputTokens}`)
+    }
+    if (stats.requests) {
+        title.push(`Requests: ${stats.requests}`)
+    }
+    if (stats.duration) {
+        title.push(`Duration: ${stats.duration}ms`)
+    }
+    return title.join('\n')
+}
+
 const svg = {
     clipboard: `<svg class="w-6 h-6" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><g fill="none"><path d="M8 5H6a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2v-1M8 5a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2M8 5a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2m0 0h2a2 2 0 0 1 2 2v3m2 4H10m0 0l3-3m-3 3l3 3" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"></path></g></svg>`,
     check: `<svg class="w-6 h-6 text-green-500" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"></path></svg>`,

{llms_py-2.0.14.dist-info → llms_py-2.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llms-py
-Version: 2.0.14
+Version: 2.0.16
 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
@@ -42,7 +42,7 @@ Dynamic: requires-python
 
 Lightweight CLI and OpenAI-compatible server for querying multiple Large Language Model (LLM) providers.
 
-Configure additional providers and models in [llms.json](llms.json)
+Configure additional providers and models in [llms.json](llms/llms.json)
  - Mix and match local models with models from different API providers
  - Requests automatically routed to available providers that supports the requested model (in defined order)
  - Define free/cheapest/local providers first to save on costs
@@ -73,28 +73,10 @@ Read the [Introductory Blog Post](https://servicestack.net/posts/llms-py-ui).
 
 ## Installation
 
-### Option 1: Install from PyPI
-
 ```bash
 pip install llms-py
 ```
 
-### Option 2: Download directly
-
-1. Download [llms.py](llms.py)
-
-```bash
-curl -O https://raw.githubusercontent.com/ServiceStack/llms/main/llms.py
-chmod +x llms.py
-mv llms.py ~/.local/bin/llms
-```
-
-2. Install single dependency:
-
-```bash
-pip install aiohttp
-```
-
 ## Quick Start
 
 ### 1. Set API Keys
@@ -102,12 +84,12 @@ pip install aiohttp
 Set environment variables for the providers you want to use:
 
 ```bash
-export OPENROUTER_FREE_API_KEY="..."
+export OPENROUTER_API_KEY="..."
 ```
 
 | Provider        | Variable                  | Description         | Example |
 |-----------------|---------------------------|---------------------|---------|
-| openrouter_free | `OPENROUTER_FREE_API_KEY` | OpenRouter FREE models API key | `sk-or-...` |
+| openrouter_free | `OPENROUTER_API_KEY` | OpenRouter FREE models API key | `sk-or-...` |
 | groq            | `GROQ_API_KEY`            | Groq API key        | `gsk_...` |
 | google_free     | `GOOGLE_FREE_API_KEY`     | Google FREE API key | `AIza...` |
 | codestral       | `CODESTRAL_API_KEY`       | Codestral API key   | `...` |
@@ -151,7 +133,7 @@ llms "What is the capital of France?"
 
 ## Configuration
 
-The configuration file [llms.json](llms.json) is saved to `~/.llms/llms.json` and defines available providers, models, and default settings. Key sections:
+The configuration file [llms.json](llms/llms.json) is saved to `~/.llms/llms.json` and defines available providers, models, and default settings. Key sections:
 
 ### Defaults
 - `headers`: Common HTTP headers for all requests
@@ -193,7 +175,7 @@ llms "Explain quantum computing" --raw
 
 ### Using a Chat Template
 
-By default llms uses the `defaults/text` chat completion request defined in [llms.json](llms.json).
+By default llms uses the `defaults/text` chat completion request defined in [llms.json](llms/llms.json).
 
 You can instead use a custom chat completion request with `--chat`, e.g:
 
@@ -485,19 +467,10 @@ llms --default grok-4
 
 ### Update
 
-1. Installed from PyPI
-
 ```bash
 pip install llms-py --upgrade
 ```
 
-2. Using Direct Download
-
-```bash
-# Update to latest version (Downloads latest llms.py)
-llms --update
-```
-
 ### Advanced Options
 
 ```bash
@@ -596,7 +569,7 @@ llms --update
 ```
 
 This command:
-- Downloads the latest `llms.py` from `https://raw.githubusercontent.com/ServiceStack/llms/refs/heads/main/llms.py`
+- Downloads the latest `llms.py` from `github.com/ServiceStack/llms/blob/main/llms/main.py`
 - Overwrites your current `llms.py` file with the latest version
 - Preserves your existing configuration file (`llms.json`)
 - Requires an internet connection to download the update
@@ -633,7 +606,7 @@ or directly in your `llms.json`.
 
 | Provider        | Variable                  | Description         | Example |
 |-----------------|---------------------------|---------------------|---------|
-| openrouter_free | `OPENROUTER_FREE_API_KEY` | OpenRouter FREE models API key | `sk-or-...` |
+| openrouter_free | `OPENROUTER_API_KEY` | OpenRouter FREE models API key | `sk-or-...` |
 | groq            | `GROQ_API_KEY`            | Groq API key        | `gsk_...` |
 | google_free     | `GOOGLE_FREE_API_KEY`     | Google FREE API key | `AIza...` |
 | codestral       | `CODESTRAL_API_KEY`       | Codestral API key   | `...` |