freddie 0.0.48 → 0.0.50

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/agent/llm_resolver.js

@@ -13,8 +13,9 @@ export function resolveCallLLM({ provider, model } = {}) {
         if (await acptoapiReachable()) {
             return await acptoapiCall({ ...input, model: model || input.model })
         }
+        const DEFAULTS = { anthropic: 'claude-3-5-haiku-20241022', openai: 'gpt-4o-mini', groq: 'llama3-8b-8192', openrouter: 'openai/gpt-4o-mini' }
         for (const [p, k] of Object.entries(KEYS)) {
-            if (process.env[k]) return await piCall({ ...input, provider: p, model: model || input.model })
+            if (process.env[k]) return await piCall({ ...input, provider: p, model: model || input.model || DEFAULTS[p] })
         }
         throw new Error('no LLM backend reachable: start acptoapi (http://127.0.0.1:4800/v1) or set ANTHROPIC_API_KEY/OPENAI_API_KEY/GROQ_API_KEY/OPENROUTER_API_KEY')
     }

package/src/agent/pi-bridge.js

@@ -6,15 +6,17 @@ let _piAi = null
 async function pi() {
     if (_piAi) return _piAi
     _piAi = await import('@mariozechner/pi-ai')
+    _piAi.registerBuiltInApiProviders()
     return _piAi
 }
 
 export async function callLLM({ messages, tools = [], model, provider = 'anthropic' } = {}) {
     const m = await pi()
     const modelObj = m.getModel ? m.getModel(provider, model) : { provider, id: model }
+    if (!modelObj) throw new Error(`pi-bridge: unknown model ${model} for provider ${provider}`)
     const apiKey = m.getEnvApiKey ? m.getEnvApiKey(provider) : process.env[providerEnv(provider)]
     if (!apiKey) throw new Error(`pi-bridge: no API key for ${provider} (set ${providerEnv(provider)})`)
-    const result = await m.complete({ model: modelObj, apiKey, messages: messages.map(adaptMessage), tools: tools.map(adaptTool) })
+    const result = await m.complete(modelObj, { messages: messages.map(adaptMessage), tools: tools.map(adaptTool) }, { apiKey })
     log.info('completed', { model: model || 'default', usage: result.usage })
     return adaptResponse(result)
 }