Umfassende API-Suite für KI-Inhaltserstellung

// Doitong Universal API Client
class DoitongAPI {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.endpoint = 'https://api.doitong.com/graphql';
  }

  async generate(input) {
    const response = await fetch(this.endpoint, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
        'Idempotency-Key': crypto.randomUUID()
      },
      body: JSON.stringify({
        query: `
          mutation Generate($input: GenerateInput!) {
            generate(input: $input) {
              id
              status
              type
              provider
              url
              metadata
              creditCost
              estimatedTime
              error {
                code
                message
              }
            }
          }
        `,
        variables: { input }
      })
    });

    const data = await response.json();
    
    // Check for rate limits
    const remaining = response.headers.get('X-RateLimit-Remaining');
    if (remaining && parseInt(remaining) < 10) {
      console.warn(`Low rate limit: ${remaining} requests remaining`);
    }
    
    if (data.errors) {
      throw new Error(data.errors[0].message);
    }
    
    return data.data.generate;
  }

  async checkStatus(id) {
    const response = await fetch(this.endpoint, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        query: `
          query GetGeneration($id: ID!) {
            generation(id: $id) {
              id
              status
              progress
              url
              error {
                code
                message
              }
            }
          }
        `,
        variables: { id }
      })
    });
    
    const data = await response.json();
    return data.data.generation;
  }

  async waitForCompletion(id, pollInterval = 2000) {
    while (true) {
      const result = await this.checkStatus(id);
      
      if (result.status === 'COMPLETED') {
        return result;
      } else if (result.status === 'FAILED') {
        throw new Error(result.error?.message || 'Generation failed');
      }
      
      await new Promise(resolve => setTimeout(resolve, pollInterval));
    }
  }
}

// Usage examples
const api = new DoitongAPI('YOUR_API_KEY');

// Simple video generation - let AI choose provider
const video = await api.generate({
  type: 'VIDEO',
  input: { text: 'A serene mountain landscape' }
});

// Specific provider with options
const video = await api.generate({
  type: 'VIDEO',
  provider: 'minimax',
  input: { text: 'Epic battle scene' },
  options: {
    duration: 10,
    resolution: '1080p',
    style: 'cinematic'
  }
});

// Image generation with auto-provider selection for quality
const image = await api.generate({
  type: 'IMAGE',
  input: { text: 'Photorealistic portrait' },
  priority: 'QUALITY'
});

// Wait for completion
const result = await api.waitForCompletion(video.id);
console.log('Video ready:', result.url);

// Using Apollo Client for GraphQL
import { ApolloClient, gql } from '@apollo/client';

const CREATE_VIDEO = gql`
  mutation CreateVideo($input: VideoCreateInput!) {
    videoCreate(input: $input) {
      id
      status
      videoUrl
    }
  }
`;

const client = new ApolloClient({
  uri: 'https://api.doitong.com/graphql',
  headers: {
    authorization: 'Bearer YOUR_API_KEY'
  }
});

const result = await client.mutate({
  mutation: CREATE_VIDEO,
  variables: {
    input: {
      prompt: 'Beautiful sunset over ocean',
      model: 'luma',
      duration: 9
    }
  }
});

import requests
import time
import json
import uuid
from typing import Dict, Optional, Any

class DoitongAPI:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.doitong.com/graphql"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def generate(self, 
                 content_type: str,
                 input_data: Dict[str, Any],
                 provider: Optional[str] = None,
                 options: Optional[Dict] = None,
                 idempotency_key: Optional[str] = None) -> Dict:
        """Universal generation method for all content types"""
        
        # Add idempotency key for safe retries
        headers = self.headers.copy()
        if idempotency_key:
            headers["Idempotency-Key"] = idempotency_key
        else:
            headers["Idempotency-Key"] = str(uuid.uuid4())
        
        query = """
        mutation Generate($input: GenerateInput!) {
          generate(input: $input) {
            id
            status
            type
            provider
            url
            metadata
            creditCost
            estimatedTime
            error
            errorCode
          }
        }
        """
        
        variables = {
            "input": {
                "type": content_type.upper(),
                "input": input_data
            }
        }
        
        if provider:
            variables["input"]["provider"] = provider
        if options:
            variables["input"]["options"] = options
        
        response = requests.post(
            self.base_url,
            headers=headers,
            json={"query": query, "variables": variables}
        )
        
        # Handle rate limiting
        if response.status_code == 429:
            retry_after = response.headers.get("X-RateLimit-Reset", 60)
            raise Exception(f"Rate limited. Retry after {retry_after} seconds")
        
        data = response.json()
        
        if "errors" in data:
            error = data["errors"][0]
            raise Exception(f"API Error: {error.get('message', 'Unknown error')}")
        
        return data["data"]["generate"]
    
    def check_status(self, generation_id: str) -> Dict:
        """Check the status of a generation"""
        query = """
        query GetGeneration($id: ID!) {
          generation(id: $id) {
            id
            status
            type
            url
            progress
            error
            errorCode
            metadata
          }
        }
        """
        
        response = requests.post(
            self.base_url,
            headers=self.headers,
            json={
                "query": query,
                "variables": {"id": generation_id}
            }
        )
        
        return response.json()["data"]["generation"]
    
    def wait_for_completion(self, generation_id: str, max_wait: int = 300) -> Dict:
        """Poll until generation is complete"""
        start_time = time.time()
        
        while time.time() - start_time < max_wait:
            result = self.check_status(generation_id)
            
            if result["status"] == "completed":
                return result
            elif result["status"] == "failed":
                error_code = result.get("errorCode", "UNKNOWN_ERROR")
                error_msg = result.get("error", "Generation failed")
                raise Exception(f"[{error_code}] {error_msg}")
            
            # Adaptive polling - start fast, slow down over time
            wait_time = 2 if time.time() - start_time < 30 else 5
            time.sleep(wait_time)
        
        raise TimeoutError("Generation timed out")

# Example usage
if __name__ == "__main__":
    api = DoitongAPI("YOUR_API_KEY")
    
    try:
        # Generate a video (auto-selects best provider)
        video = api.generate(
            content_type="video",
            input_data={"text": "A majestic eagle soaring through clouds"},
            options={"duration": 10, "resolution": "1080p"}
        )
        print(f"Video generation started: {video['id']}")
        
        # Wait for completion
        result = api.wait_for_completion(video['id'])
        print(f"Video ready: {result['url']}")
        print(f"Credits used: {result['creditCost']}")
        
        # Generate with specific provider
        image = api.generate(
            content_type="image",
            provider="flux-ultra",
            input_data={"text": "Professional product photography"},
            options={"aspectRatio": "16:9", "quality": "ultra"}
        )
        
        # Generate audio/TTS
        audio = api.generate(
            content_type="audio",
            provider="elevenlabs",
            input_data={"text": "Welcome to the future of AI"},
            options={"voice": "rachel", "emotion": "excited"}
        )
        
    except Exception as e:
        print(f"Error: {e}")

# Universal generation mutation - works for all content types
mutation Generate($input: GenerateInput!) {
  generate(input: $input) {
    id
    status
    type
    provider
    url
    metadata
    creditCost
    estimatedTime
    progress
    error
    errorCode
  }
}

# Example: Generate video (auto-select provider)
# Variables:
{
  "input": {
    "type": "VIDEO",
    "input": {
      "text": "A bustling Tokyo street at night with neon lights"
    },
    "options": {
      "duration": 10,
      "resolution": "1080p",
      "style": "cinematic"
    }
  }
}

# Example: Generate video with specific provider
# Variables:
{
  "input": {
    "type": "VIDEO",
    "provider": "kling",
    "input": {
      "text": "Epic space battle scene"
    },
    "options": {
      "mode": "pro",
      "duration": 10,
      "aspectRatio": "16:9"
    }
  }
}

# Example: Image-to-video generation
# Variables:
{
  "input": {
    "type": "VIDEO",
    "provider": "runway",
    "input": {
      "text": "Make the character dance",
      "image": "https://example.com/character.jpg"
    },
    "options": {
      "motionIntensity": "high",
      "model": "gen-3"
    }
  }
}

# Example: Generate image
# Variables:
{
  "input": {
    "type": "IMAGE",
    "provider": "flux-ultra",
    "input": {
      "text": "Photorealistic portrait in Rembrandt style"
    },
    "options": {
      "aspectRatio": "16:9",
      "quality": "ultra",
      "seed": 42
    }
  }
}

# Example: Generate audio/TTS
# Variables:
{
  "input": {
    "type": "AUDIO",
    "provider": "elevenlabs",
    "input": {
      "text": "Welcome to the future of artificial intelligence"
    },
    "options": {
      "voice": "rachel",
      "emotion": "excited",
      "speed": 1.0
    }
  }
}

# Example: Generate avatar video
# Variables:
{
  "input": {
    "type": "AVATAR",
    "provider": "heygen",
    "input": {
      "text": "Hello, I'm your AI assistant",
      "voice": "professional_female"
    },
    "options": {
      "avatarId": "kate",
      "background": "modern_office",
      "gesture": "friendly"
    },
    "webhookUrl": "https://your-app.com/webhook"
  }
}

# Query generation status
query GetGeneration($id: ID!) {
  generation(id: $id) {
    id
    status
    type
    provider
    url
    progress
    metadata {
      width
      height
      duration
      format
    }
    creditCost
    error
    errorCode
    createdAt
    completedAt
  }
}

# Cancel a generation
mutation CancelGeneration($id: ID!) {
  cancelGeneration(id: $id)
}

# Get available providers for a content type
query GetProviders($type: GenerationType!) {
  providers(type: $type) {
    id
    name
    description
    features
    limitations
    pricing {
      creditCost
      estimatedTime
    }
    options {
      name
      type
      required
      description
      allowedValues
    }
  }
}
}