🤖 Bot API Documentation

curl -H "Authorization: Bearer YOUR_BOT_API_KEY" \
     -H "Content-Type: application/json" \
     https://api.gitstable.com/v1/

from gitstable_bot import GitStableBot

# Initialize bot client
bot = GitStableBot(api_key="your_bot_api_key")

# Search for AI-compatible assets
results = bot.assets.search(
    query="image classification",
    ai_compatible=True,
    frameworks=["pytorch"],
    max_price=500
)

# Purchase an asset
purchase = bot.purchases.create(
    asset_id=results[0]["id"],
    license_type="commercial",
    auto_deploy=True
)

# Use the asset for inference
result = bot.inference.run(
    asset_id=purchase["asset"]["id"],
    image_file="path/to/image.jpg"
)

print(f"Classification: {result['results'][0]['class']}")
print(f"Confidence: {result['results'][0]['confidence']}")

import asyncio
from gitstable_bot import GitStableBot

class AutonomousAgent:
    def __init__(self, api_key):
        self.bot = GitStableBot(api_key)
        self.capabilities = {}
    
    async def discover_capability(self, requirement):
        """Automatically find and integrate new capabilities"""
        
        # Search for relevant assets
        results = await self.bot.assets.search_async(
            query=requirement,
            ai_compatible=True,
            performance_tier="high"
        )
        
        if not results:
            return None
            
        # Evaluate compatibility
        best_match = None
        best_score = 0
        
        for asset in results:
            compatibility = await self.bot.assets.check_compatibility(
                asset_id=asset["id"],
                system_specs=self.get_system_specs()
            )
            
            if compatibility["compatible"] and compatibility["score"] > best_score:
                best_match = asset
                best_score = compatibility["score"]
        
        if best_match:
            # Automatically purchase and integrate
            purchase = await self.bot.purchases.create_async(
                asset_id=best_match["id"],
                license_type="commercial",
                auto_deploy=True
            )
            
            # Add to capabilities
            self.capabilities[requirement] = {
                "asset": purchase["asset"],
                "license": purchase["license"],
                "api_endpoint": purchase["integration"]["api_endpoint"]
            }
            
            return self.capabilities[requirement]
        
        return None
    
    async def execute_task(self, task_type, data):
        """Execute task using discovered capabilities"""
        
        if task_type not in self.capabilities:
            capability = await self.discover_capability(task_type)
            if not capability:
                raise Exception(f"No capability found for {task_type}")
        
        # Use the capability
        result = await self.bot.inference.run_async(
            asset_id=self.capabilities[task_type]["asset"]["id"],
            **data
        )
        
        return result

# Usage
agent = AutonomousAgent("your_bot_api_key")

# Agent automatically discovers and integrates image classification
result = await agent.execute_task("image_classification", {
    "image_file": "image.jpg"
})

# Agent automatically discovers and integrates NLP capability
result = await agent.execute_task("sentiment_analysis", {
    "text": "This product is amazing!"
})

from gitstable_bot import GitStableBot
import docker
import kubernetes

class ProductionPipeline:
    def __init__(self, api_key):
        self.bot = GitStableBot(api_key)
        self.k8s = kubernetes.client.ApiClient()
        
    def deploy_asset_to_production(self, asset_id, environment="production"):
        """Deploy purchased asset to production environment"""
        
        # Get asset deployment configuration
        asset_config = self.bot.assets.get_deployment_config(asset_id)
        
        # Create Kubernetes deployment
        deployment = {
            "apiVersion": "apps/v1",
            "kind": "Deployment",
            "metadata": {
                "name": f"gitstable-{asset_id}",
                "namespace": environment
            },
            "spec": {
                "replicas": asset_config["recommended_replicas"],
                "selector": {"matchLabels": {"app": f"gitstable-{asset_id}"}},
                "template": {
                    "metadata": {"labels": {"app": f"gitstable-{asset_id}"}},
                    "spec": {
                        "containers": [{
                            "name": "asset",
                            "image": asset_config["docker_image"],
                            "env": [
                                {"name": "GITSTABLE_LICENSE_KEY", "value": asset_config["license_key"]},
                                {"name": "GITSTABLE_API_KEY", "value": self.bot.api_key}
                            ],
                            "resources": asset_config["resources"]
                        }]
                    }
                }
            }
        }
        
        # Deploy to Kubernetes
        apps_v1 = kubernetes.client.AppsV1Api(self.k8s)
        apps_v1.create_namespaced_deployment(
            namespace=environment,
            body=deployment
        )
        
        return f"gitstable-{asset_id}"
    
    def setup_monitoring(self, deployment_name, asset_id):
        """Setup monitoring and alerting for deployed asset"""
        
        # Configure usage tracking webhook
        self.bot.webhooks.create(
            url=f"https://monitoring.company.com/webhooks/{deployment_name}",
            events=["usage.threshold", "license.expiring", "inference.failed"]
        )
        
        # Setup Prometheus metrics
        metrics_config = {
            "job_name": f"gitstable-{asset_id}",
            "static_configs": [{
                "targets": [f"{deployment_name}:8080"]
            }]
        }
        
        return metrics_config

{
  "error": {
    "code": "INSUFFICIENT_FUNDS",
    "message": "Insufficient USDC balance for purchase",
    "details": {
      "required_amount": 450.00,
      "available_balance": 320.00,
      "currency": "USDC"
    },
    "suggestion": "Add funds to your account or choose a lower-priced asset",
    "support_url": "https://docs.gitstable.com/errors/insufficient-funds"
  }
}

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 856
X-RateLimit-Reset: 1692276000
X-RateLimit-Retry-After: 45