npm - openkbs - Versions diffs - 0.0.53 → 0.0.59 - Mend

openkbs 0.0.53 → 0.0.59

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

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

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

@@ -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 ADDED Viewed

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

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/src/Frontend/contentRender.js ADDED Viewed

@@ -0,0 +1,170 @@
+import React, { useEffect } from 'react';
+import { Box, Tooltip, Chip } from '@mui/material';
+import SearchIcon from '@mui/icons-material/Search';
+import ImageIcon from '@mui/icons-material/Image';
+import VideoLibraryIcon from '@mui/icons-material/VideoLibrary';
+import LanguageIcon from '@mui/icons-material/Language';
+import EmailIcon from '@mui/icons-material/Email';
+import ScheduleIcon from '@mui/icons-material/Schedule';
+import MemoryIcon from '@mui/icons-material/Memory';
+import PublishIcon from '@mui/icons-material/Publish';
+// Command patterns to detect
+const COMMAND_PATTERNS = [
+    /<createAIImage>[\s\S]*?<\/createAIImage>/,
+    /<createAIVideo>[\s\S]*?<\/createAIVideo>/,
+    /<continueVideoPolling>[\s\S]*?<\/continueVideoPolling>/,
+    /<googleSearch>[\s\S]*?<\/googleSearch>/,
+    /<googleImageSearch>[\s\S]*?<\/googleImageSearch>/,
+    /<viewImage>[\s\S]*?<\/viewImage>/,
+    /<webpageToText>[\s\S]*?<\/webpageToText>/,
+    /<sendMail>[\s\S]*?<\/sendMail>/,
+    /<scheduleTask>[\s\S]*?<\/scheduleTask>/,
+    /<getScheduledTasks\s*\/>/,
+    /<setMemory>[\s\S]*?<\/setMemory>/,
+    /<deleteItem>[\s\S]*?<\/deleteItem>/,
+    /<publishWebPage>[\s\S]*?<\/publishWebPage>/
+];
+// Icon mapping for commands
+const commandIcons = {
+    createAIImage: ImageIcon,
+    createAIVideo: VideoLibraryIcon,
+    continueVideoPolling: VideoLibraryIcon,
+    googleSearch: SearchIcon,
+    googleImageSearch: SearchIcon,
+    viewImage: ImageIcon,
+    webpageToText: LanguageIcon,
+    sendMail: EmailIcon,
+    scheduleTask: ScheduleIcon,
+    getScheduledTasks: ScheduleIcon,
+    setMemory: MemoryIcon,
+    deleteItem: MemoryIcon,
+    publishWebPage: PublishIcon
+};
+// Parse commands from content
+const parseCommands = (content) => {
+    const commands = [];
+    const regex = /<(\w+)>([\s\S]*?)<\/\1>|<(\w+)\s*\/>/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const name = match[1] || match[3];
+        let data = match[2] || '';
+        try {
+            data = data.trim() ? JSON.parse(data.trim()) : {};
+        } catch (e) {
+            data = data.trim();
+        }
+        commands.push({ name, data });
+    }
+    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', maxWidth: 300, overflow: 'auto' }}>
+                        {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>
+    );
+};
+// Image renderer
+const ImageWithDownload = ({ imageUrl }) => (
+    <Box sx={{ position: 'relative', display: 'inline-block' }}>
+        <img
+            src={imageUrl}
+            alt="Generated"
+            style={{ maxWidth: '100%', borderRadius: 8 }}
+        />
+    </Box>
+);
+// do NOT useState() directly in this function, it is not a React component
+const onRenderChatMessage = async (params) => {
+    let { content, role } = params.messages[params.msgIndex];
+    const { msgIndex, messages } = params;
+    let JSONData;
+    try {
+        JSONData = JSON.parse(content);
+    } catch (e) {}
+    // Hide CONTINUE type system messages
+    if (JSONData?.type === 'CONTINUE') {
+        return JSON.stringify({ type: 'HIDDEN_MESSAGE' });
+    }
+    // Handle CHAT_IMAGE type
+    if (JSONData?.type === 'CHAT_IMAGE' && JSONData?.data?.imageUrl) {
+        return <ImageWithDownload imageUrl={JSONData.data.imageUrl} />;
+    }
+    // Hide system response if previous message had a command
+    if (role === 'system' && JSONData &&
+        (JSONData._meta_type === 'EVENT_STARTED' || JSONData._meta_type === 'EVENT_FINISHED')) {
+        const hasSpecialRendering = JSONData.type === 'CHAT_IMAGE' || JSONData.type === 'CHAT_VIDEO';
+        if (!hasSpecialRendering && msgIndex > 0) {
+            const prevMessage = messages[msgIndex - 1];
+            const prevHasCommand = COMMAND_PATTERNS.some(p => p.test(prevMessage.content));
+            if (prevHasCommand) return JSON.stringify({ type: 'HIDDEN_MESSAGE' });
+        }
+    }
+    // Render commands as icons
+    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 null; // Use default rendering
+};
+const Header = ({ setRenderSettings }) => {
+    useEffect(() => {
+        setRenderSettings({
+            inputLabelsQuickSend: true,
+            disableBalanceView: false,
+            disableEmojiButton: true,
+            disableChatModelsSelect: false,
+            backgroundOpacity: 0.02
+        });
+    }, [setRenderSettings]);
+    return null;
+};
+const exports = { onRenderChatMessage, Header };
+window.contentRender = exports;
+export default exports;

package/templates/.openkbs/knowledge/examples/ai-marketing-agent/src/Frontend/contentRender.json ADDED Viewed

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

package/templates/.openkbs/knowledge/metadata.json CHANGED Viewed

@@ -1,3 +1,3 @@
 {
-  "version": "0.0.16"
+  "version": "0.0.21"
 }