freddie 0.0.41 → 0.0.42

package/src/gateway/platforms/qqbot.js

@@ -1,32 +0,0 @@
-import express from 'express'
-import { EventEmitter } from 'node:events'
-
-export class QqbotAdapter extends EventEmitter {
-    constructor(opts = {}) {
-        super()
-        this.platform = 'qqbot'
-        this.token = opts.token || process.env.QQBOT_TOKEN
-        this.port = opts.port || 0
-        this.api = opts.api || "https://api.sgroup.qq.com/channels/messages"
-        this._server = null
-    }
-    getRequiredEnv() { return ["QQBOT_TOKEN"] }
-    async start() {
-        if (!this.token) throw new Error('QqbotAdapter: ' + this.getRequiredEnv().join(', ') + ' required')
-        const app = express()
-        app.use(express.json())
-        app.post('/webhook', (req, res) => {
-            const text = req.body?.text || req.body?.message?.text || req.body?.content || ''
-            const from = req.body?.from || req.body?.user_id || req.body?.sender_id || ''
-            this.emit('message', { from: String(from), text, raw: req.body })
-            res.json({ ok: true })
-        })
-        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
-        this.port = this._server.address().port
-    }
-    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
-    async send(reply) {
-        if (!this.token) throw new Error('QqbotAdapter: token required')
-        return fetch(this.api, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ to: reply.to, text: reply.text }) }).then(r => r.json())
-    }
-}

package/src/gateway/platforms/signal.js

@@ -1,33 +0,0 @@
-import { EventEmitter } from 'node:events'
-
-export class SignalAdapter extends EventEmitter {
-    constructor(opts = {}) {
-        super()
-        this.platform = 'signal'
-        this.api = opts.api || process.env.SIGNAL_CLI_URL || 'http://127.0.0.1:8080'
-        this.number = opts.number || process.env.SIGNAL_NUMBER
-        this._running = false
-    }
-    getRequiredEnv() { return ['SIGNAL_CLI_URL', 'SIGNAL_NUMBER'] }
-    async start() {
-        if (!this.number) throw new Error('SignalAdapter: SIGNAL_NUMBER required')
-        this._running = true
-        this._loop()
-    }
-    async stop() { this._running = false }
-    async _loop() {
-        while (this._running) {
-            try {
-                const res = await fetch(`${this.api}/v1/receive/${this.number}`)
-                const items = await res.json()
-                for (const it of items) {
-                    const msg = it?.envelope?.dataMessage
-                    if (msg) this.emit('message', { from: it.envelope.source, text: msg.message || '', raw: it })
-                }
-            } catch (e) { await new Promise(r => setTimeout(r, 2000)) }
-        }
-    }
-    async send(reply) {
-        return fetch(`${this.api}/v2/send`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ number: this.number, recipients: [reply.to], message: reply.text }) }).then(r => r.json())
-    }
-}

package/src/gateway/platforms/slack.js

@@ -1,34 +0,0 @@
-import express from 'express'
-import { EventEmitter } from 'node:events'
-
-export class SlackAdapter extends EventEmitter {
-    constructor(opts = {}) {
-        super()
-        this.platform = 'slack'
-        this.token = opts.token || process.env.SLACK_BOT_TOKEN
-        this.signingSecret = opts.signingSecret || process.env.SLACK_SIGNING_SECRET
-        this.port = opts.port || 0
-        this.path = opts.path || '/slack/events'
-        this.api = opts.api || 'https://slack.com/api'
-        this._server = null
-    }
-    getRequiredEnv() { return ['SLACK_BOT_TOKEN', 'SLACK_SIGNING_SECRET'] }
-    async start() {
-        if (!this.token) throw new Error('SlackAdapter: SLACK_BOT_TOKEN required')
-        const app = express()
-        app.use(express.json())
-        app.post(this.path, (req, res) => {
-            if (req.body?.type === 'url_verification') return res.json({ challenge: req.body.challenge })
-            const ev = req.body?.event
-            if (ev?.type === 'message' && !ev.bot_id) this.emit('message', { from: ev.channel, text: ev.text || '', user: ev.user, raw: req.body })
-            res.json({ ok: true })
-        })
-        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
-        this.port = this._server.address().port
-    }
-    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
-    async send(reply) {
-        if (!this.token) throw new Error('SlackAdapter: token required')
-        return fetch(`${this.api}/chat.postMessage`, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ channel: reply.to, text: reply.text }) }).then(r => r.json())
-    }
-}

package/src/gateway/platforms/sms.js

@@ -1,34 +0,0 @@
-import express from 'express'
-import { EventEmitter } from 'node:events'
-
-export class SmsAdapter extends EventEmitter {
-    constructor(opts = {}) {
-        super()
-        this.platform = 'sms'
-        this.sid = opts.sid || process.env.TWILIO_SID
-        this.token = opts.token || process.env.TWILIO_TOKEN
-        this.from = opts.from || process.env.TWILIO_FROM
-        this.port = opts.port || 0
-        this._server = null
-    }
-    getRequiredEnv() { return ['TWILIO_SID', 'TWILIO_TOKEN', 'TWILIO_FROM'] }
-    async start() {
-        if (!this.sid || !this.token || !this.from) throw new Error('SmsAdapter: TWILIO_SID/TOKEN/FROM required')
-        const app = express()
-        app.use(express.urlencoded({ extended: true }))
-        app.post('/sms', (req, res) => {
-            this.emit('message', { from: req.body.From, text: req.body.Body || '', raw: req.body })
-            res.set('content-type', 'text/xml')
-            res.send('<Response/>')
-        })
-        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
-        this.port = this._server.address().port
-    }
-    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
-    async send(reply) {
-        const url = `https://api.twilio.com/2010-04-01/Accounts/${this.sid}/Messages.json`
-        const body = new URLSearchParams({ To: reply.to, From: this.from, Body: reply.text }).toString()
-        const auth = 'Basic ' + Buffer.from(`${this.sid}:${this.token}`).toString('base64')
-        return fetch(url, { method: 'POST', headers: { authorization: auth, 'content-type': 'application/x-www-form-urlencoded' }, body }).then(r => r.json())
-    }
-}

package/src/gateway/platforms/telegram.js

@@ -1,38 +0,0 @@
-import { EventEmitter } from 'node:events'
-
-export class TelegramAdapter extends EventEmitter {
-    constructor(opts = {}) {
-        super()
-        this.platform = 'telegram'
-        this.token = opts.token || process.env.TELEGRAM_BOT_TOKEN
-        this.api = opts.api || 'https://api.telegram.org'
-        this.offset = 0
-        this._running = false
-        this._poll = null
-    }
-    getRequiredEnv() { return ['TELEGRAM_BOT_TOKEN'] }
-    async start() {
-        if (!this.token) throw new Error('TelegramAdapter: TELEGRAM_BOT_TOKEN required')
-        this._running = true
-        this._loop()
-    }
-    async stop() { this._running = false; if (this._poll) clearTimeout(this._poll) }
-    async _loop() {
-        while (this._running) {
-            try {
-                const url = `${this.api}/bot${this.token}/getUpdates?timeout=25&offset=${this.offset + 1}`
-                const res = await fetch(url)
-                const data = await res.json()
-                if (data.ok) for (const u of data.result) {
-                    this.offset = Math.max(this.offset, u.update_id)
-                    if (u.message) this.emit('message', { from: String(u.message.from?.id || ''), text: u.message.text || '', raw: u })
-                }
-            } catch (e) { await new Promise(r => setTimeout(r, 5000)) }
-        }
-    }
-    async send(reply) {
-        if (!this.token) throw new Error('TelegramAdapter: token required')
-        const url = `${this.api}/bot${this.token}/sendMessage`
-        return fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ chat_id: reply.to, text: reply.text }) }).then(r => r.json())
-    }
-}

package/src/gateway/platforms/telegram_network.js

@@ -1,17 +0,0 @@
-export function tgFloodWait(error) {
-    const m = String(error?.message || '').match(/FLOOD_WAIT_(\d+)/)
-    return m ? Number(m[1]) * 1000 : null
-}
-export async function tgWithRetry(fn, { attempts = 3 } = {}) {
-    let last
-    for (let i = 0; i < attempts; i++) {
-        try { return await fn() } catch (e) {
-            last = e
-            const wait = tgFloodWait(e)
-            if (wait != null) await new Promise(r => setTimeout(r, wait + 100))
-            else if (i < attempts - 1) await new Promise(r => setTimeout(r, 500 * (i + 1)))
-        }
-    }
-    throw last
-}
-export function withProxy(fetchOpts, proxy) { return proxy ? { ...fetchOpts, proxy } : fetchOpts }

package/src/gateway/platforms/webhook.js

@@ -1,19 +0,0 @@
-import express from 'express'
-import { EventEmitter } from 'node:events'
-
-export class WebhookAdapter extends EventEmitter {
-    constructor({ port = 0, path = '/webhook' } = {}) { super(); this.port = port; this.path = path; this._server = null; this.outbox = [] }
-    async start() {
-        const app = express()
-        app.use(express.json())
-        app.post(this.path, (req, res) => {
-            const m = { from: req.body?.from || 'webhook', text: req.body?.text || '', raw: req.body }
-            this.emit('message', m)
-            res.json({ ok: true })
-        })
-        await new Promise(resolve => { this._server = app.listen(this.port, () => resolve()) })
-        this.port = this._server.address().port
-    }
-    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
-    async send(reply) { this.outbox.push(reply) }
-}

package/src/gateway/platforms/wecom.js

@@ -1,32 +0,0 @@
-import express from 'express'
-import { EventEmitter } from 'node:events'
-
-export class WecomAdapter extends EventEmitter {
-    constructor(opts = {}) {
-        super()
-        this.platform = 'wecom'
-        this.token = opts.token || process.env.WECOM_WEBHOOK_KEY
-        this.port = opts.port || 0
-        this.api = opts.api || "https://qyapi.weixin.qq.com/cgi-bin/webhook/send"
-        this._server = null
-    }
-    getRequiredEnv() { return ["WECOM_WEBHOOK_KEY"] }
-    async start() {
-        if (!this.token) throw new Error('WecomAdapter: ' + this.getRequiredEnv().join(', ') + ' required')
-        const app = express()
-        app.use(express.json())
-        app.post('/webhook', (req, res) => {
-            const text = req.body?.text || req.body?.message?.text || req.body?.content || ''
-            const from = req.body?.from || req.body?.user_id || req.body?.sender_id || ''
-            this.emit('message', { from: String(from), text, raw: req.body })
-            res.json({ ok: true })
-        })
-        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
-        this.port = this._server.address().port
-    }
-    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
-    async send(reply) {
-        if (!this.token) throw new Error('WecomAdapter: token required')
-        return fetch(this.api, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ to: reply.to, text: reply.text }) }).then(r => r.json())
-    }
-}

package/src/gateway/platforms/wecom_callback.js

@@ -1,15 +0,0 @@
-import express from 'express'
-import { EventEmitter } from 'node:events'
-export class WecomCallbackAdapter extends EventEmitter {
-    constructor(opts = {}) { super(); this.platform = 'wecom_callback'; this.token = opts.token || process.env.WECOM_CALLBACK_TOKEN; this.aesKey = opts.aesKey || process.env.WECOM_ENCODING_AES_KEY; this.port = opts.port || 0 }
-    getRequiredEnv() { return ['WECOM_CALLBACK_TOKEN'] }
-    async start() {
-        if (!this.token) throw new Error('WECOM_CALLBACK_TOKEN required')
-        const app = express(); app.use(express.text({ type: '*/*' }))
-        app.post('/wecom/callback', (req, res) => { this.emit('message', { from: 'wecom', text: req.body || '', raw: req.body }); res.send('') })
-        this._server = await new Promise(r => { const s = app.listen(this.port, () => r(s)) })
-        this.port = this._server.address().port
-    }
-    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
-    async send() { return { error: 'wecom_callback is receive-only; use wecom adapter for outbound' } }
-}

package/src/gateway/platforms/wecom_crypto.js

@@ -1,16 +0,0 @@
-import crypto from 'node:crypto'
-export function sha1(...parts) { return crypto.createHash('sha1').update(parts.sort().join('')).digest('hex') }
-export function verifyMsgSignature({ token, timestamp, nonce, encrypt, signature }) {
-    return sha1(token, timestamp, nonce, encrypt) === signature
-}
-export function decryptMsg(encryptedB64, encodingAesKey) {
-    const aesKey = Buffer.from(encodingAesKey + '=', 'base64')
-    const iv = aesKey.slice(0, 16)
-    const decipher = crypto.createDecipheriv('aes-256-cbc', aesKey, iv)
-    decipher.setAutoPadding(false)
-    const decrypted = Buffer.concat([decipher.update(Buffer.from(encryptedB64, 'base64')), decipher.final()])
-    const padLen = decrypted[decrypted.length - 1]
-    const trimmed = decrypted.slice(16, decrypted.length - padLen)
-    const xmlLen = trimmed.readUInt32BE(0)
-    return { xml: trimmed.slice(4, 4 + xmlLen).toString('utf8'), corpId: trimmed.slice(4 + xmlLen).toString('utf8') }
-}

package/src/gateway/platforms/weixin.js

@@ -1,32 +0,0 @@
-import express from 'express'
-import { EventEmitter } from 'node:events'
-
-export class WeixinAdapter extends EventEmitter {
-    constructor(opts = {}) {
-        super()
-        this.platform = 'weixin'
-        this.token = opts.token || process.env.WEIXIN_TOKEN
-        this.port = opts.port || 0
-        this.api = opts.api || "https://api.weixin.qq.com/cgi-bin/message/send"
-        this._server = null
-    }
-    getRequiredEnv() { return ["WEIXIN_TOKEN"] }
-    async start() {
-        if (!this.token) throw new Error('WeixinAdapter: ' + this.getRequiredEnv().join(', ') + ' required')
-        const app = express()
-        app.use(express.json())
-        app.post('/webhook', (req, res) => {
-            const text = req.body?.text || req.body?.message?.text || req.body?.content || ''
-            const from = req.body?.from || req.body?.user_id || req.body?.sender_id || ''
-            this.emit('message', { from: String(from), text, raw: req.body })
-            res.json({ ok: true })
-        })
-        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
-        this.port = this._server.address().port
-    }
-    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
-    async send(reply) {
-        if (!this.token) throw new Error('WeixinAdapter: token required')
-        return fetch(this.api, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ to: reply.to, text: reply.text }) }).then(r => r.json())
-    }
-}

package/src/gateway/platforms/whatsapp.js

@@ -1,40 +0,0 @@
-import express from 'express'
-import { EventEmitter } from 'node:events'
-
-export class WhatsappAdapter extends EventEmitter {
-    constructor(opts = {}) {
-        super()
-        this.platform = 'whatsapp'
-        this.token = opts.token || process.env.WHATSAPP_API_TOKEN
-        this.phoneId = opts.phoneId || process.env.WHATSAPP_PHONE_NUMBER_ID
-        this.verifyToken = opts.verifyToken || process.env.WHATSAPP_VERIFY_TOKEN || 'freddie'
-        this.port = opts.port || 0
-        this.api = opts.api || 'https://graph.facebook.com/v20.0'
-        this._server = null
-    }
-    getRequiredEnv() { return ['WHATSAPP_API_TOKEN', 'WHATSAPP_PHONE_NUMBER_ID'] }
-    async start() {
-        if (!this.token || !this.phoneId) throw new Error('WhatsappAdapter: WHATSAPP_API_TOKEN + WHATSAPP_PHONE_NUMBER_ID required')
-        const app = express()
-        app.use(express.json())
-        app.get('/webhook', (req, res) => {
-            if (req.query['hub.verify_token'] === this.verifyToken) return res.send(req.query['hub.challenge'])
-            res.sendStatus(403)
-        })
-        app.post('/webhook', (req, res) => {
-            const entries = req.body?.entry || []
-            for (const e of entries) for (const c of (e.changes || [])) {
-                const msgs = c.value?.messages || []
-                for (const m of msgs) this.emit('message', { from: m.from, text: m.text?.body || '', raw: m })
-            }
-            res.json({ ok: true })
-        })
-        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
-        this.port = this._server.address().port
-    }
-    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
-    async send(reply) {
-        if (!this.token) throw new Error('WhatsappAdapter: token required')
-        return fetch(`${this.api}/${this.phoneId}/messages`, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ messaging_product: 'whatsapp', to: reply.to, text: { body: reply.text } }) }).then(r => r.json())
-    }
-}

package/src/gateway/platforms/yuanbao.js

@@ -1,9 +0,0 @@
-import { BasePlatformAdapter } from '../base.js'
-export class YuanbaoAdapter extends BasePlatformAdapter {
-    constructor(opts = {}) { super({ ...opts, platform: 'yuanbao' }); this.token = opts.token || process.env.YUANBAO_API_KEY; this.api = opts.api || 'https://api.hunyuan.cloud.tencent.com/v1' }
-    getRequiredEnv() { return ['YUANBAO_API_KEY'] }
-    async send(reply) {
-        const r = await fetch(this.api + '/chat/completions', { method: 'POST', headers: { authorization: 'Bearer ' + this.token, 'content-type': 'application/json' }, body: JSON.stringify({ model: 'hunyuan-pro', messages: [{ role: 'user', content: reply.text }] }) })
-        return await r.json()
-    }
-}

package/src/gateway/platforms/yuanbao_media.js

@@ -1,5 +0,0 @@
-export async function uploadMedia({ token, file, mime = 'image/png' }) {
-    if (!token) throw new Error('yuanbao token required')
-    const r = await fetch('https://api.hunyuan.cloud.tencent.com/v1/files', { method: 'POST', headers: { authorization: 'Bearer ' + token, 'content-type': mime }, body: file })
-    return await r.json()
-}

package/src/gateway/platforms/yuanbao_proto.js

@@ -1,9 +0,0 @@
-export function buildChatPayload({ model = 'hunyuan-pro', messages, stream = false, tools = [] }) {
-    return { model, messages, stream, ...(tools.length ? { tools: tools.map(t => ({ type: 'function', function: t })) } : {}) }
-}
-export function parseChatResponse(json) {
-    const choice = json?.choices?.[0]
-    if (!choice) return { content: '', tool_calls: [] }
-    const tc = (choice.message?.tool_calls || []).map(c => ({ id: c.id, name: c.function?.name, arguments: c.function?.arguments ? JSON.parse(c.function.arguments) : {} }))
-    return { content: choice.message?.content || '', tool_calls: tc }
-}

package/src/gateway/platforms/yuanbao_sticker.js

@@ -1,6 +0,0 @@
-export const STICKER_PACK = ['cute', 'work', 'celebration', 'thinking', 'thumbs-up']
-export function buildStickerMessage({ to, sticker }) {
-    if (!STICKER_PACK.includes(sticker)) throw new Error('unknown sticker: ' + sticker)
-    return { to, type: 'sticker', sticker }
-}
-export function listStickers() { return STICKER_PACK }

package/src/plugins/memory/_index.js

@@ -1,8 +0,0 @@
-export { HonchoMemory } from './honcho.js'
-export { Mem0Memory } from './mem0.js'
-export { SupermemoryMemory } from './supermemory.js'
-export { ByteroverMemory } from './byterover.js'
-export { HindsightMemory } from './hindsight.js'
-export { HolographicMemory } from './holographic.js'
-export { OpenvikingMemory } from './openviking.js'
-export { RetaindbMemory } from './retaindb.js'

package/src/plugins/memory/byterover.js

@@ -1,25 +0,0 @@
-export class ByteroverMemory {
-    constructor(opts = {}) {
-        this.name = 'byterover'
-        this.apiKey = opts.apiKey || process.env.BYTEROVER_API_KEY
-        this.base = opts.base || "https://api.byterover.com"
-        this.userId = opts.userId || 'default'
-    }
-    getRequiredEnv() { return ["BYTEROVER_API_KEY"] }
-    _headers() {
-        if (!this.apiKey) throw new Error('ByteroverMemory: BYTEROVER_API_KEY required')
-        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
-    }
-    async syncTurn(messages) {
-        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
-        return { status: res.status, ok: res.ok }
-    }
-    async prefetch(query) {
-        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
-        const res = await fetch(url, { headers: this._headers() })
-        if (!res.ok) return { items: [], status: res.status }
-        return { items: await res.json() }
-    }
-    async shutdown() {}
-    async postSetup() {}
-}

package/src/plugins/memory/hindsight.js

@@ -1,25 +0,0 @@
-export class HindsightMemory {
-    constructor(opts = {}) {
-        this.name = 'hindsight'
-        this.apiKey = opts.apiKey || process.env.HINDSIGHT_API_KEY
-        this.base = opts.base || "https://api.hindsightai.com"
-        this.userId = opts.userId || 'default'
-    }
-    getRequiredEnv() { return ["HINDSIGHT_API_KEY"] }
-    _headers() {
-        if (!this.apiKey) throw new Error('HindsightMemory: HINDSIGHT_API_KEY required')
-        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
-    }
-    async syncTurn(messages) {
-        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
-        return { status: res.status, ok: res.ok }
-    }
-    async prefetch(query) {
-        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
-        const res = await fetch(url, { headers: this._headers() })
-        if (!res.ok) return { items: [], status: res.status }
-        return { items: await res.json() }
-    }
-    async shutdown() {}
-    async postSetup() {}
-}

package/src/plugins/memory/holographic.js

@@ -1,31 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { getFophHome } from '../../home.js'
-
-export class HolographicMemory {
-    constructor(opts = {}) {
-        this.name = 'holographic'
-        this.dir = opts.dir || path.join(getFophHome(), 'memory', 'holographic')
-        fs.mkdirSync(this.dir, { recursive: true })
-    }
-    getRequiredEnv() { return [] }
-    async syncTurn(messages) {
-        const file = path.join(this.dir, Date.now() + '.json')
-        fs.writeFileSync(file, JSON.stringify({ ts: Date.now(), messages }), 'utf8')
-        return { stored: file }
-    }
-    async prefetch(query) {
-        const files = fs.readdirSync(this.dir).filter(f => f.endsWith('.json')).sort().slice(-20)
-        const items = []
-        for (const f of files) {
-            try {
-                const data = JSON.parse(fs.readFileSync(path.join(this.dir, f), 'utf8'))
-                const last = data.messages?.slice(-2).map(m => m.content).join(' ') || ''
-                if (!query || last.toLowerCase().includes(String(query).toLowerCase())) items.push({ file: f, summary: last.slice(0, 200) })
-            } catch {}
-        }
-        return { items }
-    }
-    async shutdown() {}
-    async postSetup() {}
-}

package/src/plugins/memory/honcho.js

@@ -1,25 +0,0 @@
-export class HonchoMemory {
-    constructor(opts = {}) {
-        this.name = 'honcho'
-        this.apiKey = opts.apiKey || process.env.HONCHO_API_KEY
-        this.base = opts.base || "https://api.honcho.dev"
-        this.userId = opts.userId || 'default'
-    }
-    getRequiredEnv() { return ["HONCHO_API_KEY"] }
-    _headers() {
-        if (!this.apiKey) throw new Error('HonchoMemory: HONCHO_API_KEY required')
-        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
-    }
-    async syncTurn(messages) {
-        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
-        return { status: res.status, ok: res.ok }
-    }
-    async prefetch(query) {
-        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
-        const res = await fetch(url, { headers: this._headers() })
-        if (!res.ok) return { items: [], status: res.status }
-        return { items: await res.json() }
-    }
-    async shutdown() {}
-    async postSetup() {}
-}

package/src/plugins/memory/mem0.js

@@ -1,25 +0,0 @@
-export class Mem0Memory {
-    constructor(opts = {}) {
-        this.name = 'mem0'
-        this.apiKey = opts.apiKey || process.env.MEM0_API_KEY
-        this.base = opts.base || "https://api.mem0.ai/v1"
-        this.userId = opts.userId || 'default'
-    }
-    getRequiredEnv() { return ["MEM0_API_KEY"] }
-    _headers() {
-        if (!this.apiKey) throw new Error('Mem0Memory: MEM0_API_KEY required')
-        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
-    }
-    async syncTurn(messages) {
-        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
-        return { status: res.status, ok: res.ok }
-    }
-    async prefetch(query) {
-        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
-        const res = await fetch(url, { headers: this._headers() })
-        if (!res.ok) return { items: [], status: res.status }
-        return { items: await res.json() }
-    }
-    async shutdown() {}
-    async postSetup() {}
-}

package/src/plugins/memory/openviking.js

@@ -1,25 +0,0 @@
-export class OpenvikingMemory {
-    constructor(opts = {}) {
-        this.name = 'openviking'
-        this.apiKey = opts.apiKey || process.env.OPENVIKING_API_KEY
-        this.base = opts.base || "https://api.openviking.com"
-        this.userId = opts.userId || 'default'
-    }
-    getRequiredEnv() { return ["OPENVIKING_API_KEY"] }
-    _headers() {
-        if (!this.apiKey) throw new Error('OpenvikingMemory: OPENVIKING_API_KEY required')
-        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
-    }
-    async syncTurn(messages) {
-        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
-        return { status: res.status, ok: res.ok }
-    }
-    async prefetch(query) {
-        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
-        const res = await fetch(url, { headers: this._headers() })
-        if (!res.ok) return { items: [], status: res.status }
-        return { items: await res.json() }
-    }
-    async shutdown() {}
-    async postSetup() {}
-}

package/src/plugins/memory/retaindb.js

@@ -1,25 +0,0 @@
-export class RetaindbMemory {
-    constructor(opts = {}) {
-        this.name = 'retaindb'
-        this.apiKey = opts.apiKey || process.env.RETAINDB_API_KEY
-        this.base = opts.base || "https://api.retaindb.com"
-        this.userId = opts.userId || 'default'
-    }
-    getRequiredEnv() { return ["RETAINDB_API_KEY"] }
-    _headers() {
-        if (!this.apiKey) throw new Error('RetaindbMemory: RETAINDB_API_KEY required')
-        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
-    }
-    async syncTurn(messages) {
-        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
-        return { status: res.status, ok: res.ok }
-    }
-    async prefetch(query) {
-        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
-        const res = await fetch(url, { headers: this._headers() })
-        if (!res.ok) return { items: [], status: res.status }
-        return { items: await res.json() }
-    }
-    async shutdown() {}
-    async postSetup() {}
-}

package/src/plugins/memory/supermemory.js

@@ -1,25 +0,0 @@
-export class SupermemoryMemory {
-    constructor(opts = {}) {
-        this.name = 'supermemory'
-        this.apiKey = opts.apiKey || process.env.SUPERMEMORY_API_KEY
-        this.base = opts.base || "https://api.supermemory.ai/v3"
-        this.userId = opts.userId || 'default'
-    }
-    getRequiredEnv() { return ["SUPERMEMORY_API_KEY"] }
-    _headers() {
-        if (!this.apiKey) throw new Error('SupermemoryMemory: SUPERMEMORY_API_KEY required')
-        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
-    }
-    async syncTurn(messages) {
-        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
-        return { status: res.status, ok: res.ok }
-    }
-    async prefetch(query) {
-        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
-        const res = await fetch(url, { headers: this._headers() })
-        if (!res.ok) return { items: [], status: res.status }
-        return { items: await res.json() }
-    }
-    async shutdown() {}
-    async postSetup() {}
-}

package/src/tools/ansi_strip.js

@@ -1,8 +0,0 @@
-import { ansiStrip } from '../utils.js'
-import { registry } from './registry.js'
-registry.register({
-    name: 'ansi_strip',
-    toolset: 'core',
-    schema: { name: 'ansi_strip', description: 'Strip ANSI escape sequences.', parameters: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] } },
-    handler: async ({ text }) => ({ text: ansiStrip(text) }),
-})