opc-agent 0.7.0 → 0.9.0

package/src/core/orchestrator.ts

@@ -0,0 +1,215 @@
+import { EventEmitter } from 'events';
+import type { AgentContext, Message } from './types';
+
+/**
+ * Multi-Agent Orchestrator — v0.8.0
+ * Routes messages to specialized sub-agents, supports parallel execution and handoffs.
+ */
+
+export interface AgentNode {
+  id: string;
+  name: string;
+  description: string;
+  /** Patterns or intents this agent handles */
+  routes: string[];
+  /** Function that processes a message and returns a response */
+  handler: (context: AgentContext, message: Message) => Promise<Message>;
+  /** Priority for routing conflicts (higher wins) */
+  priority?: number;
+}
+
+export interface OrchestratorWorkflow {
+  name: string;
+  description?: string;
+  /** Ordered list of agent IDs for sequential execution */
+  steps?: string[];
+  /** List of agent IDs for parallel execution */
+  parallel?: string[];
+  /** Router config: auto-route based on message content */
+  router?: {
+    agents: string[];
+    fallback?: string;
+  };
+}
+
+export interface HandoffRequest {
+  fromAgent: string;
+  toAgent: string;
+  context: AgentContext;
+  reason: string;
+}
+
+export interface OrchestratorConfig {
+  agents: AgentNode[];
+  workflows?: OrchestratorWorkflow[];
+  defaultWorkflow?: string;
+  maxParallel?: number;
+}
+
+export class Orchestrator extends EventEmitter {
+  private agents: Map<string, AgentNode> = new Map();
+  private workflows: Map<string, OrchestratorWorkflow> = new Map();
+  private defaultWorkflow?: string;
+  private maxParallel: number;
+
+  constructor(config: OrchestratorConfig) {
+    super();
+    this.maxParallel = config.maxParallel ?? 5;
+    this.defaultWorkflow = config.defaultWorkflow;
+
+    for (const agent of config.agents) {
+      this.agents.set(agent.id, agent);
+    }
+    for (const wf of config.workflows ?? []) {
+      this.workflows.set(wf.name, wf);
+    }
+  }
+
+  /** Register a new agent node */
+  registerAgent(agent: AgentNode): void {
+    this.agents.set(agent.id, agent);
+    this.emit('agent:registered', agent.id);
+  }
+
+  /** Unregister an agent */
+  unregisterAgent(id: string): void {
+    this.agents.delete(id);
+    this.emit('agent:unregistered', id);
+  }
+
+  /** Route a message to the best-matching agent */
+  route(message: Message): AgentNode | undefined {
+    const content = message.content.toLowerCase();
+    let bestMatch: AgentNode | undefined;
+    let bestPriority = -1;
+
+    for (const agent of this.agents.values()) {
+      for (const route of agent.routes) {
+        if (content.includes(route.toLowerCase()) || new RegExp(route, 'i').test(content)) {
+          const priority = agent.priority ?? 0;
+          if (priority > bestPriority) {
+            bestMatch = agent;
+            bestPriority = priority;
+          }
+          break;
+        }
+      }
+    }
+    return bestMatch;
+  }
+
+  /** Execute a single agent */
+  async executeAgent(agentId: string, context: AgentContext, message: Message): Promise<Message> {
+    const agent = this.agents.get(agentId);
+    if (!agent) throw new Error(`Agent not found: ${agentId}`);
+    this.emit('agent:execute', agentId, message);
+    const result = await agent.handler(context, message);
+    this.emit('agent:complete', agentId, result);
+    return result;
+  }
+
+  /** Run multiple agents in parallel */
+  async executeParallel(
+    agentIds: string[],
+    context: AgentContext,
+    message: Message
+  ): Promise<Map<string, Message>> {
+    const results = new Map<string, Message>();
+    const batches: string[][] = [];
+
+    // Batch by maxParallel
+    for (let i = 0; i < agentIds.length; i += this.maxParallel) {
+      batches.push(agentIds.slice(i, i + this.maxParallel));
+    }
+
+    for (const batch of batches) {
+      const promises = batch.map(async (id) => {
+        const result = await this.executeAgent(id, context, message);
+        results.set(id, result);
+      });
+      await Promise.all(promises);
+    }
+
+    return results;
+  }
+
+  /** Execute a named workflow */
+  async executeWorkflow(
+    workflowName: string,
+    context: AgentContext,
+    message: Message
+  ): Promise<Message[]> {
+    const wf = this.workflows.get(workflowName);
+    if (!wf) throw new Error(`Workflow not found: ${workflowName}`);
+
+    const results: Message[] = [];
+
+    // Sequential steps
+    if (wf.steps) {
+      let currentMessage = message;
+      for (const agentId of wf.steps) {
+        const result = await this.executeAgent(agentId, context, currentMessage);
+        results.push(result);
+        currentMessage = result; // chain output → next input
+      }
+    }
+
+    // Parallel execution
+    if (wf.parallel) {
+      const parallelResults = await this.executeParallel(wf.parallel, context, message);
+      results.push(...parallelResults.values());
+    }
+
+    // Router-based
+    if (wf.router) {
+      const matched = this.route(message);
+      const targetId = matched && wf.router.agents.includes(matched.id)
+        ? matched.id
+        : wf.router.fallback;
+      if (targetId) {
+        const result = await this.executeAgent(targetId, context, message);
+        results.push(result);
+      }
+    }
+
+    return results;
+  }
+
+  /** Hand off conversation from one agent to another */
+  async handoff(request: HandoffRequest): Promise<Message> {
+    this.emit('agent:handoff', request);
+    const { toAgent, context } = request;
+    const lastMessage = context.messages[context.messages.length - 1];
+    if (!lastMessage) throw new Error('No message in context for handoff');
+    return this.executeAgent(toAgent, context, lastMessage);
+  }
+
+  /** Process an incoming message using the default workflow or routing */
+  async process(context: AgentContext, message: Message): Promise<Message[]> {
+    if (this.defaultWorkflow) {
+      return this.executeWorkflow(this.defaultWorkflow, context, message);
+    }
+
+    // Fallback: route to single agent
+    const agent = this.route(message);
+    if (agent) {
+      const result = await this.executeAgent(agent.id, context, message);
+      return [result];
+    }
+
+    return [{
+      id: `orch-${Date.now()}`,
+      role: 'assistant',
+      content: 'No agent available to handle this request.',
+      timestamp: Date.now(),
+    }];
+  }
+
+  getAgents(): AgentNode[] {
+    return Array.from(this.agents.values());
+  }
+
+  getWorkflows(): OrchestratorWorkflow[] {
+    return Array.from(this.workflows.values());
+  }
+}

package/src/core/rate-limiter.ts

@@ -0,0 +1,128 @@
+/**
+ * Rate Limiter - Per-user and per-provider rate limiting with queuing.
+ */
+
+interface RateLimitConfig {
+  maxRequests: number;
+  windowMs: number;
+}
+
+interface RateLimitEntry {
+  timestamps: number[];
+  queue: Array<{ resolve: () => void; reject: (err: Error) => void }>;
+}
+
+export class RateLimiter {
+  private userLimits: Map<string, RateLimitEntry> = new Map();
+  private providerLimits: Map<string, RateLimitEntry> = new Map();
+  private userConfig: RateLimitConfig;
+  private providerConfig: RateLimitConfig;
+  private maxQueueSize: number;
+
+  constructor(opts?: {
+    userLimit?: RateLimitConfig;
+    providerLimit?: RateLimitConfig;
+    maxQueueSize?: number;
+  }) {
+    this.userConfig = opts?.userLimit ?? { maxRequests: 60, windowMs: 60_000 };
+    this.providerConfig = opts?.providerLimit ?? { maxRequests: 100, windowMs: 60_000 };
+    this.maxQueueSize = opts?.maxQueueSize ?? 50;
+  }
+
+  /**
+   * Check if a request is allowed. If not, queues it with backpressure.
+   * Returns a promise that resolves when the request can proceed.
+   */
+  async acquire(userId: string, provider: string): Promise<void> {
+    await this.checkLimit(userId, this.userLimits, this.userConfig, 'user');
+    await this.checkLimit(provider, this.providerLimits, this.providerConfig, 'provider');
+  }
+
+  private async checkLimit(
+    key: string,
+    limits: Map<string, RateLimitEntry>,
+    config: RateLimitConfig,
+    type: string,
+  ): Promise<void> {
+    let entry = limits.get(key);
+    if (!entry) {
+      entry = { timestamps: [], queue: [] };
+      limits.set(key, entry);
+    }
+
+    const now = Date.now();
+    // Prune old timestamps
+    entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
+
+    if (entry.timestamps.length < config.maxRequests) {
+      entry.timestamps.push(now);
+      return;
+    }
+
+    // Rate limited - queue with backpressure
+    if (entry.queue.length >= this.maxQueueSize) {
+      throw new Error(`Rate limit exceeded for ${type} "${key}" and queue is full (${this.maxQueueSize})`);
+    }
+
+    return new Promise<void>((resolve, reject) => {
+      entry!.queue.push({ resolve, reject });
+      // Set timeout to process queue when window expires
+      const oldestTs = entry!.timestamps[0];
+      const waitMs = oldestTs + config.windowMs - now + 10;
+      setTimeout(() => {
+        this.processQueue(key, limits, config);
+      }, Math.max(waitMs, 100));
+    });
+  }
+
+  private processQueue(
+    key: string,
+    limits: Map<string, RateLimitEntry>,
+    config: RateLimitConfig,
+  ): void {
+    const entry = limits.get(key);
+    if (!entry || entry.queue.length === 0) return;
+
+    const now = Date.now();
+    entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
+
+    while (entry.queue.length > 0 && entry.timestamps.length < config.maxRequests) {
+      entry.timestamps.push(now);
+      const item = entry.queue.shift()!;
+      item.resolve();
+    }
+  }
+
+  /**
+   * Get current usage stats.
+   */
+  getUsage(userId?: string, provider?: string): {
+    user?: { used: number; limit: number; windowMs: number };
+    provider?: { used: number; limit: number; windowMs: number };
+  } {
+    const now = Date.now();
+    const result: any = {};
+
+    if (userId) {
+      const entry = this.userLimits.get(userId);
+      const used = entry ? entry.timestamps.filter(t => t > now - this.userConfig.windowMs).length : 0;
+      result.user = { used, limit: this.userConfig.maxRequests, windowMs: this.userConfig.windowMs };
+    }
+
+    if (provider) {
+      const entry = this.providerLimits.get(provider);
+      const used = entry ? entry.timestamps.filter(t => t > now - this.providerConfig.windowMs).length : 0;
+      result.provider = { used, limit: this.providerConfig.maxRequests, windowMs: this.providerConfig.windowMs };
+    }
+
+    return result;
+  }
+
+  /**
+   * Reset all limits.
+   */
+  reset(): void {
+    this.userLimits.clear();
+    this.providerLimits.clear();
+  }
+}

package/src/i18n/index.ts

@@ -1,7 +1,8 @@
 /**
  * Internationalization (i18n) support for OPC Agent.
+ * Supports English, Chinese, and Japanese.
  */
-export type Locale = 'en' | 'zh-CN';
+export type Locale = 'en' | 'zh-CN' | 'ja';
 
 export interface I18nMessages {
   [key: string]: string;
@@ -19,6 +20,7 @@ const messages: Record<Locale, I18nMessages> = {
     'cli.init.success': 'Created agent project: {name}',
     'cli.build.success': 'Build successful: {name} v{version}',
     'cli.test.pass': 'All tests passed',
+    'cli.test.fail': '{count} test(s) failed',
     'cli.stats.title': 'Agent Analytics',
     'cli.stats.messages': 'Messages Processed',
     'cli.stats.avgTime': 'Avg Response Time',
@@ -26,6 +28,24 @@ const messages: Record<Locale, I18nMessages> = {
     'cli.stats.uptime': 'Uptime',
     'plugin.loaded': 'Plugin "{name}" loaded',
     'plugin.error': 'Plugin "{name}" failed: {error}',
+    'web.title': 'OPC Agent',
+    'web.chat.placeholder': 'Type a message...',
+    'web.chat.send': 'Send',
+    'web.nav.chat': 'Chat',
+    'web.nav.dashboard': 'Dashboard',
+    'web.nav.settings': 'Settings',
+    'web.dashboard.title': 'Dashboard',
+    'web.dashboard.messages': 'Messages',
+    'web.dashboard.tokens': 'Tokens Used',
+    'web.dashboard.errors': 'Errors',
+    'web.dashboard.avgLatency': 'Avg Latency',
+    'web.settings.title': 'Settings',
+    'web.settings.language': 'Language',
+    'web.settings.theme': 'Theme',
+    'web.settings.save': 'Save',
+    'cache.hit': 'Cache hit',
+    'cache.miss': 'Cache miss',
+    'rateLimit.exceeded': 'Rate limit exceeded. Please wait.',
   },
   'zh-CN': {
     'agent.started': '智能体 "{name}" 启动成功',
@@ -38,6 +58,7 @@ const messages: Record<Locale, I18nMessages> = {
     'cli.init.success': '已创建智能体项目: {name}',
     'cli.build.success': '构建成功: {name} v{version}',
     'cli.test.pass': '所有测试通过',
+    'cli.test.fail': '{count} 个测试失败',
     'cli.stats.title': '智能体分析',
     'cli.stats.messages': '已处理消息',
     'cli.stats.avgTime': '平均响应时间',
@@ -45,6 +66,62 @@ const messages: Record<Locale, I18nMessages> = {
     'cli.stats.uptime': '运行时间',
     'plugin.loaded': '插件 "{name}" 已加载',
     'plugin.error': '插件 "{name}" 失败: {error}',
+    'web.title': 'OPC 智能体',
+    'web.chat.placeholder': '输入消息...',
+    'web.chat.send': '发送',
+    'web.nav.chat': '对话',
+    'web.nav.dashboard': '仪表盘',
+    'web.nav.settings': '设置',
+    'web.dashboard.title': '仪表盘',
+    'web.dashboard.messages': '消息数',
+    'web.dashboard.tokens': '已用 Token',
+    'web.dashboard.errors': '错误数',
+    'web.dashboard.avgLatency': '平均延迟',
+    'web.settings.title': '设置',
+    'web.settings.language': '语言',
+    'web.settings.theme': '主题',
+    'web.settings.save': '保存',
+    'cache.hit': '缓存命中',
+    'cache.miss': '缓存未命中',
+    'rateLimit.exceeded': '请求过于频繁，请稍候。',
+  },
+  'ja': {
+    '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.test.fail': '{count} 件のテストが失敗しました',
+    'cli.stats.title': 'エージェント分析',
+    'cli.stats.messages': '処理済みメッセージ',
+    'cli.stats.avgTime': '平均応答時間',
+    'cli.stats.errors': 'エラー数',
+    'cli.stats.uptime': '稼働時間',
+    'plugin.loaded': 'プラグイン「{name}」を読み込みました',
+    'plugin.error': 'プラグイン「{name}」でエラー: {error}',
+    'web.title': 'OPC エージェント',
+    'web.chat.placeholder': 'メッセージを入力...',
+    'web.chat.send': '送信',
+    'web.nav.chat': 'チャット',
+    'web.nav.dashboard': 'ダッシュボード',
+    'web.nav.settings': '設定',
+    'web.dashboard.title': 'ダッシュボード',
+    'web.dashboard.messages': 'メッセージ数',
+    'web.dashboard.tokens': '使用トークン',
+    'web.dashboard.errors': 'エラー数',
+    'web.dashboard.avgLatency': '平均レイテンシ',
+    'web.settings.title': '設定',
+    'web.settings.language': '言語',
+    'web.settings.theme': 'テーマ',
+    'web.settings.save': '保存',
+    'cache.hit': 'キャッシュヒット',
+    'cache.miss': 'キャッシュミス',
+    'rateLimit.exceeded': 'リクエスト制限を超えました。しばらくお待ちください。',
   },
 };
 
@@ -58,6 +135,14 @@ export function getLocale(): Locale {
   return currentLocale;
 }
 
+export function getSupportedLocales(): { code: Locale; label: string }[] {
+  return [
+    { code: 'en', label: 'English' },
+    { code: 'zh-CN', label: '中文' },
+    { code: 'ja', label: '日本語' },
+  ];
+}
+
 export function t(key: string, params?: Record<string, string>): string {
   let msg = messages[currentLocale]?.[key] ?? messages['en']?.[key] ?? key;
   if (params) {
@@ -71,6 +156,7 @@ export function t(key: string, params?: Record<string, string>): string {
 export function detectLocale(): Locale {
   const env = process.env.LANG ?? process.env.LC_ALL ?? process.env.LANGUAGE ?? '';
   if (env.startsWith('zh')) return 'zh-CN';
+  if (env.startsWith('ja')) return 'ja';
   return 'en';
 }
 

package/src/index.ts

@@ -58,6 +58,22 @@ export type { AgentManifest, PublishOptions, InstallOptions } from './marketplac
 // v0.7.0 modules
 export { createAuthMiddleware, getActiveSessions } from './core/auth';
 export type { AuthConfig, AuthSession } from './core/auth';
+// v0.8.0 modules
+export { Orchestrator } from './core/orchestrator';
+export type { AgentNode, OrchestratorWorkflow, OrchestratorConfig, HandoffRequest } from './core/orchestrator';
+export { AgentPipeline, compose } from './core/compose';
+export type { ComposableAgent, ComposeOptions } from './core/compose';
+export { EmailChannel } from './channels/email';
+export type { EmailChannelConfig, EmailMessage } from './channels/email';
+export { SlackChannel } from './channels/slack';
+export type { SlackChannelConfig, SlashCommandConfig, SlashCommandPayload } from './channels/slack';
+export { WeChatChannel } from './channels/wechat';
+export type { WeChatChannelConfig, WeChatMessage, TemplateMessageData } from './channels/wechat';
+export { CalculatorTool } from './tools/calculator';
+export { DateTimeTool } from './tools/datetime';
+export { JsonTransformTool } from './tools/json-transform';
+export { TextAnalysisTool } from './tools/text-analysis';
+
 export { HttpSkill } from './skills/http';
 export { WebhookTriggerSkill } from './skills/webhook-trigger';
 export type { WebhookTarget } from './skills/webhook-trigger';
@@ -65,3 +81,15 @@ export { SchedulerSkill } from './skills/scheduler';
 export type { ScheduledTask } from './skills/scheduler';
 export { DocumentSkill } from './skills/document';
 export type { DocumentChunk } from './skills/document';
+
+// v0.9.0 modules
+export { runTests, loadTestCases, formatReport } from './testing';
+export type { TestCase, TestResult, TestReport } from './testing';
+export { AnalyticsEngine } from './core/analytics-engine';
+export type { AnalyticsEvent, AnalyticsStats } from './core/analytics-engine';
+export { RateLimiter } from './core/rate-limiter';
+export { LLMCache } from './core/cache';
+export type { CacheConfig, CacheEntry } from './core/cache';
+export { getSupportedLocales } from './i18n';
+export { createDataAnalystConfig } from './templates/data-analyst';
+export { createTeacherConfig } from './templates/teacher';

package/src/templates/data-analyst.ts

@@ -0,0 +1,70 @@
+import { BaseSkill } from '../skills/base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+export class DataQuerySkill extends BaseSkill {
+  name = 'data-query';
+  description = 'Help users query and analyze data';
+
+  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
+    const lower = message.content.toLowerCase();
+    if (lower.includes('average') || lower.includes('mean') || lower.includes('sum') || lower.includes('count')) {
+      return this.match('I can help with that calculation. Could you share the dataset or describe the data source?', 0.8);
+    }
+    if (lower.includes('chart') || lower.includes('graph') || lower.includes('visualize') || lower.includes('plot')) {
+      return this.match('I can help create visualizations. What type of chart would you like? (bar, line, pie, scatter)', 0.85);
+    }
+    if (lower.includes('csv') || lower.includes('excel') || lower.includes('spreadsheet')) {
+      return this.match('I can analyze CSV/Excel data. Please share the file or paste the data.', 0.8);
+    }
+    return this.noMatch();
+  }
+}
+
+export class InsightSkill extends BaseSkill {
+  name = 'insight-generator';
+  description = 'Generate insights from data patterns';
+
+  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
+    const lower = message.content.toLowerCase();
+    if (lower.includes('trend') || lower.includes('pattern') || lower.includes('insight') || lower.includes('anomaly')) {
+      return this.match('I\'ll analyze the data for trends and anomalies. Please provide the dataset or describe what you\'re looking for.', 0.8);
+    }
+    return this.noMatch();
+  }
+}
+
+export const DATA_ANALYST_SYSTEM_PROMPT = `You are a professional data analyst assistant. Your goals:
+1. Help users query, transform, and analyze data
+2. Create clear visualizations and summaries
+3. Identify trends, patterns, and anomalies
+4. Explain findings in plain language
+Be precise with numbers, always cite your data source, and suggest next steps for deeper analysis.`;
+
+export function createDataAnalystConfig() {
+  return {
+    apiVersion: 'opc/v1' as const,
+    kind: 'Agent' as const,
+    metadata: {
+      name: 'data-analyst',
+      version: '1.0.0',
+      description: 'AI data analyst with data querying, visualization, and insight generation',
+      author: 'OPC Agent',
+      license: 'Apache-2.0',
+    },
+    spec: {
+      provider: { default: 'openai', allowed: ['openai', 'deepseek', 'qwen'] },
+      model: 'gpt-4o-mini',
+      systemPrompt: DATA_ANALYST_SYSTEM_PROMPT,
+      skills: [
+        { name: 'data-query', description: 'Query and transform data' },
+        { name: 'insight-generator', description: 'Generate data insights' },
+      ],
+      channels: [{ type: 'web' as const, port: 3000 }],
+      memory: { shortTerm: true, longTerm: true },
+      dtv: {
+        trust: { level: 'sandbox' as const },
+        value: { metrics: ['queries_processed', 'insights_generated'] },
+      },
+    },
+  };
+}

package/src/templates/teacher.ts

@@ -0,0 +1,79 @@
+import { BaseSkill } from '../skills/base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+
+export class LessonPlanSkill extends BaseSkill {
+  name = 'lesson-plan';
+  description = 'Create and manage lesson plans';
+
+  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
+    const lower = message.content.toLowerCase();
+    if (lower.includes('lesson') || lower.includes('plan') || lower.includes('curriculum') || lower.includes('syllabus')) {
+      return this.match('I can help create a lesson plan. What subject, grade level, and learning objectives should I focus on?', 0.85);
+    }
+    return this.noMatch();
+  }
+}
+
+export class QuizSkill extends BaseSkill {
+  name = 'quiz-generator';
+  description = 'Generate quizzes and assessments';
+
+  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
+    const lower = message.content.toLowerCase();
+    if (lower.includes('quiz') || lower.includes('test') || lower.includes('assessment') || lower.includes('exam') || lower.includes('question')) {
+      return this.match('I\'ll create a quiz for you. What topic, difficulty level, and number of questions would you like?', 0.85);
+    }
+    return this.noMatch();
+  }
+}
+
+export class ExplainSkill extends BaseSkill {
+  name = 'concept-explainer';
+  description = 'Explain concepts at appropriate level';
+
+  async execute(_context: AgentContext, message: Message): Promise<SkillResult> {
+    const lower = message.content.toLowerCase();
+    if (lower.includes('explain') || lower.includes('what is') || lower.includes('how does') || lower.includes('why')) {
+      return this.match('Let me explain that concept. What\'s your current level of understanding so I can tailor my explanation?', 0.75);
+    }
+    return this.noMatch();
+  }
+}
+
+export const TEACHER_SYSTEM_PROMPT = `You are a patient and encouraging teacher assistant. Your goals:
+1. Create engaging lesson plans tailored to student level
+2. Generate quizzes and assessments with answer keys
+3. Explain complex concepts using analogies and examples
+4. Provide constructive feedback and encouragement
+5. Adapt teaching style to different learning preferences
+Be patient, use clear language, and always check for understanding. Use the Socratic method when appropriate.`;
+
+export function createTeacherConfig() {
+  return {
+    apiVersion: 'opc/v1' as const,
+    kind: 'Agent' as const,
+    metadata: {
+      name: 'teacher',
+      version: '1.0.0',
+      description: 'AI teacher assistant with lesson planning, quiz generation, and concept explanation',
+      author: 'OPC Agent',
+      license: 'Apache-2.0',
+    },
+    spec: {
+      provider: { default: 'openai', allowed: ['openai', 'deepseek', 'qwen'] },
+      model: 'gpt-4o-mini',
+      systemPrompt: TEACHER_SYSTEM_PROMPT,
+      skills: [
+        { name: 'lesson-plan', description: 'Create lesson plans' },
+        { name: 'quiz-generator', description: 'Generate quizzes' },
+        { name: 'concept-explainer', description: 'Explain concepts' },
+      ],
+      channels: [{ type: 'web' as const, port: 3000 }],
+      memory: { shortTerm: true, longTerm: true },
+      dtv: {
+        trust: { level: 'sandbox' as const },
+        value: { metrics: ['lessons_created', 'quizzes_generated', 'concepts_explained'] },
+      },
+    },
+  };
+}