OpenClaw × Gemini AI Partner Guide— Build Custom AI for LINE, Discord, WhatsApp

// image-analysis-skill.js
module.exports = {
  name: 'analyze_image',
 
  async execute(params) {
    const { imageUrl, context } = params;
 
    // Gemini Vision image analysis
    const analysis = await gemini.analyzeImage({
      image: imageUrl,
      prompt: `
        Analyze this image and:
        1. Describe image content briefly
        2. Provide 3 situation-relevant suggestions
        3. Share interesting related knowledge
 
        User context: ${context}
      `
    });
 
    return {
      actionType: 'message',
      content: analysis,
      includeImage: true
    };
  }
};

// voice-handler.js
module.exports = {
  async handleVoiceMessage(audioFile, platform) {
    // 1. Voice transcription (Google Cloud Speech-to-Text)
    const transcript = await speechToText(audioFile);
 
    // 2. Gemini response generation
    const response = await gemini.generateMessage(transcript);
 
    // 3. Response voice conversion (Google Cloud TTS)
    const audioResponse = await textToSpeech(response, {
      language: 'ja-JP',
      voiceType: 'natural',
      emotionLevel: 0.7,
    });
 
    // 4. Send voice reply
    await sendVoiceMessage(audioResponse, platform);
  }
};

// video-stream-handler.js
module.exports = {
  async analyzeVideoStream(streamUrl) {
    // Capture video frames
    const frames = await captureFrames(streamUrl, {
      interval: 5000,  // Every 5 seconds
    });
 
    for (const frame of frames) {
      // Gemini analyzes each frame
      const analysis = await gemini.analyzeImage(frame, {
        systemPrompt: 'Real-time user support active. Track changes, comment concisely.'
      });
 
      await sendUpdate(analysis);
    }
  }
};

Plan Comparison:
  Free Tier:
    rateLimit: "60 RPM"
    monthlyQuota: 1500
    cost: "$0"
 
  Pro ($20/month):
    rateLimit: "1000 RPM"  # 16.7x faster
    monthlyQuota: "Unlimited"
    concurrentRequests: 100
    prioritySupport: false
    cost: "$20"
 
  Ultra ($40/month):
    rateLimit: "10000 RPM"
    monthlyQuota: "Unlimited"
    concurrentRequests: 1000
    prioritySupport: "24/7"
    sla: "99.9%"
    cost: "$40"

// gemini-pro-config.js
module.exports = {
  // Request parallelization
  concurrency: {
    maxConcurrentRequests: 50,  // Pro-enabled
    queueStrategy: 'priority',
  },
 
  // Batch requests
  batching: {
    enabled: true,
    maxBatchSize: 100,
    batchTimeoutMs: 500,  // Send at 500ms
  },
 
  // Caching (Pro-supported)
  caching: {
    enabled: true,
    ttl: 3600,  // 1-hour cache
    minLength: 1024,  // Cache 1024+ chars only
  },
 
  // Deep Think (Ultra-recommended)
  deepThink: {
    enabled: true,
    useFor: ['complex_reasoning', 'career_advice', 'creative_writing'],
    maxTokens: 16000,
  }
};

// gmail-integration.js
module.exports = {
  async handleEmailAsync() {
    // Morning important email summary notification
    const schedule = require('node-schedule');
 
    schedule.scheduleJob('0 7 * * *', async () => {
      // Fetch unread important emails
      const emails = await gmailClient.getMessages({
        query: 'is:unread label:important',
        maxResults: 5,
      });
 
      for (const email of emails) {
        const summary = await gemini.summarize(email.body, {
          maxLength: 200,
          includingAction: true,
        });
 
        const suggestion = await gemini.generateEmailResponse(email, {
          tone: 'professional',
        });
 
        // Notify user
        await notifyUser({
          title: `Email: ${email.subject}`,
          summary,
          suggestion,
          actionRequired: email.requiresResponse,
        });
      }
    });
  }
};

module.exports = {
  async integrateCalendar() {
    // Gemini recognizes user schedule
    const getUserScheduleContext = async () => {
      const events = await calendarClient.getEvents({
        timeMin: new Date(),
        timeMax: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),  // 7 days
        maxResults: 50,
      });
 
      return {
        todaySchedule: events.filter(e => isToday(e.start)),
        upcomingDeadlines: events.filter(e => e.title.includes('deadline')),
        busyHours: events.map(e => e.start),
      };
    };
 
    return {
      systemPrompt: `
        User schedule context:
        ${JSON.stringify(await getUserScheduleContext())}
 
        Consider schedule info in proposals/time management advice.
      `
    };
  }
};

module.exports = {
  async accessUserDocuments() {
    const docs = await driveClient.listFiles({
      pageSize: 100,
      fields: 'files(id, name, mimeType)',
    });
 
    return {
      documents: docs,
      indexedContent: docs.map(async doc => ({
        id: doc.id,
        title: doc.name,
        content: await getDocumentContent(doc.id),
        lastModified: doc.modifiedTime,
      }))
    };
  },
 
  async answerAboutDocuments(userQuestion) {
    // Search relevant docs
    const relevantDocs = await searchDocuments(userQuestion);
 
    // Gemini answers referencing documents
    const answer = await gemini.generateAnswer({
      question: userQuestion,
      documents: relevantDocs,
      prompt: 'Extract most relevant document info, provide practical advice.'
    });
 
    return answer;
  }
};