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

llms/ui/ai.mjs

@@ -1,12 +1,12 @@
 import { reactive } from "vue"
-import { ApiResult } from "@servicestack/client"
+import { useThreadStore } from "./threadStore.mjs"
 
 const base = ''
 const headers = { 'Accept': 'application/json' }
 const prefsKey = 'llms.prefs'
 
 export const o = {
-    version: '3.0.0',
+    version: '3.0.0b1',
     base,
     prefsKey,
     welcome: 'Welcome to llms.py',
@@ -15,11 +15,6 @@ export const o = {
     authType: 'apikey',  // 'oauth' or 'apikey' - controls which SignIn component to use
     headers,
     isSidebarOpen: true,  // Shared sidebar state (default open for lg+ screens)
-    cacheUrlInfo: {},
-
-    get hasAccess() {
-        return !this.requiresAuth || this.auth
-    },
 
     resolveUrl(url) {
         return url.startsWith('http') || url.startsWith('/v1') ? url : base + url
@@ -30,73 +25,14 @@ export const o = {
             headers: Object.assign({}, this.headers, options?.headers),
         })
     },
-    async getJson(url, options) {
-        const res = await this.get(url, options)
-        return await this.createJsonResult(res, url)
-    },
-    async post(url, options) {
-        return await fetch(this.resolveUrl(url), {
+    post(url, options) {
+        return fetch(this.resolveUrl(url), {
             method: 'POST',
             ...options,
             headers: Object.assign({ 'Content-Type': 'application/json' }, this.headers, options?.headers),
         })
     },
-    async postForm(url, options) {
-        return await fetch(this.resolveUrl(url), {
-            method: 'POST',
-            ...options,
-            headers: Object.assign({}, options?.headers),
-        })
-    },
-    async postJson(url, options) {
-        const res = await this.post(url, options)
-        return await this.createJsonResult(res, url)
-    },
-    async createJsonResult(res, msg = null) {
-        let txt = ''
-        try {
-            txt = await res.text()
-            const response = JSON.parse(txt)
-            if (response?.responseStatus?.errorCode) {
-                return new ApiResult({ error: response.responseStatus })
-            }
-            if (!res.ok) {
-                return new ApiResult({ error: { errorCode: 'Error', message: res.statusText } })
-            }
-            return new ApiResult({ response })
-        } catch (e) {
-            console.error('Failed to parse JSON', e, msg, txt)
-            const responseStatus = {
-                errorCode: 'Error',
-                message: `${e.message ?? e}`,
-                stackTrace: msg ? `${msg}\n${txt}` : txt,
-            }
-            return { responseStatus }
-        }
-    },
-    createErrorStatus({ message, errorCode, stackTrace, errors, meta }) {
-        const ret = {
-            errorCode: errorCode || 'Error',
-            message: message,
-        }
-        if (stackTrace) {
-            ret.stackTrace = stackTrace
-        }
-        if (errors && Array.isArray(errors)) {
-            ret.errors = errors
-        }
-        if (meta) {
-            ret.meta = meta
-        }
-        return ret
-    },
-    createErrorResult(e) {
-        return new ApiResult({
-            error: e.errorCode
-                ? this.createErrorStatus(e)
-                : this.createErrorStatus({ message: `${e.message ?? e}` })
-        })
-    },
+
     async getConfig() {
         return this.get('/config')
     },
@@ -116,33 +52,51 @@ export const o = {
         this.auth = auth
         if (auth?.apiKey) {
             this.headers.Authorization = `Bearer ${auth.apiKey}`
+            //localStorage.setItem('llms:auth', JSON.stringify({ apiKey: auth.apiKey }))
+        } else if (auth?.sessionToken) {
+            this.headers['X-Session-Token'] = auth.sessionToken
+            localStorage.setItem('llms:auth', JSON.stringify({ sessionToken: auth.sessionToken }))
         } else {
             if (this.headers.Authorization) {
                 delete this.headers.Authorization
             }
+            if (this.headers['X-Session-Token']) {
+                delete this.headers['X-Session-Token']
+            }
         }
     },
     async signOut() {
-        try {
-            await this.post('/auth/logout')
-        } catch (error) {
-            console.error('Logout error:', error)
+        if (this.auth?.sessionToken) {
+            // Call logout endpoint for OAuth sessions
+            try {
+                await this.post('/auth/logout', {
+                    headers: {
+                        'X-Session-Token': this.auth.sessionToken
+                    }
+                })
+            } catch (error) {
+                console.error('Logout error:', error)
+            }
         }
         this.auth = null
         if (this.headers.Authorization) {
             delete this.headers.Authorization
         }
+        if (this.headers['X-Session-Token']) {
+            delete this.headers['X-Session-Token']
+        }
+        localStorage.removeItem('llms:auth')
     },
-    async init(ctx) {
+    async init() {
         // Load models and prompts
-        const [configRes, modelsRes, extensionsRes] = await Promise.all([
+        const { initDB } = useThreadStore()
+        const [_, configRes, modelsRes] = await Promise.all([
+            initDB(),
             this.getConfig(),
             this.getModels(),
-            this.get('/ext'),
         ])
         const config = await configRes.json()
         const models = await modelsRes.json()
-        const extensions = await extensionsRes.json()
 
         // Update auth settings from server config
         if (config.requiresAuth != null) {
@@ -152,6 +106,25 @@ export const o = {
             this.authType = config.authType
         }
 
+        // Try to restore session from localStorage
+        if (this.requiresAuth) {
+            const storedAuth = localStorage.getItem('llms:auth')
+            if (storedAuth) {
+                try {
+                    const authData = JSON.parse(storedAuth)
+                    if (authData.sessionToken) {
+                        this.headers['X-Session-Token'] = authData.sessionToken
+                    }
+                    // else if (authData.apiKey) {
+                    //     this.headers.Authorization = `Bearer ${authData.apiKey}`
+                    // }
+                } catch (e) {
+                    console.error('Failed to restore auth from localStorage:', e)
+                    localStorage.removeItem('llms:auth')
+                }
+            }
+        }
+
         // Get auth status
         const authRes = await this.getAuth()
         const auth = this.requiresAuth
@@ -159,59 +132,14 @@ export const o = {
             : null
         if (auth?.responseStatus?.errorCode) {
             console.error(auth.responseStatus.errorCode, auth.responseStatus.message)
+            // Clear invalid session from localStorage
+            localStorage.removeItem('llms:auth')
         } else {
             this.signIn(auth)
         }
-        return { config, models, extensions, auth }
-    },
-
-
-    async uploadFile(file) {
-        const formData = new FormData()
-        formData.append('file', file)
-        const response = await fetch(this.resolveUrl('/upload'), {
-            method: 'POST',
-            body: formData
-        })
-        if (!response.ok) {
-            throw new Error(`Upload failed: ${response.statusText}`)
-        }
-        return response.json()
-    },
-
-
-    getCacheInfo(url) {
-        return this.cacheUrlInfo[url]
-    },
-    async fetchCacheInfos(urls) {
-        const infos = {}
-        const fetchInfos = []
-        for (const url of urls) {
-            const info = this.getCacheInfo(url)
-            if (info) {
-                infos[url] = info
-            } else {
-                fetchInfos.push(fetch(this.resolveUrl(url + "?info")))
-            }
-        }
-        const responses = await Promise.all(fetchInfos)
-        for (let i = 0; i < urls.length; i++) {
-            try {
-                const info = await responses[i].json()
-                this.setCacheInfo(urls[i], info)
-                infos[urls[i]] = info
-            } catch (e) {
-                console.error('Failed to fetch info for', urls[i], e)
-            }
-        }
-        return infos
-    },
-    setCacheInfo(url, info) {
-        this.cacheUrlInfo[url] = info
+        return { config, models, auth }
     }
-
 }
 
-
 let ai = reactive(o)
 export default ai