@bolloon/bolloon-agent 0.1.0

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

@@ -0,0 +1,300 @@
+/**
+ * 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.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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 { Judgment, DistillationTrigger, DistillationRequest } from './index.js';
+export interface DistillationResult {
+    success: boolean;
+    judgment?: Judgment;
+    error?: string;
+    trigger: DistillationTrigger;
+}
+export interface FeedbackSignal {
+    judgmentId: string;
+    type: 'approve' | 'reject' | 'correct';
+    correction?: {
+        original: string;
+        corrected: string;
+        reason?: string;
+    };
+}
+export interface TrajectoryEntry {
+    timestamp: string;
+    action: string;
+    outcome: string;
+    approved: boolean;
+}
+/**
+ * Initialize the distillation system
+ */
+export declare function initializeDistillation(): Promise<void>;
+/**
+ * Detect trigger type from human input
+ */
+export declare function detectTrigger(input: string): DistillationTrigger | null;
+/**
+ * Check if input indicates a judgment correction
+ */
+export declare function detectCorrection(input: string): {
+    original: string;
+    corrected: string;
+} | null;
+/**
+ * Add to trajectory buffer
+ */
+export declare function addToTrajectory(agentId: string, action: string, outcome: string, approved: boolean): void;
+/**
+ * Detect trajectory pattern (repeated similar actions)
+ */
+export declare function detectTrajectoryPattern(agentId: string): TrajectoryEntry[] | null;
+/**
+ * Distill human input to judgment using LLM
+ */
+export declare function distillInput(request: DistillationRequest): Promise<DistillationResult>;
+/**
+ * Process feedback signal
+ */
+export declare function processFeedback(signal: FeedbackSignal): Promise<void>;
+/**
+ * Check if human input contains judgment signal
+ */
+export declare function isJudgmentSignal(input: string): boolean;
+/**
+ * Get trajectory buffer statistics
+ */
+export declare function getTrajectoryStats(): Record<string, {
+    count: number;
+    approvalRate: number;
+}>;
+/**
+ * Clear trajectory buffer for agent
+ */
+export declare function clearTrajectory(agentId?: string): void;

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

@@ -0,0 +1,291 @@
+/**
+ * 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();
+    }
+}