@bolloon/bolloon-agent 0.1.38 → 0.1.39

package/dist/bollharness-integration/pi-ecosystem-judgment/decision.js

@@ -1,300 +0,0 @@
-/**
- * Decision Request & Authorization Flow
- *
- * Handles decision requests when agent confidence is below threshold.
- * Supports consulting internal agents (colony/subagents) and external agents (P2P).
- *
- * Flow:
- * Agent Decision Need
- *     ↓
- * Query ValueFunction → Calculate Confidence
- *     ↓
- * Confidence > Threshold → Execute
- *     ↓ (No)
- * DecisionRequest → [Human | Internal Agents | External Agents]
- *     ↓
- * Authorization / Collaboration
- *     ↓
- * Execute & Archive Judgment
- */
-import { EventEmitter } from 'events';
-import { getValueFunction, calculateConfidence, } from './index.js';
-import { distillInput, isJudgmentSignal, detectTrigger, processFeedback, } from './distillation.js';
-import { listAnts } from '../pi-ecosystem-colony/index.js';
-import { listSubagents } from '../pi-ecosystem-subagents/index.js';
-class DecisionEventEmitter extends EventEmitter {
-}
-const decisionEvents = new DecisionEventEmitter();
-const decisionRequests = new Map();
-let defaultThreshold = 0.7;
-let defaultLevel = 'autonomous';
-function generateDecisionId() {
-    return `dec-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-}
-/**
- * Set default confidence threshold
- */
-export function setConfidenceThreshold(threshold) {
-    defaultThreshold = Math.max(0, Math.min(1, threshold));
-}
-/**
- * Get default confidence threshold
- */
-export function getConfidenceThreshold() {
-    return defaultThreshold;
-}
-/**
- * Set default decision level
- */
-export function setDefaultDecisionLevel(level) {
-    defaultLevel = level;
-}
-/**
- * Get default decision level
- */
-export function getDefaultDecisionLevel() {
-    return defaultLevel;
-}
-/**
- * Evaluate a decision need and determine appropriate level
- */
-export async function evaluateDecision(description, context, agentId, threshold) {
-    const effectiveThreshold = threshold ?? defaultThreshold;
-    const valueFunction = await getValueFunction(context);
-    const judgments = valueFunction.judgments.filter((j) => j.context?.toLowerCase().includes(context.toLowerCase()));
-    const confidence = calculateConfidence(judgments);
-    const level = determineDecisionLevel(confidence, effectiveThreshold);
-    const targets = determineConsultationTargets(level);
-    const request = {
-        id: generateDecisionId(),
-        description,
-        context,
-        confidence,
-        threshold: effectiveThreshold,
-        level,
-        targets,
-        status: 'pending',
-        agentId,
-        createdAt: new Date().toISOString(),
-    };
-    decisionRequests.set(request.id, request);
-    decisionEvents.emit('decisionCreated', request);
-    console.log(`[Decision] Request ${request.id}: confidence=${confidence.toFixed(2)}, level=${level}`);
-    return request;
-}
-/**
- * Determine decision level based on confidence
- */
-function determineDecisionLevel(confidence, threshold) {
-    if (confidence >= threshold) {
-        return 'autonomous';
-    }
-    if (confidence >= threshold * 0.7) {
-        return 'consult_internal';
-    }
-    if (confidence >= threshold * 0.4) {
-        return 'consult_external';
-    }
-    return 'require_human';
-}
-/**
- * Determine consultation targets based on decision level
- */
-function determineConsultationTargets(level) {
-    switch (level) {
-        case 'autonomous':
-            return [];
-        case 'consult_internal':
-            return ['colony_ant', 'subagent'];
-        case 'consult_external':
-            return ['colony_ant', 'subagent', 'p2p_agent'];
-        case 'require_human':
-            return ['human'];
-        default:
-            return [];
-    }
-}
-/**
- * Submit a decision response
- */
-export async function submitDecisionResponse(requestId, response) {
-    const request = decisionRequests.get(requestId);
-    if (!request)
-        return null;
-    request.response = response;
-    request.respondedAt = new Date().toISOString();
-    if (response.authorized) {
-        request.status = 'authorized';
-    }
-    else {
-        request.status = 'rejected';
-    }
-    decisionRequests.set(requestId, request);
-    decisionEvents.emit('decisionResponded', request);
-    if (response.delegate) {
-        console.log(`[Decision] Request ${requestId} delegated to ${response.delegate}`);
-    }
-    return request;
-}
-/**
- * Check if input is a decision response
- */
-export function isDecisionResponse(input) {
-    const patterns = [
-        /^(是|可以|同意|授权|执行|对|好|ok|yes|y)/i,
-        /^(不|否|拒绝|不行|no|n)/i,
-        /^(修改|改为|改成|用|用这个)/i,
-    ];
-    return patterns.some((p) => p.test(input.trim()));
-}
-/**
- * Parse decision response from natural language
- */
-export function parseDecisionResponse(input) {
-    const trimmed = input.trim().toLowerCase();
-    if (/^(是|可以|同意|授权|执行|对|好|ok|yes|y)/.test(trimmed)) {
-        return { authorized: true, content: input };
-    }
-    if (/^(不|否|拒绝|不行|no|n)/.test(trimmed)) {
-        return { authorized: false, content: input };
-    }
-    if (/^(修改|改为|改成|用|用这个)/.test(trimmed)) {
-        const match = input.match(/^(?:修改|改为|改成|用|用这个)\s*(.+)/i);
-        return {
-            authorized: true,
-            modifier: match ? match[1] : input,
-            content: input,
-        };
-    }
-    return { authorized: true, content: input };
-}
-/**
- * Query internal agents (colony ants and subagents)
- */
-export async function queryInternalAgents(request) {
-    const results = [];
-    if (request.targets.includes('colony_ant')) {
-        const ants = listAnts().filter((a) => a.signal !== 'COMPLETE' && a.signal !== 'FAILED');
-        for (const ant of ants.slice(0, 3)) {
-            const result = await consultColonyAnt(ant, request);
-            if (result)
-                results.push(result);
-        }
-    }
-    if (request.targets.includes('subagent')) {
-        const subagents = listSubagents().filter((s) => s.status === 'running');
-        for (const subagent of subagents.slice(0, 2)) {
-            const result = await consultSubagent(subagent, request);
-            if (result)
-                results.push(result);
-        }
-    }
-    return results;
-}
-/**
- * Consult a colony ant
- */
-async function consultColonyAnt(ant, request) {
-    console.log(`[Decision] Consulting ant ${ant.name} for ${request.id}`);
-    return {
-        target: 'colony_ant',
-        agentId: ant.id,
-        response: `[Simulated] Ant ${ant.name} suggests: ${request.description.substring(0, 30)}...`,
-        confidence: 0.6,
-    };
-}
-/**
- * Consult a subagent
- */
-async function consultSubagent(subagent, request) {
-    console.log(`[Decision] Consulting subagent ${subagent.name} for ${request.id}`);
-    return {
-        target: 'subagent',
-        agentId: subagent.id,
-        response: `[Simulated] Subagent ${subagent.name} advises: ${request.description.substring(0, 30)}...`,
-        confidence: 0.65,
-    };
-}
-/**
- * Process human feedback and distill to judgment
- */
-export async function processHumanFeedback(requestId, input) {
-    const request = decisionRequests.get(requestId);
-    if (!request)
-        return null;
-    const parsed = parseDecisionResponse(input);
-    const by = 'human';
-    const response = {
-        authorized: parsed.authorized ?? false,
-        content: parsed.content ?? input,
-        modifier: parsed.modifier,
-        delegate: parsed.delegate,
-        by,
-        timestamp: new Date().toISOString(),
-    };
-    await submitDecisionResponse(requestId, response);
-    if (isJudgmentSignal(input)) {
-        const trigger = detectTrigger(input);
-        if (trigger) {
-            const result = await distillInput({
-                rawInput: input,
-                trigger,
-                context: request.context,
-            });
-            if (result.success && result.judgment) {
-                request.judgment = result.judgment;
-                decisionRequests.set(requestId, request);
-            }
-        }
-    }
-    const feedback = {
-        judgmentId: request.judgment?.id || '',
-        type: parsed.authorized ? 'approve' : 'reject',
-        correction: parsed.modifier
-            ? {
-                original: request.description,
-                corrected: parsed.modifier,
-            }
-            : undefined,
-    };
-    if (feedback.judgmentId) {
-        await processFeedback(feedback);
-    }
-    return request;
-}
-/**
- * Get pending decision requests
- */
-export function getPendingDecisions() {
-    return Array.from(decisionRequests.values()).filter((r) => r.status === 'pending');
-}
-/**
- * Get decision request by ID
- */
-export function getDecisionRequest(id) {
-    return decisionRequests.get(id);
-}
-/**
- * Get decision statistics
- */
-export function getDecisionStats() {
-    const requests = Array.from(decisionRequests.values());
-    return {
-        pending: requests.filter((r) => r.status === 'pending').length,
-        authorized: requests.filter((r) => r.status === 'authorized').length,
-        rejected: requests.filter((r) => r.status === 'rejected').length,
-        total: requests.length,
-    };
-}
-/**
- * Subscribe to decision events
- */
-export function onDecisionEvent(event, callback) {
-    decisionEvents.on(event, callback);
-}
-/**
- * Unsubscribe from decision events
- */
-export function offDecisionEvent(event, callback) {
-    decisionEvents.off(event, callback);
-}

package/dist/bollharness-integration/pi-ecosystem-judgment/distillation.js

@@ -1,291 +0,0 @@
-/**
- * Judgment Distillation Module
- *
- * Real-time LLM-based distillation of human input into Judgment principles.
- *
- * Flow:
- * Human Input → Trigger Detection → LLM Extraction → Judgment
- *                    ↓
- *            Confidence + Evidence
- */
-import { createJudgment, updateJudgmentConfidence, } from './index.js';
-import { getModel } from '../llm/pi-ai.js';
-const TRIGGER_PATTERNS = {
-    explicit: [
-        /不，我想要(.+)而不是(.+)/i,
-        /错了，应该是(.+)/i,
-        /这不是我想要的(.+)，要(.+)/i,
-        /不对，应该(.+)/i,
-        /重做，要(.+)/i,
-        /不对，(?:我|应该|要|必须)(.+)/i,
-    ],
-    implicit: [
-        /^(?!.*[?!]).{10,50}$/, // Short statements that might indicate preference
-    ],
-};
-const MIN_TRAJECTORY_COUNT = 3;
-const IMPLICIT_THRESHOLD = 0.7;
-let trajectoryBuffer = new Map();
-let llmModel = null;
-/**
- * Initialize the distillation system
- */
-export async function initializeDistillation() {
-    try {
-        llmModel = getModel();
-    }
-    catch {
-        console.warn('[Distillation] LLM model not available, using fallback');
-    }
-}
-/**
- * Detect trigger type from human input
- */
-export function detectTrigger(input) {
-    for (const pattern of TRIGGER_PATTERNS.explicit) {
-        if (pattern.test(input)) {
-            return 'explicit';
-        }
-    }
-    for (const pattern of TRIGGER_PATTERNS.implicit) {
-        if (pattern.test(input)) {
-            return 'implicit';
-        }
-    }
-    return null;
-}
-/**
- * Check if input indicates a judgment correction
- */
-export function detectCorrection(input) {
-    for (const pattern of TRIGGER_PATTERNS.explicit) {
-        const match = input.match(pattern);
-        if (match) {
-            if (match.length >= 3) {
-                return { original: match[2], corrected: match[1] };
-            }
-            else if (match.length >= 2) {
-                return { original: '', corrected: match[1] };
-            }
-        }
-    }
-    return null;
-}
-/**
- * Add to trajectory buffer
- */
-export function addToTrajectory(agentId, action, outcome, approved) {
-    if (!trajectoryBuffer.has(agentId)) {
-        trajectoryBuffer.set(agentId, []);
-    }
-    const entries = trajectoryBuffer.get(agentId);
-    entries.push({
-        timestamp: new Date().toISOString(),
-        action,
-        outcome,
-        approved,
-    });
-    if (entries.length > 20) {
-        entries.shift();
-    }
-}
-/**
- * Detect trajectory pattern (repeated similar actions)
- */
-export function detectTrajectoryPattern(agentId) {
-    const entries = trajectoryBuffer.get(agentId);
-    if (!entries || entries.length < MIN_TRAJECTORY_COUNT)
-        return null;
-    const approvals = entries.filter((e) => e.approved);
-    const approvalRate = approvals.length / entries.length;
-    if (approvalRate >= IMPLICIT_THRESHOLD) {
-        return entries.slice(-MIN_TRAJECTORY_COUNT);
-    }
-    return null;
-}
-/**
- * Distill human input to judgment using LLM
- */
-export async function distillInput(request) {
-    const { rawInput, trigger, context, conversationHistory } = request;
-    console.log(`[Distillation] Distilling input (${trigger}): ${rawInput.substring(0, 50)}...`);
-    try {
-        const judgment = await llmDistill(rawInput, trigger, context, conversationHistory);
-        const created = await createJudgment({
-            type: judgment.type,
-            content: judgment.content,
-            source: 'human',
-            confidence: judgment.confidence,
-            context: context,
-            evidence: judgment.evidence,
-        });
-        return {
-            success: true,
-            judgment: created,
-            trigger,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: String(error),
-            trigger,
-        };
-    }
-}
-/**
- * LLM-based distillation
- */
-async function llmDistill(rawInput, trigger, context, conversationHistory) {
-    if (!llmModel) {
-        return fallbackDistill(rawInput, trigger);
-    }
-    const historyText = conversationHistory
-        ? conversationHistory.slice(-5).join('\n')
-        : 'No history';
-    const prompt = `从以下人类输入中提取判断力原理。
-
-输入类型: ${trigger}
-输入内容: ${rawInput}
-上下文: ${context}
-对话历史:
-${historyText}
-
-请提取：
-1. type: rule(明确规则) | preference(偏好) | trajectory(行为轨迹) | reward(奖励信号)
-2. content: 凝练后的原理（简洁，1-2句话）
-3. confidence: 0.0-1.0 的置信度
-4. evidence: 支持证据（如有）
-
-直接输出JSON格式，不需要解释。`;
-    try {
-        const response = await llmModel.chat(`对话: ${historyText}\n\n输入: ${rawInput}`, `你是判断力提取专家。从人类输入中提取判断力原理。输入类型: ${trigger}`);
-        return parseDistillationResponse(response.reply, rawInput, trigger);
-    }
-    catch (error) {
-        console.warn('[Distillation] LLM distillation failed, using fallback:', error);
-        return fallbackDistill(rawInput, trigger);
-    }
-}
-/**
- * Parse LLM distillation response
- */
-function parseDistillationResponse(response, rawInput, trigger) {
-    try {
-        const jsonMatch = response.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-            const parsed = JSON.parse(jsonMatch[0]);
-            return {
-                type: parsed.type || inferType(rawInput, trigger),
-                content: parsed.content || rawInput,
-                confidence: Math.min(1, Math.max(0, parseFloat(parsed.confidence) || 0.7)),
-            };
-        }
-    }
-    catch { }
-    return {
-        ...fallbackDistill(rawInput, trigger),
-    };
-}
-/**
- * Fallback distillation when LLM is unavailable
- */
-function fallbackDistill(rawInput, trigger) {
-    const correction = detectCorrection(rawInput);
-    if (correction) {
-        return {
-            type: 'rule',
-            content: `${correction.corrected}（而非 ${correction.original}）`,
-            confidence: 0.95,
-        };
-    }
-    if (trigger === 'explicit') {
-        return {
-            type: 'rule',
-            content: rawInput,
-            confidence: 0.9,
-        };
-    }
-    if (trigger === 'trajectory') {
-        return {
-            type: 'trajectory',
-            content: '检测到重复行为模式',
-            confidence: 0.75,
-        };
-    }
-    return {
-        type: 'preference',
-        content: rawInput,
-        confidence: 0.6,
-    };
-}
-/**
- * Infer judgment type from input content
- */
-function inferType(input, trigger) {
-    const lower = input.toLowerCase();
-    if (lower.includes('不要') || lower.includes('禁止') || lower.includes('必须') || lower.includes('应该')) {
-        return 'rule';
-    }
-    if (lower.includes('喜欢') || lower.includes('偏好') || lower.includes('宁愿')) {
-        return 'preference';
-    }
-    if (trigger === 'trajectory') {
-        return 'trajectory';
-    }
-    return 'preference';
-}
-/**
- * Process feedback signal
- */
-export async function processFeedback(signal) {
-    const { judgmentId, type, correction } = signal;
-    if (correction) {
-        await createJudgment({
-            type: 'rule',
-            content: correction.corrected,
-            source: 'human',
-            confidence: 0.95,
-            evidence: {
-                correction: {
-                    original: correction.original,
-                    corrected: correction.corrected,
-                    reason: correction.reason,
-                    timestamp: new Date().toISOString(),
-                },
-            },
-        });
-    }
-    await updateJudgmentConfidence(judgmentId, 0.1, type);
-}
-/**
- * Check if human input contains judgment signal
- */
-export function isJudgmentSignal(input) {
-    return detectTrigger(input) !== null;
-}
-/**
- * Get trajectory buffer statistics
- */
-export function getTrajectoryStats() {
-    const stats = {};
-    for (const [agentId, entries] of trajectoryBuffer.entries()) {
-        const approvals = entries.filter((e) => e.approved).length;
-        stats[agentId] = {
-            count: entries.length,
-            approvalRate: entries.length > 0 ? approvals / entries.length : 0,
-        };
-    }
-    return stats;
-}
-/**
- * Clear trajectory buffer for agent
- */
-export function clearTrajectory(agentId) {
-    if (agentId) {
-        trajectoryBuffer.delete(agentId);
-    }
-    else {
-        trajectoryBuffer.clear();
-    }
-}