opc-agent 0.6.0 → 0.7.0

package/dist/skills/scheduler.d.ts

@@ -0,0 +1,21 @@
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+export interface ScheduledTask {
+    id: string;
+    name: string;
+    cronExpr: string;
+    action: string;
+    enabled: boolean;
+    lastRun?: number;
+    nextRun?: number;
+}
+export declare class SchedulerSkill extends BaseSkill {
+    name: string;
+    description: string;
+    private tasks;
+    private timers;
+    execute(context: AgentContext, message: Message): Promise<SkillResult>;
+    private parseCronToInterval;
+    destroy(): void;
+}
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/skills/scheduler.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchedulerSkill = void 0;
+const base_1 = require("./base");
+class SchedulerSkill extends base_1.BaseSkill {
+    name = 'scheduler';
+    description = 'Schedule recurring tasks. Usage: schedule list | schedule add <name> <cron> <action> | schedule remove <id>';
+    tasks = new Map();
+    timers = new Map();
+    async execute(context, message) {
+        const text = message.content.trim();
+        if (/^schedule\s+list$/i.test(text)) {
+            if (this.tasks.size === 0)
+                return this.match('No scheduled tasks.');
+            const lines = Array.from(this.tasks.values()).map(t => `• ${t.name} (${t.id}) — ${t.cronExpr} — ${t.enabled ? '✅' : '❌'} — Last: ${t.lastRun ? new Date(t.lastRun).toISOString() : 'never'}`);
+            return this.match(`Scheduled tasks:\n${lines.join('\n')}`);
+        }
+        const addMatch = text.match(/^schedule\s+add\s+(\S+)\s+(".*?"|\S+)\s+(.+)$/i);
+        if (addMatch) {
+            const [, name, cronExpr, action] = addMatch;
+            const id = `task_${Date.now().toString(36)}`;
+            const task = {
+                id, name, cronExpr: cronExpr.replace(/"/g, ''), action, enabled: true,
+            };
+            this.tasks.set(id, task);
+            // Simple interval-based scheduling (parse cron for interval in minutes)
+            const intervalMs = this.parseCronToInterval(task.cronExpr);
+            if (intervalMs > 0) {
+                const timer = setInterval(() => {
+                    task.lastRun = Date.now();
+                }, intervalMs);
+                this.timers.set(id, timer);
+            }
+            return this.match(`Task scheduled: ${name} (${id}) — ${task.cronExpr} → "${action}"`);
+        }
+        const rmMatch = text.match(/^schedule\s+remove\s+(\S+)$/i);
+        if (rmMatch) {
+            const id = rmMatch[1];
+            const timer = this.timers.get(id);
+            if (timer)
+                clearInterval(timer);
+            this.timers.delete(id);
+            const removed = this.tasks.delete(id);
+            return this.match(removed ? `Task ${id} removed.` : `Task ${id} not found.`);
+        }
+        return this.noMatch();
+    }
+    parseCronToInterval(expr) {
+        // Simple: support "every Xm" or "every Xh" or basic intervals
+        const m = expr.match(/every\s+(\d+)\s*(m|min|h|hr|s|sec)/i);
+        if (m) {
+            const val = parseInt(m[1]);
+            const unit = m[2].toLowerCase();
+            if (unit.startsWith('h'))
+                return val * 3600_000;
+            if (unit.startsWith('m'))
+                return val * 60_000;
+            if (unit.startsWith('s'))
+                return val * 1000;
+        }
+        return 0; // Unknown cron format, no auto-schedule
+    }
+    destroy() {
+        for (const timer of this.timers.values())
+            clearInterval(timer);
+        this.timers.clear();
+    }
+}
+exports.SchedulerSkill = SchedulerSkill;
+//# sourceMappingURL=scheduler.js.map

package/dist/skills/webhook-trigger.d.ts

@@ -0,0 +1,17 @@
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+export interface WebhookTarget {
+    name: string;
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    secret?: string;
+}
+export declare class WebhookTriggerSkill extends BaseSkill {
+    name: string;
+    description: string;
+    private targets;
+    registerTarget(target: WebhookTarget): void;
+    execute(context: AgentContext, message: Message): Promise<SkillResult>;
+}
+//# sourceMappingURL=webhook-trigger.d.ts.map

package/dist/skills/webhook-trigger.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookTriggerSkill = void 0;
+const base_1 = require("./base");
+class WebhookTriggerSkill extends base_1.BaseSkill {
+    name = 'webhook-trigger';
+    description = 'Trigger external webhooks. Usage: webhook <name> [payload JSON]';
+    targets = new Map();
+    registerTarget(target) {
+        this.targets.set(target.name, target);
+    }
+    async execute(context, message) {
+        const match = message.content.trim().match(/^webhook\s+(\S+)(?:\s+(.+))?$/is);
+        if (!match)
+            return this.noMatch();
+        const [, name, payloadStr] = match;
+        const target = this.targets.get(name);
+        if (!target) {
+            const available = Array.from(this.targets.keys()).join(', ') || 'none';
+            return this.match(`Unknown webhook "${name}". Available: ${available}`);
+        }
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+                'User-Agent': 'OPC-Agent/0.7.0',
+                ...target.headers,
+            };
+            if (target.secret) {
+                headers['X-Webhook-Secret'] = target.secret;
+            }
+            const body = payloadStr ?? JSON.stringify({
+                agent: context.agentName,
+                timestamp: Date.now(),
+                trigger: 'manual',
+            });
+            const res = await fetch(target.url, {
+                method: target.method ?? 'POST',
+                headers,
+                body,
+            });
+            return this.match(`Webhook "${name}" triggered → ${res.status} ${res.statusText}`);
+        }
+        catch (err) {
+            return this.match(`Webhook error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+exports.WebhookTriggerSkill = WebhookTriggerSkill;
+//# sourceMappingURL=webhook-trigger.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opc-agent",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Open Agent Framework — Build, test, and run AI Agents for business workstations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/channels/web.ts

@@ -4,6 +4,59 @@ import type { Message } from '../core/types';
 import { BaseChannel } from './index';
 import { KnowledgeBase } from '../core/knowledge';
 import { createProvider, type LLMProvider } from '../providers';
+import { createAuthMiddleware, type AuthConfig } from '../core/auth';
+
+const AGENT_TEMPLATES = [
+  { id: 'customer-service', name: 'Customer Service', description: 'Handle support tickets, FAQs, and customer inquiries', icon: '🎧', category: 'Business' },
+  { id: 'code-reviewer', name: 'Code Reviewer', description: 'Review PRs, suggest improvements, check for bugs', icon: '🔍', category: 'Engineering' },
+  { id: 'content-writer', name: 'Content Writer', description: 'Write blogs, social media posts, and marketing copy', icon: '✍️', category: 'Marketing' },
+  { id: 'executive-assistant', name: 'Executive Assistant', description: 'Schedule management, email drafting, meeting prep', icon: '📋', category: 'Business' },
+  { id: 'knowledge-base', name: 'Knowledge Base', description: 'RAG-powered Q&A over your documents', icon: '📚', category: 'Knowledge' },
+  { id: 'project-manager', name: 'Project Manager', description: 'Track tasks, milestones, and team coordination', icon: '📊', category: 'Business' },
+  { id: 'sales-assistant', name: 'Sales Assistant', description: 'Lead qualification, outreach drafting, CRM updates', icon: '💼', category: 'Sales' },
+  { id: 'financial-advisor', name: 'Financial Advisor', description: 'Budget analysis, financial planning, cost optimization', icon: '💰', category: 'Finance' },
+  { id: 'hr-recruiter', name: 'HR Recruiter', description: 'Resume screening, interview scheduling, candidate comms', icon: '👥', category: 'HR' },
+  { id: 'legal-assistant', name: 'Legal Assistant', description: 'Contract review, compliance checks, legal research', icon: '⚖️', category: 'Legal' },
+];
+
+const TEMPLATES_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1.0">
+<title>Agent Templates</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{background:#0a0a0f;color:#e0e0e0;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;padding:24px}
+h1{font-size:28px;margin-bottom:8px;color:#fff}
+.sub{color:#888;margin-bottom:32px;font-size:14px}
+nav{margin-bottom:24px}
+nav a{color:#818cf8;text-decoration:none;margin-right:16px;font-size:14px}
+.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:16px}
+.card{background:#12121a;border:1px solid #1e1e2e;border-radius:12px;padding:24px;cursor:pointer;transition:all .2s}
+.card:hover{border-color:#818cf8;transform:translateY(-2px)}
+.card .icon{font-size:32px;margin-bottom:12px}
+.card h3{font-size:16px;color:#fff;margin-bottom:8px}
+.card p{font-size:13px;color:#888;line-height:1.5}
+.card .cat{font-size:11px;color:#818cf8;text-transform:uppercase;letter-spacing:1px;margin-top:12px}
+.btn{display:inline-block;background:#2563eb;color:#fff;border:none;border-radius:8px;padding:8px 16px;font-size:13px;cursor:pointer;margin-top:12px}
+.btn:hover{background:#1d4ed8}
+</style>
+</head>
+<body>
+<nav><a href="/">← Chat</a><a href="/dashboard">Dashboard</a><a href="/templates">Templates</a></nav>
+<h1>🧩 Agent Templates</h1>
+<p class="sub">Create a new agent from a pre-built template in one click.</p>
+<div class="grid" id="grid"></div>
+<script>
+fetch('/api/templates').then(r=>r.json()).then(d=>{
+  const g=document.getElementById('grid');
+  d.templates.forEach(t=>{
+    g.innerHTML+=\`<div class="card"><div class="icon">\${t.icon}</div><h3>\${t.name}</h3><p>\${t.description}</p><div class="cat">\${t.category}</div><button class="btn" onclick="alert('Creating agent from template: '+'\${t.id}'+'\\\\nRun: opc init --template \${t.id}')">Use Template</button></div>\`;
+  });
+});
+</script>
+</body>
+</html>`;
 
 const CHAT_HTML = `<!DOCTYPE html>
 <html lang="en">
@@ -157,8 +210,12 @@ export class WebChannel extends BaseChannel {
   private streamHandler: ((msg: Message, res: Response) => Promise<void>) | null = null;
   private agentName: string = 'OPC Agent';
   private currentProvider: string = 'openai';
-  private stats = { sessions: 0, messages: 0, totalResponseMs: 0, tokenUsage: 0, knowledgeFiles: 0, startedAt: Date.now() };
+  private stats = { sessions: 0, messages: 0, totalResponseMs: 0, tokenUsage: 0, knowledgeFiles: 0, startedAt: Date.now(), errors: 0 };
   private eventHandlers: Map<string, Function[]> = new Map();
+  private conversations: Map<string, Message[]> = new Map();
+  private requestCount = 0;
+  private llmLatencySum = 0;
+  private llmCalls = 0;
 
   private emit(event: string, data: any): void {
     const handlers = this.eventHandlers.get(event) ?? [];
@@ -175,15 +232,23 @@ export class WebChannel extends BaseChannel {
     this.stats.messages++;
     this.stats.totalResponseMs += responseMs;
     this.stats.tokenUsage += tokens;
+    this.requestCount++;
+    this.llmLatencySum += responseMs;
+    this.llmCalls++;
   }
 
+  trackError(): void { this.stats.errors++; }
+
   trackSession(): void { this.stats.sessions++; }
 
-  constructor(port: number = 3000) {
+  constructor(port: number = 3000, authConfig?: AuthConfig) {
     super();
     this.port = port;
     this.app = express();
-    this.app.use(express.json());
+    this.app.use(express.json({ limit: '10mb' }));
+    if (authConfig && authConfig.apiKeys.length > 0) {
+      this.app.use(createAuthMiddleware(authConfig));
+    }
     this.setupRoutes();
   }
 
@@ -211,6 +276,7 @@ export class WebChannel extends BaseChannel {
     // Streaming chat endpoint
     this.app.post('/api/chat', async (req: Request, res: Response) => {
       const { message, sessionId } = req.body;
+      const sid = sessionId ?? 'default';
       if (!message) {
         res.status(400).json({ error: 'message is required' });
         return;
@@ -221,9 +287,13 @@ export class WebChannel extends BaseChannel {
         role: 'user',
         content: message,
         timestamp: Date.now(),
-        metadata: { sessionId: sessionId ?? 'default' },
+        metadata: { sessionId: sid },
       };
 
+      // Track conversation
+      if (!this.conversations.has(sid)) this.conversations.set(sid, []);
+      this.conversations.get(sid)!.push(msg);
+
       if (this.streamHandler) {
         try {
           await this.streamHandler(msg, res);
@@ -301,6 +371,107 @@ export class WebChannel extends BaseChannel {
       } catch { res.json({ totalEntries: 0, sources: [] }); }
     });
 
+    // --- Health Check (detailed) ---
+    this.app.get('/api/health', (_req: Request, res: Response) => {
+      const uptimeMs = Date.now() - this.stats.startedAt;
+      res.json({
+        status: 'ok',
+        timestamp: Date.now(),
+        uptime: uptimeMs,
+        uptimeHuman: `${Math.floor(uptimeMs / 3600000)}h ${Math.floor((uptimeMs % 3600000) / 60000)}m`,
+        version: '0.7.0',
+        agent: this.agentName,
+        stats: {
+          sessions: this.stats.sessions,
+          messages: this.stats.messages,
+          errors: this.stats.errors,
+          avgResponseMs: this.stats.messages > 0 ? Math.round(this.stats.totalResponseMs / this.stats.messages) : 0,
+        },
+        memory: {
+          rss: process.memoryUsage().rss,
+          heapUsed: process.memoryUsage().heapUsed,
+        },
+      });
+    });
+
+    // --- Prometheus Metrics ---
+    this.app.get('/api/metrics', (_req: Request, res: Response) => {
+      const uptimeMs = Date.now() - this.stats.startedAt;
+      const avgLatency = this.llmCalls > 0 ? this.llmLatencySum / this.llmCalls : 0;
+      const mem = process.memoryUsage();
+      res.type('text/plain').send(
+        `# HELP opc_uptime_seconds Agent uptime in seconds\n` +
+        `# TYPE opc_uptime_seconds gauge\n` +
+        `opc_uptime_seconds ${(uptimeMs / 1000).toFixed(1)}\n` +
+        `# HELP opc_requests_total Total requests\n` +
+        `# TYPE opc_requests_total counter\n` +
+        `opc_requests_total ${this.requestCount}\n` +
+        `# HELP opc_messages_total Total messages processed\n` +
+        `# TYPE opc_messages_total counter\n` +
+        `opc_messages_total ${this.stats.messages}\n` +
+        `# HELP opc_errors_total Total errors\n` +
+        `# TYPE opc_errors_total counter\n` +
+        `opc_errors_total ${this.stats.errors}\n` +
+        `# HELP opc_llm_latency_avg_ms Average LLM response latency\n` +
+        `# TYPE opc_llm_latency_avg_ms gauge\n` +
+        `opc_llm_latency_avg_ms ${avgLatency.toFixed(1)}\n` +
+        `# HELP opc_sessions_total Total sessions\n` +
+        `# TYPE opc_sessions_total counter\n` +
+        `opc_sessions_total ${this.stats.sessions}\n` +
+        `# HELP opc_token_usage_total Total token usage\n` +
+        `# TYPE opc_token_usage_total counter\n` +
+        `opc_token_usage_total ${this.stats.tokenUsage}\n` +
+        `# HELP process_resident_memory_bytes Resident memory size\n` +
+        `# TYPE process_resident_memory_bytes gauge\n` +
+        `process_resident_memory_bytes ${mem.rss}\n`
+      );
+    });
+
+    // --- Conversation tracking & export ---
+    this.app.get('/api/conversations/export', (req: Request, res: Response) => {
+      const sessionId = req.query.sessionId as string;
+      const format = (req.query.format as string) ?? 'json';
+
+      const messages = sessionId ? (this.conversations.get(sessionId) ?? []) : Array.from(this.conversations.values()).flat();
+
+      if (format === 'markdown') {
+        const md = messages.map(m => `**${m.role}** (${new Date(m.timestamp).toISOString()}):\n${m.content}`).join('\n\n---\n\n');
+        res.type('text/markdown').send(md);
+      } else if (format === 'csv') {
+        const header = 'id,role,content,timestamp\n';
+        const rows = messages.map(m => `"${m.id}","${m.role}","${m.content.replace(/"/g, '""')}",${m.timestamp}`).join('\n');
+        res.type('text/csv').send(header + rows);
+      } else {
+        res.json({ sessionId: sessionId ?? 'all', messages, count: messages.length });
+      }
+    });
+
+    // --- Document Upload ---
+    this.app.post('/api/documents/upload', async (req: Request, res: Response) => {
+      try {
+        const { content, filename, mimeType } = req.body;
+        if (!content || !filename) {
+          res.status(400).json({ error: 'content and filename are required' });
+          return;
+        }
+        const kb = new KnowledgeBase('.');
+        const result = await kb.addText(content, filename);
+        this.stats.knowledgeFiles++;
+        res.json({ ok: true, filename, chunks: result.chunks, chars: content.length });
+      } catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : 'Upload failed' });
+      }
+    });
+
+    // --- Agent Templates Gallery ---
+    this.app.get('/api/templates', (_req: Request, res: Response) => {
+      res.json({ templates: AGENT_TEMPLATES });
+    });
+
+    this.app.get('/templates', (_req: Request, res: Response) => {
+      res.type('html').send(TEMPLATES_HTML);
+    });
+
     // Legacy endpoint
     this.app.post('/chat', async (req: Request, res: Response) => {
       if (!this.handler) {

package/src/core/auth.ts

@@ -0,0 +1,57 @@
+import type { Request, Response, NextFunction } from 'express';
+
+export interface AuthConfig {
+  apiKeys: string[];
+  sessionIsolation?: boolean;
+}
+
+export interface AuthSession {
+  apiKey: string;
+  userId: string;
+  createdAt: number;
+}
+
+const sessions = new Map<string, AuthSession>();
+
+export function createAuthMiddleware(config: AuthConfig) {
+  return (req: Request, res: Response, next: NextFunction): void => {
+    // Skip auth for non-API routes and health/metrics
+    if (!req.path.startsWith('/api/') || req.path === '/api/health' || req.path === '/api/metrics') {
+      next();
+      return;
+    }
+
+    const apiKey = req.headers['x-api-key'] as string
+      ?? req.headers['authorization']?.replace(/^Bearer\s+/i, '')
+      ?? (req.query as any).apiKey;
+
+    if (!apiKey || !config.apiKeys.includes(apiKey)) {
+      res.status(401).json({ error: 'Unauthorized. Provide a valid API key via X-API-Key header, Bearer token, or ?apiKey query.' });
+      return;
+    }
+
+    // Derive userId from API key for session isolation
+    const userId = `user_${hashKey(apiKey)}`;
+    if (!sessions.has(apiKey)) {
+      sessions.set(apiKey, { apiKey, userId, createdAt: Date.now() });
+    }
+
+    // Attach user info to request
+    (req as any).userId = userId;
+    (req as any).sessionPrefix = config.sessionIsolation ? `${userId}:` : '';
+
+    next();
+  };
+}
+
+function hashKey(key: string): string {
+  let h = 0;
+  for (let i = 0; i < key.length; i++) {
+    h = ((h << 5) - h + key.charCodeAt(i)) | 0;
+  }
+  return Math.abs(h).toString(36);
+}
+
+export function getActiveSessions(): AuthSession[] {
+  return Array.from(sessions.values());
+}

package/src/index.ts

@@ -54,3 +54,14 @@ export { deployToHermes } from './deploy/hermes';
 export type { HermesDeployOptions, HermesDeployResult } from './deploy/hermes';
 export { publishAgent, installAgent } from './marketplace';
 export type { AgentManifest, PublishOptions, InstallOptions } from './marketplace';
+
+// v0.7.0 modules
+export { createAuthMiddleware, getActiveSessions } from './core/auth';
+export type { AuthConfig, AuthSession } from './core/auth';
+export { HttpSkill } from './skills/http';
+export { WebhookTriggerSkill } from './skills/webhook-trigger';
+export type { WebhookTarget } from './skills/webhook-trigger';
+export { SchedulerSkill } from './skills/scheduler';
+export type { ScheduledTask } from './skills/scheduler';
+export { DocumentSkill } from './skills/document';
+export type { DocumentChunk } from './skills/document';

package/src/schema/oad.ts

@@ -48,6 +48,12 @@ export const HITLSchema = z.object({
   defaultAction: z.enum(['approve', 'deny']).default('deny'),
 });
 
+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(),
@@ -124,6 +130,7 @@ export const SpecSchema = z.object({
   voice: VoiceSchema.optional(),
   webhook: WebhookSchema.optional(),
   hitl: HITLSchema.optional(),
+  auth: AuthSchema.optional(),
 });
 
 export const OADSchema = z.object({

package/src/skills/document.ts

@@ -0,0 +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 };
+  }
+}

package/src/skills/http.ts

@@ -0,0 +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)}`);
+    }
+  }
+}