python -m venv venv
source venv/bin/activate
pip install httpx openai pydantic pyyaml
export OPENAI_API_KEY="sk-your-key"

# discovery/openapi_parser.py
import yaml
import json
from typing import Dict, List
import httpx

class OpenAPIParser:
    def __init__(self):
        self.spec = None
        self.endpoints: List[Dict] = []

    def parse_file(self, file_path: str) -> Dict:
        with open(file_path, "r") as f:
            if file_path.endswith((".yaml", ".yml")):
                self.spec = yaml.safe_load(f)
            else:
                self.spec = json.load(f)
        self._extract_endpoints()
        return self.spec

    def parse_url(self, url: str) -> Dict:
        response = httpx.get(url)
        if url.endswith((".yaml", ".yml")):
            self.spec = yaml.safe_load(response.text)
        else:
            self.spec = response.json()
        self._extract_endpoints()
        return self.spec

    def _extract_endpoints(self) -> None:
        if not self.spec or "paths" not in self.spec:
            return
        for path, methods in self.spec["paths"].items():
            for method, details in methods.items():
                if method.lower() in ("get", "post", "put", "patch", "delete"):
                    self.endpoints.append({
                        "path": path,
                        "method": method.upper(),
                        "summary": details.get("summary", ""),
                        "description": details.get("description", ""),
                        "parameters": details.get("parameters", []),
                        "request_body": details.get("requestBody", {}),
                        "responses": details.get("responses", {}),
                        "tags": details.get("tags", []),
                    })

    def get_endpoints_summary(self) -> str:
        summary = []
        for ep in self.endpoints:
            params = len(ep.get("parameters", []))
            summary.append(f"{ep['method']} {ep['path']} - {ep['summary']} (params: {params})")
        return "\n".join(summary)

    def find_endpoint(self, description: str) -> Dict:
        for ep in self.endpoints:
            if description.lower() in ep.get("summary", "").lower():
                return ep
        return {}

# auth/manager.py
from typing import Dict, Optional
import httpx

class AuthManager:
    def __init__(self):
        self.credentials: Dict[str, Dict] = {}

    def add_api_key(self, name: str, key: str, header: str = "Authorization") -> None:
        self.credentials[name] = {"type": "api_key", "key": key, "header": header}

    def add_oauth2(self, name: str, token: str) -> None:
        self.credentials[name] = {"type": "oauth2", "token": token, "header": "Authorization"}

    def get_auth_headers(self, name: str) -> Dict[str, str]:
        cred = self.credentials.get(name)
        if not cred:
            return {}
        if cred["type"] == "api_key":
            return {cred["header"]: f"Bearer {cred['key']}"}
        elif cred["type"] == "oauth2":
            return {cred["header"]: f"Bearer {cred['token']}"}
        return {}

# execution/request_builder.py
import httpx
from typing import Dict, Any

class RequestBuilder:
    def __init__(self):
        self.client = httpx.Client(timeout=30.0)

    def build_and_send(
        self,
        method: str,
        url: str,
        params: Dict = None,
        json_data: Dict = None,
        headers: Dict = None,
    ) -> Dict:
        try:
            response = self.client.request(
                method=method,
                url=url,
                params=params,
                json=json_data,
                headers=headers or {},
            )
            return {
                "success": response.status_code < 400,
                "status_code": response.status_code,
                "headers": dict(response.headers),
                "data": self._parse_response(response),
                "text": response.text[:5000],
            }
        except Exception as e:
            return {"success": False, "error": str(e)}

    def _parse_response(self, response: httpx.Response) -> Any:
        content_type = response.headers.get("content-type", "")
        if "json" in content_type:
            return response.json()
        return response.text

# execution/error_handler.py
import time
from typing import Dict, Callable
from functools import wraps

class ErrorHandler:
    def __init__(self, max_retries: int = 3, backoff_factor: float = 1.5):
        self.max_retries = max_retries
        self.backoff_factor = backoff_factor

    def with_retry(self, func: Callable) -> Callable:
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_error = None
            for attempt in range(self.max_retries):
                result = func(*args, **kwargs)
                if result.get("success"):
                    return result
                last_error = result.get("error", "Unknown error")
                status = result.get("status_code", 500)
                if status == 429:
                    wait = self.backoff_factor ** attempt
                    time.sleep(wait)
                elif status >= 500:
                    wait = self.backoff_factor ** attempt
                    time.sleep(wait)
                else:
                    break
            return {"success": False, "error": f"Failed after {self.max_retries} retries: {last_error}"}
        return wrapper

# agent.py
from discovery.openapi_parser import OpenAPIParser
from auth.manager import AuthManager
from execution.request_builder import RequestBuilder
from execution.error_handler import ErrorHandler
from openai import OpenAI
from typing import Dict
import json

class APIIntegrationAgent:
    def __init__(self, model: str = "gpt-4-turbo-preview"):
        self.parser = OpenAPIParser()
        self.auth = AuthManager()
        self.request_builder = RequestBuilder()
        self.error_handler = ErrorHandler()
        self.llm = OpenAI()
        self.model = model

    def load_api(self, spec_path: str = None, spec_url: str = None) -> str:
        if spec_path:
            self.parser.parse_file(spec_path)
        elif spec_url:
            self.parser.parse_url(spec_url)
        return f"Loaded {len(self.parser.endpoints)} endpoints"

    def call_api(self, instruction: str, auth_name: str = None) -> Dict:
        endpoint = self.parser.find_endpoint(instruction)
        if not endpoint:
            endpoint = self._llm_find_endpoint(instruction)
        headers = self.auth.get_auth_headers(auth_name) if auth_name else {}
        request_info = self._build_request(endpoint, instruction)
        wrapped = self.error_handler.with_retry(self.request_builder.build_and_send)
        return wrapped(
            method=endpoint.get("method", "GET"),
            url=f"https://api.example.com{endpoint.get('path', '/')}",
            params=request_info.get("params"),
            json_data=request_info.get("body"),
            headers=headers,
        )

    def _llm_find_endpoint(self, instruction: str) -> Dict:
        endpoints_desc = self.parser.get_endpoints_summary()
        response = self.llm.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": f"Given these API endpoints:\n{endpoints_desc}\n\nFind the best endpoint for the user's request. Return JSON with path and method."},
                {"role": "user", "content": instruction},
            ],
            temperature=0.0,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except:
            return {"path": "/", "method": "GET"}

    def _build_request(self, endpoint: Dict, instruction: str) -> Dict:
        params = {}
        body = {}
        for param in endpoint.get("parameters", []):
            name = param.get("name", "")
            if param.get("required"):
                params[name] = f"value_for_{name}"
        return {"params": params, "body": body}

import pytest
from discovery.openapi_parser import OpenAPIParser

def test_parse_openapi():
    parser = OpenAPIParser()
    parser.parse_file("petstore.yaml")
    assert len(parser.endpoints) > 0

def test_auth_manager():
    manager = AuthManager()
    manager.add_api_key("test", "abc123")
    headers = manager.get_auth_headers("test")
    assert "Authorization" in headers

# main.py
from agent import APIIntegrationAgent

def main():
    agent = APIIntegrationAgent()
    agent.load_api(spec_url="https://petstore3.swagger.io/api/v3/openapi.json")
    print("API Agent Ready\n")
    while True:
        instruction = input("API instruction: ").strip()
        if instruction.lower() == "quit":
            break
        result = agent.call_api(instruction)
        print(f"\nStatus: {result.get('status_code', 'error')}")
        print(f"Data: {str(result.get('data', ''))[:500]}\n")

if __name__ == "__main__":
    main()