opc-agent 0.2.0 → 0.3.0

package/src/analytics/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Agent Analytics — track messages, response times, skill usage, errors, tokens.
+ */
+export interface AnalyticsSnapshot {
+  messagesProcessed: number;
+  avgResponseTimeMs: number;
+  skillUsage: Record<string, number>;
+  errorCount: number;
+  tokenUsage: { input: number; output: number; total: number };
+  uptime: number;
+  startedAt: number;
+}
+
+export class Analytics {
+  private messagesProcessed = 0;
+  private totalResponseTimeMs = 0;
+  private skillUsage: Record<string, number> = {};
+  private errorCount = 0;
+  private tokenUsage = { input: 0, output: 0 };
+  private startedAt = Date.now();
+
+  recordMessage(responseTimeMs: number): void {
+    this.messagesProcessed++;
+    this.totalResponseTimeMs += responseTimeMs;
+  }
+
+  recordSkillUsage(skillName: string): void {
+    this.skillUsage[skillName] = (this.skillUsage[skillName] ?? 0) + 1;
+  }
+
+  recordError(): void {
+    this.errorCount++;
+  }
+
+  recordTokens(input: number, output: number): void {
+    this.tokenUsage.input += input;
+    this.tokenUsage.output += output;
+  }
+
+  getSnapshot(): AnalyticsSnapshot {
+    return {
+      messagesProcessed: this.messagesProcessed,
+      avgResponseTimeMs: this.messagesProcessed > 0
+        ? Math.round(this.totalResponseTimeMs / this.messagesProcessed)
+        : 0,
+      skillUsage: { ...this.skillUsage },
+      errorCount: this.errorCount,
+      tokenUsage: {
+        input: this.tokenUsage.input,
+        output: this.tokenUsage.output,
+        total: this.tokenUsage.input + this.tokenUsage.output,
+      },
+      uptime: Date.now() - this.startedAt,
+      startedAt: this.startedAt,
+    };
+  }
+
+  reset(): void {
+    this.messagesProcessed = 0;
+    this.totalResponseTimeMs = 0;
+    this.skillUsage = {};
+    this.errorCount = 0;
+    this.tokenUsage = { input: 0, output: 0 };
+    this.startedAt = Date.now();
+  }
+}

package/src/cli.ts

@@ -9,12 +9,14 @@ import { createCustomerServiceConfig } from './templates/customer-service';
 import { createSalesAssistantConfig } from './templates/sales-assistant';
 import { createKnowledgeBaseConfig } from './templates/knowledge-base';
 import { createCodeReviewerConfig } from './templates/code-reviewer';
+import { createHRRecruiterConfig } from './templates/hr-recruiter';
+import { createProjectManagerConfig } from './templates/project-manager';
+import { createContentWriterConfig } from './templates/content-writer';
 import { FAQSkill, HandoffSkill } from './templates/customer-service';
+import { Analytics } from './analytics';
 
 const program = new Command();
 
-// ── Colorful output helpers ──────────────────────────────────
-
 const color = {
   green: (s: string) => `\x1b[32m${s}\x1b[0m`,
   red: (s: string) => `\x1b[31m${s}\x1b[0m`,
@@ -42,6 +44,9 @@ const TEMPLATES: Record<string, { label: string; factory: () => any }> = {
   'sales-assistant': { label: 'Sales Assistant — product Q&A + lead capture', factory: createSalesAssistantConfig },
   'knowledge-base': { label: 'Knowledge Base — RAG with DeepBrain', factory: createKnowledgeBaseConfig },
   'code-reviewer': { label: 'Code Reviewer — bug detection + style checks', factory: createCodeReviewerConfig },
+  'hr-recruiter': { label: 'HR Recruiter — resume screening + interview scheduling', factory: createHRRecruiterConfig },
+  'project-manager': { label: 'Project Manager — task tracking + meeting notes', factory: createProjectManagerConfig },
+  'content-writer': { label: 'Content Writer — blog posts + social media + SEO', factory: createContentWriterConfig },
 };
 
 async function prompt(question: string, defaultValue?: string): Promise<string> {
@@ -68,7 +73,7 @@ async function select(question: string, options: { value: string; label: string
 program
   .name('opc')
   .description('OPC Agent — Open Agent Framework for business workstations')
-  .version('0.2.0');
+  .version('0.3.0');
 
 program
   .command('init')
@@ -80,7 +85,6 @@ program
     console.log(`\n${icon.rocket} ${color.bold('OPC Agent — Create New Project')}\n`);
 
     const name = opts.yes ? (nameArg ?? 'my-agent') : (nameArg ?? await prompt('Project name', 'my-agent'));
-
     const template = opts.yes
       ? (opts.template ?? 'customer-service')
       : (opts.template ?? await select('Select a template:', Object.entries(TEMPLATES).map(([value, { label }]) => ({ value, label }))));
@@ -92,7 +96,6 @@ program
     }
 
     fs.mkdirSync(dir, { recursive: true });
-
     const factory = TEMPLATES[template]?.factory ?? createCustomerServiceConfig;
     const config = factory();
     config.metadata.name = name;
@@ -146,6 +149,11 @@ program
       console.log(`  Channels:    ${s.channels.map(c => c.type).join(', ') || color.dim('(none)')}`);
       console.log(`  Skills:      ${s.skills.map(sk => sk.name).join(', ') || color.dim('(none)')}`);
       console.log(`  Trust:       ${s.dtv?.trust?.level ?? 'sandbox'}`);
+      console.log(`  Streaming:   ${s.streaming ? 'enabled' : 'disabled'}`);
+      console.log(`  Locale:      ${s.locale ?? 'en'}`);
+      if (s.room) {
+        console.log(`  Room:        ${s.room.name}`);
+      }
       if (m.marketplace) {
         console.log(`  Category:    ${m.marketplace.category ?? color.dim('(none)')}`);
         console.log(`  Pricing:     ${m.marketplace.pricing ?? 'free'}`);
@@ -239,12 +247,11 @@ program
 
     await startAgent();
 
-    // Watch for file changes
     const watchPaths = [opts.file, 'src'];
     for (const watchPath of watchPaths) {
       if (fs.existsSync(watchPath)) {
         const isDir = fs.statSync(watchPath).isDirectory();
-        fs.watch(watchPath, { recursive: isDir }, async (event, filename) => {
+        fs.watch(watchPath, { recursive: isDir }, async (_event, filename) => {
           console.log(`\n${icon.info} ${color.dim(`Change detected: ${filename}`)} — restarting...`);
           await startAgent();
         });
@@ -312,4 +319,66 @@ program
     console.log(`\n   Available templates: ${Object.keys(TEMPLATES).map(t => color.cyan(t)).join(', ')}\n`);
   });
 
+// ── Tool commands ────────────────────────────────────────────
+
+const toolCmd = program.command('tool').description('Manage MCP tools');
+
+toolCmd
+  .command('list')
+  .description('List available MCP tools')
+  .action(() => {
+    console.log(`\n${icon.gear} ${color.bold('MCP Tools')}\n`);
+    console.log(`  ${color.dim('No tools installed yet.')}`);
+    console.log(`\n  Add tools with: ${color.cyan('opc tool add <name>')}\n`);
+  });
+
+toolCmd
+  .command('add')
+  .description('Add an MCP tool from registry')
+  .argument('<name>', 'Tool name')
+  .action((name: string) => {
+    console.log(`\n🚧 Tool registry coming soon!`);
+    console.log(`   Would add tool: ${color.cyan(name)}\n`);
+  });
+
+// ── Plugin commands ──────────────────────────────────────────
+
+const pluginCmd = program.command('plugin').description('Manage plugins');
+
+pluginCmd
+  .command('list')
+  .description('List installed plugins')
+  .action(() => {
+    console.log(`\n${icon.gear} ${color.bold('Installed Plugins')}\n`);
+    console.log(`  ${color.dim('No plugins installed yet.')}`);
+    console.log(`\n  Add plugins with: ${color.cyan('opc plugin add <name>')}\n`);
+  });
+
+pluginCmd
+  .command('add')
+  .description('Add a plugin')
+  .argument('<name>', 'Plugin name')
+  .action((name: string) => {
+    console.log(`\n🚧 Plugin registry coming soon!`);
+    console.log(`   Would add plugin: ${color.cyan(name)}\n`);
+  });
+
+// ── Stats command ────────────────────────────────────────────
+
+program
+  .command('stats')
+  .description('Show agent analytics')
+  .action(() => {
+    const analytics = new Analytics();
+    // Show demo stats
+    const snap = analytics.getSnapshot();
+    console.log(`\n${icon.gear} ${color.bold('Agent Analytics')}\n`);
+    console.log(`  Messages Processed: ${snap.messagesProcessed}`);
+    console.log(`  Avg Response Time:  ${snap.avgResponseTimeMs}ms`);
+    console.log(`  Error Count:        ${snap.errorCount}`);
+    console.log(`  Token Usage:        ${snap.tokenUsage.total} (in: ${snap.tokenUsage.input}, out: ${snap.tokenUsage.output})`);
+    console.log(`  Uptime:             ${Math.round(snap.uptime / 1000)}s`);
+    console.log(`\n  ${color.dim('Run an agent to collect analytics data.')}\n`);
+  });
+
 program.parse();

package/src/core/room.ts

@@ -0,0 +1,109 @@
+import { EventEmitter } from 'events';
+import type { Message, IAgent } from './types';
+
+export interface RoomMessage {
+  from: string;
+  to?: string; // undefined = broadcast
+  topic?: string;
+  message: Message;
+}
+
+export class Room extends EventEmitter {
+  readonly name: string;
+  private agents: Map<string, IAgent> = new Map();
+  private subscriptions: Map<string, Set<string>> = new Map(); // topic -> agentNames
+
+  constructor(name: string) {
+    super();
+    this.name = name;
+  }
+
+  addAgent(agent: IAgent): void {
+    this.agents.set(agent.name, agent);
+    this.emit('agent:join', agent.name);
+  }
+
+  removeAgent(name: string): void {
+    this.agents.delete(name);
+    // Remove from all subscriptions
+    for (const [, subscribers] of this.subscriptions) {
+      subscribers.delete(name);
+    }
+    this.emit('agent:leave', name);
+  }
+
+  getAgents(): string[] {
+    return Array.from(this.agents.keys());
+  }
+
+  subscribe(agentName: string, topic: string): void {
+    if (!this.subscriptions.has(topic)) {
+      this.subscriptions.set(topic, new Set());
+    }
+    this.subscriptions.get(topic)!.add(agentName);
+  }
+
+  unsubscribe(agentName: string, topic: string): void {
+    this.subscriptions.get(topic)?.delete(agentName);
+  }
+
+  getSubscribers(topic: string): string[] {
+    return Array.from(this.subscriptions.get(topic) ?? []);
+  }
+
+  async send(roomMessage: RoomMessage): Promise<Message[]> {
+    const responses: Message[] = [];
+    this.emit('message', roomMessage);
+
+    if (roomMessage.to) {
+      // Direct message
+      const agent = this.agents.get(roomMessage.to);
+      if (agent) {
+        const response = await agent.handleMessage(roomMessage.message);
+        responses.push(response);
+      }
+    } else if (roomMessage.topic) {
+      // Topic-based pub/sub
+      const subscribers = this.subscriptions.get(roomMessage.topic) ?? new Set();
+      for (const name of subscribers) {
+        if (name === roomMessage.from) continue;
+        const agent = this.agents.get(name);
+        if (agent) {
+          const response = await agent.handleMessage(roomMessage.message);
+          responses.push(response);
+        }
+      }
+    } else {
+      // Broadcast to all except sender
+      for (const [name, agent] of this.agents) {
+        if (name === roomMessage.from) continue;
+        const response = await agent.handleMessage(roomMessage.message);
+        responses.push(response);
+      }
+    }
+
+    return responses;
+  }
+
+  async broadcast(from: string, content: string): Promise<Message[]> {
+    const message: Message = {
+      id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      role: 'user',
+      content,
+      timestamp: Date.now(),
+      metadata: { room: this.name, from },
+    };
+    return this.send({ from, message });
+  }
+
+  async publishToTopic(from: string, topic: string, content: string): Promise<Message[]> {
+    const message: Message = {
+      id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      role: 'user',
+      content,
+      timestamp: Date.now(),
+      metadata: { room: this.name, from, topic },
+    };
+    return this.send({ from, topic, message });
+  }
+}

package/src/core/sandbox.ts

@@ -0,0 +1,101 @@
+import type { TrustLevelType } from '../schema/oad';
+import * as path from 'path';
+
+export interface SandboxConfig {
+  trustLevel: TrustLevelType;
+  agentDir: string;
+  networkAllowlist?: string[];
+  shellAllowed?: boolean;
+}
+
+export interface SandboxRestrictions {
+  fileSystem: { read: string[]; write: string[] };
+  network: { allowed: string[] };
+  shell: boolean;
+}
+
+const TRUST_RESTRICTIONS: Record<string, SandboxRestrictions> = {
+  sandbox: {
+    fileSystem: { read: ['.'], write: ['.'] },
+    network: { allowed: [] },
+    shell: false,
+  },
+  verified: {
+    fileSystem: { read: ['.', '..'], write: ['.'] },
+    network: { allowed: ['*.deepleaper.com', 'api.openai.com', 'api.deepseek.com'] },
+    shell: false,
+  },
+  certified: {
+    fileSystem: { read: ['*'], write: ['.', '..'] },
+    network: { allowed: ['*'] },
+    shell: true,
+  },
+  listed: {
+    fileSystem: { read: ['*'], write: ['*'] },
+    network: { allowed: ['*'] },
+    shell: true,
+  },
+};
+
+export class Sandbox {
+  private config: SandboxConfig;
+  private restrictions: SandboxRestrictions;
+
+  constructor(config: SandboxConfig) {
+    this.config = config;
+    this.restrictions = {
+      ...TRUST_RESTRICTIONS[config.trustLevel] ?? TRUST_RESTRICTIONS.sandbox,
+    };
+    if (config.networkAllowlist) {
+      this.restrictions.network.allowed = config.networkAllowlist;
+    }
+    if (config.shellAllowed !== undefined) {
+      this.restrictions.shell = config.shellAllowed;
+    }
+  }
+
+  get trustLevel(): TrustLevelType {
+    return this.config.trustLevel;
+  }
+
+  getRestrictions(): SandboxRestrictions {
+    return { ...this.restrictions };
+  }
+
+  checkFileAccess(filePath: string, mode: 'read' | 'write'): boolean {
+    const resolved = path.resolve(filePath);
+    const agentDir = path.resolve(this.config.agentDir);
+    const allowedPaths = mode === 'read' ? this.restrictions.fileSystem.read : this.restrictions.fileSystem.write;
+
+    if (allowedPaths.includes('*')) return true;
+
+    for (const allowed of allowedPaths) {
+      const allowedResolved = path.resolve(this.config.agentDir, allowed);
+      if (resolved.startsWith(allowedResolved)) return true;
+    }
+
+    // Always allow access within agent's own directory
+    return resolved.startsWith(agentDir);
+  }
+
+  checkNetworkAccess(url: string): boolean {
+    if (this.restrictions.network.allowed.includes('*')) return true;
+    if (this.restrictions.network.allowed.length === 0) return false;
+
+    try {
+      const hostname = new URL(url).hostname;
+      return this.restrictions.network.allowed.some((pattern) => {
+        if (pattern.startsWith('*.')) {
+          return hostname.endsWith(pattern.slice(1));
+        }
+        return hostname === pattern;
+      });
+    } catch {
+      return false;
+    }
+  }
+
+  checkShellAccess(): boolean {
+    return this.restrictions.shell;
+  }
+}

package/src/i18n/index.ts

@@ -0,0 +1,79 @@
+/**
+ * Internationalization (i18n) support for OPC Agent.
+ */
+export type Locale = 'en' | 'zh-CN';
+
+export interface I18nMessages {
+  [key: string]: string;
+}
+
+const messages: Record<Locale, I18nMessages> = {
+  'en': {
+    'agent.started': 'Agent "{name}" started successfully',
+    'agent.stopped': 'Agent "{name}" stopped',
+    'agent.error': 'An error occurred: {error}',
+    'agent.greeting': 'Hello! How can I help you?',
+    'agent.farewell': 'Goodbye! Have a great day.',
+    'agent.notUnderstood': 'I\'m not sure I understand. Could you rephrase?',
+    'agent.handoff': 'Let me connect you with a human agent.',
+    'cli.init.success': 'Created agent project: {name}',
+    'cli.build.success': 'Build successful: {name} v{version}',
+    'cli.test.pass': 'All tests passed',
+    'cli.stats.title': 'Agent Analytics',
+    'cli.stats.messages': 'Messages Processed',
+    'cli.stats.avgTime': 'Avg Response Time',
+    'cli.stats.errors': 'Errors',
+    'cli.stats.uptime': 'Uptime',
+    'plugin.loaded': 'Plugin "{name}" loaded',
+    'plugin.error': 'Plugin "{name}" failed: {error}',
+  },
+  'zh-CN': {
+    'agent.started': '智能体 "{name}" 启动成功',
+    'agent.stopped': '智能体 "{name}" 已停止',
+    'agent.error': '发生错误: {error}',
+    'agent.greeting': '您好！有什么可以帮您的？',
+    'agent.farewell': '再见！祝您愉快。',
+    'agent.notUnderstood': '抱歉，我没有理解您的意思。能换个方式描述吗？',
+    'agent.handoff': '我来为您转接人工客服。',
+    'cli.init.success': '已创建智能体项目: {name}',
+    'cli.build.success': '构建成功: {name} v{version}',
+    'cli.test.pass': '所有测试通过',
+    'cli.stats.title': '智能体分析',
+    'cli.stats.messages': '已处理消息',
+    'cli.stats.avgTime': '平均响应时间',
+    'cli.stats.errors': '错误数',
+    'cli.stats.uptime': '运行时间',
+    'plugin.loaded': '插件 "{name}" 已加载',
+    'plugin.error': '插件 "{name}" 失败: {error}',
+  },
+};
+
+let currentLocale: Locale = 'en';
+
+export function setLocale(locale: Locale): void {
+  currentLocale = locale;
+}
+
+export function getLocale(): Locale {
+  return currentLocale;
+}
+
+export function t(key: string, params?: Record<string, string>): string {
+  let msg = messages[currentLocale]?.[key] ?? messages['en']?.[key] ?? key;
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      msg = msg.replace(new RegExp(`\\{${k}\\}`, 'g'), v);
+    }
+  }
+  return msg;
+}
+
+export function detectLocale(): Locale {
+  const env = process.env.LANG ?? process.env.LC_ALL ?? process.env.LANGUAGE ?? '';
+  if (env.startsWith('zh')) return 'zh-CN';
+  return 'en';
+}
+
+export function addMessages(locale: Locale, newMessages: I18nMessages): void {
+  messages[locale] = { ...messages[locale], ...newMessages };
+}

package/src/index.ts

@@ -18,3 +18,17 @@ export { TrustManager } from './dtv/trust';
 export { ValueTracker } from './dtv/value';
 export { MRGConfigReader } from './dtv/data';
 export { createProvider, SUPPORTED_PROVIDERS } from './providers';
+
+// v0.3.0 new modules
+export { Room } from './core/room';
+export type { RoomMessage } from './core/room';
+export { MCPToolRegistry, createMCPTool } from './tools/mcp';
+export type { MCPTool, MCPToolDefinition, MCPToolResult } from './tools/mcp';
+export { PluginManager } from './plugins';
+export type { IPlugin, PluginHooks } from './plugins';
+export { Sandbox } from './core/sandbox';
+export type { SandboxConfig, SandboxRestrictions } from './core/sandbox';
+export { Analytics } from './analytics';
+export type { AnalyticsSnapshot } from './analytics';
+export { t, setLocale, getLocale, detectLocale, addMessages } from './i18n';
+export type { Locale } from './i18n';

package/src/plugins/index.ts

@@ -0,0 +1,87 @@
+import type { ISkill, IChannel } from '../core/types';
+import type { MCPTool } from '../tools/mcp';
+
+/**
+ * Plugin lifecycle hooks.
+ */
+export interface PluginHooks {
+  beforeInit?: () => Promise<void>;
+  afterInit?: () => Promise<void>;
+  beforeMessage?: (message: { content: string }) => Promise<void>;
+  afterMessage?: (message: { content: string }, response: { content: string }) => Promise<void>;
+  beforeShutdown?: () => Promise<void>;
+}
+
+/**
+ * Plugin interface — extend agent with skills, tools, channels, and lifecycle hooks.
+ */
+export interface IPlugin {
+  name: string;
+  version: string;
+  description?: string;
+  hooks?: PluginHooks;
+  skills?: ISkill[];
+  tools?: MCPTool[];
+  channels?: IChannel[];
+}
+
+export class PluginManager {
+  private plugins: Map<string, IPlugin> = new Map();
+
+  register(plugin: IPlugin): void {
+    this.plugins.set(plugin.name, plugin);
+  }
+
+  unregister(name: string): void {
+    this.plugins.delete(name);
+  }
+
+  get(name: string): IPlugin | undefined {
+    return this.plugins.get(name);
+  }
+
+  list(): { name: string; version: string; description?: string }[] {
+    return Array.from(this.plugins.values()).map(({ name, version, description }) => ({
+      name,
+      version,
+      description,
+    }));
+  }
+
+  has(name: string): boolean {
+    return this.plugins.has(name);
+  }
+
+  async runHook(hookName: keyof PluginHooks, ...args: unknown[]): Promise<void> {
+    for (const plugin of this.plugins.values()) {
+      const hook = plugin.hooks?.[hookName];
+      if (hook) {
+        await (hook as (...a: unknown[]) => Promise<void>)(...args);
+      }
+    }
+  }
+
+  getAllSkills(): ISkill[] {
+    const skills: ISkill[] = [];
+    for (const plugin of this.plugins.values()) {
+      if (plugin.skills) skills.push(...plugin.skills);
+    }
+    return skills;
+  }
+
+  getAllTools(): MCPTool[] {
+    const tools: MCPTool[] = [];
+    for (const plugin of this.plugins.values()) {
+      if (plugin.tools) tools.push(...plugin.tools);
+    }
+    return tools;
+  }
+
+  getAllChannels(): IChannel[] {
+    const channels: IChannel[] = [];
+    for (const plugin of this.plugins.values()) {
+      if (plugin.channels) channels.push(...plugin.channels);
+    }
+    return channels;
+  }
+}

package/src/schema/oad.ts

@@ -58,6 +58,17 @@ export const MetadataSchema = z.object({
   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'),
@@ -66,6 +77,9 @@ export const SpecSchema = z.object({
   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(),
 });
 
 export const OADSchema = z.object({

package/src/templates/content-writer.ts

@@ -0,0 +1,58 @@
+import { BaseSkill } from '../skills/base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+
+export class BlogWriterSkill extends BaseSkill {
+  name = 'blog-writer';
+  description = 'Help write blog posts with SEO optimization';
+
+  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
+    const lower = message.content.toLowerCase();
+    if (lower.includes('blog') || lower.includes('article') || lower.includes('post')) {
+      return this.match(
+        'I can help write blog posts! Please share the topic, target audience, and any keywords you\'d like to include for SEO.',
+        0.8,
+      );
+    }
+    return this.noMatch();
+  }
+}
+
+export class SocialMediaSkill extends BaseSkill {
+  name = 'social-media';
+  description = 'Create social media content';
+
+  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
+    const lower = message.content.toLowerCase();
+    if (lower.includes('social') || lower.includes('tweet') || lower.includes('linkedin')) {
+      return this.match(
+        'I can create social media content! Tell me the platform (Twitter/LinkedIn/etc.), topic, and tone you prefer.',
+        0.8,
+      );
+    }
+    return this.noMatch();
+  }
+}
+
+export function createContentWriterConfig() {
+  return {
+    apiVersion: 'opc/v1',
+    kind: 'Agent',
+    metadata: {
+      name: 'content-writer',
+      version: '1.0.0',
+      description: 'Content Writer — blog posts, social media, SEO optimization',
+      author: 'Deepleaper',
+      license: 'Apache-2.0',
+    },
+    spec: {
+      model: 'deepseek-chat',
+      systemPrompt: 'You are a content writing assistant. Help create blog posts, social media content, and optimize for SEO. Be creative, engaging, and audience-aware.',
+      skills: [
+        { name: 'blog-writer', description: 'Write blog posts' },
+        { name: 'social-media', description: 'Create social media content' },
+      ],
+      channels: [{ type: 'web', port: 3000 }],
+    },
+  };
+}