opc-agent 1.4.0 → 2.0.0

package/src/schema/oad.ts

@@ -1,154 +1,167 @@
-import { z } from 'zod';
-
-// ─── OAD Schema v1 ───────────────────────────────────────────
-
-export const SkillRefSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  config: z.record(z.unknown()).optional(),
-});
-
-export const WorkflowStepSchema: z.ZodType<any> = z.lazy(() => z.object({
-  id: z.string(),
-  type: z.enum(['skill', 'tool', 'agent', 'condition', 'parallel']),
-  name: z.string(),
-  config: z.record(z.unknown()).optional(),
-  condition: z.string().optional(),
-  branches: z.object({ if: z.array(WorkflowStepSchema), else: z.array(WorkflowStepSchema).optional() }).optional(),
-  parallel: z.array(WorkflowStepSchema).optional(),
-  timeout: z.number().optional(),
-  retries: z.number().optional(),
-}));
-
-export const WorkflowSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  version: z.string().optional(),
-  steps: z.array(WorkflowStepSchema).default([]),
-  onError: z.enum(['stop', 'skip', 'retry']).optional(),
-});
-
-export const VoiceSchema = z.object({
-  enabled: z.boolean().default(false),
-  sttProvider: z.string().optional(),
-  ttsProvider: z.string().optional(),
-  language: z.string().optional(),
-});
-
-export const WebhookSchema = z.object({
-  path: z.string().optional(),
-  secret: z.string().optional(),
-  retryAttempts: z.number().optional(),
-});
-
-export const HITLSchema = z.object({
-  enabled: z.boolean().default(false),
-  requireApproval: z.array(z.string()).default([]),
-  defaultTimeoutMs: z.number().default(60000),
-  defaultAction: z.enum(['approve', 'deny']).default('deny'),
-});
-
-export const PluginRefSchema = z.object({
-  name: z.string(),
-  config: z.record(z.unknown()).optional(),
-});
-
-export const AuthSchema = z.object({
-  enabled: z.boolean().default(false),
-  apiKeys: z.array(z.string()).default([]),
-  sessionIsolation: z.boolean().default(true),
-});
-
-export const ChannelSchema = z.object({
-  type: z.enum(['web', 'websocket', 'telegram', 'cli', 'voice', 'webhook']),
-  port: z.number().optional(),
-  config: z.record(z.unknown()).optional(),
-});
-
-export const LongTermMemorySchema = z.object({
-  provider: z.enum(['in-memory', 'deepbrain']).default('in-memory'),
-  collection: z.string().optional(),
-  config: z.record(z.unknown()).optional(),
-});
-
-export const MemorySchema = z.object({
-  shortTerm: z.boolean().default(true),
-  longTerm: z.union([z.boolean(), LongTermMemorySchema]).default(false),
-  provider: z.string().optional(),
-});
-
-export const TrustLevel = z.enum(['sandbox', 'verified', 'certified', 'listed']);
-
-export const DTVSchema = z.object({
-  trust: z.object({
-    level: TrustLevel.default('sandbox'),
-  }).optional(),
-  value: z.object({
-    metrics: z.array(z.string()).default([]),
-  }).optional(),
-});
-
-export const ProviderSchema = z.object({
-  default: z.string().default('deepseek'),
-  allowed: z.array(z.string()).default(['openai', 'deepseek', 'qwen']),
-});
-
-export const MarketplaceSchema = z.object({
-  certified: z.boolean().default(false),
-  category: z.string().optional(),
-  pricing: z.enum(['free', 'freemium', 'paid', 'enterprise']).optional(),
-  tags: z.array(z.string()).optional(),
-});
-
-export const MetadataSchema = z.object({
-  name: z.string(),
-  version: z.string().default('1.0.0'),
-  description: z.string().optional(),
-  author: z.string().optional(),
-  license: z.string().default('Apache-2.0'),
-  marketplace: MarketplaceSchema.optional(),
-});
-
-export const RoomSchema = z.object({
-  name: z.string(),
-  agents: z.array(z.string()).default([]),
-  topics: z.array(z.string()).default([]),
-});
-
-export const StreamingSchema = z.object({
-  enabled: z.boolean().default(false),
-  chunkSize: z.number().optional(),
-});
-
-export const SpecSchema = z.object({
-  provider: ProviderSchema.optional(),
-  model: z.string().default('deepseek-chat'),
-  systemPrompt: z.string().optional(),
-  skills: z.array(SkillRefSchema).default([]),
-  channels: z.array(ChannelSchema).default([]),
-  memory: MemorySchema.optional(),
-  dtv: DTVSchema.optional(),
-  room: RoomSchema.optional(),
-  streaming: z.union([z.boolean(), StreamingSchema]).default(false),
-  locale: z.enum(['en', 'zh-CN']).optional(),
-  workflows: z.array(WorkflowSchema).optional(),
-  voice: VoiceSchema.optional(),
-  webhook: WebhookSchema.optional(),
-  hitl: HITLSchema.optional(),
-  auth: AuthSchema.optional(),
-  plugins: z.array(PluginRefSchema).optional(),
-});
-
-export const OADSchema = z.object({
-  apiVersion: z.literal('opc/v1'),
-  kind: z.literal('Agent'),
-  metadata: MetadataSchema,
-  spec: SpecSchema,
-});
-
-export type OADDocument = z.infer<typeof OADSchema>;
-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 TrustLevelType = string;
+import { z } from 'zod';
+
+// ─── OAD Schema v1 ───────────────────────────────────────────
+
+export const SkillRefSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  config: z.record(z.unknown()).optional(),
+});
+
+export const WorkflowStepSchema: z.ZodType<any> = z.lazy(() => z.object({
+  id: z.string(),
+  type: z.enum(['skill', 'tool', 'agent', 'condition', 'parallel']),
+  name: z.string(),
+  config: z.record(z.unknown()).optional(),
+  condition: z.string().optional(),
+  branches: z.object({ if: z.array(WorkflowStepSchema), else: z.array(WorkflowStepSchema).optional() }).optional(),
+  parallel: z.array(WorkflowStepSchema).optional(),
+  timeout: z.number().optional(),
+  retries: z.number().optional(),
+}));
+
+export const WorkflowSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  version: z.string().optional(),
+  steps: z.array(WorkflowStepSchema).default([]),
+  onError: z.enum(['stop', 'skip', 'retry']).optional(),
+});
+
+export const VoiceSchema = z.object({
+  enabled: z.boolean().default(false),
+  sttProvider: z.string().optional(),
+  ttsProvider: z.string().optional(),
+  language: z.string().optional(),
+});
+
+export const WebhookSchema = z.object({
+  path: z.string().optional(),
+  secret: z.string().optional(),
+  retryAttempts: z.number().optional(),
+});
+
+export const HITLSchema = z.object({
+  enabled: z.boolean().default(false),
+  requireApproval: z.array(z.string()).default([]),
+  defaultTimeoutMs: z.number().default(60000),
+  defaultAction: z.enum(['approve', 'deny']).default('deny'),
+});
+
+export const PluginRefSchema = z.object({
+  name: z.string(),
+  config: z.record(z.unknown()).optional(),
+});
+
+export const AuthSchema = z.object({
+  enabled: z.boolean().default(false),
+  apiKeys: z.array(z.string()).default([]),
+  sessionIsolation: z.boolean().default(true),
+});
+
+export const ChannelSchema = z.object({
+  type: z.enum(['web', 'websocket', 'telegram', 'cli', 'voice', 'webhook']),
+  port: z.number().optional(),
+  config: z.record(z.unknown()).optional(),
+});
+
+export const LongTermMemorySchema = z.object({
+  provider: z.enum(['in-memory', 'deepbrain']).default('in-memory'),
+  collection: z.string().optional(),
+  config: z.record(z.unknown()).optional(),
+});
+
+export const MemorySchema = z.object({
+  shortTerm: z.boolean().default(true),
+  longTerm: z.union([z.boolean(), LongTermMemorySchema]).default(false),
+  provider: z.string().optional(),
+});
+
+export const TrustLevel = z.enum(['sandbox', 'verified', 'certified', 'listed']);
+
+export const DTVSchema = z.object({
+  trust: z.object({
+    level: TrustLevel.default('sandbox'),
+  }).optional(),
+  value: z.object({
+    metrics: z.array(z.string()).default([]),
+  }).optional(),
+});
+
+export const ProviderSchema = z.object({
+  default: z.string().default('deepseek'),
+  allowed: z.array(z.string()).default(['openai', 'deepseek', 'qwen']),
+});
+
+export const MarketplaceSchema = z.object({
+  certified: z.boolean().default(false),
+  category: z.string().optional(),
+  pricing: z.enum(['free', 'freemium', 'paid', 'enterprise']).optional(),
+  tags: z.array(z.string()).optional(),
+});
+
+export const MetadataSchema = z.object({
+  name: z.string(),
+  version: z.string().default('1.0.0'),
+  description: z.string().optional(),
+  author: z.string().optional(),
+  license: z.string().default('Apache-2.0'),
+  marketplace: MarketplaceSchema.optional(),
+});
+
+export const RoomSchema = z.object({
+  name: z.string(),
+  agents: z.array(z.string()).default([]),
+  topics: z.array(z.string()).default([]),
+});
+
+export const StreamingSchema = z.object({
+  enabled: z.boolean().default(false),
+  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'),
+  systemPrompt: z.string().optional(),
+  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),
+  locale: z.enum(['en', 'zh-CN']).optional(),
+  workflows: z.array(WorkflowSchema).optional(),
+  voice: VoiceSchema.optional(),
+  webhook: WebhookSchema.optional(),
+  hitl: HITLSchema.optional(),
+  auth: AuthSchema.optional(),
+  plugins: z.array(PluginRefSchema).optional(),
+});
+
+export const OADSchema = z.object({
+  apiVersion: z.literal('opc/v1'),
+  kind: z.literal('Agent'),
+  metadata: MetadataSchema,
+  spec: SpecSchema,
+});
+
+export type OADDocument = z.infer<typeof OADSchema>;
+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 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/tools/builtin/datetime.ts

@@ -0,0 +1,41 @@
+import type { MCPTool, MCPToolResult } from '../mcp';
+
+export const datetimeTool: MCPTool = {
+  name: 'datetime',
+  description: 'Get current date, time, timezone info',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      format: { type: 'string', default: 'iso' },
+      timezone: { type: 'string' },
+    },
+  },
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const now = new Date();
+    const timezone = input.timezone as string | undefined;
+    const format = (input.format as string) || 'iso';
+
+    let content: string;
+    if (format === 'iso') {
+      content = now.toISOString();
+    } else if (format === 'locale') {
+      content = timezone
+        ? now.toLocaleString('en-US', { timeZone: timezone })
+        : now.toLocaleString();
+    } else if (format === 'unix') {
+      content = String(Math.floor(now.getTime() / 1000));
+    } else {
+      content = now.toISOString();
+    }
+
+    return {
+      content: JSON.stringify({
+        iso: now.toISOString(),
+        unix: Math.floor(now.getTime() / 1000),
+        formatted: content,
+        timezone: timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+      }),
+      isError: false,
+    };
+  },
+};