opc-agent 1.3.2 → 2.0.0

package/src/schema/oad.ts

@@ -120,6 +120,18 @@ export const StreamingSchema = z.object({
   chunkSize: z.number().optional(),
 });
 
+export const MCPServerSchema = z.object({
+  name: z.string(),
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string()).optional(),
+});
+
+export const ToolsSchema = z.object({
+  builtin: z.array(z.string()).optional(),
+  mcp: z.array(MCPServerSchema).optional(),
+});
+
 export const SpecSchema = z.object({
   provider: ProviderSchema.optional(),
   model: z.string().default('deepseek-chat'),
@@ -127,6 +139,7 @@ export const SpecSchema = z.object({
   skills: z.array(SkillRefSchema).default([]),
   channels: z.array(ChannelSchema).default([]),
   memory: MemorySchema.optional(),
+  tools: ToolsSchema.optional(),
   dtv: DTVSchema.optional(),
   room: RoomSchema.optional(),
   streaming: z.union([z.boolean(), StreamingSchema]).default(false),
@@ -151,5 +164,4 @@ export type SkillRef = z.infer<typeof SkillRefSchema>;
 export type Channel = z.infer<typeof ChannelSchema>;
 export type Metadata = z.infer<typeof MetadataSchema>;
 export type Spec = z.infer<typeof SpecSchema>;
-export type DTVConfig = z.infer<typeof DTVSchema>;
-export type TrustLevelType = z.infer<typeof TrustLevel>;
+export type TrustLevelType = string;

package/src/skills/auto-learn.ts

@@ -0,0 +1,262 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import type { Message } from '../core/types';
+import type { LLMProvider } from '../providers';
+
+export interface LearnedSkill {
+  name: string;
+  description: string;
+  trigger: string;
+  instructions: string;
+  examples: string[];
+  createdAt: Date;
+  usageCount: number;
+  lastUsed?: Date;
+  version: number;
+}
+
+const SKILL_EXTRACTION_PROMPT = `Analyze this conversation and determine if it represents a repeatable task that should be saved as a reusable skill.
+
+Criteria for creating a skill:
+1. The task is specific and well-defined
+2. It could reasonably happen again
+3. The solution has clear steps
+
+If yes, extract:
+- name: short kebab-case name
+- description: one-line description
+- trigger: regex pattern or keywords that would identify this task
+- instructions: step-by-step instructions to complete the task
+- examples: 2-3 example user inputs that would trigger this skill
+
+If this is just casual chat or a one-off question, return null.
+
+Respond in JSON format only: { "shouldCreate": boolean, "skill": { "name": string, "description": string, "trigger": string, "instructions": string, "examples": string[] } | null }
+
+Conversation:
+`;
+
+const SKILL_IMPROVEMENT_PROMPT = `This skill was just used. Based on the outcome, suggest improvements:
+
+Current skill:
+`;
+
+const SKILL_IMPROVEMENT_SUFFIX = `
+
+Respond in JSON only: { "shouldImprove": boolean, "improvements": { "instructions"?: string, "trigger"?: string, "examples"?: string[] } | null }`;
+
+export class SkillLearner {
+  private skillsDir: string;
+  private skills: LearnedSkill[] = [];
+  private loaded = false;
+
+  constructor(skillsDir: string) {
+    this.skillsDir = skillsDir;
+  }
+
+  async analyzeForSkillCreation(
+    conversation: Message[],
+    provider: LLMProvider,
+  ): Promise<LearnedSkill | null> {
+    const conversationText = conversation
+      .map((m) => `${m.role}: ${m.content}`)
+      .join('\n');
+
+    const prompt = SKILL_EXTRACTION_PROMPT + conversationText;
+
+    try {
+      const response = await provider.chat(
+        [{ id: 'analysis', role: 'user', content: prompt, timestamp: Date.now() }],
+        'You are a skill extraction assistant. Respond only with valid JSON.',
+      );
+
+      const json = extractJson(response);
+      if (!json || !json.shouldCreate || !json.skill) return null;
+
+      const skill: LearnedSkill = {
+        name: json.skill.name,
+        description: json.skill.description,
+        trigger: json.skill.trigger,
+        instructions: json.skill.instructions,
+        examples: json.skill.examples || [],
+        createdAt: new Date(),
+        usageCount: 0,
+        version: 1,
+      };
+
+      return skill;
+    } catch {
+      return null;
+    }
+  }
+
+  async saveSkill(skill: LearnedSkill): Promise<void> {
+    fs.mkdirSync(this.skillsDir, { recursive: true });
+    const filePath = path.join(this.skillsDir, `${skill.name}.md`);
+    fs.writeFileSync(filePath, skillToMarkdown(skill), 'utf-8');
+
+    // Update cache
+    const idx = this.skills.findIndex((s) => s.name === skill.name);
+    if (idx >= 0) {
+      this.skills[idx] = skill;
+    } else {
+      this.skills.push(skill);
+    }
+  }
+
+  async loadLearnedSkills(): Promise<LearnedSkill[]> {
+    if (!fs.existsSync(this.skillsDir)) return [];
+
+    const files = fs.readdirSync(this.skillsDir).filter((f) => f.endsWith('.md'));
+    this.skills = files
+      .map((f) => {
+        try {
+          const content = fs.readFileSync(path.join(this.skillsDir, f), 'utf-8');
+          return parseSkillMarkdown(content);
+        } catch {
+          return null;
+        }
+      })
+      .filter((s): s is LearnedSkill => s !== null);
+
+    this.loaded = true;
+    return this.skills;
+  }
+
+  matchSkill(message: string): LearnedSkill | null {
+    if (!this.loaded) return null;
+
+    for (const skill of this.skills) {
+      try {
+        const regex = new RegExp(skill.trigger, 'i');
+        if (regex.test(message)) return skill;
+      } catch {
+        // Fallback: keyword matching — split on common separators, strip non-word chars
+        const keywords = skill.trigger.split(/[\s,;|]+/).map(k => k.replace(/[^\w-]/g, '').toLowerCase()).filter(k => k.length > 2);
+        const lower = message.toLowerCase();
+        if (keywords.some((kw) => lower.includes(kw))) return skill;
+      }
+    }
+    return null;
+  }
+
+  async improveSkill(
+    skill: LearnedSkill,
+    conversation: Message[],
+    provider: LLMProvider,
+  ): Promise<void> {
+    const conversationText = conversation
+      .map((m) => `${m.role}: ${m.content}`)
+      .join('\n');
+
+    const prompt =
+      SKILL_IMPROVEMENT_PROMPT +
+      skillToMarkdown(skill) +
+      '\n\nConversation where it was used:\n' +
+      conversationText +
+      SKILL_IMPROVEMENT_SUFFIX;
+
+    try {
+      const response = await provider.chat(
+        [{ id: 'improve', role: 'user', content: prompt, timestamp: Date.now() }],
+        'You are a skill improvement assistant. Respond only with valid JSON.',
+      );
+
+      const json = extractJson(response);
+      if (!json || !json.shouldImprove || !json.improvements) return;
+
+      const { improvements } = json;
+      if (improvements.instructions) skill.instructions = improvements.instructions;
+      if (improvements.trigger) skill.trigger = improvements.trigger;
+      if (improvements.examples) skill.examples = [...skill.examples, ...improvements.examples];
+      skill.version++;
+
+      await this.saveSkill(skill);
+    } catch {
+      // Silently fail — improvement is best-effort
+    }
+  }
+
+  getSkills(): LearnedSkill[] {
+    return [...this.skills];
+  }
+}
+
+// ─── Helpers ────────────────────────────────────────────────
+
+function extractJson(text: string): any {
+  // Try to extract JSON from response (may be wrapped in markdown code block)
+  const match = text.match(/\{[\s\S]*\}/);
+  if (!match) return null;
+  try {
+    return JSON.parse(match[0]);
+  } catch {
+    return null;
+  }
+}
+
+export function skillToMarkdown(skill: LearnedSkill): string {
+  const lines = [
+    `# Skill: ${skill.name}`,
+    '',
+    '## Description',
+    skill.description,
+    '',
+    '## Trigger',
+    `Pattern: ${skill.trigger}`,
+    '',
+    '## Instructions',
+    skill.instructions,
+    '',
+    '## Examples',
+    ...skill.examples.map((e) => `- "${e}"`),
+    '',
+    '## Metadata',
+    `- Created: ${skill.createdAt.toISOString()}`,
+    `- Version: ${skill.version}`,
+    `- Usage Count: ${skill.usageCount}`,
+    `- Last Used: ${skill.lastUsed?.toISOString() ?? 'never'}`,
+    '',
+  ];
+  return lines.join('\n');
+}
+
+export function parseSkillMarkdown(content: string): LearnedSkill | null {
+  const nameMatch = content.match(/^# Skill:\s*(.+)$/m);
+  if (!nameMatch) return null;
+
+  const section = (heading: string): string => {
+    const re = new RegExp(`## ${heading}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`);
+    const m = content.match(re);
+    return m ? m[1].trim() : '';
+  };
+
+  const description = section('Description');
+  const triggerLine = section('Trigger');
+  const trigger = triggerLine.replace(/^Pattern:\s*/i, '').trim();
+  const instructions = section('Instructions');
+
+  const examplesRaw = section('Examples');
+  const examples = examplesRaw
+    .split('\n')
+    .map((l) => l.replace(/^-\s*"?|"?\s*$/g, '').trim())
+    .filter(Boolean);
+
+  const metadata = section('Metadata');
+  const getMeta = (key: string): string => {
+    const m = metadata.match(new RegExp(`- ${key}:\\s*(.+)`, 'i'));
+    return m ? m[1].trim() : '';
+  };
+
+  return {
+    name: nameMatch[1].trim(),
+    description,
+    trigger,
+    instructions,
+    examples,
+    createdAt: new Date(getMeta('Created') || Date.now()),
+    version: parseInt(getMeta('Version') || '1', 10),
+    usageCount: parseInt(getMeta('Usage Count') || '0', 10),
+    lastUsed: getMeta('Last Used') !== 'never' ? new Date(getMeta('Last Used')) : undefined,
+  };
+}

package/src/skills/base.ts

@@ -1,16 +1,16 @@
-import type { ISkill, AgentContext, Message, SkillResult } from '../core/types';
-
-export abstract class BaseSkill implements ISkill {
-  abstract name: string;
-  abstract description: string;
-
-  abstract execute(context: AgentContext, message: Message): Promise<SkillResult>;
-
-  protected noMatch(): SkillResult {
-    return { handled: false, confidence: 0 };
-  }
-
-  protected match(response: string, confidence: number = 1.0): SkillResult {
-    return { handled: true, response, confidence };
-  }
-}
+import type { ISkill, AgentContext, Message, SkillResult } from '../core/types';
+
+export abstract class BaseSkill implements ISkill {
+  abstract name: string;
+  abstract description: string;
+
+  abstract execute(context: AgentContext, message: Message): Promise<SkillResult>;
+
+  protected noMatch(): SkillResult {
+    return { handled: false, confidence: 0 };
+  }
+
+  protected match(response: string, confidence: number = 1.0): SkillResult {
+    return { handled: true, response, confidence };
+  }
+}

package/src/skills/document.ts

@@ -1,100 +1,100 @@
-import { BaseSkill } from './base';
-import type { AgentContext, Message, SkillResult } from '../core/types';
-import { KnowledgeBase } from '../core/knowledge';
-
-export interface DocumentChunk {
-  content: string;
-  metadata: {
-    filename: string;
-    mimeType: string;
-    chunkIndex: number;
-    totalChunks: number;
-  };
-}
-
-export class DocumentSkill extends BaseSkill {
-  name = 'document';
-  description = 'Process uploaded documents (PDF, TXT, MD, DOCX). Chunks content and adds to knowledge base.';
-  private knowledgeBase: KnowledgeBase;
-
-  constructor(kbPath: string = '.') {
-    super();
-    this.knowledgeBase = new KnowledgeBase(kbPath);
-  }
-
-  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
-    // Check if message has document attachment metadata
-    const meta = message.metadata;
-    if (!meta?.document) return this.noMatch();
-
-    const { content, filename, mimeType } = meta.document as {
-      content: string; filename: string; mimeType: string;
-    };
-
-    try {
-      const text = this.extractText(content, mimeType ?? this.guessMime(filename));
-      const chunks = this.chunk(text, 1000, 100);
-
-      const result = await this.knowledgeBase.addText(
-        chunks.map(c => c.content).join('\n\n---\n\n'),
-        filename
-      );
-
-      return this.match(
-        `📄 Processed "${filename}": ${chunks.length} chunks, ${text.length} chars → added to knowledge base (${result.chunks} KB entries)`
-      );
-    } catch (err) {
-      return this.match(`Document processing error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-
-  extractText(content: string, mimeType: string): string {
-    // For plain text formats, content is already text
-    if (mimeType.includes('text/') || mimeType.includes('markdown')) {
-      return content;
-    }
-    // For other formats, assume base64-encoded or pre-extracted text
-    // In a real implementation, you'd use pdf-parse, mammoth, etc.
-    return content;
-  }
-
-  chunk(text: string, size: number = 1000, overlap: number = 100): DocumentChunk[] {
-    const chunks: DocumentChunk[] = [];
-    let start = 0;
-    while (start < text.length) {
-      const end = Math.min(start + size, text.length);
-      chunks.push({
-        content: text.slice(start, end),
-        metadata: {
-          filename: '',
-          mimeType: '',
-          chunkIndex: chunks.length,
-          totalChunks: 0, // filled after
-        },
-      });
-      start = end - overlap;
-      if (start >= text.length) break;
-    }
-    // Fill totalChunks
-    for (const c of chunks) c.metadata.totalChunks = chunks.length;
-    return chunks;
-  }
-
-  private guessMime(filename: string): string {
-    const ext = filename.split('.').pop()?.toLowerCase();
-    switch (ext) {
-      case 'pdf': return 'application/pdf';
-      case 'txt': return 'text/plain';
-      case 'md': return 'text/markdown';
-      case 'docx': return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
-      default: return 'text/plain';
-    }
-  }
-
-  /** Process raw text content directly (for API uploads) */
-  async processText(content: string, filename: string): Promise<{ chunks: number; chars: number }> {
-    const chunks = this.chunk(content);
-    const result = await this.knowledgeBase.addText(content, filename);
-    return { chunks: chunks.length, chars: content.length };
-  }
-}
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+import { KnowledgeBase } from '../core/knowledge';
+
+export interface DocumentChunk {
+  content: string;
+  metadata: {
+    filename: string;
+    mimeType: string;
+    chunkIndex: number;
+    totalChunks: number;
+  };
+}
+
+export class DocumentSkill extends BaseSkill {
+  name = 'document';
+  description = 'Process uploaded documents (PDF, TXT, MD, DOCX). Chunks content and adds to knowledge base.';
+  private knowledgeBase: KnowledgeBase;
+
+  constructor(kbPath: string = '.') {
+    super();
+    this.knowledgeBase = new KnowledgeBase(kbPath);
+  }
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    // Check if message has document attachment metadata
+    const meta = message.metadata;
+    if (!meta?.document) return this.noMatch();
+
+    const { content, filename, mimeType } = meta.document as {
+      content: string; filename: string; mimeType: string;
+    };
+
+    try {
+      const text = this.extractText(content, mimeType ?? this.guessMime(filename));
+      const chunks = this.chunk(text, 1000, 100);
+
+      const result = await this.knowledgeBase.addText(
+        chunks.map(c => c.content).join('\n\n---\n\n'),
+        filename
+      );
+
+      return this.match(
+        `📄 Processed "${filename}": ${chunks.length} chunks, ${text.length} chars → added to knowledge base (${result.chunks} KB entries)`
+      );
+    } catch (err) {
+      return this.match(`Document processing error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  extractText(content: string, mimeType: string): string {
+    // For plain text formats, content is already text
+    if (mimeType.includes('text/') || mimeType.includes('markdown')) {
+      return content;
+    }
+    // For other formats, assume base64-encoded or pre-extracted text
+    // In a real implementation, you'd use pdf-parse, mammoth, etc.
+    return content;
+  }
+
+  chunk(text: string, size: number = 1000, overlap: number = 100): DocumentChunk[] {
+    const chunks: DocumentChunk[] = [];
+    let start = 0;
+    while (start < text.length) {
+      const end = Math.min(start + size, text.length);
+      chunks.push({
+        content: text.slice(start, end),
+        metadata: {
+          filename: '',
+          mimeType: '',
+          chunkIndex: chunks.length,
+          totalChunks: 0, // filled after
+        },
+      });
+      start = end - overlap;
+      if (start >= text.length) break;
+    }
+    // Fill totalChunks
+    for (const c of chunks) c.metadata.totalChunks = chunks.length;
+    return chunks;
+  }
+
+  private guessMime(filename: string): string {
+    const ext = filename.split('.').pop()?.toLowerCase();
+    switch (ext) {
+      case 'pdf': return 'application/pdf';
+      case 'txt': return 'text/plain';
+      case 'md': return 'text/markdown';
+      case 'docx': return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+      default: return 'text/plain';
+    }
+  }
+
+  /** Process raw text content directly (for API uploads) */
+  async processText(content: string, filename: string): Promise<{ chunks: number; chars: number }> {
+    const chunks = this.chunk(content);
+    const result = await this.knowledgeBase.addText(content, filename);
+    return { chunks: chunks.length, chars: content.length };
+  }
+}

package/src/skills/http.ts

@@ -1,35 +1,35 @@
-import { BaseSkill } from './base';
-import type { AgentContext, Message, SkillResult } from '../core/types';
-
-export class HttpSkill extends BaseSkill {
-  name = 'http';
-  description = 'Make HTTP requests to external APIs. Usage: http GET|POST|PUT|DELETE <url> [body]';
-
-  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
-    const text = message.content.trim();
-    const match = text.match(/^http\s+(GET|POST|PUT|PATCH|DELETE)\s+(\S+)(?:\s+(.+))?$/is);
-    if (!match) return this.noMatch();
-
-    const [, method, url, bodyStr] = match;
-
-    try {
-      const opts: RequestInit = {
-        method: method.toUpperCase(),
-        headers: { 'Content-Type': 'application/json', 'User-Agent': 'OPC-Agent/0.7.0' },
-      };
-
-      if (bodyStr && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
-        opts.body = bodyStr;
-      }
-
-      const res = await fetch(url, opts);
-      const contentType = res.headers.get('content-type') ?? '';
-      const body = contentType.includes('json') ? JSON.stringify(await res.json(), null, 2) : await res.text();
-
-      const truncated = body.length > 4000 ? body.slice(0, 4000) + '\n...[truncated]' : body;
-      return this.match(`HTTP ${res.status} ${res.statusText}\n\n${truncated}`);
-    } catch (err) {
-      return this.match(`HTTP Error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-}
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+export class HttpSkill extends BaseSkill {
+  name = 'http';
+  description = 'Make HTTP requests to external APIs. Usage: http GET|POST|PUT|DELETE <url> [body]';
+
+  async execute(context: AgentContext, message: Message): Promise<SkillResult> {
+    const text = message.content.trim();
+    const match = text.match(/^http\s+(GET|POST|PUT|PATCH|DELETE)\s+(\S+)(?:\s+(.+))?$/is);
+    if (!match) return this.noMatch();
+
+    const [, method, url, bodyStr] = match;
+
+    try {
+      const opts: RequestInit = {
+        method: method.toUpperCase(),
+        headers: { 'Content-Type': 'application/json', 'User-Agent': 'OPC-Agent/0.7.0' },
+      };
+
+      if (bodyStr && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
+        opts.body = bodyStr;
+      }
+
+      const res = await fetch(url, opts);
+      const contentType = res.headers.get('content-type') ?? '';
+      const body = contentType.includes('json') ? JSON.stringify(await res.json(), null, 2) : await res.text();
+
+      const truncated = body.length > 4000 ? body.slice(0, 4000) + '\n...[truncated]' : body;
+      return this.match(`HTTP ${res.status} ${res.statusText}\n\n${truncated}`);
+    } catch (err) {
+      return this.match(`HTTP Error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}

package/src/skills/index.ts

@@ -1,27 +1,27 @@
-import type { ISkill, AgentContext, Message, SkillResult } from '../core/types';
-
-export type { ISkill } from '../core/types';
-
-export class SkillRegistry {
-  private skills: Map<string, ISkill> = new Map();
-
-  register(skill: ISkill): void {
-    this.skills.set(skill.name, skill);
-  }
-
-  get(name: string): ISkill | undefined {
-    return this.skills.get(name);
-  }
-
-  list(): ISkill[] {
-    return Array.from(this.skills.values());
-  }
-
-  async executeAll(context: AgentContext, message: Message): Promise<SkillResult | null> {
-    for (const skill of this.skills.values()) {
-      const result = await skill.execute(context, message);
-      if (result.handled) return result;
-    }
-    return null;
-  }
-}
+import type { ISkill, AgentContext, Message, SkillResult } from '../core/types';
+
+export type { ISkill } from '../core/types';
+
+export class SkillRegistry {
+  private skills: Map<string, ISkill> = new Map();
+
+  register(skill: ISkill): void {
+    this.skills.set(skill.name, skill);
+  }
+
+  get(name: string): ISkill | undefined {
+    return this.skills.get(name);
+  }
+
+  list(): ISkill[] {
+    return Array.from(this.skills.values());
+  }
+
+  async executeAll(context: AgentContext, message: Message): Promise<SkillResult | null> {
+    for (const skill of this.skills.values()) {
+      const result = await skill.execute(context, message);
+      if (result.handled) return result;
+    }
+    return null;
+  }
+}