freddie 0.0.47 → 0.0.49

package/plugins/tool_result_storage/handler.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { getFreddieHome } from '../../src/home.js'
+function dir() { const d = path.join(getFreddieHome(), 'tool-results'); fs.mkdirSync(d, { recursive: true }); return d }
+
+export const _tool = ({
+    name: 'tool_result_storage',
+    toolset: 'core',
+    schema: { name: 'tool_result_storage', description: 'Persist a large tool result to disk; return reference token. Actions: store, fetch, list, delete.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['store', 'fetch', 'list', 'delete'] }, content: { type: 'string' }, token: { type: 'string' } }, required: ['action'] } },
+    handler: async ({ action, content, token }) => {
+        if (action === 'store') { const t = crypto.randomBytes(8).toString('hex'); fs.writeFileSync(path.join(dir(), t + '.txt'), content || '', 'utf8'); return { token: t, bytes: (content || '').length } }
+        if (action === 'fetch') { const f = path.join(dir(), token + '.txt'); return fs.existsSync(f) ? { content: fs.readFileSync(f, 'utf8') } : { error: 'not found' } }
+        if (action === 'list') return { tokens: fs.readdirSync(dir()).filter(f => f.endsWith('.txt')).map(f => f.replace(/\.txt$/, '')) }
+        if (action === 'delete') { const f = path.join(dir(), token + '.txt'); if (fs.existsSync(f)) fs.unlinkSync(f); return { deleted: token } }
+        return { error: 'unknown action' }
+    },
+})

package/plugins/tool_result_storage/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-tool_result_storage', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/plugins/transcription/handler.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs'
+export const _tool = ({
+    name: 'transcription',
+    toolset: 'creative',
+    schema: { name: 'transcription', description: 'Transcribe audio with OpenAI Whisper.', parameters: { type: 'object', properties: { file_path: { type: 'string' }, model: { type: 'string', default: 'whisper-1' } }, required: ['file_path'] } },
+    requiresEnv: ['OPENAI_API_KEY'],
+    checkFn: () => Boolean(process.env.OPENAI_API_KEY),
+    handler: async ({ file_path, model = 'whisper-1' }) => {
+        if (!process.env.OPENAI_API_KEY) return { error: 'OPENAI_API_KEY required' }
+        if (!fs.existsSync(file_path)) return { error: 'file not found: ' + file_path }
+        const blob = new Blob([fs.readFileSync(file_path)])
+        const fd = new FormData()
+        fd.append('file', blob, file_path.split(/[\\/]/).pop())
+        fd.append('model', model)
+        const r = await fetch('https://api.openai.com/v1/audio/transcriptions', { method: 'POST', headers: { authorization: `Bearer ${process.env.OPENAI_API_KEY}` }, body: fd })
+        return await r.json()
+    },
+})

package/plugins/transcription/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-transcription', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/plugins/tts/handler.js

@@ -0,0 +1,18 @@
+export const _tool = ({
+    name: 'tts',
+    toolset: 'creative',
+    schema: { name: 'tts', description: 'Synthesize speech (OpenAI tts-1 or ElevenLabs).', parameters: { type: 'object', properties: { text: { type: 'string' }, provider: { type: 'string', enum: ['openai', 'elevenlabs'], default: 'openai' }, voice: { type: 'string' } }, required: ['text'] } },
+    requiresEnv: ['OPENAI_API_KEY or ELEVENLABS_API_KEY'],
+    checkFn: () => Boolean(process.env.OPENAI_API_KEY || process.env.ELEVENLABS_API_KEY),
+    handler: async ({ text, provider = 'openai', voice = 'alloy' }) => {
+        if (provider === 'elevenlabs') {
+            if (!process.env.ELEVENLABS_API_KEY) return { error: 'ELEVENLABS_API_KEY required' }
+            const v = voice || '21m00Tcm4TlvDq8ikWAM'
+            const r = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${v}`, { method: 'POST', headers: { 'xi-api-key': process.env.ELEVENLABS_API_KEY, 'content-type': 'application/json' }, body: JSON.stringify({ text }) })
+            return { status: r.status, contentType: r.headers.get('content-type'), bytes: (await r.arrayBuffer()).byteLength }
+        }
+        if (!process.env.OPENAI_API_KEY) return { error: 'OPENAI_API_KEY required' }
+        const r = await fetch('https://api.openai.com/v1/audio/speech', { method: 'POST', headers: { authorization: `Bearer ${process.env.OPENAI_API_KEY}`, 'content-type': 'application/json' }, body: JSON.stringify({ model: 'tts-1', input: text, voice }) })
+        return { status: r.status, bytes: (await r.arrayBuffer()).byteLength }
+    },
+})

package/plugins/tts/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-tts', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/plugins/url_safety/handler.js

@@ -0,0 +1,14 @@
+const SUSPICIOUS = ['phish', 'malware', '.onion']
+const PRIVATE_RANGES = [/^10\./, /^192\.168\./, /^172\.(1[6-9]|2\d|3[01])\./, /^127\./, /^0\./, /^169\.254\./]
+export const _tool = ({
+    name: 'url_safety',
+    toolset: 'core',
+    schema: { name: 'url_safety', description: 'Heuristic URL safety check (private IPs, known-bad TLDs, scheme).', parameters: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] } },
+    handler: async ({ url }) => {
+        let u; try { u = new URL(url) } catch { return { safe: false, reason: 'invalid URL' } }
+        if (!['http:', 'https:'].includes(u.protocol)) return { safe: false, reason: 'unsupported scheme: ' + u.protocol }
+        if (PRIVATE_RANGES.some(re => re.test(u.hostname))) return { safe: false, reason: 'private IP host' }
+        for (const s of SUSPICIOUS) if (u.hostname.includes(s)) return { safe: false, reason: 'suspicious token: ' + s }
+        return { safe: true, host: u.hostname }
+    },
+})

package/plugins/url_safety/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-url_safety', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/plugins/vision/handler.js

@@ -0,0 +1,17 @@
+export const _tool = ({
+    name: 'vision',
+    toolset: 'creative',
+    schema: { name: 'vision', description: 'Describe an image (URL or base64) using a vision-capable LLM.', parameters: { type: 'object', properties: { image_url: { type: 'string' }, prompt: { type: 'string', default: 'Describe this image.' }, provider: { type: 'string', enum: ['openai', 'anthropic'], default: 'openai' } }, required: ['image_url'] } },
+    requiresEnv: ['OPENAI_API_KEY or ANTHROPIC_API_KEY'],
+    checkFn: () => Boolean(process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY),
+    handler: async ({ image_url, prompt = 'Describe this image.', provider = 'openai' }) => {
+        if (provider === 'anthropic') {
+            if (!process.env.ANTHROPIC_API_KEY) return { error: 'ANTHROPIC_API_KEY required' }
+            const r = await fetch('https://api.anthropic.com/v1/messages', { method: 'POST', headers: { 'x-api-key': process.env.ANTHROPIC_API_KEY, 'anthropic-version': '2023-06-01', 'content-type': 'application/json' }, body: JSON.stringify({ model: 'claude-sonnet-4-6', max_tokens: 1024, messages: [{ role: 'user', content: [{ type: 'image', source: { type: 'url', url: image_url } }, { type: 'text', text: prompt }] }] }) })
+            return await r.json()
+        }
+        if (!process.env.OPENAI_API_KEY) return { error: 'OPENAI_API_KEY required' }
+        const r = await fetch('https://api.openai.com/v1/chat/completions', { method: 'POST', headers: { authorization: `Bearer ${process.env.OPENAI_API_KEY}`, 'content-type': 'application/json' }, body: JSON.stringify({ model: 'gpt-4o-mini', messages: [{ role: 'user', content: [{ type: 'text', text: prompt }, { type: 'image_url', image_url: { url: image_url } }] }] }) })
+        return await r.json()
+    },
+})

package/plugins/vision/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-vision', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/plugins/voice_mode/handler.js

@@ -0,0 +1,9 @@
+export const _tool = ({
+    name: 'voice_mode',
+    toolset: 'creative',
+    schema: { name: 'voice_mode', description: 'Toggle full-duplex voice (transcription in + tts out) for the active session. Returns the new state.', parameters: { type: 'object', properties: { enabled: { type: 'boolean' } } } },
+    handler: async ({ enabled }, ctx = {}) => {
+        if (typeof ctx.setVoiceMode === 'function') return await ctx.setVoiceMode(Boolean(enabled))
+        return { enabled: Boolean(enabled), note: 'voice mode toggled in-process; bind ctx.setVoiceMode to wire to a real audio loop' }
+    },
+})

package/plugins/voice_mode/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-voice_mode', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/plugins/web_search/handler.js

@@ -0,0 +1,35 @@
+export const _tool = ({
+    name: 'web_search',
+    toolset: 'browse',
+    schema: {
+        name: 'web_search',
+        description: 'Search the web (DuckDuckGo HTML or SerpAPI). Returns title/url/snippet list.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                limit: { type: 'number', default: 5 },
+            },
+            required: ['query'],
+        },
+    },
+    checkFn: () => true,
+    requiresEnv: ['SERPAPI_KEY (optional, falls back to DDG)'],
+    handler: async ({ query, limit = 5 }) => {
+        if (process.env.SERPAPI_KEY) {
+            const url = `https://serpapi.com/search.json?q=${encodeURIComponent(query)}&api_key=${process.env.SERPAPI_KEY}`
+            const data = await fetch(url).then(r => r.json())
+            const results = (data.organic_results || []).slice(0, limit).map(r => ({ title: r.title, url: r.link, snippet: r.snippet }))
+            return { results }
+        }
+        const fetchFn = globalThis.__freddieFetch || fetch
+        const html = await fetchFn(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`).then(r => r.text())
+        const results = []
+        const re = /<a class="result__a"[^>]*href="([^"]+)"[^>]*>([^<]+)<\/a>[\s\S]*?<a class="result__snippet"[^>]*>([^<]+)<\/a>/g
+        let m
+        while ((m = re.exec(html)) && results.length < limit) {
+            results.push({ url: m[1], title: m[2].replace(/&amp;/g, '&'), snippet: m[3].replace(/<\/?b>/g, '') })
+        }
+        return { results }
+    },
+})

package/plugins/web_search/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-web_search', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/plugins/web_tools/handler.js

@@ -0,0 +1,17 @@
+export const _tool0 = ({
+    name: 'web_fetch',
+    toolset: 'browse',
+    schema: { name: 'web_fetch', description: 'Fetch a URL and return text/json/headers.', parameters: { type: 'object', properties: { url: { type: 'string' }, method: { type: 'string', default: 'GET' }, headers: {}, body: { type: 'string' }, parse: { type: 'string', enum: ['text', 'json'] } }, required: ['url'] } },
+    handler: async ({ url, method = 'GET', headers = {}, body, parse = 'text' }) => {
+        const r = await fetch(url, { method, headers, body })
+        const ct = r.headers.get('content-type')
+        const out = parse === 'json' ? await r.json().catch(() => null) : await r.text()
+        return { status: r.status, contentType: ct, body: out }
+    },
+})
+export const _tool1 = ({
+    name: 'web_extract',
+    toolset: 'browse',
+    schema: { name: 'web_extract', description: 'Strip tags from HTML to plain text.', parameters: { type: 'object', properties: { html: { type: 'string' } }, required: ['html'] } },
+    handler: async ({ html }) => ({ text: String(html).replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim() }),
+})

package/plugins/web_tools/plugin.js

@@ -0,0 +1,2 @@
+import { _tool0, _tool1 } from './handler.js'
+export default { name: 'tool-web_tools', surfaces: 'pi', register({ pi }) { for (const t of [_tool0, _tool1]) pi.tools.register(t) } }

package/plugins/website_policy/handler.js

@@ -0,0 +1,13 @@
+import { getConfigValue } from '../../src/config.js'
+export const _tool = ({
+    name: 'website_policy',
+    toolset: 'core',
+    schema: { name: 'website_policy', description: 'Per-host fetch policy (rate limit, allow/deny). Reads config.website_policy.', parameters: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] } },
+    handler: async ({ url }) => {
+        const policy = getConfigValue('website_policy', { allow: [], deny: [], ratelimit_ms: 1000 }) || {}
+        const u = new URL(url)
+        if (policy.deny?.some(d => u.hostname.includes(d))) return { decision: 'deny' }
+        if (policy.allow?.length && !policy.allow.some(a => u.hostname.includes(a))) return { decision: 'deny', reason: 'not in allow list' }
+        return { decision: 'allow', ratelimit_ms: policy.ratelimit_ms || 1000 }
+    },
+})

package/plugins/website_policy/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-website_policy', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/plugins/write/handler.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs'
+import path from 'node:path'
+export const _tool = ({
+    name: 'write',
+    toolset: 'core',
+    schema: {
+        name: 'write',
+        description: 'Write content to a file (overwrites).',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' },
+                content: { type: 'string' },
+            },
+            required: ['path', 'content'],
+        },
+    },
+    handler: async ({ path: p, content }) => {
+        fs.mkdirSync(path.dirname(p), { recursive: true })
+        fs.writeFileSync(p, content, 'utf8')
+        return { path: p, bytes: Buffer.byteLength(content, 'utf8') }
+    },
+})

package/plugins/write/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-write', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/plugins/xai_http/handler.js

@@ -0,0 +1,12 @@
+export const _tool = ({
+    name: 'xai_grok',
+    toolset: 'core',
+    schema: { name: 'xai_grok', description: 'Chat completion via xAI Grok.', parameters: { type: 'object', properties: { prompt: { type: 'string' }, model: { type: 'string', default: 'grok-3' } }, required: ['prompt'] } },
+    requiresEnv: ['XAI_API_KEY'],
+    checkFn: () => Boolean(process.env.XAI_API_KEY),
+    handler: async ({ prompt, model = 'grok-3' }) => {
+        if (!process.env.XAI_API_KEY) return { error: 'XAI_API_KEY required' }
+        const r = await fetch('https://api.x.ai/v1/chat/completions', { method: 'POST', headers: { authorization: `Bearer ${process.env.XAI_API_KEY}`, 'content-type': 'application/json' }, body: JSON.stringify({ model, messages: [{ role: 'user', content: prompt }] }) })
+        return await r.json()
+    },
+})

package/plugins/xai_http/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-xai_http', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/plugins/yuanbao_tools/handler.js

@@ -0,0 +1,12 @@
+export const _tool = ({
+    name: 'yuanbao_tools',
+    toolset: 'core',
+    schema: { name: 'yuanbao_tools', description: 'Tencent Yuanbao chat completion (Hunyuan).', parameters: { type: 'object', properties: { prompt: { type: 'string' }, model: { type: 'string', default: 'hunyuan-pro' } }, required: ['prompt'] } },
+    requiresEnv: ['YUANBAO_API_KEY'],
+    checkFn: () => Boolean(process.env.YUANBAO_API_KEY),
+    handler: async ({ prompt, model = 'hunyuan-pro' }) => {
+        if (!process.env.YUANBAO_API_KEY) return { error: 'YUANBAO_API_KEY required' }
+        const r = await fetch('https://api.hunyuan.cloud.tencent.com/v1/chat/completions', { method: 'POST', headers: { authorization: `Bearer ${process.env.YUANBAO_API_KEY}`, 'content-type': 'application/json' }, body: JSON.stringify({ model, messages: [{ role: 'user', content: prompt }] }) })
+        return await r.json()
+    },
+})

package/plugins/yuanbao_tools/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-yuanbao_tools', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }

package/src/sessions.js

@@ -69,6 +69,7 @@ export async function listSessions(limit = 50) {
 
 export async function search(query, limit = 20) {
     const d = await db()
+    const likePattern = `%${query}%`
     // Try FTS5 if available (libsql, but not busybase since triggers can't be created)
     try {
         const ftsResult = await d.prepare(`SELECT m.id, m.session_id, m.content FROM messages_fts f JOIN messages m ON m.id = f.rowid WHERE messages_fts MATCH ? ORDER BY rank LIMIT ?`).all(query, limit)
@@ -77,7 +78,7 @@ export async function search(query, limit = 20) {
         // FTS5 not available, fall through to LIKE
     }
     // Fallback to LIKE search
-    return await d.prepare(`SELECT id, session_id, content FROM messages WHERE content LIKE ? ORDER BY ts DESC LIMIT ?`).all(`%${query}%`, limit)
+    return await d.prepare(`SELECT id, session_id, content FROM messages WHERE content LIKE ? ORDER BY ts DESC LIMIT ?`).all(likePattern, limit)
 }
 
 export function closeDb() { return closeDbImpl() }

package/src/web/app.js

@@ -6,6 +6,7 @@ await installStyles()
 
 if (!window.__debug) { try { window.__debug = {} } catch { Object.defineProperty(window, '__debug', { value: {}, writable: true, configurable: true }) } }
 window.__debug.dashboard = () => ({ booted: true, ts: Date.now(), framework: 'anentrypoint-design+webjsx', route: location.hash || '#/sessions' })
+window.__debug.agents = () => ({ registered: true, active: AppState.agents?.active || null, count: AppState.agents?.count || 0 })
 
 const j = async (u, opts) => { try { const r = await fetch(u, opts); if (!r.ok) throw new Error(r.status + ' ' + r.statusText); return await r.json() } catch (e) { return { __error: String(e) } } }
 
@@ -13,6 +14,7 @@ const ROUTES = [
     { path: '#/home',      label: 'Home',          glyph: '⌂' },
     { path: '#/chat',      label: 'Chat',          glyph: '⌨' },
     { path: '#/sessions',  label: 'Sessions',      glyph: '✉' },
+    { path: '#/agents',    label: 'Agents',        glyph: '◈' },
     { path: '#/analytics', label: 'Analytics',     glyph: '◉' },
     { path: '#/models',    label: 'Models',        glyph: '◎' },
     { path: '#/logs',      label: 'Logs',          glyph: '☰' },
@@ -36,6 +38,7 @@ const AppState = {
     sessionsFilter: '',
     chat: { messages: [], draft: '', streaming: false },
     batch: { results: null, running: false },
+    agents: { count: 0, active: null },
 }
 function applyTheme() { document.documentElement.setAttribute('data-theme', AppState.theme) }
 applyTheme()
@@ -141,6 +144,20 @@ const PAGES = {
         ]
     },
 
+    '#/agents': async () => {
+        const agents = await j('/api/agents')
+        const count = agents.__error ? 0 : (agents.count || 0)
+        const active = agents.active || null
+        return [
+            kpi([[count || 0, 'Total agents'], [active ? 1 : 0, 'Active']]),
+            Panel({ title: 'Agent overview', children: Receipt({ rows: [
+                ['Total agent turns', String(agents.turns || 0)],
+                ['Active agent', active || '(none)'],
+                ['Last activity', agents.last_activity ? new Date(agents.last_activity).toLocaleString() : '—'],
+            ]}) }),
+        ]
+    },
+
     '#/analytics': async () => {
         const [sessions, tools, debug] = await Promise.all([j('/api/sessions'), j('/api/tools'), j('/api/debug')])
         const all = Array.isArray(sessions) ? sessions : []

package/src/web/index.html

@@ -146,10 +146,12 @@ html[data-theme="dark"] .ds-247420 {
 .ds-247420 .kpi-card .num { font-size: 1.75rem; color: var(--panel-text); font-weight: 400; font-family: 'JetBrains Mono', monospace; }
 .ds-247420 .kpi-card .lbl { font-size: 0.75rem; color: var(--panel-text-2); font-weight: 600; text-transform: uppercase; letter-spacing: 0.08em; margin-top: 2px; }
 
-.ds-247420 .row-form { display: flex; gap: 8px; flex-wrap: wrap; align-items: stretch; margin-bottom: 12px; }
-.ds-247420 .row-form input { flex: 1; min-width: 140px; }
+.ds-247420 .row-form { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; margin-bottom: 12px; }
+.ds-247420 .row-form input { flex: 1; min-width: 140px; padding: 10px 12px !important; }
 
-.ds-247420 .chat .chat-thread { max-height: calc(100vh - 320px); overflow-y: auto; }
+.ds-247420 .chat { display: flex; flex-direction: column; height: 100%; }
+.ds-247420 .chat .chat-thread { flex: 1; max-height: calc(100vh - 320px); overflow-y: auto; }
+.ds-247420 .chat .chat-composer { padding-top: 12px; border-top: 1px solid var(--panel-2); }
 
 .ds-247420 .chip { border-radius: 6px; padding: 4px 10px; font-size: 12px; font-weight: 600; display: inline-block; }
 .ds-247420 .chip.ok   { background: var(--green); color: white; }
@@ -158,6 +160,8 @@ html[data-theme="dark"] .ds-247420 {
 .ds-247420 .empty { color: var(--panel-text-3); padding: 12px 0; }
 .ds-247420 a { color: var(--link); text-decoration: none; }
 .ds-247420 a:hover { text-decoration: underline; }
+
+#app { padding: 16px 20px; }
 </style>
 </head>
 <body>