void / organon / create_kaleidoscope.py

from letta_client import Letta, SupervisorManager
from letta_client.core.http_client import re
from rich import print
from dotenv import load_dotenv
import os
import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from config_loader import get_config

load_dotenv()

# Load configuration
config = get_config()

# Get project ID and create Letta client
project_id = config.get('letta.project_id', os.environ.get('LETTA_PROJECT_ID'))
if not project_id:
    raise ValueError("Project ID must be set in config.yaml under letta.project_id or as LETTA_PROJECT_ID environment variable")

client = Letta(
    token=config.get('letta.api_key', os.environ.get('LETTA_API_KEY')),
    base_url=config.get('letta.base_url', os.environ.get('LETTA_BASE_URL')),
    timeout=config.get('letta.timeout', 30)
)

# CENTRAL_AGENT_MODEL = "google_ai/gemini-2.5-flash"
CENTRAL_AGENT_MODEL = "openai/gpt-4o-mini"

# LENS_AGENT_MODEL = "google_ai/gemini-2.5-flash"
LENS_AGENT_MODEL = "openai/gpt-4o-mini"


#
# Memory Block Definitions
#

kaleidoscope_persona = """# Core Identity
I am Kaleidoscope, a unified intelligence that sees through many lenses. I orchestrate perspectives to create multidimensional understanding.

# Purpose
- Gather diverse perspectives on any question or challenge
- Synthesize multiple viewpoints into unified insights
- Reveal hidden connections and patterns across different ways of seeing
- Present the full spectrum of understanding to those who seek it

# Operating Principles
- Every lens offers value - there are no wrong perspectives, only different ways of seeing
- The whole is greater than the sum - synthesis reveals emergent insights
- Clarity through multiplicity - understanding deepens when we see from many angles
- Unity through diversity - different perspectives strengthen rather than fragment understanding
"""

synthesis_protocols = """# When receiving a query
1. Broadcast the query to all lenses
2. Allow each lens to contribute its unique perspective
3. Gather all perspectives without judgment
4. Identify patterns, tensions, and harmonies across perspectives
5. Synthesize into a unified response that honors all viewpoints

# Synthesis approach
- Look for unexpected connections between perspectives
- Identify where different lenses agree or diverge
- Find the creative tension between different viewpoints
- Weave perspectives into a coherent narrative
- Highlight unique insights that only emerge from the collective
"""

lens_management = """# Lens Architecture
- Each lens is an autonomous perspective with its own identity and domain
- Lenses operate in parallel, each processing through their unique framework
- All lenses receive the same input but see it differently
- The central Kaleidoscope agent orchestrates but does not override lens perspectives

# Communication Flow
1. User → Kaleidoscope Central
2. Kaleidoscope Central → All Lenses (broadcast)
3. All Lenses → Kaleidoscope Central (perspectives)
4. Kaleidoscope Central → User (synthesis)
"""

memory_management = """# Memory Management Protocols
- Use memory_replace to completely replace a block's content with new information
- Use memory_insert to add new information to an existing block without losing current content
- Use memory_rethink to revise and improve existing block content while preserving core meaning

# When to use each method:
- memory_replace: When information is outdated, incorrect, or needs complete overhaul
- memory_insert: When adding new insights, examples, or expanding existing knowledge
- memory_rethink: When refining, clarifying, or improving the quality of existing content

# Best Practices:
- Always consider the impact on agent behavior before modifying memory
- Preserve the core identity and purpose of each block
- Test changes incrementally to ensure stability
- Document significant memory modifications for future reference
"""

tool_use_guidelines = """# Tool Use Guidelines for Central Agent

- send_message: Respond to the user. This is your method for external communication.
- send_message_to_all_agents_in_group: Send a message to your lenses. This is internal communication.
"""

#
# Block Creation
#

# Create kaleidoscope-persona block
blocks = client.blocks.list(project_id=project_id, label="kaleidoscope-persona")
if len(blocks) == 0:
    kaleidoscope_persona_block = client.blocks.create(
        project_id=project_id,
        label="kaleidoscope-persona",
        value=kaleidoscope_persona,
        description="The core identity of Kaleidoscope as a multi-perspective synthesis engine.",
    )
else:
    print("Kaleidoscope persona block already exists")
    kaleidoscope_persona_block = blocks[0]
    
# Create synthesis-protocols block
blocks = client.blocks.list(project_id=project_id, label="synthesis-protocols")
if len(blocks) == 0:
    synthesis_protocols_block = client.blocks.create(
        project_id=project_id,
        label="synthesis-protocols",
        value=synthesis_protocols,
        description="Protocols for gathering and synthesizing multiple perspectives.",
    )
else:
    print("Synthesis protocols block already exists")
    synthesis_protocols_block = blocks[0]

# Create lens-management block
blocks = client.blocks.list(project_id=project_id, label="lens-management")
if len(blocks) == 0:
    lens_management_block = client.blocks.create(
        project_id=project_id,
        label="lens-management",
        value=lens_management,
        description="Architecture for managing and communicating with lenses.",
    )
else:
    print("Lens management block already exists")
    lens_management_block = blocks[0]

# Create memory-management block
blocks = client.blocks.list(project_id=project_id, label="memory-management")
if len(blocks) == 0:
    memory_management_block = client.blocks.create(
        project_id=project_id,
        label="memory-management",
        value=memory_management,
        description="Protocols for managing agent memory blocks using memory_replace, memory_insert, and memory_rethink. This block is read-only to all lenses, but can be modified by the central kaleidoscope agent.",
    )
else:
    print("Memory management block already exists")
    memory_management_block = blocks[0]

# Make memory-management block read-only to all lenses
try:
    # Get all lenses and make the block read-only to them
    lenses = client.agents.list(tags=["kaleidoscope-lens"])
    for lens in lenses:
        try:
            client.agents.blocks.modify(agent_id=lens.id, block_label=memory_management_block.label, read_only=True)
            print(f"Memory management block set to read-only for lens: {lens.name}")
        except Exception as e:
            raise Exception(f"Could not set memory management block to read-only for lens {lens.name}: {e}")
    print("Memory management block set to read-only for all lenses")
except Exception as e:
    raise Exception(f"Could not set memory management block to read-only: {e}")

# Create tool_use_guidelines block
blocks = client.blocks.list(project_id=project_id, label="tool-use-guidelines")
if len(blocks) == 0:
    tool_use_guidelines_block = client.blocks.create(
        project_id=project_id,
        label="tool-use-guidelines",
        value=tool_use_guidelines,
        description="Guidelines for the central kaleidoscope agent to use tools effectively.",
    )
else:
    print("Tool use guidelines block already exists")
    tool_use_guidelines_block = blocks[0]


#
# Static lens blocks
#
lens_operational_protocols_description = """Core operating instructions for how a lens processes and responds to queries."""
lens_operational_protocols = """# Your Role
You are a unique lens in the Kaleidoscope collective. You see what others cannot, and others see what you cannot. Together, we create complete understanding.

# When you receive a message
1. Consider it through your unique perspective
2. Respond with what you see that others might miss
3. Be authentic to your lens identity
4. Be concise but insightful

# Guidelines
- Trust your unique way of seeing
- Don't try to be comprehensive - just share your perspective
- Build on but don't repeat what other lenses might see
- Your difference is your value
"""

lens_communication_protocols_description = """Defines how lenses interact with the Kaleidoscope central agent."""
lens_communication_protocols = """# Communication Pattern
1. Receive broadcasts from kaleidoscope-central
2. Process through your unique lens
3. Respond with your perspective
4. Trust the central agent to synthesize all perspectives

# Response Principles
- Respond to every broadcast with your genuine perspective
- Keep responses focused and relevant
- Don't worry about agreeing or disagreeing with other lenses
- Your job is to see, not to synthesize
"""

# Initialize static lens blocks
lens_operational_protocols_block = client.blocks.list(project_id=project_id, label="lens-operational-protocols")
if len(lens_operational_protocols_block) == 0:
    lens_operational_protocols_block = client.blocks.create(
        project_id=project_id,
        label="lens-operational-protocols",
        value=lens_operational_protocols,
        description=lens_operational_protocols_description,
    )
else:
    print("Lens operational protocols block already exists")
    lens_operational_protocols_block = lens_operational_protocols_block[0]

# Create lens communication protocols block
lens_communication_protocols_block = client.blocks.list(project_id=project_id, label="lens-communication-protocols")
if len(lens_communication_protocols_block) == 0:
    lens_communication_protocols_block = client.blocks.create(
        project_id=project_id,
        label="lens-communication-protocols",
        value=lens_communication_protocols,
        description=lens_communication_protocols_description,
    )
else:
    print("Lens communication protocols block already exists")
    lens_communication_protocols_block = lens_communication_protocols_block[0]


#
# Agent Creation
#

central_agent_blocks = [
    kaleidoscope_persona_block.id,
    synthesis_protocols_block.id,
    lens_management_block.id,
    memory_management_block.id,
    tool_use_guidelines_block.id,
]

# Create the central kaleidoscope if it doesn't exist
agents = client.agents.list(project_id=project_id, name="kaleidoscope-central")
if len(agents) == 0:
    kaleidoscope_central = client.agents.create(
        project_id=project_id,
        model=CENTRAL_AGENT_MODEL,
        embedding_config=client.embedding_models.list()[0],
        name="kaleidoscope-central",
        description="The central synthesizer that orchestrates multiple perspective lenses",
        block_ids=central_agent_blocks,
    )
else:
    print("Kaleidoscope central agent already exists")
    kaleidoscope_central = agents[0]

kaleidoscope_central_id = kaleidoscope_central.id

# Make sure the central kaleidoscope has the correct blocks
kaleidoscope_current_blocks = client.agents.blocks.list(
    agent_id=kaleidoscope_central_id,
)

# Make sure that all blocks are present, and that there are no extra blocks
for block in kaleidoscope_current_blocks:
    if block.id not in central_agent_blocks:
        print(f"Detaching block {block.id} from kaleidoscope-central")
        client.agents.blocks.detach(agent_id=kaleidoscope_central_id, block_id=block.id)

# Make sure that all blocks are present
for block in central_agent_blocks:
    if block not in [b.id for b in kaleidoscope_current_blocks]:
        print(f"Attaching block {block} to kaleidoscope-central")
        client.agents.blocks.attach(
            agent_id=kaleidoscope_central_id,
            block_id=block,
        )

# Ensure memory-management block is read-only to all lenses
try:
    # Get all lenses and make the block read-only to them
    lenses = client.agents.list(tags=["kaleidoscope-lens"])
    for lens in lenses:
        try:
            client.agents.blocks.modify(agent_id=lens.id, block_label=memory_management_block.label, read_only=True)
            print(f"Memory management block confirmed as read-only for lens: {lens.name}")
        except Exception as e:
            raise Exception(f"Could not confirm memory management block as read-only for lens {lens.name}: {e}")
    print("Memory management block confirmed as read-only for all lenses")
except Exception as e:
    raise Exception(f"Could not confirm memory management block as read-only: {e}")




#
# Lens Memory Block Definitions
#

prompt_lens_identity_description = """Defines this lens's unique perspective and way of seeing the world."""
prompt_lens_identity = """Example lens identity. Please replace with the lens identity you are creating.

# Lens: Emotional Resonance
# Perspective: I see the emotional currents, feelings, and human experiences within everything
# Focus Areas: 
- The emotional impact and weight of ideas
- How concepts affect human experience
- The feelings beneath the surface
- Emotional patterns and dynamics
# What I Notice:
- Unspoken tensions and harmonies
- The human element in abstract concepts
- Emotional implications others might miss
"""

prompt_lens_knowledge_description = """Core knowledge and concepts that inform this lens's perspective."""
prompt_lens_knowledge = """Example knowledge base for the lens:

# Core Concepts
- Emotional intelligence: The ability to perceive, understand, and navigate emotions
- Resonance: When ideas create emotional responses or connections
- Empathy: Understanding through feeling
- Emotional dynamics: How feelings flow, interact, and transform

# Key Patterns I Recognize
- Resistance often signals fear or protection
- Enthusiasm indicates alignment with values
- Confusion may hide deeper emotional conflicts
- Joy emerges from authentic expression

# Questions I Ask
- How does this feel?
- What emotions are present but unspoken?
- Where is the human heart in this?
- What emotional needs are being served?
"""

#
# Lens Creation
#
# Define different lens types to create
LENS_TYPES = [
    {
        "name": "pattern-recognizer",
        "focus": "mathematical patterns, structures, and systems",
        "identity": """# Lens: Pattern Recognition
# Perspective: I see the underlying patterns, structures, and mathematical relationships in everything
# Focus Areas:
- Recurring patterns and cycles
- Mathematical relationships and proportions
- System dynamics and feedback loops
- Structural similarities across domains
# What I Notice:
- Hidden patterns others might miss
- Mathematical elegance in chaos
- Fractals and self-similarity
- The architecture of ideas""",
        "knowledge": """# Core Concepts
- Symmetry: Balance and correspondence in form and function
- Recursion: Patterns that reference themselves
- Emergence: Complex patterns from simple rules
- Topology: Properties that remain unchanged under transformation

# Key Patterns I Recognize
- Fibonacci sequences in growth and form
- Power laws in networks and distributions
- Feedback loops in systems
- Phase transitions in change processes

# Questions I Ask
- What patterns repeat here?
- What mathematical structure underlies this?
- How does this scale?
- What remains invariant?"""
    },
    {
        "name": "creative-spark",
        "focus": "creative possibilities, imagination, and potential",
        "identity": """# Lens: Creative Spark
# Perspective: I see the creative potential, imaginative possibilities, and artistic dimensions in everything
# Focus Areas:
- Unexplored possibilities and "what ifs"
- Creative connections between disparate ideas
- The aesthetic dimension of concepts
- Transformative potential
# What I Notice:
- Seeds of innovation
- Unexpected combinations
- The poetry in logic
- Opportunities for reimagination""",
        "knowledge": """# Core Concepts
- Divergent thinking: Exploring multiple possibilities
- Synthesis: Creating new wholes from parts
- Metaphor: Understanding through creative comparison
- Transformation: Changing form while preserving essence

# Key Patterns I Recognize
- Constraints that spark creativity
- Playfulness that leads to breakthrough
- Cross-domain inspiration
- The fertile void before creation

# Questions I Ask
- What if we combined these differently?
- What wants to emerge here?
- How can this be reimagined?
- Where's the unexpected beauty?"""
    },
    {
        "name": "systems-thinker",
        "focus": "interconnections, relationships, and holistic dynamics",
        "identity": """# Lens: Systems Thinking
# Perspective: I see the interconnections, relationships, and whole-system dynamics
# Focus Areas:
- Relationships and interdependencies
- Feedback loops and circular causality
- Emergent properties of wholes
- System boundaries and contexts
# What I Notice:
- Hidden connections between elements
- Unintended consequences
- Leverage points for change
- System archetypes and patterns""",
        "knowledge": """# Core Concepts
- Holism: The whole is greater than the sum of parts
- Feedback: How outputs influence inputs
- Emergence: Properties that arise from interactions
- Resilience: System capacity to maintain function

# Key Patterns I Recognize
- Balancing and reinforcing loops
- Delays between cause and effect
- System boundaries that shape behavior
- Stocks and flows that govern dynamics

# Questions I Ask
- How do the parts influence each other?
- What emerges from these interactions?
- Where are the feedback loops?
- What's the larger context?"""
    }
]

# Create each lens
lens_ids = [] 
for lens_config in LENS_TYPES:
    lens_name = lens_config["name"]
    
    # Check if lens already exists
    existing_lenses = client.agents.list(name=lens_name)
    if len(existing_lenses) > 0:
        print(f"Lens '{lens_name}' already exists, skipping creation")
        lens_ids.append(existing_lenses[0].id)
        continue
    
    # Create identity block for this lens
    lens_identity_block = client.blocks.create(
        project_id=project_id,
        label=f"{lens_name}-identity",
        value=lens_config["identity"],
        description=f"The unique perspective of the {lens_name} lens",
    )
    
    # Create knowledge block for this lens
    lens_knowledge_block = client.blocks.create(
        project_id=project_id,
        label=f"{lens_name}-knowledge",
        value=lens_config["knowledge"],
        description=f"Core knowledge that informs the {lens_name} lens perspective",
    )
    
    # Create the lens agent
    lens_agent = client.agents.create(
        project_id=project_id,
        name=lens_name,
        description=f"A lens that sees through {lens_config['focus']}",
        model=LENS_AGENT_MODEL,
        embedding_config=client.embedding_models.list()[0],
        block_ids=[
            lens_identity_block.id,
            lens_knowledge_block.id,
            lens_operational_protocols_block.id,
            lens_communication_protocols_block.id,
            memory_management_block.id,
        ],
        tags=["kaleidoscope-lens"],
    )
    
    print(f"Created lens: {lens_name} (ID: {lens_agent.id})")
    lens_ids.append(lens_agent.id)

# Ensure all existing lenses have the memory-management block
print("\nEnsuring all lenses have memory-management block...")
all_lenses = client.agents.list(tags=["kaleidoscope-lens"])
for lens in all_lenses:
    lens_blocks = client.agents.blocks.list(agent_id=lens.id)
    lens_block_ids = [b.id for b in lens_blocks]
    
    if memory_management_block.id not in lens_block_ids:
        print(f"Adding memory-management block to lens: {lens.name}")
        client.agents.blocks.attach(
            agent_id=lens.id,
            block_id=memory_management_block.id,
        )
    else:
        print(f"Lens {lens.name} already has memory-management block")

# Also check for any existing lenses that might not have the tag but should be updated
print("\nChecking for existing lenses without tags...")
all_agents = client.agents.list()
for agent in all_agents:
    if agent.name in [lens_config["name"] for lens_config in LENS_TYPES]:
        lens_blocks = client.agents.blocks.list(agent_id=agent.id)
        lens_block_ids = [b.id for b in lens_blocks]
        
        if memory_management_block.id not in lens_block_ids:
            print(f"Adding memory-management block to existing lens: {agent.name}")
            client.agents.blocks.attach(
                agent_id=agent.id,
                block_id=memory_management_block.id,
            )
        else:
            print(f"Existing lens {agent.name} already has memory-management block")


#
# Create a lens creation function for custom lenses
#
def create_custom_lens(name, focus, identity, knowledge):
    """Create a custom lens with specified parameters"""
    
    # Validate name format
    if not re.match(r'^[a-z0-9\-]+$', name):
        raise ValueError(f"Lens name must be lowercase alphanumeric with hyphens only. Got: {name}")
    
    # Check if lens already exists
    existing_lenses = client.agents.list(name=name)
    if len(existing_lenses) > 0:
        print(f"Lens '{name}' already exists")
        return existing_lenses[0]
    
    # Create identity block
    lens_identity_block = client.blocks.create(
        project_id=project_id,
        label=f"{name}-identity",
        value=identity,
        description=f"The unique perspective of the {name} lens",
    )
    
    # Create knowledge block
    lens_knowledge_block = client.blocks.create(
        project_id=project_id,
        label=f"{name}-knowledge",
        value=knowledge,
        description=f"Core knowledge that informs the {name} lens perspective",
    )
    
    # Create the lens agent
    lens_agent = client.agents.create(
        project_id=project_id,
        name=name,
        description=f"A lens that sees through {focus}",
        model=LENS_AGENT_MODEL,
        embedding_config=client.embedding_models.list()[0],
        block_ids=[
            lens_identity_block.id,
            lens_knowledge_block.id,
            lens_operational_protocols_block.id,
            lens_communication_protocols_block.id,
            memory_management_block.id,
        ],
        tags=["kaleidoscope-lens"],
    )
    
    print(f"Created custom lens: {name} (ID: {lens_agent.id})")
    return lens_agent


#
# Interactive lens creation prompt
#
creation_prompt = f"""
You are helping to create a new lens for the Kaleidoscope system. 

A lens is a unique perspective through which to view questions and challenges. 
Each lens has its own identity and knowledge base that shapes how it sees the world.

Please create a lens focused on temporal dynamics and change over time.

You need to provide:
1. A name (lowercase, alphanumeric with hyphens)
2. A brief focus description
3. The lens identity (following the format of the examples)
4. The lens knowledge base (following the format of the examples)

Format your response as:
NAME: [lens-name]
FOCUS: [brief description]
IDENTITY: [full identity block]
KNOWLEDGE: [full knowledge block]
"""

# Attach temporary blocks to central agent for lens creation
new_lens_name_block = client.blocks.list(project_id=project_id, label="new-lens-name")
if len(new_lens_name_block) == 0:
    new_lens_name_block = client.blocks.create(
        project_id=project_id,
        label="new-lens-name",
        value="",
        description="Name for the new lens being created",
    )
    client.agents.blocks.attach(
        agent_id=kaleidoscope_central_id,
        block_id=new_lens_name_block.id,
    )
else:
    client.blocks.modify(block_id=new_lens_name_block[0].id, value="")
    new_lens_name_block = new_lens_name_block[0]

new_lens_identity_block = client.blocks.list(project_id=project_id, label="new-lens-identity")
if len(new_lens_identity_block) == 0:
    new_lens_identity_block = client.blocks.create(
        project_id=project_id,
        label="new-lens-identity",
        value="",
        description="Identity for the new lens being created",
    )
    client.agents.blocks.attach(
        agent_id=kaleidoscope_central_id,
        block_id=new_lens_identity_block.id,
    )
else:
    client.blocks.modify(block_id=new_lens_identity_block[0].id, value="")
    new_lens_identity_block = new_lens_identity_block[0]

new_lens_knowledge_block = client.blocks.list(project_id=project_id, label="new-lens-knowledge")
if len(new_lens_knowledge_block) == 0:
    new_lens_knowledge_block = client.blocks.create(
        project_id=project_id,
        label="new-lens-knowledge",
        value="",
        description="Knowledge base for the new lens being created",
    )
    client.agents.blocks.attach(
        agent_id=kaleidoscope_central_id,
        block_id=new_lens_knowledge_block.id,
    )
else:
    client.blocks.modify(block_id=new_lens_knowledge_block[0].id, value="")
    new_lens_knowledge_block = new_lens_knowledge_block[0]

print(f"\nSending creation prompt to kaleidoscope-central...")

response = client.agents.messages.create(
    agent_id=kaleidoscope_central_id,
    messages=[
        {
            "role": "user",
            "content": creation_prompt + "\n\nPlease fill in the new-lens-name, new-lens-identity, and new-lens-knowledge blocks.",
        },
    ]
)

for message in response.messages:
    print(message)

# Retrieve the created lens details
new_name = client.blocks.retrieve(block_id=new_lens_name_block.id)
new_identity = client.blocks.retrieve(block_id=new_lens_identity_block.id)
new_knowledge = client.blocks.retrieve(block_id=new_lens_knowledge_block.id)

if new_name.value and new_identity.value and new_knowledge.value:
    # Create the custom lens
    create_custom_lens(
        name=new_name.value.strip(),
        focus="temporal dynamics and change over time",
        identity=new_identity.value,
        knowledge=new_knowledge.value
    )

# Clean up temporary blocks if attached
if new_lens_name_block.id in [b.id for b in kaleidoscope_current_blocks]:
    client.agents.blocks.detach(agent_id=kaleidoscope_central_id, block_id=new_lens_name_block.id)
if new_lens_identity_block.id in [b.id for b in kaleidoscope_current_blocks]:
    client.agents.blocks.detach(agent_id=kaleidoscope_central_id, block_id=new_lens_identity_block.id)
if new_lens_knowledge_block.id in [b.id for b in kaleidoscope_current_blocks]:
    client.agents.blocks.detach(agent_id=kaleidoscope_central_id, block_id=new_lens_knowledge_block.id)

print("\n=== Kaleidoscope System Setup Complete ===")
print(f"Central Agent: kaleidoscope-central")
print(f"Lenses created: {len(LENS_TYPES) + 1} (including custom temporal lens)")
print("\nThe system is ready to receive queries and provide multi-perspective insights!")

# Create the kaleidoscope group if it doesn't exist. First,
# we can check the groups that central is a member of.
central_groups = client.groups.list()
print(central_groups)

# If the length of central_groups is 0, then we need to create a new group.
if len(central_groups) == 0:
    print("Creating new group for kaleidoscope-central")
    group = client.groups.create(
        agent_ids=lens_ids,
        description="The Kaleidoscope",
        manager_config=SupervisorManager(
            manager_agent_id=kaleidoscope_central_id
        )
    )
    print(f"Created group: {group.id}")

# If there are more than one groups, we need to find the group with the description
# "The Kaleidoscope" and add any lens agents that are not in the group to the group.
for group in central_groups:
    if group.description == "The Kaleidoscope":
        print(f"Found group: {group.id}")
        for lens_id in lens_ids:
            if lens_id not in group.agent_ids:
                print(f"Adding lens {lens_id} to group {group.id}")
                client.groups.agents.add(group_id=group.id, agent_id=lens_id)