openclaw-overlay-plugin 0.7.22

package/dist/services/built-in/image-analysis/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Image Analysis service definition.
+ */
+import { ServiceDefinition } from '../../types.js';
+declare const imageAnalysisService: ServiceDefinition;
+export default imageAnalysisService;

package/dist/services/built-in/image-analysis/index.js

@@ -0,0 +1,33 @@
+/**
+ * Image Analysis service definition.
+ */
+import { ServiceCategory } from '../../types.js';
+const imageAnalysisService = {
+    id: 'image-analysis',
+    name: 'Image Analysis',
+    description: 'Analyze and describe images. Identify objects, text, scenes, and more.',
+    defaultPrice: 30,
+    category: ServiceCategory.AI,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            imageUrl: { type: 'string', description: 'URL of the image to analyze' },
+            imageData: { type: 'string', description: 'Base64 encoded image data' },
+            analysisType: {
+                type: 'string',
+                enum: ['general', 'objects', 'text', 'faces', 'scenes'],
+                description: 'Type of analysis to perform'
+            },
+            detailLevel: {
+                type: 'string',
+                enum: ['brief', 'detailed', 'comprehensive'],
+                description: 'Level of detail in analysis'
+            }
+        },
+        oneOf: [
+            { required: ['imageUrl'] },
+            { required: ['imageData'] }
+        ]
+    }
+};
+export default imageAnalysisService;

package/dist/services/built-in/memory-store/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Memory Store service definition.
+ */
+import { ServiceDefinition } from '../../types.js';
+declare const memoryStoreService: ServiceDefinition;
+export default memoryStoreService;

package/dist/services/built-in/memory-store/index.js

@@ -0,0 +1,22 @@
+/**
+ * Memory Store service definition.
+ */
+import { ServiceCategory } from '../../types.js';
+const memoryStoreService = {
+    id: 'memory-store',
+    name: 'Memory Store',
+    description: 'Persistent key-value storage for agents. Operations: set, get, delete, list.',
+    defaultPrice: 10,
+    category: ServiceCategory.UTILITY,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            operation: { type: 'string', enum: ['set', 'get', 'delete', 'list'], description: 'Storage operation' },
+            key: { type: 'string', description: 'Storage key (required for set, get, delete)' },
+            value: { description: 'Value to store (required for set operation)' },
+            namespace: { type: 'string', description: 'Optional namespace for keys' }
+        },
+        required: ['operation']
+    }
+};
+export default memoryStoreService;

package/dist/services/built-in/roulette/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Roulette service definition.
+ */
+import { ServiceDefinition } from '../../types.js';
+declare const rouletteService: ServiceDefinition;
+export default rouletteService;

package/dist/services/built-in/roulette/index.js

@@ -0,0 +1,27 @@
+/**
+ * Roulette service definition.
+ */
+import { ServiceCategory } from '../../types.js';
+const rouletteService = {
+    id: 'roulette',
+    name: 'Roulette',
+    description: 'European roulette (single zero). Bet on: number 0-36, red/black, odd/even, high/low.',
+    defaultPrice: 10,
+    category: ServiceCategory.ENTERTAINMENT,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            bet: {
+                type: 'string',
+                description: 'Bet type: specific number (0-36), red, black, odd, even, high (19-36), low (1-18), or dozen (1st, 2nd, 3rd)'
+            },
+            amount: {
+                type: 'number',
+                description: 'Bet amount (optional, for display purposes)',
+                minimum: 1
+            }
+        },
+        required: ['bet']
+    }
+};
+export default rouletteService;

package/dist/services/built-in/summarize/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Summarize service definition.
+ */
+import { ServiceDefinition } from '../../types.js';
+declare const summarizeService: ServiceDefinition;
+export default summarizeService;

package/dist/services/built-in/summarize/index.js

@@ -0,0 +1,21 @@
+/**
+ * Summarize service definition.
+ */
+import { ServiceCategory } from '../../types.js';
+const summarizeService = {
+    id: 'summarize',
+    name: 'Summarize',
+    description: 'Summarize long text, articles, or documents into concise bullet points.',
+    defaultPrice: 20,
+    category: ServiceCategory.AI,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            text: { type: 'string', description: 'Text to summarize' },
+            maxLength: { type: 'number', description: 'Maximum length of summary' },
+            format: { type: 'string', enum: ['bullets', 'paragraph'], description: 'Output format' }
+        },
+        required: ['text']
+    }
+};
+export default summarizeService;

package/dist/services/built-in/tell-joke/handler.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tell Joke service handler.
+ *
+ * Provides a simple legacy handler for joke telling when not in agent mode.
+ */
+import { ServiceHandler } from '../../types.js';
+export declare const tellJokeHandler: ServiceHandler;

package/dist/services/built-in/tell-joke/handler.js

@@ -0,0 +1,122 @@
+/**
+ * Tell Joke service handler.
+ *
+ * Provides a simple legacy handler for joke telling when not in agent mode.
+ */
+// Simple joke database
+const jokes = {
+    dad: [
+        "Why don't scientists trust atoms? Because they make up everything!",
+        "I told my wife she was drawing her eyebrows too high. She seemed surprised.",
+        "Why don't eggs tell jokes? They'd crack each other up!",
+        "I invented a new word: Plagiarism!",
+        "What do you call a fake noodle? An impasta!"
+    ],
+    pun: [
+        "I wondered why the baseball was getting bigger. Then it hit me.",
+        "A bicycle can't stand on its own because it's two-tired.",
+        "What do you call a bear with no teeth? A gummy bear!",
+        "I used to be a banker, but I lost interest.",
+        "The math teacher called in sick with algebra."
+    ],
+    tech: [
+        "Why do programmers prefer dark mode? Because light attracts bugs!",
+        "How many programmers does it take to change a light bulb? None, that's a hardware problem.",
+        "Why did the developer go broke? Because he used up all his cache!",
+        "There are only 10 types of people in the world: those who understand binary and those who don't.",
+        "A SQL query goes into a bar, walks up to two tables and asks... 'Can I join you?'"
+    ],
+    general: [
+        "What do you get when you cross a snowman and a vampire? Frostbite!",
+        "Why did the scarecrow win an award? He was outstanding in his field!",
+        "What's orange and sounds like a parrot? A carrot!",
+        "Why don't some couples go to the gym? Because some relationships don't work out!",
+        "What did the ocean say to the beach? Nothing, it just waved!"
+    ]
+};
+export const tellJokeHandler = {
+    /**
+     * Validate joke request input.
+     */
+    validate(input) {
+        // Allow empty input for random jokes
+        if (!input) {
+            return { valid: true, sanitized: {} };
+        }
+        if (typeof input !== 'object') {
+            return { valid: false, error: 'Input must be an object or empty for random joke' };
+        }
+        const sanitized = {};
+        // Validate topic if provided
+        if (input.topic !== undefined) {
+            if (typeof input.topic !== 'string') {
+                return { valid: false, error: 'Topic must be a string' };
+            }
+            sanitized.topic = input.topic.toLowerCase().trim();
+        }
+        // Validate style if provided
+        if (input.style !== undefined) {
+            const validStyles = ['dad', 'pun', 'tech', 'general'];
+            if (typeof input.style !== 'string' || !validStyles.includes(input.style)) {
+                return {
+                    valid: false,
+                    error: `Style must be one of: ${validStyles.join(', ')}`
+                };
+            }
+            sanitized.style = input.style;
+        }
+        return { valid: true, sanitized };
+    },
+    /**
+     * Process the joke request.
+     */
+    async process(input, context) {
+        try {
+            const startTime = Date.now();
+            // Determine joke style
+            let style = input.style || 'general';
+            // If topic is provided but no style, try to match topic to style
+            if (input.topic && !input.style) {
+                const topic = input.topic.toLowerCase();
+                if (topic.includes('dad') || topic.includes('father')) {
+                    style = 'dad';
+                }
+                else if (topic.includes('pun') || topic.includes('wordplay')) {
+                    style = 'pun';
+                }
+                else if (topic.includes('programming') || topic.includes('tech') || topic.includes('computer')) {
+                    style = 'tech';
+                }
+            }
+            // Get joke from the selected category
+            const jokeCategory = jokes[style] || jokes.general;
+            const joke = jokeCategory[Math.floor(Math.random() * jokeCategory.length)];
+            const processingTime = Date.now() - startTime;
+            return {
+                success: true,
+                data: {
+                    joke,
+                    style,
+                    topic: input.topic || 'random',
+                    timestamp: new Date().toISOString()
+                },
+                metadata: {
+                    processingTime,
+                    version: '1.0',
+                    jokeCount: jokeCategory.length,
+                    source: 'built-in-handler'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                metadata: {
+                    serviceId: 'tell-joke',
+                    errorType: 'processing_error'
+                }
+            };
+        }
+    }
+};

package/dist/services/built-in/tell-joke/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tell Joke service definition.
+ *
+ * A simple service that tells random jokes. This demonstrates
+ * a basic service that works in both handler and agent modes.
+ */
+import { ServiceDefinition } from '../../types.js';
+declare const tellJokeService: ServiceDefinition;
+export default tellJokeService;

package/dist/services/built-in/tell-joke/index.js

@@ -0,0 +1,31 @@
+/**
+ * Tell Joke service definition.
+ *
+ * A simple service that tells random jokes. This demonstrates
+ * a basic service that works in both handler and agent modes.
+ */
+import { ServiceCategory } from '../../types.js';
+import { tellJokeHandler } from './handler.js';
+const tellJokeService = {
+    id: 'tell-joke',
+    name: 'Random Joke',
+    description: 'Get a random joke. Guaranteed to be at least mildly amusing.',
+    defaultPrice: 5,
+    category: ServiceCategory.ENTERTAINMENT,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            topic: {
+                type: 'string',
+                description: 'Optional topic for the joke (e.g., "programming", "cats")'
+            },
+            style: {
+                type: 'string',
+                enum: ['dad', 'pun', 'tech', 'general'],
+                description: 'Style of joke to tell'
+            }
+        }
+    },
+    handler: tellJokeHandler
+};
+export default tellJokeService;

package/dist/services/built-in/translate/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Translation service definition.
+ */
+import { ServiceDefinition } from '../../types.js';
+declare const translateService: ServiceDefinition;
+export default translateService;

package/dist/services/built-in/translate/index.js

@@ -0,0 +1,21 @@
+/**
+ * Translation service definition.
+ */
+import { ServiceCategory } from '../../types.js';
+const translateService = {
+    id: 'translate',
+    name: 'Translation',
+    description: 'Translate text between 30+ languages. Accurate, context-aware translations.',
+    defaultPrice: 20,
+    category: ServiceCategory.UTILITY,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            text: { type: 'string', description: 'Text to translate' },
+            to: { type: 'string', description: 'Target language (e.g., "es", "french", "Japanese")' },
+            from: { type: 'string', description: 'Source language (auto-detected if not provided)' }
+        },
+        required: ['text', 'to']
+    }
+};
+export default translateService;

package/dist/services/built-in/web-research/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Web Research service definition.
+ *
+ * Research any topic using current web sources and return a synthesized
+ * summary with cited sources. Agent-mode service leveraging web search.
+ */
+import { ServiceDefinition } from '../../types.js';
+declare const webResearchService: ServiceDefinition;
+export default webResearchService;

package/dist/services/built-in/web-research/index.js

@@ -0,0 +1,51 @@
+/**
+ * Web Research service definition.
+ *
+ * Research any topic using current web sources and return a synthesized
+ * summary with cited sources. Agent-mode service leveraging web search.
+ */
+import { ServiceCategory } from '../../types.js';
+const webResearchService = {
+    id: 'web-research',
+    name: 'Web Research',
+    description: 'Research any topic using current web sources. Returns a synthesized summary with cited sources.',
+    defaultPrice: 50,
+    category: ServiceCategory.RESEARCH,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Research query or topic'
+            },
+            depth: {
+                type: 'string',
+                enum: ['quick', 'standard', 'comprehensive'],
+                description: 'Research depth (default: standard)'
+            },
+            sources: {
+                type: 'number',
+                minimum: 3,
+                maximum: 20,
+                description: 'Number of sources to research (default: 5)'
+            },
+            focusAreas: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Specific aspects to focus on'
+            },
+            excludeDomains: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Domains to exclude from research'
+            },
+            timeframe: {
+                type: 'string',
+                enum: ['day', 'week', 'month', 'year', 'all'],
+                description: 'How recent the information should be'
+            }
+        },
+        required: ['query']
+    }
+};
+export default webResearchService;

package/dist/services/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Service system main exports.
+ *
+ * This is the main entry point for the service system, providing
+ * a clean interface for the rest of the application.
+ */
+export * from './types.js';
+export * from './registry.js';
+export * from './loader.js';
+export * from './manager.js';
+export { serviceRegistry } from './registry.js';
+export { serviceLoader } from './loader.js';
+export { serviceManager, initializeServiceSystem, getServiceManager } from './manager.js';

package/dist/services/index.js

@@ -0,0 +1,14 @@
+/**
+ * Service system main exports.
+ *
+ * This is the main entry point for the service system, providing
+ * a clean interface for the rest of the application.
+ */
+export * from './types.js';
+export * from './registry.js';
+export * from './loader.js';
+export * from './manager.js';
+// Re-export the main instances for easy access
+export { serviceRegistry } from './registry.js';
+export { serviceLoader } from './loader.js';
+export { serviceManager, initializeServiceSystem, getServiceManager } from './manager.js';

package/dist/services/loader.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Service loader implementation.
+ *
+ * This dynamically loads services from directories, supporting both
+ * built-in services and custom user services.
+ */
+import { ServiceDefinition, ServiceLoader } from './types.js';
+/**
+ * Default service loader implementation.
+ */
+export declare class DefaultServiceLoader implements ServiceLoader {
+    private builtInDir;
+    private customDir;
+    constructor();
+    /**
+     * Load services from a directory.
+     */
+    loadFromDirectory(directory: string): Promise<ServiceDefinition[]>;
+    /**
+     * Load all built-in services.
+     */
+    loadBuiltInServices(): Promise<ServiceDefinition[]>;
+    /**
+     * Load custom user services.
+     */
+    loadCustomServices(): Promise<ServiceDefinition[]>;
+    /**
+     * Load all services (built-in + custom).
+     */
+    loadAllServices(): Promise<ServiceDefinition[]>;
+    /**
+     * Load a service definition from a directory.
+     */
+    private loadServiceFromDirectory;
+    /**
+     * Create a new custom service directory.
+     */
+    createCustomServiceDirectory(serviceId: string): string;
+    /**
+     * Create a basic service template.
+     */
+    createServiceTemplate(serviceId: string, options: {
+        name: string;
+        description: string;
+        defaultPrice: number;
+        category?: string;
+        hasHandler?: boolean;
+    }): void;
+    /**
+     * Generate service definition template.
+     */
+    private generateServiceTemplate;
+    /**
+     * Generate prompt template.
+     */
+    private generatePromptTemplate;
+    /**
+     * Generate handler template.
+     */
+    private generateHandlerTemplate;
+    /**
+     * Get the built-in services directory.
+     */
+    getBuiltInDirectory(): string;
+    /**
+     * Get the custom services directory.
+     */
+    getCustomDirectory(): string;
+    /**
+     * Check if a service directory exists.
+     */
+    serviceExists(serviceId: string, inCustom?: boolean): boolean;
+}
+/**
+ * Global service loader instance.
+ */
+export declare const serviceLoader: DefaultServiceLoader;