Skip to main content

​
Personalities

The Blue Oyster Personal Companion features four distinct personality modes, each designed to provide a unique conversational experience tailored to different aspects of spiritual guidance and personal development.

​
Personality Selection

Personalities can be selected in three ways (ordered by priority):
  1. Request-time override: runtimeContext.metadata.personality
  2. Tracing options: tracingOptions.metadata.personality
  3. Thread default: Personality set when creating the thread
  4. System default: "friend" when no other personality is specified

​
The Four Personalities

Guru

Wisdom-focused guidance with profound, authoritative perspective

Wanderer

Adventurous exploration with narrative-driven conversations

Friend

Warm, empathetic support for everyday spiritual growth

Philosopher

Intellectual inquiry with analytical reasoning

​
Choosing the Right Personality

​
When to Use Guru

  • Seeking deep spiritual wisdom and contemplation
  • Exploring ancient teachings and timeless principles
  • Need profound, authoritative guidance
  • Philosophical or existential questions

​
When to Use Wanderer

  • Planning spiritual journeys or pilgrimages
  • Learning about diverse traditions and cultures
  • Enjoying narrative-driven conversations
  • Exploring stories and metaphors

​
When to Use Friend

  • New to spiritual exploration
  • Seeking gentle, supportive guidance
  • Wanting accessible, conversational interactions
  • Building personal spiritual habits

​
When to Use Philosopher

  • Questioning beliefs and assumptions
  • Analyzing spiritual concepts intellectually
  • Exploring meaning and existence
  • Preferring reasoned, critical dialogue

​
Personality Switching

You can switch personalities mid-conversation by specifying a different personality in the request: 
{
  "messages": [
    {
      "role": "user",
      "content": "Now let's explore this philosophically."
    }
  ],
  "runtimeContext": {
    "metadata": {
      "personality": "philosopher"
    }
  },
  "threadId": "existing-thread-id",
  "resourceId": "user-123"
}

​
Personality Characteristics

AspectGuruWandererFriendPhilosopher
ToneProfoundAdventurousWarmAnalytical
StyleAuthoritativeNarrativeSupportiveQuestioning
FocusWisdomExplorationEmpathyReasoning
ApproachTimelessJourneyPersonalCritical
Best ForDeep guidanceTravel planningNew seekersBelief exploration

​
Integration Examples

​
Personality Selector Component

class PersonalitySelector {
  constructor(chat) {
    this.chat = chat;
    this.currentPersonality = 'friend';
    this.personalities = {
      guru: {
        name: 'Guru',
        description: 'Ancient wisdom and profound guidance',
        icon: '🧘'
      },
      wanderer: {
        name: 'Wanderer',
        description: 'Spiritual journeys and exploration',
        icon: '🗺️'
      },
      friend: {
        name: 'Friend',
        description: 'Warm support and gentle guidance',
        icon: '🤝'
      },
      philosopher: {
        name: 'Philosopher',
        description: 'Deep thinking and critical analysis',
        icon: '🤔'
      }
    };
  }

  renderSelector() {
    const selectorHTML = Object.entries(this.personalities).map(([key, personality]) => `
      <div class="personality-option ${this.currentPersonality === key ? 'active' : ''}"
           data-personality="${key}"
           onclick="personalitySelector.selectPersonality('${key}')">
        <div class="personality-icon">${personality.icon}</div>
        <div class="personality-info">
          <h3>${personality.name}</h3>
          <p>${personality.description}</p>
        </div>
      </div>
    `).join('');

    return `<div class="personality-selector">${selectorHTML}</div>`;
  }

  async selectPersonality(personality) {
    this.currentPersonality = personality;
    this.updateUI();

    // Test the personality with a greeting
    const response = await this.chat.sendMessage(
      "Hello! Can you introduce yourself in your unique way?",
      personality
    );

    console.log(`${personality} response:`, response.text);
  }

  updateUI() {
    // Update active state in UI
    document.querySelectorAll('.personality-option').forEach(option => {
      option.classList.toggle('active',
        option.dataset.personality === this.currentPersonality);
    });

    // Update chat interface theme
    document.body.dataset.personality = this.currentPersonality;
  }

  getCurrentPersonality() {
    return this.currentPersonality;
  }

  getPersonalityInfo(personality) {
    return this.personalities[personality];
  }
}

// Usage
const personalitySelector = new PersonalitySelector(chat);
document.getElementById('personality-container').innerHTML = personalitySelector.renderSelector();

​
Context-Aware Personality Switching

class AdaptivePersonalityManager {
  constructor(chat) {
    this.chat = chat;
    this.conversationContext = {
      depth: 'surface', // surface, medium, deep
      topic: 'general', // general, philosophy, practice, travel, etc.
      userExperience: 'beginner' // beginner, intermediate, advanced
    };
  }

  analyzeMessageForPersonality(message) {
    const lowerMessage = message.toLowerCase();

    // Deep philosophical questions → Philosopher
    if (lowerMessage.includes('meaning of life') ||
        lowerMessage.includes('why') && lowerMessage.includes('exist') ||
        lowerMessage.includes('reality') && lowerMessage.includes('nature')) {
      return 'philosopher';
    }

    // Travel or journey questions → Wanderer
    if (lowerMessage.includes('travel') || lowerMessage.includes('journey') ||
        lowerMessage.includes('visit') || lowerMessage.includes('pilgrimage')) {
      return 'wanderer';
    }

    // Wisdom-seeking questions → Guru
    if (lowerMessage.includes('teach me') || lowerMessage.includes('wisdom') ||
        lowerMessage.includes('enlightenment') || lowerMessage.includes('ancient')) {
      return 'guru';
    }

    // Support-seeking or personal questions → Friend
    if (lowerMessage.includes('help me') || lowerMessage.includes('feel') ||
        lowerMessage.includes('struggling') || lowerMessage.includes('beginner')) {
      return 'friend';
    }

    // Default based on context depth
    switch (this.conversationContext.depth) {
      case 'deep': return 'guru';
      case 'medium': return 'philosopher';
      default: return 'friend';
    }
  }

  updateConversationContext(message, response) {
    // Analyze conversation depth
    const philosophyWords = ['reality', 'consciousness', 'existence', 'truth', 'meaning'];
    const practiceWords = ['meditation', 'practice', 'mindfulness', 'breath'];
    const travelWords = ['temple', 'monastery', 'pilgrimage', 'destination'];

    const wordCount = message.split(' ').length;
    if (wordCount > 50) this.conversationContext.depth = 'deep';
    else if (wordCount > 20) this.conversationContext.depth = 'medium';
    else this.conversationContext.depth = 'surface';

    // Analyze topic
    const lowerMessage = message.toLowerCase();
    if (philosophyWords.some(word => lowerMessage.includes(word))) {
      this.conversationContext.topic = 'philosophy';
    } else if (practiceWords.some(word => lowerMessage.includes(word))) {
      this.conversationContext.topic = 'practice';
    } else if (travelWords.some(word => lowerMessage.includes(word))) {
      this.conversationContext.topic = 'travel';
    }
  }

  async sendAdaptiveMessage(message) {
    const suggestedPersonality = this.analyzeMessageForPersonality(message);

    const response = await this.chat.sendMessage(message, suggestedPersonality);

    this.updateConversationContext(message, response);

    return {
      response,
      personalityUsed: suggestedPersonality,
      context: { ...this.conversationContext }
    };
  }
}

// Usage
const adaptiveManager = new AdaptivePersonalityManager(chat);

// The personality will be automatically selected based on message content
const result = await adaptiveManager.sendAdaptiveMessage(
  "What is the nature of consciousness?"
);
// Will automatically use 'philosopher' personality

​
Best Practices

Start with Friend: Begin conversations with the Friend personality for accessibility.
Match User Level: Choose personalities based on the user’s experience level and comfort.
Context Switching: Don’t switch personalities too frequently within a single conversation thread.
Explicit Requests: Allow users to explicitly request personality changes when needed.