opc-agent 0.5.1 → 0.7.0

package/dist/schema/oad.d.ts

@@ -77,6 +77,19 @@ export declare const HITLSchema: z.ZodObject<{
     defaultTimeoutMs?: number | undefined;
     defaultAction?: "approve" | "deny" | undefined;
 }>;
+export declare const AuthSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    apiKeys: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sessionIsolation: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    apiKeys: string[];
+    sessionIsolation: boolean;
+}, {
+    enabled?: boolean | undefined;
+    apiKeys?: string[] | undefined;
+    sessionIsolation?: boolean | undefined;
+}>;
 export declare const ChannelSchema: z.ZodObject<{
     type: z.ZodEnum<["web", "websocket", "telegram", "cli", "voice", "webhook"]>;
     port: z.ZodOptional<z.ZodNumber>;
@@ -453,6 +466,19 @@ export declare const SpecSchema: z.ZodObject<{
         defaultTimeoutMs?: number | undefined;
         defaultAction?: "approve" | "deny" | undefined;
     }>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        apiKeys: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        sessionIsolation: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        apiKeys: string[];
+        sessionIsolation: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        apiKeys?: string[] | undefined;
+        sessionIsolation?: boolean | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     model: string;
     skills: {
@@ -469,6 +495,11 @@ export declare const SpecSchema: z.ZodObject<{
         enabled: boolean;
         chunkSize?: number | undefined;
     };
+    auth?: {
+        enabled: boolean;
+        apiKeys: string[];
+        sessionIsolation: boolean;
+    } | undefined;
     voice?: {
         enabled: boolean;
         sttProvider?: string | undefined;
@@ -522,6 +553,11 @@ export declare const SpecSchema: z.ZodObject<{
         defaultAction: "approve" | "deny";
     } | undefined;
 }, {
+    auth?: {
+        enabled?: boolean | undefined;
+        apiKeys?: string[] | undefined;
+        sessionIsolation?: boolean | undefined;
+    } | undefined;
     voice?: {
         enabled?: boolean | undefined;
         sttProvider?: string | undefined;
@@ -830,6 +866,19 @@ export declare const OADSchema: z.ZodObject<{
             defaultTimeoutMs?: number | undefined;
             defaultAction?: "approve" | "deny" | undefined;
         }>>;
+        auth: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            apiKeys: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            sessionIsolation: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            apiKeys: string[];
+            sessionIsolation: boolean;
+        }, {
+            enabled?: boolean | undefined;
+            apiKeys?: string[] | undefined;
+            sessionIsolation?: boolean | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         model: string;
         skills: {
@@ -846,6 +895,11 @@ export declare const OADSchema: z.ZodObject<{
             enabled: boolean;
             chunkSize?: number | undefined;
         };
+        auth?: {
+            enabled: boolean;
+            apiKeys: string[];
+            sessionIsolation: boolean;
+        } | undefined;
         voice?: {
             enabled: boolean;
             sttProvider?: string | undefined;
@@ -899,6 +953,11 @@ export declare const OADSchema: z.ZodObject<{
             defaultAction: "approve" | "deny";
         } | undefined;
     }, {
+        auth?: {
+            enabled?: boolean | undefined;
+            apiKeys?: string[] | undefined;
+            sessionIsolation?: boolean | undefined;
+        } | undefined;
         voice?: {
             enabled?: boolean | undefined;
             sttProvider?: string | undefined;
@@ -999,6 +1058,11 @@ export declare const OADSchema: z.ZodObject<{
             enabled: boolean;
             chunkSize?: number | undefined;
         };
+        auth?: {
+            enabled: boolean;
+            apiKeys: string[];
+            sessionIsolation: boolean;
+        } | undefined;
         voice?: {
             enabled: boolean;
             sttProvider?: string | undefined;
@@ -1069,6 +1133,11 @@ export declare const OADSchema: z.ZodObject<{
         } | undefined;
     };
     spec: {
+        auth?: {
+            enabled?: boolean | undefined;
+            apiKeys?: string[] | undefined;
+            sessionIsolation?: boolean | undefined;
+        } | undefined;
         voice?: {
             enabled?: boolean | undefined;
             sttProvider?: string | undefined;

package/dist/schema/oad.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OADSchema = exports.SpecSchema = exports.StreamingSchema = exports.RoomSchema = exports.MetadataSchema = exports.MarketplaceSchema = exports.ProviderSchema = exports.DTVSchema = exports.TrustLevel = exports.MemorySchema = exports.LongTermMemorySchema = exports.ChannelSchema = exports.HITLSchema = exports.WebhookSchema = exports.VoiceSchema = exports.WorkflowSchema = exports.WorkflowStepSchema = exports.SkillRefSchema = void 0;
+exports.OADSchema = exports.SpecSchema = exports.StreamingSchema = exports.RoomSchema = exports.MetadataSchema = exports.MarketplaceSchema = exports.ProviderSchema = exports.DTVSchema = exports.TrustLevel = exports.MemorySchema = exports.LongTermMemorySchema = exports.ChannelSchema = exports.AuthSchema = exports.HITLSchema = exports.WebhookSchema = exports.VoiceSchema = exports.WorkflowSchema = exports.WorkflowStepSchema = exports.SkillRefSchema = void 0;
 const zod_1 = require("zod");
 // ─── OAD Schema v1 ───────────────────────────────────────────
 exports.SkillRefSchema = zod_1.z.object({
@@ -43,6 +43,11 @@ exports.HITLSchema = zod_1.z.object({
     defaultTimeoutMs: zod_1.z.number().default(60000),
     defaultAction: zod_1.z.enum(['approve', 'deny']).default('deny'),
 });
+exports.AuthSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().default(false),
+    apiKeys: zod_1.z.array(zod_1.z.string()).default([]),
+    sessionIsolation: zod_1.z.boolean().default(true),
+});
 exports.ChannelSchema = zod_1.z.object({
     type: zod_1.z.enum(['web', 'websocket', 'telegram', 'cli', 'voice', 'webhook']),
     port: zod_1.z.number().optional(),
@@ -109,6 +114,7 @@ exports.SpecSchema = zod_1.z.object({
     voice: exports.VoiceSchema.optional(),
     webhook: exports.WebhookSchema.optional(),
     hitl: exports.HITLSchema.optional(),
+    auth: exports.AuthSchema.optional(),
 });
 exports.OADSchema = zod_1.z.object({
     apiVersion: zod_1.z.literal('opc/v1'),

package/dist/skills/document.d.ts

@@ -0,0 +1,27 @@
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+export interface DocumentChunk {
+    content: string;
+    metadata: {
+        filename: string;
+        mimeType: string;
+        chunkIndex: number;
+        totalChunks: number;
+    };
+}
+export declare class DocumentSkill extends BaseSkill {
+    name: string;
+    description: string;
+    private knowledgeBase;
+    constructor(kbPath?: string);
+    execute(context: AgentContext, message: Message): Promise<SkillResult>;
+    extractText(content: string, mimeType: string): string;
+    chunk(text: string, size?: number, overlap?: number): DocumentChunk[];
+    private guessMime;
+    /** Process raw text content directly (for API uploads) */
+    processText(content: string, filename: string): Promise<{
+        chunks: number;
+        chars: number;
+    }>;
+}
+//# sourceMappingURL=document.d.ts.map

package/dist/skills/document.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentSkill = void 0;
+const base_1 = require("./base");
+const knowledge_1 = require("../core/knowledge");
+class DocumentSkill extends base_1.BaseSkill {
+    name = 'document';
+    description = 'Process uploaded documents (PDF, TXT, MD, DOCX). Chunks content and adds to knowledge base.';
+    knowledgeBase;
+    constructor(kbPath = '.') {
+        super();
+        this.knowledgeBase = new knowledge_1.KnowledgeBase(kbPath);
+    }
+    async execute(context, message) {
+        // Check if message has document attachment metadata
+        const meta = message.metadata;
+        if (!meta?.document)
+            return this.noMatch();
+        const { content, filename, mimeType } = meta.document;
+        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, mimeType) {
+        // 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, size = 1000, overlap = 100) {
+        const chunks = [];
+        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;
+    }
+    guessMime(filename) {
+        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, filename) {
+        const chunks = this.chunk(content);
+        const result = await this.knowledgeBase.addText(content, filename);
+        return { chunks: chunks.length, chars: content.length };
+    }
+}
+exports.DocumentSkill = DocumentSkill;
+//# sourceMappingURL=document.js.map

package/dist/skills/http.d.ts

@@ -0,0 +1,8 @@
+import { BaseSkill } from './base';
+import type { AgentContext, Message, SkillResult } from '../core/types';
+export declare class HttpSkill extends BaseSkill {
+    name: string;
+    description: string;
+    execute(context: AgentContext, message: Message): Promise<SkillResult>;
+}
+//# sourceMappingURL=http.d.ts.map

package/dist/skills/http.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpSkill = void 0;
+const base_1 = require("./base");
+class HttpSkill extends base_1.BaseSkill {
+    name = 'http';
+    description = 'Make HTTP requests to external APIs. Usage: http GET|POST|PUT|DELETE <url> [body]';
+    async execute(context, message) {
+        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 = {
+                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)}`);
+        }
+    }
+}
+exports.HttpSkill = HttpSkill;
+//# sourceMappingURL=http.js.map

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.5.1",
+  "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",