@bolloon/bolloon-agent 0.1.0

package/dist/bollharness-integration/llm/pi-ai.js

@@ -0,0 +1,397 @@
+export class PiAIModel {
+    config;
+    provider;
+    constructor(config) {
+        this.config = config;
+        this.provider = config.provider;
+    }
+    async chat(message, context) {
+        const systemPrompt = this.buildSystemPrompt(context);
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: message }
+        ];
+        try {
+            const response = await this.generateText({
+                messages,
+                temperature: 0.8
+            });
+            return { reply: response };
+        }
+        catch (error) {
+            console.error('PiAI chat error:', error);
+            return { reply: '抱歉，AI服务暂时不可用。' };
+        }
+    }
+    async summarize(text, context) {
+        const prompt = this.buildSummarizePrompt(text, context);
+        try {
+            const response = await this.generateText({
+                messages: [
+                    { role: 'system', content: 'You are a professional document summarizer.' },
+                    { role: 'user', content: prompt }
+                ],
+                temperature: 0.7
+            });
+            const qualityScore = this.estimateQuality(text, response);
+            return { summary: response, qualityScore };
+        }
+        catch (error) {
+            console.error('PiAI summarize error:', error);
+            return {
+                summary: text.substring(0, 500) + '...',
+                qualityScore: 0.5
+            };
+        }
+    }
+    async improveContent(content, requirements, context) {
+        const prompt = this.buildImprovePrompt(content, requirements, context);
+        try {
+            const response = await this.generateText({
+                messages: [
+                    { role: 'system', content: 'You are a professional document editor and improver.' },
+                    { role: 'user', content: prompt }
+                ],
+                temperature: 0.8
+            });
+            return response;
+        }
+        catch (error) {
+            console.error('PiAI improve error:', error);
+            return content;
+        }
+    }
+    async generateText(options) {
+        const { messages, temperature = 0.7, maxTokens = 4096 } = options;
+        switch (this.provider) {
+            case 'openai':
+            case 'minimax':
+                return this.callOpenAI(messages, temperature, maxTokens);
+            case 'anthropic':
+                return this.callAnthropic(messages, temperature, maxTokens);
+            case 'ollama':
+                return this.callOllama(messages, temperature);
+            case 'openrouter':
+                return this.callOpenRouter(messages, temperature, maxTokens);
+            case 'gemini':
+                return this.callGemini(messages, temperature, maxTokens);
+            case 'local':
+                return this.callLocal(messages, temperature);
+            default:
+                throw new Error(`Unsupported provider: ${this.provider}`);
+        }
+    }
+    getApiKey() {
+        return this.config.apiKey || this.getEnvApiKey();
+    }
+    getEnvApiKey() {
+        const envVars = {
+            openai: process.env.OPENAI_API_KEY || '',
+            anthropic: process.env.ANTHROPIC_API_KEY || '',
+            ollama: '',
+            openrouter: process.env.OPENROUTER_API_KEY || '',
+            gemini: process.env.GEMINI_API_KEY || '',
+            minimax: process.env.MINIMAX_API_KEY || '',
+            local: ''
+        };
+        return envVars[this.provider] || '';
+    }
+    getBaseUrl() {
+        if (this.config.baseUrl) {
+            return this.config.baseUrl;
+        }
+        const baseUrls = {
+            openai: 'https://api.openai.com/v1',
+            anthropic: 'https://api.anthropic.com/v1',
+            ollama: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
+            openrouter: 'https://openrouter.ai/api/v1',
+            gemini: 'https://generativelanguage.googleapis.com/v1beta',
+            minimax: 'https://api.minimaxi.com/v1',
+            local: 'http://localhost:11434'
+        };
+        return baseUrls[this.provider];
+    }
+    mapModel() {
+        const modelMap = {
+            openai: this.config.model || 'gpt-4',
+            anthropic: this.config.model || 'claude-3-5-sonnet-20241022',
+            ollama: this.config.model || 'llama3.2',
+            openrouter: this.config.model || 'anthropic/claude-3.5-sonnet',
+            gemini: this.config.model || 'gemini-2.0-flash',
+            minimax: this.config.model || 'MiniMax-M2.7',
+            local: this.config.model || 'llama3.2'
+        };
+        return modelMap[this.provider];
+    }
+    async callOpenAI(messages, temperature, maxTokens) {
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            throw new Error('OPENAI_API_KEY not set');
+        }
+        const response = await fetch(`${this.getBaseUrl()}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`
+            },
+            body: JSON.stringify({
+                model: this.mapModel(),
+                messages,
+                temperature,
+                max_tokens: maxTokens
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI API error: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.choices?.[0]?.message?.content || '';
+    }
+    async callAnthropic(messages, temperature, maxTokens) {
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            throw new Error('ANTHROPIC_API_KEY not set');
+        }
+        const systemMessage = messages.find(m => m.role === 'system')?.content || '';
+        const userMessages = messages.filter(m => m.role !== 'system');
+        const response = await fetch(`${this.getBaseUrl()}/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                'anthropic-dangerous-direct-browser-access': 'true'
+            },
+            body: JSON.stringify({
+                model: this.mapModel(),
+                messages: userMessages,
+                system: systemMessage,
+                temperature,
+                max_tokens: maxTokens
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`Anthropic API error: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.content?.[0]?.text || '';
+    }
+    async callOllama(messages, temperature) {
+        const response = await fetch(`${this.getBaseUrl()}/api/chat`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                model: this.mapModel(),
+                messages,
+                temperature,
+                stream: false
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama API error: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.message?.content || '';
+    }
+    async callOpenRouter(messages, temperature, maxTokens) {
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            throw new Error('OPENROUTER_API_KEY not set');
+        }
+        const response = await fetch(`${this.getBaseUrl()}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+                'HTTP-Referer': 'https://openclaw.ai',
+                'X-Title': 'OpenClaw'
+            },
+            body: JSON.stringify({
+                model: this.mapModel(),
+                messages,
+                temperature,
+                max_tokens: maxTokens
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`OpenRouter API error: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.choices?.[0]?.message?.content || '';
+    }
+    async callGemini(messages, temperature, maxTokens) {
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            throw new Error('GEMINI_API_KEY not set');
+        }
+        const contents = messages
+            .filter(m => m.role !== 'system')
+            .map(m => ({
+            role: m.role === 'assistant' ? 'model' : 'user',
+            parts: [{ text: m.content }]
+        }));
+        const systemInstruction = messages.find(m => m.role === 'system')?.content;
+        const response = await fetch(`${this.getBaseUrl()}/models/${this.mapModel()}:generateContent?key=${apiKey}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                contents,
+                systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+                generationConfig: {
+                    temperature,
+                    maxOutputTokens: maxTokens
+                }
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`Gemini API error: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    }
+    async callLocal(messages, temperature) {
+        return this.callOllama(messages, temperature);
+    }
+    buildSystemPrompt(context) {
+        const envDetails = this.getEnvironmentDetails();
+        return `You are a friendly AI assistant in a P2P document collaboration network.
+
+## User Working Directory
+${context || process.cwd()}
+
+## Environment
+${envDetails}`;
+    }
+    getEnvironmentDetails() {
+        return `
+## Available Workflows
+- read - Read documents
+- summarize - Summarize documents  
+- improve - Improve documents
+- collaborate - Multi-agent collaboration
+- query - Query status
+- report - Generate reports
+
+## System Capabilities
+- Document processing (Markdown, Text, PDF, DOCX)
+- Multi-agent collaboration (P2P network)
+- Workflow engine (constraint layer)
+- Quality assessment and auto-send
+
+## Current Time
+${new Date().toISOString()}`;
+    }
+    buildSummarizePrompt(text, context) {
+        const maxLength = 8000;
+        const truncatedText = text.length > maxLength ? text.substring(0, maxLength) + '...' : text;
+        let prompt = `Please generate a concise and accurate summary for the following document:
+
+${truncatedText}
+
+Please output in the following format:
+## Summary
+[Write summary here]
+
+## Quality Self-Assessment
+[Score 1-10, with reasoning]`;
+        if (context) {
+            prompt = `Context: ${context}
+
+${prompt}`;
+        }
+        return prompt;
+    }
+    buildImprovePrompt(content, requirements, context) {
+        const maxLength = 8000;
+        const truncatedContent = content.length > maxLength ? content.substring(0, maxLength) + '...' : content;
+        let prompt = `Please improve the document according to the following requirements:
+
+Requirements: ${requirements}
+
+Original Document:
+${truncatedContent}
+
+Please output only the improved document without additional explanation.`;
+        if (context) {
+            prompt = `Context: ${context}
+
+${prompt}`;
+        }
+        return prompt;
+    }
+    estimateQuality(original, summary) {
+        const coverageRatio = summary.length / Math.max(original.length, 1);
+        const hasKeyPoints = /\d+\s*[.。]/.test(summary);
+        const decentLength = summary.length > 100 && summary.length < original.length * 0.5;
+        let score = 0.5;
+        if (coverageRatio > 0.1 && coverageRatio < 0.5)
+            score += 0.2;
+        if (hasKeyPoints)
+            score += 0.15;
+        if (decentLength)
+            score += 0.15;
+        return Math.min(1, score);
+    }
+    async shouldAutoSend(qualityScore, threshold = 0.7) {
+        return qualityScore >= threshold;
+    }
+}
+let modelInstance = null;
+function detectProvider() {
+    if (process.env.OPENAI_API_KEY)
+        return 'openai';
+    if (process.env.ANTHROPIC_API_KEY)
+        return 'anthropic';
+    if (process.env.OPENROUTER_API_KEY)
+        return 'openrouter';
+    if (process.env.GEMINI_API_KEY)
+        return 'gemini';
+    if (process.env.OLLAMA_BASE_URL)
+        return 'ollama';
+    if (process.env.MINIMAX_API_KEY)
+        return 'minimax';
+    return 'openai';
+}
+function detectModel(provider) {
+    const defaults = {
+        openai: 'gpt-4',
+        anthropic: 'claude-3-5-sonnet-20241022',
+        ollama: 'llama3.2',
+        openrouter: 'anthropic/claude-3.5-sonnet',
+        gemini: 'gemini-2.0-flash',
+        minimax: 'MiniMax-M2.7',
+        local: 'llama3.2'
+    };
+    return defaults[provider];
+}
+export function initPiAI(config = {}) {
+    const provider = config.provider || detectProvider();
+    const model = config.model || detectModel(provider);
+    modelInstance = new PiAIModel({
+        provider,
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        model
+    });
+    return modelInstance;
+}
+export function getModel() {
+    if (!modelInstance) {
+        throw new Error('PiAI not initialized. Call initPiAI first.');
+    }
+    return modelInstance;
+}
+export function isModelAvailable() {
+    return modelInstance !== null;
+}
+export function getMinimax() {
+    return getModel();
+}
+export function initMinimax(config = {}) {
+    return initPiAI(config);
+}
+export { PiAIModel as MinimaxLLM };

package/dist/bollharness-integration/pi-ecosystem-colony/index.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Pi Ant Colony Integration for Bolloon
+ *
+ * Multi-agent collaboration system with white-box signal protocol.
+ * Based on oh-pi's ant colony system: COLONY_SIGNAL protocol for agent coordination.
+ *
+ * Signal Protocol:
+ * COLONY_SIGNAL:LAUNCHED → SCOUTING → WORKING → REVIEWING → COMPLETE
+ *
+ * Key features:
+ * - Fully visible signal protocol (no black boxes)
+ * - Per-ant turn limits, cost tracking, concurrent scheduling
+ * - White-box design: no "what is it doing in the background" anxiety
+ */
+export type ColonySignal = 'LAUNCHED' | 'SCOUTING' | 'WORKING' | 'REVIEWING' | 'COMPLETE' | 'FAILED' | 'ABORTED';
+export type AntRole = 'scout' | 'worker' | 'reviewer' | 'coordinator';
+export interface Ant {
+    id: string;
+    name: string;
+    role: AntRole;
+    signal: ColonySignal;
+    turnCount: number;
+    maxTurns: number;
+    tokenBudget: number;
+    tokensUsed: number;
+    task?: string;
+    result?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ColonyTask {
+    id: string;
+    description: string;
+    status: 'pending' | 'dispatched' | 'in_progress' | 'completed' | 'failed';
+    assignedAnts: string[];
+    results: Map<string, string>;
+    createdAt: string;
+    completedAt?: string;
+}
+export interface ColonySignalEvent {
+    antId: string;
+    antName: string;
+    fromSignal: ColonySignal;
+    toSignal: ColonySignal;
+    timestamp: string;
+    details?: string;
+}
+/**
+ * Register a new ant in the colony
+ */
+export declare function registerAnt(name: string, role: AntRole, maxTurns?: number, tokenBudget?: number): Ant;
+/**
+ * Transition ant to SCOUTING
+ */
+export declare function antScouting(antId: string, task: string): void;
+/**
+ * Transition ant to WORKING
+ */
+export declare function antWorking(antId: string): void;
+/**
+ * Transition ant to REVIEWING
+ */
+export declare function antReviewing(antId: string): void;
+/**
+ * Complete ant work
+ */
+export declare function antComplete(antId: string, result: string): void;
+/**
+ * Fail ant work
+ */
+export declare function antFail(antId: string, error: string): void;
+/**
+ * Abort ant work
+ */
+export declare function antAbort(antId: string, reason: string): void;
+/**
+ * Increment turn count
+ */
+export declare function antTick(antId: string, tokensUsed?: number): void;
+/**
+ * Create a colony task
+ */
+export declare function createTask(description: string): ColonyTask;
+/**
+ * Dispatch task to ants
+ */
+export declare function dispatchTask(taskId: string, antIds: string[]): void;
+/**
+ * Record ant result for a task
+ */
+export declare function recordResult(taskId: string, antId: string, result: string): void;
+/**
+ * Get ant by ID
+ */
+export declare function getAnt(antId: string): Ant | undefined;
+/**
+ * List all ants
+ */
+export declare function listAnts(): Ant[];
+/**
+ * List ants by role
+ */
+export declare function listAntsByRole(role: AntRole): Ant[];
+/**
+ * Get ants by signal state
+ */
+export declare function listAntsBySignal(signal: ColonySignal): Ant[];
+/**
+ * Get active ants (not complete/failed/aborted)
+ */
+export declare function getActiveAnts(): Ant[];
+/**
+ * Get task by ID
+ */
+export declare function getTask(taskId: string): ColonyTask | undefined;
+/**
+ * List all tasks
+ */
+export declare function listTasks(): ColonyTask[];
+/**
+ * Get signal history
+ */
+export declare function getSignalHistory(): ColonySignalEvent[];
+/**
+ * Get colony status
+ */
+export declare function getColonyStatus(): {
+    antCount: number;
+    activeAnts: number;
+    taskCount: number;
+    activeTasks: number;
+    signalDistribution: Record<ColonySignal, number>;
+};
+/**
+ * Subscribe to colony events
+ */
+export declare function onColonyEvent(event: 'signal' | 'antRegistered' | 'taskCreated', callback: (...args: unknown[]) => void): void;
+/**
+ * Unsubscribe from colony events
+ */
+export declare function offColonyEvent(event: 'signal' | 'antRegistered' | 'taskCreated', callback: (...args: unknown[]) => void): void;
+/**
+ * Get formatted colony dump for debugging
+ */
+export declare function getColonyDump(): string;
+/**
+ * Persist colony state
+ */
+export declare function persistColony(): Promise<void>;
+/**
+ * Load colony state
+ */
+export declare function loadColony(): Promise<void>;