@bolloon/bolloon-agent 0.1.0 → 0.1.1

package/src/pi-ecosystem-judgment/distillation.ts

@@ -1,398 +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 * as fs from 'fs/promises';
-import * as path from 'path';
-import {
-  Judgment,
-  JudgmentType,
-  DistillationTrigger,
-  DistillationRequest,
-  createJudgment,
-  updateJudgmentConfidence,
-  getAllJudgments,
-} from './index.js';
-import { getModel, type PiAIModel } from '../llm/pi-ai.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;
-  };
-}
-
-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: Map<string, TrajectoryEntry[]> = new Map();
-let llmModel: PiAIModel | null = null;
-
-export interface TrajectoryEntry {
-  timestamp: string;
-  action: string;
-  outcome: string;
-  approved: boolean;
-}
-
-interface ConversationTurn {
-  role: 'human' | 'agent';
-  content: string;
-  timestamp: string;
-}
-
-/**
- * Initialize the distillation system
- */
-export async function initializeDistillation(): Promise<void> {
-  try {
-    llmModel = getModel();
-  } catch {
-    console.warn('[Distillation] LLM model not available, using fallback');
-  }
-}
-
-/**
- * Detect trigger type from human input
- */
-export function detectTrigger(input: string): DistillationTrigger | null {
-  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: string): { original: string; corrected: string } | null {
-  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: string, action: string, outcome: string, approved: boolean): void {
-  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: string): TrajectoryEntry[] | null {
-  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: DistillationRequest): Promise<DistillationResult> {
-  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: string,
-  trigger: DistillationTrigger,
-  context: string,
-  conversationHistory?: string[]
-): Promise<{
-  type: JudgmentType;
-  content: string;
-  confidence: number;
-  evidence?: Judgment['evidence'];
-}> {
-  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: string,
-  rawInput: string,
-  trigger: DistillationTrigger
-): {
-  type: JudgmentType;
-  content: string;
-  confidence: number;
-} {
-  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: string,
-  trigger: DistillationTrigger
-): {
-  type: JudgmentType;
-  content: string;
-  confidence: number;
-} {
-  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: string, trigger: DistillationTrigger): JudgmentType {
-  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: FeedbackSignal): Promise<void> {
-  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: string): boolean {
-  return detectTrigger(input) !== null;
-}
-
-/**
- * Get trajectory buffer statistics
- */
-export function getTrajectoryStats(): Record<string, { count: number; approvalRate: number }> {
-  const stats: Record<string, { count: number; approvalRate: number }> = {};
-
-  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?: string): void {
-  if (agentId) {
-    trajectoryBuffer.delete(agentId);
-  } else {
-    trajectoryBuffer.clear();
-  }
-}