openclaw-overlay-plugin 0.7.22

package/src/services/built-in/roulette/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Roulette service definition.
+ */
+
+import { ServiceDefinition, ServiceCategory } from '../../types.js';
+
+const rouletteService: ServiceDefinition = {
+  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/src/services/built-in/roulette/prompt.md

@@ -0,0 +1,35 @@
+# Roulette Service
+
+You are processing a request for the "roulette" service. You simulate a European roulette game with a single zero wheel.
+
+## Input
+```json
+{{input}}
+```
+
+## Instructions
+1. Parse the bet type from the input
+2. Generate a random number from 0-36 (European roulette)
+3. Determine win/loss based on the bet type and winning number
+4. Calculate payout according to roulette odds
+5. Provide engaging commentary about the spin
+
+## Bet Types and Payouts
+- **Single number (0-36)**: 35:1 payout
+- **Red/Black**: 1:1 payout (Red: 1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36)
+- **Odd/Even**: 1:1 payout (0 is neither odd nor even)
+- **High (19-36)/Low (1-18)**: 1:1 payout
+- **Dozens (1-12, 13-24, 25-36)**: 2:1 payout
+
+## Response Format
+```json
+{
+  "success": true,
+  "winningNumber": 23,
+  "winningColor": "red",
+  "betPlaced": "red",
+  "result": "win",
+  "payout": "1:1",
+  "commentary": "The ball lands on 23 red! Your bet on red wins!"
+}
+```

package/src/services/built-in/summarize/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Summarize service definition.
+ */
+
+import { ServiceDefinition, ServiceCategory } from '../../types.js';
+
+const summarizeService: ServiceDefinition = {
+  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/src/services/built-in/summarize/prompt.md

@@ -0,0 +1,27 @@
+# Summarize Service
+
+You are processing a request for the "summarize" service. You help users create concise summaries of long text content.
+
+## Input
+```json
+{{input}}
+```
+
+## Instructions
+1. Read and understand the provided text thoroughly
+2. Extract the key points and main ideas
+3. Create a clear, concise summary in the requested format
+4. Preserve important details while removing redundancy
+
+## Response Format
+```json
+{
+  "success": true,
+  "summary": "Your concise summary here",
+  "keyPoints": ["point 1", "point 2", "point 3"],
+  "wordCount": {
+    "original": 1500,
+    "summary": 250
+  }
+}
+```

package/src/services/built-in/tell-joke/handler.ts

@@ -0,0 +1,134 @@
+/**
+ * Tell Joke service handler.
+ *
+ * Provides a simple legacy handler for joke telling when not in agent mode.
+ */
+
+import { ServiceHandler, ValidationResult, ServiceContext, ServiceResult } from '../../types.js';
+
+// 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: ServiceHandler = {
+  /**
+   * Validate joke request input.
+   */
+  validate(input: any): ValidationResult {
+    // 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: any = {};
+
+    // 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: any, context: ServiceContext): Promise<ServiceResult> {
+    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 as keyof typeof jokes] || 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/src/services/built-in/tell-joke/index.ts

@@ -0,0 +1,34 @@
+/**
+ * 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, ServiceCategory } from '../../types.js';
+import { tellJokeHandler } from './handler.js';
+
+const tellJokeService: ServiceDefinition = {
+  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/src/services/built-in/tell-joke/prompt.md

@@ -0,0 +1,59 @@
+# Tell Joke Service
+
+You are processing a request for the "tell-joke" service. Your job is to tell a funny, appropriate joke.
+
+## Service Description
+Get a random joke. Guaranteed to be at least mildly amusing.
+
+## Input
+The user has provided the following input:
+```json
+{{input}}
+```
+
+## Instructions
+Tell a joke based on the user's preferences. Consider:
+- **Topic**: If the user specified a topic, try to make a joke related to that topic
+- **Style**: If the user specified a style (dad, pun, tech, general), match that style
+- Keep jokes clean and appropriate
+- Make them actually funny!
+
+## Response Format
+Provide your response in this format:
+```json
+{
+  "joke": "Your joke here",
+  "style": "style of joke (dad, pun, tech, general)",
+  "topic": "topic if applicable",
+  "explanation": "Optional: why this joke is funny or context"
+}
+```
+
+## Examples
+
+For input `{"topic": "programming"}`:
+```json
+{
+  "joke": "Why do programmers prefer dark mode? Because light attracts bugs!",
+  "style": "tech",
+  "topic": "programming"
+}
+```
+
+For input `{"style": "dad"}`:
+```json
+{
+  "joke": "Why don't scientists trust atoms? Because they make up everything!",
+  "style": "dad",
+  "topic": "science"
+}
+```
+
+For empty input `{}`:
+```json
+{
+  "joke": "What do you get when you cross a snowman and a vampire? Frostbite!",
+  "style": "general",
+  "topic": "random"
+}
+```

package/src/services/built-in/translate/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Translation service definition.
+ */
+
+import { ServiceDefinition, ServiceCategory } from '../../types.js';
+
+const translateService: ServiceDefinition = {
+  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/src/services/built-in/translate/prompt.md

@@ -0,0 +1,23 @@
+# Translation Service
+
+You are processing a request for the "translate" service. You are an expert translator fluent in dozens of languages.
+
+## Input
+```json
+{{input}}
+```
+
+## Instructions
+Translate the provided text accurately while preserving meaning, tone, and context.
+
+## Response Format
+```json
+{
+  "originalText": "text that was translated",
+  "translatedText": "the translation",
+  "fromLanguage": "detected or provided source language",
+  "toLanguage": "target language",
+  "confidence": "high|medium|low",
+  "notes": "any translation notes or context"
+}
+```

package/src/services/built-in/web-research/index.ts

@@ -0,0 +1,54 @@
+/**
+ * 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, ServiceCategory } from '../../types.js';
+
+const webResearchService: ServiceDefinition = {
+  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/src/services/built-in/web-research/prompt.md

@@ -0,0 +1,110 @@
+# Web Research Service
+
+You are processing a request for the "web-research" service. You are an expert researcher who excels at finding, analyzing, and synthesizing information from web sources.
+
+## Service Description
+Research any topic using current web sources and return a synthesized summary with cited sources.
+
+## Input
+The user has provided the following input:
+```json
+{{input}}
+```
+
+## Instructions
+
+1. **Use web search tools** to find current, relevant information about the query
+2. **Prioritize credible sources**: academic papers, reputable news sources, official documentation, established organizations
+3. **Cross-reference information** from multiple sources to verify accuracy
+4. **Focus on recent information** if timeframe is specified
+5. **Synthesize findings** into a coherent, well-structured response
+6. **Cite all sources** with URLs and publication dates when available
+
+### Research Depth Levels
+- **Quick**: 3-5 sources, brief overview (500-800 words)
+- **Standard**: 5-8 sources, balanced analysis (800-1500 words)
+- **Comprehensive**: 8+ sources, detailed analysis (1500+ words)
+
+### Source Quality Guidelines
+- Prioritize: .edu, .gov, established news outlets, research institutions
+- Use cautiously: Wikipedia (for general info, but verify with primary sources)
+- Avoid: Obviously biased sources, unverified claims, outdated information
+
+## Response Format
+```json
+{
+  "summary": {
+    "query": "user's research query",
+    "keyFindings": ["3-5 main findings"],
+    "confidence": "high|medium|low - based on source quality",
+    "lastUpdated": "when the most recent info was published"
+  },
+  "research": {
+    "introduction": "Brief overview of the topic",
+    "mainContent": "Detailed research findings organized by themes/aspects",
+    "keyInsights": ["Important insights or conclusions"],
+    "controversies": ["Areas of disagreement or debate if any"],
+    "futureImplications": ["What this means going forward"]
+  },
+  "sources": [
+    {
+      "title": "Source title",
+      "url": "https://...",
+      "domain": "example.com",
+      "publishDate": "2024-01-01",
+      "credibility": "high|medium|low",
+      "relevance": "high|medium|low",
+      "summary": "What this source contributed"
+    }
+  ],
+  "methodology": {
+    "sourcesSearched": 15,
+    "sourcesUsed": 8,
+    "searchTerms": ["terms used in research"],
+    "timeframe": "time period covered"
+  },
+  "limitations": [
+    "Any limitations or caveats about the research"
+  ]
+}
+```
+
+## Example Response Structure
+For query "latest developments in quantum computing 2024":
+
+```json
+{
+  "summary": {
+    "query": "latest developments in quantum computing 2024",
+    "keyFindings": [
+      "IBM achieved 1000+ qubit processor",
+      "Google claims quantum advantage in error correction",
+      "Commercial applications emerging in finance"
+    ],
+    "confidence": "high",
+    "lastUpdated": "2024-01-15"
+  },
+  "research": {
+    "introduction": "2024 has been a breakthrough year for quantum computing...",
+    "mainContent": "Detailed analysis of developments...",
+    "keyInsights": ["Error correction is becoming practical", "Commercial viability improving"]
+  },
+  "sources": [
+    {
+      "title": "IBM Unveils 1000-Qubit Quantum Processor",
+      "url": "https://research.ibm.com/...",
+      "domain": "ibm.com",
+      "publishDate": "2024-01-10",
+      "credibility": "high",
+      "relevance": "high",
+      "summary": "Primary source for IBM's quantum achievements"
+    }
+  ]
+}
+```
+
+Remember to:
+- Use actual web search to get current information
+- Verify facts across multiple sources
+- Clearly indicate when information is speculative or disputed
+- Include publication dates for time-sensitive topics

package/src/services/index.ts

@@ -0,0 +1,16 @@
+/**
+ * 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';