freddie 0.0.48 → 0.0.50

package/plugins/read/handler.js

@@ -0,0 +1,24 @@
+import fs from 'node:fs'
+export const _tool = ({
+    name: 'read',
+    toolset: 'core',
+    schema: {
+        name: 'read',
+        description: 'Read a file from disk. Returns lines with line numbers.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string' },
+                offset: { type: 'number', default: 0 },
+                limit: { type: 'number', default: 2000 },
+            },
+            required: ['path'],
+        },
+    },
+    handler: async ({ path: p, offset = 0, limit = 2000 }) => {
+        if (!fs.existsSync(p)) return { error: `not found: ${p}` }
+        const lines = fs.readFileSync(p, 'utf8').split('\n')
+        const slice = lines.slice(offset, offset + limit)
+        return { path: p, total: lines.length, content: slice.map((l, i) => `${(offset + i + 1).toString().padStart(6)}\t${l}`).join('\n') }
+    },
+})

package/plugins/read/plugin.js

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

package/plugins/rl_training/handler.js

@@ -0,0 +1,12 @@
+export const _tool = ({
+    name: 'rl_training',
+    toolset: 'core',
+    schema: { name: 'rl_training', description: 'Kick off an RL rollout (Atropos integration).', parameters: { type: 'object', properties: { task: { type: 'string' }, model: { type: 'string' } }, required: ['task'] } },
+    requiresEnv: ['ATROPOS_URL'],
+    checkFn: () => Boolean(process.env.ATROPOS_URL),
+    handler: async ({ task, model }) => {
+        if (!process.env.ATROPOS_URL) return { error: 'ATROPOS_URL required' }
+        const r = await fetch(process.env.ATROPOS_URL + '/rollouts', { method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${process.env.ATROPOS_TOKEN || ''}` }, body: JSON.stringify({ task, model }) })
+        return await r.json()
+    },
+})

package/plugins/rl_training/plugin.js

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

package/plugins/schema_sanitizer/handler.js

@@ -0,0 +1,17 @@
+const DANGEROUS_PARAM_NAMES = new Set(['eval', 'exec', '__proto__', 'constructor'])
+export function sanitizeSchema(schema) {
+    if (!schema || typeof schema !== 'object') return schema
+    const out = JSON.parse(JSON.stringify(schema))
+    if (out.parameters?.properties) {
+        for (const k of Object.keys(out.parameters.properties)) {
+            if (DANGEROUS_PARAM_NAMES.has(k)) delete out.parameters.properties[k]
+        }
+    }
+    return out
+}
+export const _tool = ({
+    name: 'schema_sanitizer',
+    toolset: 'core',
+    schema: { name: 'schema_sanitizer', description: 'Strip dangerous fields (eval, exec, __proto__) from a tool schema.', parameters: { type: 'object', properties: { schema: {} }, required: ['schema'] } },
+    handler: async ({ schema }) => ({ sanitized: sanitizeSchema(schema) }),
+})

package/plugins/schema_sanitizer/plugin.js

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

package/plugins/send_message/handler.js

@@ -0,0 +1,30 @@
+const PLATFORM_MODULES = {
+    telegram: '../gateway/platforms/telegram.js',
+    discord: '../gateway/platforms/discord.js',
+    slack: '../gateway/platforms/slack.js',
+    whatsapp: '../gateway/platforms/whatsapp.js',
+    email: '../gateway/platforms/email.js',
+    sms: '../gateway/platforms/sms.js',
+    matrix: '../gateway/platforms/matrix.js',
+    signal: '../gateway/platforms/signal.js',
+    mattermost: '../gateway/platforms/mattermost.js',
+}
+
+export const _tool = ({
+    name: 'send_message',
+    toolset: 'core',
+    schema: { name: 'send_message', description: 'Send a message to a recipient on the named platform. Uses the gateway adapter; requires the platform credentials.', parameters: { type: 'object', properties: { platform: { type: 'string', enum: Object.keys(PLATFORM_MODULES) }, to: { type: 'string' }, text: { type: 'string' } }, required: ['platform', 'to', 'text'] } },
+    handler: async ({ platform, to, text }) => {
+        const mod = PLATFORM_MODULES[platform]
+        if (!mod) return { error: 'unknown platform: ' + platform }
+        const m = await import(mod)
+        const cls = Object.values(m)[0]
+        const inst = new cls({})
+        try { await inst.start() } catch (e) { return { error: String(e.message || e) } }
+        try {
+            const out = await inst.send({ to, text })
+            await inst.stop?.()
+            return { ok: true, response: out }
+        } catch (e) { await inst.stop?.(); return { error: String(e.message || e) } }
+    },
+})

package/plugins/send_message/plugin.js

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

package/plugins/session_search/handler.js

@@ -0,0 +1,21 @@
+import { search, listSessions, getMessages } from '../../src/sessions.js'
+export const _tool0 = ({
+    name: 'session_search',
+    toolset: 'core',
+    schema: { name: 'session_search', description: 'Full-text search across past session messages. Returns hits with session_id and content snippet.', parameters: { type: 'object', properties: { query: { type: 'string' }, limit: { type: 'number', default: 20 }, session_id: { type: 'string' } }, required: ['query'] } },
+    handler: async ({ query, limit = 20, session_id = null }) => {
+        if (session_id) {
+            const msgs = await getMessages(session_id)
+            const q = String(query).toLowerCase()
+            return { items: msgs.filter(m => String(m.content || '').toLowerCase().includes(q)).slice(0, limit) }
+        }
+        return { items: await search(query, limit) }
+    },
+})
+
+export const _tool1 = ({
+    name: 'session_list',
+    toolset: 'core',
+    schema: { name: 'session_list', description: 'List recent sessions.', parameters: { type: 'object', properties: { limit: { type: 'number', default: 20 } } } },
+    handler: async ({ limit = 20 }) => ({ sessions: await listSessions(limit) }),
+})

package/plugins/session_search/plugin.js

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

package/plugins/skill_manager/handler.js

@@ -0,0 +1,16 @@
+import { listSkills, findSkill, skillAsUserMessage } from '../../src/skills/index.js'
+
+const ACTIONS = {
+    list: () => ({ skills: listSkills().map(s => ({ name: s.name, description: s.description, file: s.file })) }),
+    get: ({ name }) => { const s = findSkill(name); return s ? { skill: s } : { error: 'not found: ' + name } },
+    invoke: ({ name, args = '' }) => {
+        const m = skillAsUserMessage(name, args)
+        return m ? { message: m } : { error: 'not found: ' + name }
+    },
+}
+export const _tool = ({
+    name: 'skill_manager',
+    toolset: 'core',
+    schema: { name: 'skill_manager', description: 'List, fetch, or invoke a skill from ~/.freddie/skills/ or bundled skills/.', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, name: { type: 'string' }, args: { type: 'string' } }, required: ['action'] } },
+    handler: async (a) => { const fn = ACTIONS[a.action]; return fn ? fn(a) : { error: 'unknown action' } },
+})

package/plugins/skill_manager/plugin.js

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

package/plugins/skill_usage/handler.js

@@ -0,0 +1,18 @@
+import { db } from '../../src/db.js'
+async function init() {
+    const d = await db()
+    await d.exec(`CREATE TABLE IF NOT EXISTS skill_usage (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, ts INTEGER NOT NULL, session_id TEXT)`)
+    return d
+}
+export const _tool = ({
+    name: 'skill_usage',
+    toolset: 'core',
+    schema: { name: 'skill_usage', description: 'Track / query skill invocation stats.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['record', 'top', 'recent'] }, name: { type: 'string' }, session_id: { type: 'string' }, limit: { type: 'number', default: 20 } }, required: ['action'] } },
+    handler: async ({ action, name, session_id = null, limit = 20 }) => {
+        const d = await init()
+        if (action === 'record') { await d.prepare(`INSERT INTO skill_usage (name, ts, session_id) VALUES (?, ?, ?)`).run(name, Date.now(), session_id); return { recorded: true } }
+        if (action === 'top') return { top: await d.prepare(`SELECT name, COUNT(*) AS uses FROM skill_usage GROUP BY name ORDER BY uses DESC LIMIT ?`).all(limit) }
+        if (action === 'recent') return { recent: await d.prepare(`SELECT name, ts, session_id FROM skill_usage ORDER BY id DESC LIMIT ?`).all(limit) }
+        return { error: 'unknown action' }
+    },
+})

package/plugins/skill_usage/plugin.js

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

package/plugins/skills_guard/handler.js

@@ -0,0 +1,16 @@
+import { detectSecrets } from '../../src/agent/redact.js'
+
+const DANGEROUS = [/rm\s+-rf\s+\//, /:\(\)\s*\{\s*:\|:&\s*\};:/, /chmod\s+-R\s+777/]
+
+export const _tool = ({
+    name: 'skills_guard',
+    toolset: 'core',
+    schema: { name: 'skills_guard', description: 'Inspect skill body for dangerous patterns (rm -rf /, fork bombs, secrets) before injection.', parameters: { type: 'object', properties: { body: { type: 'string' } }, required: ['body'] } },
+    handler: async ({ body }) => {
+        const issues = []
+        for (const re of DANGEROUS) if (re.test(body)) issues.push({ kind: 'dangerous-cmd', pattern: re.source })
+        const secrets = detectSecrets(body)
+        if (secrets.length) issues.push({ kind: 'secret', count: secrets.length })
+        return { safe: issues.length === 0, issues }
+    },
+})

package/plugins/skills_guard/plugin.js

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

package/plugins/skills_hub/handler.js

@@ -0,0 +1,29 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFreddieHome } from '../../src/home.js'
+const HUB_INDEX_URL = 'https://raw.githubusercontent.com/AnEntrypoint/freddie-skills/main/index.json'
+
+const ACTIONS = {
+    catalog: async () => {
+        try { const r = await fetch(HUB_INDEX_URL); if (!r.ok) return { items: [], error: 'fetch ' + r.status }; return { items: await r.json() } }
+        catch (e) { return { items: [], error: String(e.message || e) } }
+    },
+    install: async ({ name, body }) => {
+        if (!name || !body) return { error: 'name + body required' }
+        const dir = path.join(getFreddieHome(), 'skills', name)
+        fs.mkdirSync(dir, { recursive: true })
+        fs.writeFileSync(path.join(dir, 'SKILL.md'), body, 'utf8')
+        return { installed: dir }
+    },
+    uninstall: async ({ name }) => {
+        const dir = path.join(getFreddieHome(), 'skills', name)
+        if (fs.existsSync(dir)) { fs.rmSync(dir, { recursive: true, force: true }); return { uninstalled: name } }
+        return { error: 'not found' }
+    },
+}
+export const _tool = ({
+    name: 'skills_hub',
+    toolset: 'core',
+    schema: { name: 'skills_hub', description: 'Browse and install community skills.', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, name: { type: 'string' }, body: { type: 'string' } }, required: ['action'] } },
+    handler: async (a) => { const fn = ACTIONS[a.action]; return fn ? await fn(a) : { error: 'unknown action' } },
+})

package/plugins/skills_hub/plugin.js

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

package/plugins/skills_index/handler.js

@@ -0,0 +1,12 @@
+import { listSkills } from '../../src/skills/index.js'
+export const _tool = ({
+    name: 'skills_index',
+    toolset: 'core',
+    schema: { name: 'skills_index', description: 'Build a search index of available skills (name + description + first-line of body) for the agent to query.', parameters: { type: 'object', properties: { query: { type: 'string' } } } },
+    handler: async ({ query }) => {
+        const all = listSkills().map(s => ({ name: s.name, description: s.description, hint: (s.body || '').split('\n').find(l => l.trim()) || '' }))
+        if (!query) return { items: all }
+        const q = String(query).toLowerCase()
+        return { items: all.filter(s => (s.name + ' ' + s.description + ' ' + s.hint).toLowerCase().includes(q)) }
+    },
+})

package/plugins/skills_index/plugin.js

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

package/plugins/skills_sync/handler.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFreddieHome } from '../../src/home.js'
+export const _tool = ({
+    name: 'skills_sync',
+    toolset: 'core',
+    schema: { name: 'skills_sync', description: 'Sync ~/.freddie/skills/ with a remote git repo (clone or pull).', parameters: { type: 'object', properties: { repo: { type: 'string' } }, required: ['repo'] } },
+    handler: async ({ repo }) => {
+        const dir = path.join(getFreddieHome(), 'skills')
+        fs.mkdirSync(dir, { recursive: true })
+        const { spawnSync } = await import('node:child_process')
+        const exists = fs.existsSync(path.join(dir, '.git'))
+        const cmd = exists ? ['git', '-C', dir, 'pull'] : ['git', 'clone', repo, dir]
+        const r = spawnSync(cmd[0], cmd.slice(1), { encoding: 'utf8' })
+        return { exitCode: r.status, stdout: r.stdout, stderr: r.stderr }
+    },
+})

package/plugins/skills_sync/plugin.js

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

package/plugins/skills_tool/handler.js

@@ -0,0 +1,9 @@
+import { listSkills, findSkill, skillAsUserMessage } from '../../src/skills/index.js'
+export const _tool = ({
+    name: 'skill',
+    toolset: 'core',
+    schema: { name: 'skill', description: 'Run a skill by name. Returns the user-message representation that should be added to the conversation.', parameters: { type: 'object', properties: { name: { type: 'string' }, args: { type: 'string' } }, required: ['name'] } },
+    handler: async ({ name, args = '' }) => {
+        const m = skillAsUserMessage(name, args); return m ? { message: m } : { error: 'skill not found: ' + name, available: listSkills().map(s => s.name) }
+    },
+})

package/plugins/skills_tool/plugin.js

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

package/plugins/slash_confirm/handler.js

@@ -0,0 +1,14 @@
+import { resolveCommand, getCommand } from '../../src/commands/registry.js'
+const DESTRUCTIVE = new Set(['reset', 'clear', 'delete'])
+
+export const _tool = ({
+    name: 'slash_confirm',
+    toolset: 'core',
+    schema: { name: 'slash_confirm', description: 'Resolve a slash command and indicate whether it requires confirmation before running.', parameters: { type: 'object', properties: { input: { type: 'string' } }, required: ['input'] } },
+    handler: async ({ input }) => {
+        const name = resolveCommand(input)
+        if (!name) return { recognised: false, input }
+        const def = getCommand(name)
+        return { recognised: true, name, requiresConfirm: DESTRUCTIVE.has(name), description: def?.description }
+    },
+})

package/plugins/slash_confirm/plugin.js

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

package/plugins/terminal/handler.js

@@ -0,0 +1,27 @@
+import { spawn } from 'node:child_process'
+const _sessions = new Map()
+
+export const _tool = ({
+    name: 'terminal',
+    toolset: 'core',
+    schema: { name: 'terminal', description: 'Open a long-lived shell session, send input lines, capture output. Actions: open, send, read, close.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['open', 'send', 'read', 'close', 'list'] }, id: { type: 'string' }, input: { type: 'string' }, cwd: { type: 'string' } }, required: ['action'] } },
+    handler: async ({ action, id, input, cwd }) => {
+        if (action === 'open') {
+            const sid = 'term-' + Date.now()
+            const sh = process.platform === 'win32' ? 'cmd' : 'sh'
+            const child = spawn(sh, [], { cwd: cwd || process.cwd(), env: process.env })
+            const buf = { stdout: '', stderr: '' }
+            child.stdout?.on('data', d => buf.stdout += d.toString())
+            child.stderr?.on('data', d => buf.stderr += d.toString())
+            _sessions.set(sid, { child, buf })
+            return { id: sid, opened: true }
+        }
+        const s = _sessions.get(id)
+        if (!s) return { error: 'unknown terminal id: ' + id }
+        if (action === 'send') { s.child.stdin?.write(input + '\n'); return { sent: true } }
+        if (action === 'read') { const out = { ...s.buf }; s.buf.stdout = ''; s.buf.stderr = ''; return out }
+        if (action === 'close') { try { s.child.kill('SIGTERM') } catch {} _sessions.delete(id); return { closed: id } }
+        if (action === 'list') return { sessions: [..._sessions.keys()] }
+        return { error: 'unknown action' }
+    },
+})

package/plugins/terminal/plugin.js

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

package/plugins/tirith_security/handler.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFreddieHome } from '../../src/home.js'
+function policyPath() { return path.join(getFreddieHome(), 'policy.json') }
+function loadPolicy() { try { return JSON.parse(fs.readFileSync(policyPath(), 'utf8')) } catch { return { tools: {}, hosts: { allow: [], deny: [] } } } }
+
+export const _tool = ({
+    name: 'tirith_security',
+    toolset: 'core',
+    schema: { name: 'tirith_security', description: 'Evaluate a candidate action against ~/.freddie/policy.json. Returns allow|deny|ask.', parameters: { type: 'object', properties: { kind: { type: 'string' }, target: { type: 'string' } }, required: ['kind', 'target'] } },
+    handler: async ({ kind, target }) => {
+        const p = loadPolicy()
+        if (kind === 'tool') {
+            const t = p.tools?.[target]
+            if (t === 'allow' || t === 'deny') return { decision: t }
+        }
+        if (kind === 'host') {
+            if (p.hosts?.deny?.some(d => target.includes(d))) return { decision: 'deny' }
+            if (p.hosts?.allow?.some(d => target.includes(d))) return { decision: 'allow' }
+        }
+        return { decision: 'ask' }
+    },
+})

package/plugins/tirith_security/plugin.js

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

package/plugins/todo/handler.js

@@ -0,0 +1,52 @@
+import { db } from '../../src/db.js'
+async function init() {
+    const d = await db()
+    d.exec(`CREATE TABLE IF NOT EXISTS todos (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, content TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending', created INTEGER NOT NULL, updated INTEGER NOT NULL)`)
+    return d
+}
+
+const ACTIONS = {
+    add: async ({ session_id = null, content }) => {
+        if (!content) return { error: 'content required' }
+        const d = await init(); const now = Date.now()
+        const info = await d.prepare(`INSERT INTO todos (session_id, content, status, created, updated) VALUES (?, ?, 'pending', ?, ?)`).run(session_id, content, now, now)
+        return { id: Number(info.lastInsertRowid), content, status: 'pending' }
+    },
+    list: async ({ session_id = null }) => {
+        const d = await init()
+        const rows = session_id ? await d.prepare(`SELECT * FROM todos WHERE session_id = ? ORDER BY id DESC`).all(session_id) : await d.prepare(`SELECT * FROM todos ORDER BY id DESC`).all()
+        return { todos: rows }
+    },
+    update: async ({ id, status }) => {
+        if (!id) return { error: 'id required' }
+        await (await init()).prepare(`UPDATE todos SET status = ?, updated = ? WHERE id = ?`).run(status, Date.now(), id)
+        return { id, status }
+    },
+    complete: async ({ id }) => ACTIONS.update({ id, status: 'completed' }),
+    delete: async ({ id }) => { await (await init()).prepare(`DELETE FROM todos WHERE id = ?`).run(id); return { id, deleted: true } },
+}
+
+export const _tool = ({
+    name: 'todo',
+    toolset: 'core',
+    schema: {
+        name: 'todo',
+        description: 'Manage per-session todos. Actions: add, list, update, complete, delete.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', enum: Object.keys(ACTIONS) },
+                content: { type: 'string' },
+                id: { type: 'number' },
+                status: { type: 'string' },
+                session_id: { type: 'string' },
+            },
+            required: ['action'],
+        },
+    },
+    handler: async (args) => {
+        const fn = ACTIONS[args.action]
+        if (!fn) return { error: 'unknown action: ' + args.action }
+        return fn(args)
+    },
+})

package/plugins/todo/plugin.js

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

package/plugins/tool_backend_helpers/handler.js

@@ -0,0 +1,24 @@
+export function shapeArgs(schema, args) {
+    if (!schema?.properties) return args
+    const out = {}
+    for (const [k, def] of Object.entries(schema.properties)) {
+        if (k in args) out[k] = args[k]
+        else if ('default' in def) out[k] = def.default
+    }
+    return out
+}
+export function describeTools(filter = null) {
+    let list = registry.list()
+    if (filter) list = list.filter(t => t.toolset === filter)
+    return list.map(t => ({ name: t.name, description: t.schema.description, toolset: t.toolset }))
+}
+export const _tool = ({
+    name: 'tool_backend_helpers',
+    toolset: 'core',
+    schema: { name: 'tool_backend_helpers', description: 'Helper meta-tool: describeTools(filter), shapeArgs(schema, args).', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['describe', 'shape'] }, filter: { type: 'string' }, schema: {}, args: {} }, required: ['action'] } },
+    handler: async ({ action, filter, schema, args }) => {
+        if (action === 'describe') return { tools: describeTools(filter) }
+        if (action === 'shape') return { args: shapeArgs(schema, args || {}) }
+        return { error: 'unknown action' }
+    },
+})

package/plugins/tool_backend_helpers/plugin.js

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

package/plugins/tool_output_limits/handler.js

@@ -0,0 +1,14 @@
+import { getConfigValue } from '../../src/config.js'
+
+export function truncate(s, max = null) {
+    const limit = max ?? getConfigValue('tool.output_limit', 100_000)
+    const t = String(s)
+    if (t.length <= limit) return t
+    return t.slice(0, limit) + `\n…[truncated ${t.length - limit} chars]`
+}
+export const _tool = ({
+    name: 'tool_output_limits',
+    toolset: 'core',
+    schema: { name: 'tool_output_limits', description: 'Apply the configured output truncation cap to a string.', parameters: { type: 'object', properties: { text: { type: 'string' }, max: { type: 'number' } }, required: ['text'] } },
+    handler: async ({ text, max }) => ({ text: truncate(text, max) }),
+})

package/plugins/tool_output_limits/plugin.js

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

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) } }