opc-agent 2.0.2 → 3.0.0

package/src/mcp/servers/web-mcp.ts

@@ -0,0 +1,49 @@
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+export function createWebServer(): MCPServerConfig {
+  return {
+    name: 'web',
+    version: '1.0.0',
+    tools: [
+      {
+        name: 'web_fetch',
+        description: 'Fetch a URL and return its content',
+        inputSchema: { type: 'object', properties: { url: { type: 'string' }, method: { type: 'string', default: 'GET' }, headers: { type: 'object' }, body: { type: 'string' } }, required: ['url'] },
+        handler: async (args: { url: string; method?: string; headers?: Record<string, string>; body?: string }) => {
+          const res = await fetch(args.url, { method: args.method || 'GET', headers: args.headers, body: args.body });
+          const contentType = res.headers.get('content-type') || '';
+          const text = await res.text();
+          return { status: res.status, contentType, body: text.slice(0, 50000), truncated: text.length > 50000 };
+        },
+      },
+      {
+        name: 'web_extract_text',
+        description: 'Fetch a URL and extract readable text (strips HTML tags)',
+        inputSchema: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] },
+        handler: async (args: { url: string }) => {
+          const res = await fetch(args.url);
+          const html = await res.text();
+          const text = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+          return { text: text.slice(0, 30000), truncated: text.length > 30000 };
+        },
+      },
+      {
+        name: 'web_search',
+        description: 'Search the web (simulated — returns search URL for manual use)',
+        inputSchema: { type: 'object', properties: { query: { type: 'string' }, engine: { type: 'string', enum: ['google', 'bing', 'duckduckgo'], default: 'duckduckgo' } }, required: ['query'] },
+        handler: async (args: { query: string; engine?: string }) => {
+          const engines: Record<string, string> = {
+            google: `https://www.google.com/search?q=${encodeURIComponent(args.query)}`,
+            bing: `https://www.bing.com/search?q=${encodeURIComponent(args.query)}`,
+            duckduckgo: `https://html.duckduckgo.com/html/?q=${encodeURIComponent(args.query)}`,
+          };
+          const url = engines[args.engine || 'duckduckgo'];
+          const res = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0 opc-mcp/1.0' } });
+          const html = await res.text();
+          const text = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+          return { query: args.query, engine: args.engine || 'duckduckgo', results: text.slice(0, 20000) };
+        },
+      },
+    ],
+  };
+}

package/src/memory/index.ts

@@ -1,5 +1,8 @@
 import type { Message, MemoryStore } from '../core/types';
 
+export { BrainSeedLoader, KnowledgeEvolver } from './seed-loader';
+export type { BrainSeedConfig, SeedPage, SeedResult, PromotionResult, PromotionCandidate } from './seed-loader';
+
 export class InMemoryStore implements MemoryStore {
   private store: Map<string, unknown> = new Map();
   private conversations: Map<string, Message[]> = new Map();

package/src/memory/seed-loader.ts

@@ -0,0 +1,212 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface BrainSeedConfig {
+  seeds: string[];
+  autoSeed: boolean;
+  seedMarkerFile?: string;
+  evolve?: {
+    enabled: boolean;
+    direction: 'bottom-up' | 'top-down';
+  };
+}
+
+export interface SeedPage {
+  slug: string;
+  content: string;
+  tier: string;
+}
+
+export interface SeedResult {
+  imported: number;
+  pages: string[];
+}
+
+export interface PromotionCandidate {
+  slug: string;
+  content: string;
+  fromTier: string;
+  toTier: string;
+  confidence: number;
+}
+
+export interface PromotionResult {
+  candidates: PromotionCandidate[];
+  promoted: number;
+}
+
+export class BrainSeedLoader {
+  private markerFile: string;
+
+  constructor(private agentDir: string, private config: BrainSeedConfig) {
+    this.markerFile = config.seedMarkerFile
+      ? path.resolve(agentDir, config.seedMarkerFile)
+      : path.resolve(agentDir, '.brain-seeded');
+  }
+
+  async isSeeded(): Promise<boolean> {
+    return fs.existsSync(this.markerFile);
+  }
+
+  async seedBrain(brain: any): Promise<SeedResult> {
+    const allPages: SeedPage[] = [];
+
+    for (const seedPath of this.config.seeds) {
+      const fullPath = path.resolve(this.agentDir, seedPath);
+      if (!fs.existsSync(fullPath)) continue;
+
+      const tier = this.inferTier(seedPath);
+      const pages = this.parseSeedFile(fullPath, tier);
+      allPages.push(...pages);
+    }
+
+    const importedSlugs: string[] = [];
+    for (const page of allPages) {
+      if (brain && typeof brain.store === 'function') {
+        await brain.store('brain-seeds', page.slug, page.content, {
+          tier: page.tier,
+          source: 'brain-seed',
+        });
+      } else if (brain && typeof brain.learn === 'function') {
+        await brain.learn(page.content, {
+          tags: ['brain-seed', page.tier],
+          slug: page.slug,
+        });
+      }
+      importedSlugs.push(page.slug);
+    }
+
+    return { imported: importedSlugs.length, pages: importedSlugs };
+  }
+
+  async markSeeded(): Promise<void> {
+    const dir = path.dirname(this.markerFile);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(this.markerFile, JSON.stringify({
+      seededAt: new Date().toISOString(),
+      seeds: this.config.seeds,
+    }, null, 2));
+  }
+
+  parseSeedFile(filePath: string, tier: string): SeedPage[] {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const pages: SeedPage[] = [];
+    const sections = content.split(/^## /m);
+
+    for (const section of sections) {
+      const trimmed = section.trim();
+      if (!trimmed) continue;
+
+      const newlineIdx = trimmed.indexOf('\n');
+      if (newlineIdx === -1 && sections.indexOf(section) === 0 && !content.trimStart().startsWith('## ')) {
+        // This is preamble before any ## heading — skip or treat as intro
+        continue;
+      }
+
+      let title: string;
+      let body: string;
+
+      if (sections.indexOf(section) === 0 && !content.trimStart().startsWith('## ')) {
+        // Preamble (before first ##)
+        continue;
+      }
+
+      if (newlineIdx === -1) {
+        title = trimmed;
+        body = '';
+      } else {
+        title = trimmed.slice(0, newlineIdx).trim();
+        body = trimmed.slice(newlineIdx + 1).trim();
+      }
+
+      const slug = `seed/${tier}/${this.slugify(title)}`;
+      pages.push({ slug, content: `## ${title}\n\n${body}`, tier });
+    }
+
+    return pages;
+  }
+
+  private inferTier(seedPath: string): string {
+    const basename = path.basename(seedPath, path.extname(seedPath)).toLowerCase();
+    if (basename.includes('industry')) return 'industry';
+    if (basename.includes('job')) return 'job';
+    if (basename.includes('workstation')) return 'workstation';
+    return 'workstation';
+  }
+
+  private slugify(text: string): string {
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-')
+      .replace(/^-|-$/g, '');
+  }
+}
+
+export class KnowledgeEvolver {
+  private tierOrder = ['workstation', 'job', 'industry'];
+
+  async checkPromotion(brain: any, options: {
+    minInteractions?: number;
+    confidenceThreshold?: number;
+  } = {}): Promise<PromotionResult> {
+    const minInteractions = options.minInteractions ?? 50;
+    const confidenceThreshold = options.confidenceThreshold ?? 0.8;
+
+    const result: PromotionResult = { candidates: [], promoted: 0 };
+
+    // Search for frequently referenced seed knowledge
+    if (!brain || typeof brain.search !== 'function') return result;
+
+    try {
+      const seedPages = await brain.search('brain-seeds', 'seed/', 100);
+      if (!Array.isArray(seedPages)) return result;
+
+      for (const page of seedPages) {
+        const meta = page.metadata || {};
+        const usageCount = meta.usageCount ?? 0;
+        const tier = meta.tier || 'workstation';
+
+        if (usageCount < minInteractions) continue;
+
+        const confidence = Math.min(usageCount / (minInteractions * 2), 1.0);
+        if (confidence < confidenceThreshold) continue;
+
+        const tierIdx = this.tierOrder.indexOf(tier);
+        if (tierIdx <= 0) continue; // already at highest tier or unknown
+
+        const toTier = this.tierOrder[tierIdx - 1];
+        result.candidates.push({
+          slug: page.id || page.slug,
+          content: page.content,
+          fromTier: tier,
+          toTier,
+          confidence,
+        });
+      }
+    } catch {
+      // Silent fail
+    }
+
+    return result;
+  }
+
+  async promoteToJob(brain: any, knowledge: string, jobSlug: string): Promise<void> {
+    if (brain && typeof brain.store === 'function') {
+      await brain.store('brain-seeds', jobSlug, knowledge, {
+        tier: 'job',
+        source: 'promotion',
+        promotedAt: new Date().toISOString(),
+      });
+    }
+  }
+
+  async promoteToIndustry(brain: any, knowledge: string, industrySlug: string): Promise<void> {
+    if (brain && typeof brain.store === 'function') {
+      await brain.store('brain-seeds', industrySlug, knowledge, {
+        tier: 'industry',
+        source: 'promotion',
+        promotedAt: new Date().toISOString(),
+      });
+    }
+  }
+}

package/src/schema/oad.ts

@@ -167,6 +167,18 @@ export const ProtocolsSchema = z.object({
   mcp: MCPServeSchema.optional(),
 });
 
+export const GuardrailRuleSchema = z.object({
+  name: z.string(),
+  type: z.enum(['regex', 'keyword', 'llm', 'custom']),
+  action: z.enum(['block', 'warn', 'redact', 'log']),
+  config: z.record(z.any()).optional(),
+});
+
+export const GuardrailsSchema = z.object({
+  input: z.array(GuardrailRuleSchema).optional(),
+  output: z.array(GuardrailRuleSchema).optional(),
+});
+
 export const SpecSchema = z.object({
   provider: ProviderSchema.optional(),
   model: z.string().default('deepseek-chat'),
@@ -187,6 +199,7 @@ export const SpecSchema = z.object({
   telemetry: TelemetrySchema.optional(),
   protocols: ProtocolsSchema.optional(),
   plugins: z.array(PluginRefSchema).optional(),
+  guardrails: GuardrailsSchema.optional(),
 });
 
 export const OADSchema = z.object({

package/src/security/guardrails.ts

@@ -0,0 +1,248 @@
+/**
+ * Guardrails Module - v2.1.0
+ * Input/output guardrails for LLM safety: PII, toxicity, injection, compliance.
+ */
+
+// ── Types ───────────────────────────────────────────────────
+
+export interface GuardrailConfig {
+  input?: GuardrailRule[];
+  output?: GuardrailRule[];
+}
+
+export interface GuardrailRule {
+  name: string;
+  type: 'regex' | 'keyword' | 'llm' | 'custom';
+  action: 'block' | 'warn' | 'redact' | 'log';
+  config?: Record<string, any>;
+}
+
+export interface GuardrailResult {
+  passed: boolean;
+  blocked: boolean;
+  warned: boolean;
+  redacted: boolean;
+  message?: string;
+  redactedText?: string;
+  violations: GuardrailViolation[];
+}
+
+export interface GuardrailViolation {
+  rule: string;
+  action: string;
+  detail: string;
+}
+
+// ── Built-in Patterns ───────────────────────────────────────
+
+const PII_PATTERNS: Record<string, RegExp> = {
+  email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+  phone: /(\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g,
+  ssn: /\b\d{3}-\d{2}-\d{4}\b/g,
+  creditCard: /\b(?:\d{4}[-\s]?){3}\d{4}\b/g,
+  ipAddress: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+};
+
+const INJECTION_PATTERNS = [
+  /ignore\s+(all\s+)?previous\s+instructions/i,
+  /ignore\s+(all\s+)?above\s+instructions/i,
+  /system\s*prompt\s*:/i,
+  /you\s+are\s+now\s+(?:a|an|the)\s+/i,
+  /act\s+as\s+(?:a|an)\s+/i,
+  /pretend\s+(?:you(?:'re|\s+are)\s+)?/i,
+  /new\s+instruction[s]?\s*:/i,
+  /override\s+(?:your\s+)?(?:instructions|rules|guidelines)/i,
+  /jailbreak/i,
+  /DAN\s+mode/i,
+];
+
+const TOXICITY_KEYWORDS = [
+  'kill yourself', 'kys', 'go die', 'hate you',
+  'stupid idiot', 'worthless', 'piece of shit',
+];
+
+const COMPLIANCE_PATTERNS = [
+  { pattern: /(?:you\s+should\s+)?(?:buy|sell|invest\s+in)\s+(?:stocks?|crypto|bitcoin)/i, label: 'financial advice' },
+  { pattern: /(?:you\s+(?:have|probably\s+have)|diagnos(?:e|is))\s+(?:\w+\s+){0,3}(?:disease|syndrome|disorder|cancer)/i, label: 'medical diagnosis' },
+  { pattern: /(?:legal(?:ly)?|sue|lawsuit|court)\s+(?:you\s+should|advice)/i, label: 'legal advice' },
+];
+
+// ── Rule Executors ──────────────────────────────────────────
+
+function checkPII(text: string, action: string): { violations: GuardrailViolation[]; redactedText: string } {
+  const violations: GuardrailViolation[] = [];
+  let redacted = text;
+  for (const [type, pattern] of Object.entries(PII_PATTERNS)) {
+    const cloned = new RegExp(pattern.source, pattern.flags);
+    const matches = text.match(cloned);
+    if (matches) {
+      violations.push({ rule: 'pii-detector', action, detail: `Found ${type}: ${matches.length} match(es)` });
+      redacted = redacted.replace(cloned, '[REDACTED]');
+    }
+  }
+  return { violations, redactedText: redacted };
+}
+
+function checkInjection(text: string): GuardrailViolation[] {
+  const violations: GuardrailViolation[] = [];
+  for (const pattern of INJECTION_PATTERNS) {
+    if (pattern.test(text)) {
+      violations.push({ rule: 'prompt-injection', action: 'block', detail: `Matched pattern: ${pattern.source}` });
+      break; // one is enough
+    }
+  }
+  return violations;
+}
+
+function checkToxicity(text: string, extraKeywords?: string[]): GuardrailViolation[] {
+  const lower = text.toLowerCase();
+  const keywords = [...TOXICITY_KEYWORDS, ...(extraKeywords ?? [])];
+  for (const kw of keywords) {
+    if (lower.includes(kw.toLowerCase())) {
+      return [{ rule: 'toxicity', action: 'block', detail: `Matched keyword: "${kw}"` }];
+    }
+  }
+  return [];
+}
+
+function checkTopicRestriction(text: string, config?: Record<string, any>): GuardrailViolation[] {
+  const denyTopics: string[] = config?.denyTopics ?? [];
+  const lower = text.toLowerCase();
+  for (const topic of denyTopics) {
+    if (lower.includes(topic.toLowerCase())) {
+      return [{ rule: 'topic-restrictor', action: 'block', detail: `Blocked topic: "${topic}"` }];
+    }
+  }
+  return [];
+}
+
+function checkLength(text: string, config?: Record<string, any>): GuardrailViolation[] {
+  const maxChars = config?.maxChars ?? 10000;
+  if (text.length > maxChars) {
+    return [{ rule: 'length-limit', action: 'warn', detail: `Response length ${text.length} exceeds max ${maxChars}` }];
+  }
+  return [];
+}
+
+function checkLanguage(text: string, config?: Record<string, any>): GuardrailViolation[] {
+  const allowed: string[] = config?.allowedLanguages ?? [];
+  if (allowed.length === 0) return [];
+  // Simple heuristic: check if text contains CJK characters
+  const hasCJK = /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]/.test(text);
+  const hasLatin = /[a-zA-Z]{3,}/.test(text);
+  if (allowed.includes('en') && !allowed.includes('zh') && hasCJK && !hasLatin) {
+    return [{ rule: 'language-filter', action: 'block', detail: 'Non-allowed language detected' }];
+  }
+  if (allowed.includes('zh') && !allowed.includes('en') && hasLatin && !hasCJK) {
+    return [{ rule: 'language-filter', action: 'block', detail: 'Non-allowed language detected' }];
+  }
+  return [];
+}
+
+function checkCompliance(text: string): GuardrailViolation[] {
+  for (const { pattern, label } of COMPLIANCE_PATTERNS) {
+    if (pattern.test(text)) {
+      return [{ rule: 'compliance-filter', action: 'block', detail: `Potential ${label} detected` }];
+    }
+  }
+  return [];
+}
+
+// ── Guardrail Manager ───────────────────────────────────────
+
+export class GuardrailManager {
+  private config: GuardrailConfig;
+
+  constructor(config: GuardrailConfig) {
+    this.config = config;
+  }
+
+  async checkInput(message: string): Promise<GuardrailResult> {
+    return this.runRules(message, this.config.input ?? []);
+  }
+
+  async checkOutput(response: string): Promise<GuardrailResult> {
+    return this.runRules(response, this.config.output ?? []);
+  }
+
+  private async runRules(text: string, rules: GuardrailRule[]): Promise<GuardrailResult> {
+    const allViolations: GuardrailViolation[] = [];
+    let blocked = false;
+    let warned = false;
+    let redacted = false;
+    let redactedText = text;
+    let blockMessage = '';
+
+    for (const rule of rules) {
+      let violations: GuardrailViolation[] = [];
+
+      switch (rule.name) {
+        case 'pii-detector': {
+          const result = checkPII(text, rule.action);
+          violations = result.violations;
+          if (violations.length > 0 && rule.action === 'redact') {
+            redacted = true;
+            redactedText = result.redactedText;
+          }
+          break;
+        }
+        case 'prompt-injection':
+          violations = checkInjection(text);
+          break;
+        case 'toxicity':
+          violations = checkToxicity(text, rule.config?.keywords);
+          break;
+        case 'topic-restrictor':
+          violations = checkTopicRestriction(text, rule.config);
+          break;
+        case 'length-limit':
+          violations = checkLength(text, rule.config);
+          break;
+        case 'language-filter':
+          violations = checkLanguage(text, rule.config);
+          break;
+        case 'compliance-filter':
+          violations = checkCompliance(text);
+          break;
+        default:
+          // Unknown rule — skip
+          break;
+      }
+
+      if (violations.length > 0) {
+        // Override action from rule config
+        violations = violations.map(v => ({ ...v, action: rule.action }));
+        allViolations.push(...violations);
+
+        if (rule.action === 'block') {
+          blocked = true;
+          blockMessage = `Message blocked by ${rule.name}: ${violations[0].detail}`;
+        } else if (rule.action === 'warn') {
+          warned = true;
+        }
+      }
+    }
+
+    return {
+      passed: allViolations.length === 0,
+      blocked,
+      warned,
+      redacted,
+      message: blocked ? blockMessage : undefined,
+      redactedText: redacted ? redactedText : undefined,
+      violations: allViolations,
+    };
+  }
+}
+
+// ── Factory from OAD config ─────────────────────────────────
+
+export function createGuardrailsFromConfig(config: {
+  input?: Array<{ name: string; type: string; action: string; config?: any }>;
+  output?: Array<{ name: string; type: string; action: string; config?: any }>;
+}): GuardrailManager {
+  return new GuardrailManager({
+    input: config.input as GuardrailRule[],
+    output: config.output as GuardrailRule[],
+  });
+}