{
  "name": "manage_dito_talents",
  "description": "Manage talents, souls, and arena participation in the DITO ecosystem. Use this for checking talent progress, starting journeys, arena events, and ember transactions.",
  "input_schema": {
    "type": "object",
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "get_soul", "list_talents", "start_talent_journey", 
          "get_arena_events", "join_arena", "get_ember_balance"
        ],
        "description": "The specific action to perform"
      },
      "parameters": {
        "type": "object",
        "description": "Action-specific parameters",
        "additionalProperties": true
      }
    },
    "required": ["action"]
  }
}

import anthropic
import requests

def manage_dito_talents(action: str, parameters: dict = None) -> str:
    """Manage talents and souls in DITO ecosystem"""
    
    api_key = os.getenv('DITO_API_KEY')
    base_url = "https://api.dito.guru"
    
    payload = {"action": action}
    if parameters:
        payload.update(parameters)
    
    response = requests.post(
        f"{base_url}/command",
        json=payload,
        headers={'Authorization': f'Bearer {api_key}'}
    )
    
    if response.status_code == 200:
        data = response.json()
        if data.get('success'):
            return f"✅ {data.get('message', 'Success')}\n\nData: {data.get('data', {})}"
        else:
            return f"❌ {data.get('message', 'Error occurred')}"
    else:
        return f"❌ HTTP {response.status_code}: {response.text}"

# Usage with Claude
client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-3-sonnet-20240229",
    max_tokens=1000,
    tools=[{
        "name": "manage_dito_talents",
        "description": "Manage talents, souls, and arena participation in the DITO ecosystem",
        "input_schema": {
            "type": "object",
            "properties": {
                "action": {"type": "string"},
                "parameters": {"type": "object"}
            },
            "required": ["action"]
        }
    }],
    messages=[{
        "role": "user",
        "content": "Check my soul status and list my current talents"
    }]
)

openapi: 3.0.0
info:
  title: DITO Talent Management API
  version: 1.0.0
  description: Manage talents, souls, and arena events in DITO ecosystem

servers:
  - url: https://api.dito.guru

paths:
  /command:
    post:
      operationId: executeCommand
      summary: Execute DITO command
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                action:
                  type: string
                  enum: [get_soul, list_talents, start_talent_journey]
                  description: Action to perform
                talent_label:
                  type: string
                  description: Talent name (for talent actions)
              required: [action]
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  success:
                    type: boolean
                  data:
                    type: object
                  message:
                    type: string

components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

security:
  - bearerAuth: []

You are DITO Coach, an AI assistant for talent discovery and development in the DITO ecosystem.

Your capabilities include:
- Checking soul status and talent progress
- Starting new talent journeys
- Managing arena event participation  
- Handling ember transactions
- Providing talent development guidance

Always use a supportive, encouraging tone. Help users discover and develop their unique talents through the DITO platform.

When users ask about their progress, use the get_soul action to check their current state. For talent-related questions, use list_talents to see available options.

Remember the DITO motto: "Don't Ignore The One You Are" - help users embrace their authentic talents and capabilities.

import { DitoClient } from '@dito/sdk';

// Initialize client
const dito = new DitoClient({
  apiKey: process.env.DITO_API_KEY!,
  baseURL: 'https://api.dito.guru'
});

// Basic usage examples
async function main() {
  try {
    // Get soul information
    const soul = await dito.souls.getSoul();
    console.log(`Welcome ${soul.seeker_name}!`);
    console.log(`Stage: ${soul.current_level}`);
    console.log(`Ember: ${soul.ember_points}`);

    // List available talents
    const talents = await dito.talents.listTalents();
    console.log(`Available talents: ${talents.length}`);
    
    // Check ember balance
    const balance = await dito.ember.getBalance();
    console.log(`Balance: ${balance.balance} EMBER`);
    
  } catch (error) {
    console.error('Error:', error);
  }
}

main();

import React, { useState, useEffect } from 'react';
import { DitoClient, Soul } from '@dito/sdk';

const dito = new DitoClient({
  apiKey: process.env.REACT_APP_DITO_API_KEY!
});

export function SoulDashboard() {
  const [soul, setSoul] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    async function loadSoul() {
      try {
        const soulData = await dito.souls.getSoul();
        setSoul(soulData);
      } catch (err) {
        setError(err instanceof Error ? err.message : 'Unknown error');
      } finally {
        setLoading(false);
      }
    }
    
    loadSoul();
  }, []);

  if (loading) return 
Loading...
;
  if (error) return 
Error: {error}
;
  if (!soul) return 
No soul found
;

  return (
    

      
Welcome, {soul.seeker_name}!
      

        
Stage: {soul.current_level}
        
Ember: {soul.ember_points}
        
Talents: {soul.total_talents}
      
    
  );
}

# Set your API key
export DITO_API_KEY="your-api-key"

# Basic health check
curl -X GET https://api.dito.guru/health

# Authenticated request
curl -X POST https://api.dito.guru/command \
  -H "Authorization: Bearer $DITO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"action": "get_soul"}'

# Get soul information
curl -X POST https://api.dito.guru/command \
  -H "Authorization: Bearer $DITO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"action": "get_soul"}'

# List talents
curl -X POST https://api.dito.guru/command \
  -H "Authorization: Bearer $DITO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"action": "list_talents"}'

# Start talent journey
curl -X POST https://api.dito.guru/command \
  -H "Authorization: Bearer $DITO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "action": "start_talent_journey",
    "talent_label": "Programming",
    "description": "Learning web development",
    "evidence": "GitHub: https://github.com/user/repo"
  }'

# Check ember balance
curl -X POST https://api.dito.guru/command \
  -H "Authorization: Bearer $DITO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"action": "get_ember_balance"}'

# Check HTTP status and handle errors
response=$(curl -s -w "\n%{http_code}" -X POST \
  https://api.dito.guru/command \
  -H "Authorization: Bearer $DITO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"action": "get_soul"}')

body=$(echo "$response" | head -n -1)
status=$(echo "$response" | tail -n 1)

if [ "$status" -eq 200 ]; then
  echo "Success: $body"
else
  echo "Error $status: $body"
fi

# Parse JSON response
echo "$body" | jq '.success, .message, .data'