opc-agent 1.2.0 → 1.2.1

package/src/schema/oad.ts

@@ -1,155 +1,155 @@
-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 DTVConfig = z.infer<typeof DTVSchema>;
-export type TrustLevelType = z.infer<typeof TrustLevel>;
+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 DTVConfig = z.infer<typeof DTVSchema>;
+export type TrustLevelType = z.infer<typeof TrustLevel>;

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;
+  }
+}