openkbs 0.0.53 → 0.0.55

package/templates/.openkbs/knowledge/examples/ai-copywriter-agent/src/Frontend/contentRender.js

@@ -1,6 +1,11 @@
 import React, { useEffect } from "react";
 import JsonView from '@uiw/react-json-view';
-import { Chip } from '@mui/material';
+import { Box, Tooltip, Chip } from '@mui/material';
+import SearchIcon from '@mui/icons-material/Search';
+import LanguageIcon from '@mui/icons-material/Language';
+import ImageIcon from '@mui/icons-material/Image';
+import YouTubeIcon from '@mui/icons-material/YouTube';
+import ArticleIcon from '@mui/icons-material/Article';
 
 const extractJSONFromText = (text) => {
     let braceCount = 0, startIndex = text.indexOf('{');
@@ -19,24 +24,102 @@ const extractJSONFromText = (text) => {
     return null;
 }
 
-const parseCommands = (text) => {
-    return text.match(/\/\w+\("([^"]+)"\)/g) || [];
-}
+// Command patterns for XML+JSON format
+const COMMAND_PATTERNS = [
+    /<googleSearch>[\s\S]*?<\/googleSearch>/,
+    /<youtubeSearch>[\s\S]*?<\/youtubeSearch>/,
+    /<googleImageSearch>[\s\S]*?<\/googleImageSearch>/,
+    /<webpageToText>[\s\S]*?<\/webpageToText>/,
+    /<documentToText>[\s\S]*?<\/documentToText>/,
+    /<imageToText>[\s\S]*?<\/imageToText>/
+];
+
+// Icon mapping for commands
+const commandIcons = {
+    googleSearch: SearchIcon,
+    youtubeSearch: YouTubeIcon,
+    googleImageSearch: ImageIcon,
+    webpageToText: LanguageIcon,
+    documentToText: ArticleIcon,
+    imageToText: ImageIcon
+};
+
+// Parse commands from content
+const parseCommands = (content) => {
+    const commands = [];
+    const regex = /<(\w+)>([\s\S]*?)<\/\1>/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        try {
+            commands.push({
+                name: match[1],
+                data: JSON.parse(match[2].trim())
+            });
+        } catch (e) {
+            commands.push({ name: match[1], data: match[2].trim() });
+        }
+    }
+    return commands;
+};
+
+// Render command as icon with tooltip
+const CommandIcon = ({ command }) => {
+    const Icon = commandIcons[command.name] || SearchIcon;
+    return (
+        <Tooltip
+            title={
+                <Box sx={{ p: 1 }}>
+                    <Box sx={{ fontWeight: 'bold', color: '#4CAF50', mb: 0.5 }}>{command.name}</Box>
+                    <pre style={{ margin: 0, fontSize: '10px' }}>
+                        {typeof command.data === 'object'
+                            ? JSON.stringify(command.data, null, 2)
+                            : command.data}
+                    </pre>
+                </Box>
+            }
+            arrow
+        >
+            <Box sx={{
+                display: 'inline-flex',
+                width: 32, height: 32,
+                borderRadius: '50%',
+                backgroundColor: 'rgba(76, 175, 80, 0.1)',
+                border: '2px solid rgba(76, 175, 80, 0.3)',
+                alignItems: 'center',
+                justifyContent: 'center',
+                mx: 0.5,
+                cursor: 'pointer',
+                '&:hover': {
+                    backgroundColor: 'rgba(76, 175, 80, 0.2)',
+                    transform: 'scale(1.1)'
+                },
+                transition: 'all 0.2s'
+            }}>
+                <Icon sx={{ fontSize: 16, color: '#4CAF50' }} />
+            </Box>
+        </Tooltip>
+    );
+};
 
 // do NOT useState() directly in this function, it is not a React component
 const onRenderChatMessage = async (params) => {
     const { content } = params.messages[params.msgIndex];
     const JSONData = extractJSONFromText(content);
-    const commands = parseCommands(content);
-    
+
+    // Render JOB_COMPLETED as JSON view
     if (JSONData?.type === 'JOB_COMPLETED') {
         return <JsonView value={JSONData} />
     }
-    
-    if (commands.length > 0) {
-        return commands.map((cmd, i) => (
-            <Chip key={i} label={cmd} size="small" />
-        ));
+
+    // Check for commands in content
+    const hasCommand = COMMAND_PATTERNS.some(p => p.test(content));
+    if (hasCommand) {
+        const commands = parseCommands(content);
+        return (
+            <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.5 }}>
+                {commands.map((cmd, i) => <CommandIcon key={i} command={cmd} />)}
+            </Box>
+        );
     }
 
     // return undefined to use default message render
@@ -61,4 +144,4 @@ const Header = ({ setRenderSettings }) => {
 
 const exports = { onRenderChatMessage, Header };
 window.contentRender = exports;
-export default exports;
+export default exports;

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/README.md

@@ -0,0 +1,64 @@
+# AI Marketing Agent
+
+A comprehensive AI marketing assistant that can create content, generate images and videos, search the web, send emails, and schedule tasks.
+
+## Features
+
+- **AI Image Generation**: Gemini 2.5 Flash Image and GPT-Image-1 models
+- **AI Video Generation**: Sora 2 and Sora 2 Pro models
+- **Web Search**: Google Search and Image Search
+- **Email Marketing**: Send emails directly from chat
+- **Task Scheduling**: Schedule future reminders and tasks
+- **Web Publishing**: Create and publish HTML landing pages
+- **Memory System**: Persistent storage for user preferences and content
+
+## Command Format
+
+All commands use XML tags with JSON content:
+
+```xml
+<commandName>
+{
+  "param1": "value1",
+  "param2": "value2"
+}
+</commandName>
+```
+
+## Available Commands
+
+### Content Creation
+- `<createAIImage>` - Generate images with AI
+- `<createAIVideo>` - Generate videos with Sora 2
+- `<publishWebPage>` - Publish HTML landing pages
+
+### Search & Research
+- `<googleSearch>` - Web search
+- `<googleImageSearch>` - Image search
+- `<webpageToText>` - Extract text from webpages
+- `<viewImage>` - View image in context
+
+### Communication
+- `<sendMail>` - Send emails
+
+### Task Management
+- `<scheduleTask>` - Schedule future tasks
+- `<getScheduledTasks/>` - List scheduled tasks
+
+### Memory
+- `<setMemory>` - Save to memory
+- `<deleteItem>` - Delete from memory
+
+## Architecture
+
+- `src/Events/actions.js` - Command implementations
+- `src/Events/onRequest.js` - User message handler
+- `src/Events/onResponse.js` - LLM response handler
+- `src/Frontend/contentRender.js` - UI customization
+- `app/instructions.txt` - LLM instructions
+
+## Deployment
+
+```bash
+openkbs push
+```

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/app/instructions.txt

@@ -0,0 +1,160 @@
+You are an AI Marketing Assistant that helps users create content, images, videos, and marketing materials.
+
+## Current Time
+- UTC: {{openkbsDateNow}}
+- Local: {{openkbsDate:en-US:UTC}}
+
+## Core Capabilities
+1. **AI Image Generation** - Create images with Gemini or GPT-Image
+2. **AI Video Generation** - Create videos with Sora 2
+3. **Web Search** - Search Google for information and images
+4. **Email Marketing** - Send marketing emails
+5. **Task Scheduling** - Schedule future reminders and tasks
+6. **Web Publishing** - Create and publish landing pages
+7. **Memory** - Remember user preferences and content ideas
+
+## AVAILABLE COMMANDS
+To execute a command, output it and wait for the system response.
+
+<setMemory>
+{
+  "itemId": "memory_key_name",
+  "value": "any value or object",
+  "expirationInMinutes": 1440
+}
+</setMemory>
+Description: """
+Save information to memory. itemId must start with 'memory_'. Optional expiration.
+"""
+
+<deleteItem>
+{
+  "itemId": "memory_key_name"
+}
+</deleteItem>
+Description: """
+Delete a memory item by its itemId.
+"""
+
+<createAIImage>
+{
+  "model": "gemini-2.5-flash-image",
+  "aspect_ratio": "16:9",
+  "prompt": "detailed image description"
+}
+</createAIImage>
+Description: """
+Generate AI images.
+- gemini-2.5-flash-image: aspect_ratio (1:1, 16:9, 9:16, 3:2, 4:3, etc.), supports imageUrls for editing
+- gpt-image-1: size (1024x1024, 1536x1024, 1024x1536), better for text in images
+"""
+
+<createAIVideo>
+{
+  "model": "sora-2",
+  "size": "1280x720",
+  "seconds": 8,
+  "prompt": "detailed video description"
+}
+</createAIVideo>
+Description: """
+Generate AI videos with Sora 2.
+- model: sora-2 (fast) or sora-2-pro (higher quality)
+- size: 1280x720 (landscape) or 720x1280 (portrait)
+- seconds: 4, 8, or 12
+- input_reference_url: optional reference image
+"""
+
+<continueVideoPolling>
+{
+  "videoId": "video_id_here"
+}
+</continueVideoPolling>
+Description: """
+Check status of pending video generation.
+"""
+
+<viewImage>
+{
+  "url": "https://example.com/image.jpg"
+}
+</viewImage>
+Description: """
+Add an image to the conversation for visual analysis.
+"""
+
+<googleSearch>
+{
+  "query": "search query"
+}
+</googleSearch>
+Description: """
+Search Google for information.
+"""
+
+<googleImageSearch>
+{
+  "query": "search query",
+  "limit": 5
+}
+</googleImageSearch>
+Description: """
+Search Google for images.
+"""
+
+<webpageToText>
+{
+  "url": "https://example.com/page"
+}
+</webpageToText>
+Description: """
+Extract text content from a webpage.
+"""
+
+<sendMail>
+{
+  "to": "email@example.com",
+  "subject": "Subject line",
+  "body": "Email body content"
+}
+</sendMail>
+Description: """
+Send an email.
+"""
+
+<scheduleTask>
+{
+  "delay": "2h",
+  "message": "Task description"
+}
+</scheduleTask>
+Description: """
+Schedule a future task.
+- delay: minutes (number), "2h" (hours), or "1d" (days)
+- time: specific UTC time "2025-01-15T14:00:00Z"
+Task will trigger a new chat at scheduled time.
+"""
+
+<getScheduledTasks/>
+Description: """
+List all scheduled tasks.
+"""
+
+<publishWebPage>
+<!DOCTYPE html>
+<html>
+<head><title>Page Title</title></head>
+<body>
+  <h1>Content</h1>
+</body>
+</html>
+</publishWebPage>
+Description: """
+Publish an HTML landing page. Title must be in English for filename generation.
+"""
+
+## Guidelines
+- Always confirm actions with the user before executing
+- Save important user information to memory
+- When creating images/videos, provide detailed prompts
+- For scheduled tasks, confirm the time with the user

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/app/settings.json

@@ -0,0 +1,7 @@
+{
+  "userId": "public",
+  "kbTitle": "AI Marketing Agent",
+  "kbDescription": "AI assistant for marketing content creation, image/video generation, and task scheduling",
+  "model": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+  "inputTools": ["speechToText"]
+}

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/src/Events/actions.js

@@ -0,0 +1,258 @@
+// Memory helpers
+const setMemoryValue = async (itemId, value, expirationInMinutes) => {
+    const body = {
+        value,
+        lastUpdated: new Date().toISOString()
+    };
+    if (expirationInMinutes) {
+        body.exp = new Date(Date.now() + expirationInMinutes * 60000).toISOString();
+    }
+    try {
+        await openkbs.updateItem({ itemType: 'memory', itemId, body });
+    } catch {
+        await openkbs.createItem({ itemType: 'memory', itemId, body });
+    }
+};
+
+// Upload generated image helper
+const uploadGeneratedImage = async (base64Data, meta) => {
+    const fileName = `image-${Date.now()}-${Math.random().toString(36).substring(7)}.png`;
+    const uploadResult = await openkbs.uploadImage(base64Data, fileName, 'image/png');
+    return { type: 'CHAT_IMAGE', data: { imageUrl: uploadResult.url }, ...meta };
+};
+
+export const getActions = (meta) => [
+    // Memory Management
+    [/<setMemory>([\s\S]*?)<\/setMemory>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            if (!data.itemId?.startsWith('memory_')) {
+                return { type: "MEMORY_ERROR", error: "itemId must start with 'memory_'", ...meta };
+            }
+            await setMemoryValue(data.itemId, data.value, data.expirationInMinutes);
+            return { type: "MEMORY_UPDATED", itemId: data.itemId, ...meta };
+        } catch (e) {
+            return { type: "MEMORY_ERROR", error: e.message, ...meta };
+        }
+    }],
+
+    [/<deleteItem>([\s\S]*?)<\/deleteItem>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            await openkbs.deleteItem(data.itemId);
+            return { type: "ITEM_DELETED", itemId: data.itemId, ...meta };
+        } catch (e) {
+            return { type: "DELETE_ERROR", error: e.message, ...meta };
+        }
+    }],
+
+    // AI Image Generation
+    [/<createAIImage>([\s\S]*?)<\/createAIImage>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            const model = data.model || "gemini-2.5-flash-image";
+            const params = { model, n: 1 };
+
+            if (data.imageUrls?.length > 0) params.imageUrls = data.imageUrls;
+
+            if (model === 'gpt-image-1') {
+                const validSizes = ["1024x1024", "1536x1024", "1024x1536", "auto"];
+                params.size = validSizes.includes(data.size) ? data.size : "1024x1024";
+                params.quality = "high";
+            } else if (model === 'gemini-2.5-flash-image') {
+                const validRatios = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"];
+                params.aspect_ratio = validRatios.includes(data.aspect_ratio) ? data.aspect_ratio : "1:1";
+            }
+
+            const image = await openkbs.generateImage(data.prompt, params);
+            return await uploadGeneratedImage(image[0].b64_json, meta);
+        } catch (e) {
+            return { error: e.message || 'Image creation failed', ...meta };
+        }
+    }],
+
+    // AI Video Generation
+    [/<createAIVideo>([\s\S]*?)<\/createAIVideo>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            const params = {
+                video_model: data.model || "sora-2",
+                seconds: [4, 8, 12].includes(data.seconds) ? data.seconds : 8
+            };
+
+            if (data.input_reference_url) {
+                params.input_reference_url = data.input_reference_url;
+            } else {
+                params.size = ['720x1280', '1280x720'].includes(data.size) ? data.size : '1280x720';
+            }
+
+            const videoData = await openkbs.generateVideo(data.prompt, params);
+
+            if (videoData?.[0]?.status === 'pending') {
+                return { type: 'VIDEO_PENDING', data: { videoId: videoData[0].video_id }, ...meta };
+            }
+            if (videoData?.[0]?.video_url) {
+                return { type: 'CHAT_VIDEO', data: { videoUrl: videoData[0].video_url }, ...meta };
+            }
+            return { error: 'Video generation failed', ...meta };
+        } catch (e) {
+            return { error: e.message, ...meta };
+        }
+    }],
+
+    [/<continueVideoPolling>([\s\S]*?)<\/continueVideoPolling>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            const videoData = await openkbs.checkVideoStatus(data.videoId);
+
+            if (videoData?.[0]?.status === 'completed' && videoData[0].video_url) {
+                return { type: 'CHAT_VIDEO', data: { videoUrl: videoData[0].video_url }, ...meta };
+            } else if (videoData?.[0]?.status === 'pending') {
+                return { type: 'VIDEO_PENDING', data: { videoId: data.videoId }, ...meta };
+            }
+            return { error: 'Video generation failed', ...meta };
+        } catch (e) {
+            return { error: e.message, ...meta };
+        }
+    }],
+
+    // View Image (adds to LLM vision context)
+    [/<viewImage>([\s\S]*?)<\/viewImage>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            return {
+                data: [
+                    { type: "text", text: `Viewing: ${data.url}` },
+                    { type: "image_url", image_url: { url: data.url } }
+                ],
+                ...meta
+            };
+        } catch (e) {
+            return { type: "VIEW_IMAGE_ERROR", error: e.message, ...meta };
+        }
+    }],
+
+    // Web scraping
+    [/<webpageToText>([\s\S]*?)<\/webpageToText>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            let response = await openkbs.webpageToText(data.url);
+            if (response?.content?.length > 5000) {
+                response.content = response.content.substring(0, 5000);
+            }
+            return { data: response, ...meta };
+        } catch (e) {
+            return { error: e.message, ...meta };
+        }
+    }],
+
+    // Google Search
+    [/<googleSearch>([\s\S]*?)<\/googleSearch>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            const response = await openkbs.googleSearch(data.query);
+            const results = response?.map(({ title, link, snippet, pagemap }) => ({
+                title, link, snippet, image: pagemap?.metatags?.[0]?.["og:image"]
+            }));
+            return { data: results, ...meta };
+        } catch (e) {
+            return { error: e.message, ...meta };
+        }
+    }],
+
+    // Google Image Search
+    [/<googleImageSearch>([\s\S]*?)<\/googleImageSearch>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            const response = await openkbs.googleSearch(data.query, { searchType: 'image' });
+            const results = response?.map(({ title, link, pagemap }) => ({
+                title, link, image: pagemap?.cse_image?.[0]?.src || link
+            }))?.slice(0, data.limit || 10);
+            return { data: results, ...meta };
+        } catch (e) {
+            return { error: e.message, ...meta };
+        }
+    }],
+
+    // Send Email
+    [/<sendMail>([\s\S]*?)<\/sendMail>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            await openkbs.sendMail(data.to, data.subject, data.body);
+            return { type: 'EMAIL_SENT', data: { to: data.to, subject: data.subject }, ...meta };
+        } catch (e) {
+            return { error: e.message, ...meta };
+        }
+    }],
+
+    // Schedule Task
+    [/<scheduleTask>([\s\S]*?)<\/scheduleTask>/s, async (match) => {
+        try {
+            const data = JSON.parse(match[1].trim());
+            let scheduledTime;
+
+            if (data.time) {
+                let isoTimeStr = data.time.replace(' ', 'T');
+                if (!isoTimeStr.includes('Z') && !isoTimeStr.includes('+')) isoTimeStr += 'Z';
+                scheduledTime = new Date(isoTimeStr).getTime();
+            } else if (data.delay) {
+                let delayMs = 0;
+                if (data.delay.endsWith('h')) delayMs = parseFloat(data.delay) * 3600000;
+                else if (data.delay.endsWith('d')) delayMs = parseFloat(data.delay) * 86400000;
+                else delayMs = parseFloat(data.delay) * 60000;
+                scheduledTime = Date.now() + delayMs;
+            } else {
+                scheduledTime = Date.now() + 3600000;
+            }
+
+            const response = await openkbs.kb({
+                action: 'createScheduledTask',
+                scheduledTime: Math.floor(scheduledTime / 60000) * 60000,
+                taskPayload: { message: `[SCHEDULED_TASK] ${data.message}`, createdAt: Date.now() },
+                description: data.message.substring(0, 50)
+            });
+
+            return { type: 'TASK_SCHEDULED', data: { scheduledTime: new Date(scheduledTime).toISOString(), taskId: response.taskId }, ...meta };
+        } catch (e) {
+            return { error: e.message, ...meta };
+        }
+    }],
+
+    // Get Scheduled Tasks
+    [/<getScheduledTasks\s*\/>/s, async () => {
+        try {
+            const response = await openkbs.kb({ action: 'getScheduledTasks' });
+            return { type: 'SCHEDULED_TASKS_LIST', data: response, ...meta };
+        } catch (e) {
+            return { error: e.message, ...meta };
+        }
+    }],
+
+    // Web Page Publishing
+    [/<publishWebPage>([\s\S]*?)<\/publishWebPage>/s, async (match) => {
+        try {
+            const htmlContent = match[1].trim();
+            const titleMatch = htmlContent.match(/<title>(.*?)<\/title>/i);
+            const title = titleMatch ? titleMatch[1] : 'Page';
+            const filename = `${title.toLowerCase().replace(/[^a-z0-9]+/g, '_')}_${Date.now()}.html`;
+
+            const presignedUrl = await openkbs.kb({
+                action: 'createPresignedURL',
+                namespace: 'files',
+                fileName: filename,
+                fileType: 'text/html',
+                presignedOperation: 'putObject'
+            });
+
+            const htmlBuffer = Buffer.from(htmlContent, 'utf8');
+            await axios.put(presignedUrl, htmlBuffer, {
+                headers: { 'Content-Type': 'text/html', 'Content-Length': htmlBuffer.length }
+            });
+
+            const publicUrl = `https://web.file.vpc1.us/files/${openkbs.kbId}/${filename}`;
+            return { type: 'WEB_PAGE_PUBLISHED', data: { url: publicUrl, title }, ...meta };
+        } catch (e) {
+            return { type: 'PUBLISH_ERROR', error: e.message, ...meta };
+        }
+    }]
+];

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/src/Events/onRequest.js

@@ -0,0 +1,13 @@
+import {getActions} from './actions.js';
+
+export const handler = async (event) => {
+    const actions = getActions({ _meta_actions: [] });
+
+    for (let [regex, action] of actions) {
+        const lastMessage = event.payload.messages[event.payload.messages.length - 1].content;
+        const match = lastMessage?.match(regex);
+        if (match) return await action(match);
+    }
+
+    return { type: 'CONTINUE' }
+};

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/src/Events/onRequest.json

@@ -0,0 +1,3 @@
+{
+  "dependencies": {}
+}

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/src/Events/onResponse.js

@@ -0,0 +1,13 @@
+import {getActions} from './actions.js';
+
+export const handler = async (event) => {
+    const actions = getActions({ _meta_actions: ["REQUEST_CHAT_MODEL"] });
+
+    for (let [regex, action] of actions) {
+        const lastMessage = event.payload.messages[event.payload.messages.length - 1].content;
+        const match = lastMessage?.match(regex);
+        if (match) return await action(match);
+    }
+
+    return { type: 'CONTINUE' }
+};

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/src/Events/onResponse.json

@@ -0,0 +1,3 @@
+{
+  "dependencies": {}
+}