Build with APIs, Not Chat Apps

from openai import OpenAI

# Add this after your existing app = FastAPI() line
client = OpenAI()  # reads OPENAI_API_KEY from environment


@app.post("/summarize", response_model=SummarizeTextResponse)
def summarize(request: SummarizeTextRequest):
    """Summarize free-form text through the OpenAI-backed API endpoint.

    Args:
        request: Request model containing the source text to summarize.

    Returns:
        A validated summary payload with the summary, source word count, and key topics.
    """
    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {
                    "role": "system",
                    "content": (
                        "You are a summarizer. Given text, return a JSON object with: "
                        "summary (2-3 sentences), word_count (of the original text), "
                        "and key_topics (list of 2-4 topics). "
                        "Return ONLY valid JSON, no other text."
                    ),
                },
                {"role": "user", "content": request.text},
            ],
            temperature=0,
            response_format={"type": "json_object"},
        )
        result = json.loads(response.choices[0].message.content)
        return SummarizeTextResponse(**result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

from google import genai
from google.genai import types

client = genai.Client()


@app.post("/summarize", response_model=SummarizeTextResponse)
def summarize(request: SummarizeTextRequest):
    """Summarize free-form text through the Gemini-backed API endpoint.

    Args:
        request: Request model containing the source text to summarize.

    Returns:
        A validated summary payload with the summary, source word count, and key topics.
    """
    try:
        response = client.models.generate_content(
            model="gemini-2.5-flash",
            contents=request.text,
            config=types.GenerateContentConfig(
                system_instruction=(
                    "You are a summarizer. Given text, return a JSON object with: "
                    "summary (2-3 sentences), word_count (of the original text), "
                    "and key_topics (list of 2-4 topics). "
                    "Return only the structured result."
                ),
                temperature=0,
                response_mime_type="application/json",
                response_schema=SummarizeTextResponse,
            ),
        )
        result = response.parsed or json.loads(response.text)
        if isinstance(result, SummarizeTextResponse):
            return result
        return SummarizeTextResponse.model_validate(result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

from anthropic import Anthropic

client = Anthropic()


@app.post("/summarize", response_model=SummarizeTextResponse)
def summarize(request: SummarizeTextRequest):
    """Summarize free-form text through the Anthropic-backed API endpoint.

    Args:
        request: Request model containing the source text to summarize.

    Returns:
        A validated summary payload with the summary, source word count, and key topics.
    """
    try:
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            system=(
                "You are a summarizer. Given text, return a JSON object with: "
                "summary (2-3 sentences), word_count (of the original text), "
                "and key_topics (list of 2-4 topics). "
                "Return ONLY valid JSON, no other text."
            ),
            output_config={
                "format": {
                    "type": "json_schema",
                    "schema": {
                        "type": "object",
                        "properties": {
                            "summary": {"type": "string"},
                            "word_count": {"type": "number"},
                            "key_topics": {
                                "type": "array",
                                "items": {"type": "string"},
                            },
                        },
                        "required": ["summary", "word_count", "key_topics"],
                        "additionalProperties": False,
                    },
                },
            },
            messages=[{"role": "user", "content": request.text}],
        )
        result = json.loads(response.content[0].text)
        return SummarizeTextResponse(**result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://router.huggingface.co/v1",
    api_key=os.environ["HF_TOKEN"],
)


@app.post("/summarize", response_model=SummarizeTextResponse)
def summarize(request: SummarizeTextRequest):
    """Summarize free-form text through the Hugging Face-backed API endpoint.

    Args:
        request: Request model containing the source text to summarize.

    Returns:
        A validated summary payload with the summary, source word count, and key topics.
    """
    try:
        response = client.chat.completions.create(
            model="Qwen/Qwen2.5-7B-Instruct",
            messages=[
                {
                    "role": "system",
                    "content": (
                        "You are a summarizer. Given text, return a JSON object with: "
                        "summary (2-3 sentences), word_count (of the original text), "
                        "and key_topics (list of 2-4 topics). "
                        "Return ONLY valid JSON, no other text."
                    ),
                },
                {"role": "user", "content": request.text},
            ],
            temperature=0,
            response_format={"type": "json_object"},
        )
        result = json.loads(response.choices[0].message.content)
        return SummarizeTextResponse(**result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://models.github.ai/inference",
    api_key=os.environ["GITHUB_TOKEN"],
    default_headers={
        "Accept": "application/vnd.github+json",
        "X-GitHub-Api-Version": "2026-03-10",
    },
)


@app.post("/summarize", response_model=SummarizeTextResponse)
def summarize(request: SummarizeTextRequest):
    """Summarize free-form text through the GitHub Models-backed API endpoint.

    Args:
        request: Request model containing the source text to summarize.

    Returns:
        A validated summary payload with the summary, source word count, and key topics.
    """
    try:
        response = client.chat.completions.create(
            model="openai/gpt-4.1",
            messages=[
                {
                    "role": "system",
                    "content": (
                        "You are a summarizer. Given text, return a JSON object with: "
                        "summary (2-3 sentences), word_count (of the original text), "
                        "and key_topics (list of 2-4 topics). "
                        "Return ONLY valid JSON, no other text."
                    ),
                },
                {"role": "user", "content": request.text},
            ],
            temperature=0,
            response_format={"type": "json_object"},
        )
        result = json.loads(response.choices[0].message.content)
        return SummarizeTextResponse(**result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

ollama pull qwen3.5:latest

import os
from ollama import Client

client = Client(
    host=os.environ.get("OLLAMA_HOST", "http://localhost:11434"),
    headers={"Authorization": "Bearer " + os.environ.get("OLLAMA_API_KEY", "")},
)


@app.post("/summarize", response_model=SummarizeTextResponse)
def summarize(request: SummarizeTextRequest):
    """Summarize free-form text through the local Ollama-backed API endpoint.

    Args:
        request: Request model containing the source text to summarize.

    Returns:
        A validated summary payload with the summary, source word count, and key topics.
    """
    try:
        response = client.chat(
            model="qwen3.5:latest",
            messages=[
                {
                    "role": "system",
                    "content": (
                        "You are a summarizer. Given text, return a JSON object with: "
                        "summary (2-3 sentences), word_count (of the original text), "
                        "and key_topics (list of 2-4 topics). "
                        "Return ONLY valid JSON, no other text."
                    ),
                },
                {"role": "user", "content": request.text},
            ],
            format="json",
            options={"temperature": 0},
        )
        result = json.loads(response.message.content)
        return SummarizeTextResponse(**result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

import os
from ollama import Client

client = Client(
    host="https://ollama.com",
    headers={"Authorization": "Bearer " + os.environ["OLLAMA_API_KEY"]},
)


@app.post("/summarize", response_model=SummarizeTextResponse)
def summarize(request: SummarizeTextRequest):
    """Summarize free-form text through the Ollama Cloud-backed API endpoint.

    Args:
        request: Request model containing the source text to summarize.

    Returns:
        A validated summary payload with the summary, source word count, and key topics.
    """
    try:
        response = client.chat(
            model="gpt-oss:20b",
            messages=[
                {
                    "role": "system",
                    "content": (
                        "You are a summarizer. Given text, return a JSON object with: "
                        "summary (2-3 sentences), word_count (of the original text), "
                        "and key_topics (list of 2-4 topics). "
                        "Return ONLY valid JSON, no other text."
                    ),
                },
                {"role": "user", "content": request.text},
            ],
            format="json",
            options={"temperature": 0},
        )
        result = json.loads(response.message.content)
        return SummarizeTextResponse(**result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

# Add to app.py
from conversations import get_history, append_message, SYSTEM_PROMPT_TEXT


class ChatRequest(BaseModel):
    conversation_id: str
    message: str

class ChatResponse(BaseModel):
    conversation_id: str
    response: str
    message_count: int


@app.post("/chat", response_model=ChatResponse)
def chat(request: ChatRequest):
    """Continue one conversation through the OpenAI-backed chat endpoint.

    Args:
        request: Chat request containing the conversation ID and latest user message.

    Returns:
        A response with the assistant reply and the updated message count for the thread.
    """
    # Get history, add user message
    history = get_history(request.conversation_id)
    append_message(request.conversation_id, "user", request.message)
    messages = [{"role": "system", "content": SYSTEM_PROMPT_TEXT}, *history]

    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            temperature=0,
        )
        assistant_msg = response.choices[0].message.content
        append_message(request.conversation_id, "assistant", assistant_msg)

        return ChatResponse(
            conversation_id=request.conversation_id,
            response=assistant_msg,
            message_count=len(history),
        )
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

# Add to app.py
from google import genai
from google.genai import types
from conversations import get_history, append_message, SYSTEM_PROMPT_TEXT

client = genai.Client()


def to_gemini_contents(history: list[dict]) -> list[types.Content]:
    """Convert stored chat history into Gemini SDK content objects.

    Args:
        history: Prior conversation turns stored as role/content dictionaries.

    Returns:
        A list of Gemini ``Content`` objects with roles normalized to ``user`` and ``model``.
    """
    contents = []
    for message in history:
        role = "model" if message["role"] == "assistant" else "user"
        contents.append(
            types.Content(role=role, parts=[types.Part(text=message["content"])])
        )
    return contents


class ChatRequest(BaseModel):
    conversation_id: str
    message: str

class ChatResponse(BaseModel):
    conversation_id: str
    response: str
    message_count: int


@app.post("/chat", response_model=ChatResponse)
def chat(request: ChatRequest):
    """Continue one conversation through the Gemini-backed chat endpoint.

    Args:
        request: Chat request containing the conversation ID and latest user message.

    Returns:
        A response with the assistant reply and the updated message count for the thread.
    """
    history = get_history(request.conversation_id)
    append_message(request.conversation_id, "user", request.message)
    contents = to_gemini_contents(history)

    try:
        response = client.models.generate_content(
            model="gemini-2.5-flash",
            contents=contents,
            config=types.GenerateContentConfig(
                system_instruction=SYSTEM_PROMPT_TEXT,
                temperature=0,
            ),
        )
        assistant_msg = response.text
        append_message(request.conversation_id, "assistant", assistant_msg)

        return ChatResponse(
            conversation_id=request.conversation_id,
            response=assistant_msg,
            message_count=len(history),
        )
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

# Add to app.py
from conversations import get_history, append_message, SYSTEM_PROMPT_TEXT


class ChatRequest(BaseModel):
    conversation_id: str
    message: str

class ChatResponse(BaseModel):
    conversation_id: str
    response: str
    message_count: int


@app.post("/chat", response_model=ChatResponse)
def chat(request: ChatRequest):
    """Continue one conversation through the Anthropic-backed chat endpoint.

    Args:
        request: Chat request containing the conversation ID and latest user message.

    Returns:
        A response with the assistant reply and the updated message count for the thread.
    """
    history = get_history(request.conversation_id)
    append_message(request.conversation_id, "user", request.message)

    try:
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            system=SYSTEM_PROMPT_TEXT,
            messages=history,
        )
        assistant_msg = response.content[0].text
        append_message(request.conversation_id, "assistant", assistant_msg)

        return ChatResponse(
            conversation_id=request.conversation_id,
            response=assistant_msg,
            message_count=len(history),
        )
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

# Add to app.py
from conversations import get_history, append_message, SYSTEM_PROMPT_TEXT


class ChatRequest(BaseModel):
    conversation_id: str
    message: str

class ChatResponse(BaseModel):
    conversation_id: str
    response: str
    message_count: int


@app.post("/chat", response_model=ChatResponse)
def chat(request: ChatRequest):
    """Continue one conversation through the Hugging Face-backed chat endpoint.

    Args:
        request: Chat request containing the conversation ID and latest user message.

    Returns:
        A response with the assistant reply and the updated message count for the thread.
    """
    history = get_history(request.conversation_id)
    append_message(request.conversation_id, "user", request.message)
    messages = [{"role": "system", "content": SYSTEM_PROMPT_TEXT}, *history]

    try:
        response = client.chat.completions.create(
            model="Qwen/Qwen2.5-7B-Instruct",
            messages=messages,
            temperature=0,
        )
        assistant_msg = response.choices[0].message.content
        append_message(request.conversation_id, "assistant", assistant_msg)

        return ChatResponse(
            conversation_id=request.conversation_id,
            response=assistant_msg,
            message_count=len(history),
        )
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

# Add to app.py
from conversations import get_history, append_message, SYSTEM_PROMPT_TEXT


class ChatRequest(BaseModel):
    conversation_id: str
    message: str

class ChatResponse(BaseModel):
    conversation_id: str
    response: str
    message_count: int


@app.post("/chat", response_model=ChatResponse)
def chat(request: ChatRequest):
    """Continue one conversation through the GitHub Models-backed chat endpoint.

    Args:
        request: Chat request containing the conversation ID and latest user message.

    Returns:
        A response with the assistant reply and the updated message count for the thread.
    """
    history = get_history(request.conversation_id)
    append_message(request.conversation_id, "user", request.message)
    messages = [{"role": "system", "content": SYSTEM_PROMPT_TEXT}, *history]

    try:
        response = client.chat.completions.create(
            model="openai/gpt-4.1",
            messages=messages,
            temperature=0,
        )
        assistant_msg = response.choices[0].message.content
        append_message(request.conversation_id, "assistant", assistant_msg)

        return ChatResponse(
            conversation_id=request.conversation_id,
            response=assistant_msg,
            message_count=len(history),
        )
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

# Add to app.py
from conversations import get_history, append_message, SYSTEM_PROMPT_TEXT


class ChatRequest(BaseModel):
    conversation_id: str
    message: str

class ChatResponse(BaseModel):
    conversation_id: str
    response: str
    message_count: int


@app.post("/chat", response_model=ChatResponse)
def chat(request: ChatRequest):
    """Continue one conversation through the local Ollama-backed chat endpoint.

    Args:
        request: Chat request containing the conversation ID and latest user message.

    Returns:
        A response with the assistant reply and the updated message count for the thread.
    """
    history = get_history(request.conversation_id)
    append_message(request.conversation_id, "user", request.message)
    messages = [{"role": "system", "content": SYSTEM_PROMPT_TEXT}, *history]

    try:
        response = client.chat(
            model="qwen3.5:latest",
            messages=messages,
            options={"temperature": 0},
        )
        assistant_msg = response.message.content
        append_message(request.conversation_id, "assistant", assistant_msg)

        return ChatResponse(
            conversation_id=request.conversation_id,
            response=assistant_msg,
            message_count=len(history),
        )
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

# Add to app.py
from conversations import get_history, append_message, SYSTEM_PROMPT_TEXT


class ChatRequest(BaseModel):
    conversation_id: str
    message: str

class ChatResponse(BaseModel):
    conversation_id: str
    response: str
    message_count: int


@app.post("/chat", response_model=ChatResponse)
def chat(request: ChatRequest):
    """Continue one conversation through the Ollama Cloud-backed chat endpoint.

    Args:
        request: Chat request containing the conversation ID and latest user message.

    Returns:
        A response with the assistant reply and the updated message count for the thread.
    """
    history = get_history(request.conversation_id)
    append_message(request.conversation_id, "user", request.message)
    messages = [{"role": "system", "content": SYSTEM_PROMPT_TEXT}, *history]

    try:
        response = client.chat(
            model="gpt-oss:20b",
            messages=messages,
            options={"temperature": 0},
        )
        assistant_msg = response.message.content
        append_message(request.conversation_id, "assistant", assistant_msg)

        return ChatResponse(
            conversation_id=request.conversation_id,
            response=assistant_msg,
            message_count=len(history),
        )
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

@app.post("/extract/bug-report", response_model=BugReport)
def extract_bug_report(request: ExtractRequest):
    """Extract a structured bug report with the OpenAI-backed endpoint.

    Args:
        request: Request model containing the raw bug description text.

    Returns:
        A validated ``BugReport`` parsed from the model response.
    """
    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {
                    "role": "system",
                    "content": (
                        "Extract a structured bug report from the user's text. "
                        "Return JSON with: title, steps_to_reproduce (list of strings), "
                        "expected_behavior, actual_behavior, severity (low/medium/high/critical). "
                        "If information is missing, use 'Not specified'."
                    ),
                },
                {"role": "user", "content": request.text},
            ],
            temperature=0,
            response_format={
                "type": "json_schema",
                "json_schema": {
                    "name": "bug_report",
                    "strict": True,
                    "schema": {
                        "type": "object",
                        "properties": {
                            "title": {"type": "string"},
                            "steps_to_reproduce": {
                                "type": "array",
                                "items": {"type": "string"},
                            },
                            "expected_behavior": {"type": "string"},
                            "actual_behavior": {"type": "string"},
                            "severity": {
                                "type": "string",
                                "enum": ["low", "medium", "high", "critical"],
                            },
                        },
                        "required": [
                            "title",
                            "steps_to_reproduce",
                            "expected_behavior",
                            "actual_behavior",
                            "severity",
                        ],
                        "additionalProperties": False,
                    },
                },
            },
        )
        result = json.loads(response.choices[0].message.content)
        return BugReport(**result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

from google import genai
from google.genai import types

client = genai.Client()


@app.post("/extract/bug-report", response_model=BugReport)
def extract_bug_report(request: ExtractRequest):
    """Extract a structured bug report with the Gemini-backed endpoint.

    Args:
        request: Request model containing the raw bug description text.

    Returns:
        A validated ``BugReport`` parsed from the model response.
    """
    try:
        response = client.models.generate_content(
            model="gemini-2.5-flash",
            contents=request.text,
            config=types.GenerateContentConfig(
                system_instruction=(
                    "Extract a structured bug report from the user's text. "
                    "If information is missing, use 'Not specified'."
                ),
                temperature=0,
                response_mime_type="application/json",
                response_schema=BugReport,
            ),
        )
        result = response.parsed or json.loads(response.text)
        if isinstance(result, BugReport):
            return result
        return BugReport.model_validate(result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

from anthropic import Anthropic

client = Anthropic()


@app.post("/extract/bug-report", response_model=BugReport)
def extract_bug_report(request: ExtractRequest):
    """Extract a structured bug report with the Anthropic-backed endpoint.

    Args:
        request: Request model containing the raw bug description text.

    Returns:
        A validated ``BugReport`` parsed from the model response.
    """
    try:
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            system=(
                "Extract a structured bug report from the user's text. "
                "If information is missing, use 'Not specified'."
            ),
            output_config={
                "format": {
                    "type": "json_schema",
                    "schema": {
                        "type": "object",
                        "properties": {
                            "title": {"type": "string"},
                            "steps_to_reproduce": {
                                "type": "array",
                                "items": {"type": "string"},
                            },
                            "expected_behavior": {"type": "string"},
                            "actual_behavior": {"type": "string"},
                            "severity": {
                                "type": "string",
                                "enum": ["low", "medium", "high", "critical"],
                            },
                        },
                        "required": [
                            "title",
                            "steps_to_reproduce",
                            "expected_behavior",
                            "actual_behavior",
                            "severity",
                        ],
                        "additionalProperties": False,
                    },
                },
            },
            messages=[{"role": "user", "content": request.text}],
        )
        result = json.loads(response.content[0].text)
        return BugReport(**result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

import os
from huggingface_hub import InferenceClient

client = InferenceClient(provider="auto", api_key=os.environ["HF_TOKEN"])


@app.post("/extract/bug-report", response_model=BugReport)
def extract_bug_report(request: ExtractRequest):
    """Extract a structured bug report with the Hugging Face-backed endpoint.

    Args:
        request: Request model containing the raw bug description text.

    Returns:
        A validated ``BugReport`` parsed from the model response.
    """
    try:
        response_format = {
            "type": "json_schema",
            "json_schema": {
                "name": "bug_report",
                "schema": BugReport.model_json_schema(),
                "strict": True,
            },
        }
        response = client.chat_completion(
            model="Qwen/Qwen2.5-7B-Instruct",
            messages=[
                {
                    "role": "system",
                    "content": "Extract a structured bug report from the user's text.",
                },
                {"role": "user", "content": request.text},
            ],
            response_format=response_format,
        )
        result = json.loads(response.choices[0].message.content)
        return BugReport(**result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://models.github.ai/inference",
    api_key=os.environ["GITHUB_TOKEN"],
    default_headers={
        "Accept": "application/vnd.github+json",
        "X-GitHub-Api-Version": "2026-03-10",
    },
)


@app.post("/extract/bug-report", response_model=BugReport)
def extract_bug_report(request: ExtractRequest):
    """Extract a structured bug report with the GitHub Models-backed endpoint.

    Args:
        request: Request model containing the raw bug description text.

    Returns:
        A validated ``BugReport`` parsed from the model response.
    """
    try:
        response = client.chat.completions.create(
            model="openai/gpt-4.1",
            messages=[
                {
                    "role": "system",
                    "content": "Extract a structured bug report from the user's text.",
                },
                {"role": "user", "content": request.text},
            ],
            response_format={
                "type": "json_schema",
                "json_schema": {
                    "name": "bug_report",
                    "schema": BugReport.model_json_schema(),
                    "strict": True,
                },
            },
        )
        result = json.loads(response.choices[0].message.content)
        return BugReport(**result)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

import os
from ollama import Client

client = Client(
    host=os.environ.get("OLLAMA_HOST", "http://localhost:11434"),
    headers={"Authorization": "Bearer " + os.environ.get("OLLAMA_API_KEY", "")},
)


@app.post("/extract/bug-report", response_model=BugReport)
def extract_bug_report(request: ExtractRequest):
    """Extract a structured bug report with the local Ollama-backed endpoint.

    Args:
        request: Request model containing the raw bug description text.

    Returns:
        A validated ``BugReport`` parsed from the model response.
    """
    try:
        response = client.chat(
            model="qwen3.5:latest",
            messages=[
                {
                    "role": "system",
                    "content": (
                        "Extract a structured bug report from the user's text. "
                        "If information is missing, use 'Not specified'."
                    ),
                },
                {"role": "user", "content": request.text},
            ],
            format=BugReport.model_json_schema(),
            options={"temperature": 0},
        )
        return BugReport.model_validate_json(response.message.content)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

import os
from ollama import Client

client = Client(
    host=os.environ.get("OLLAMA_HOST", "https://ollama.com"),
    headers={"Authorization": "Bearer " + os.environ["OLLAMA_API_KEY"]},
)


@app.post("/extract/bug-report", response_model=BugReport)
def extract_bug_report(request: ExtractRequest):
    """Extract a structured bug report with the Ollama Cloud-backed endpoint.

    Args:
        request: Request model containing the raw bug description text.

    Returns:
        A validated ``BugReport`` parsed from the model response.
    """
    try:
        response = client.chat(
            model="gpt-oss:120b",
            messages=[
                {
                    "role": "user",
                    "content": (
                        "Extract a structured bug report from the user's text. "
                        "Return JSON with exactly these keys: "
                        "title, steps_to_reproduce, expected_behavior, "
                        "actual_behavior, severity. "
                        "steps_to_reproduce must be an array of strings. "
                        "severity must be one of: low, medium, high, critical. "
                        "If information is missing, use 'Not specified'.\n\n"
                        f"User text: {request.text}"
                    ),
                }
            ],
            format="json",
            options={"temperature": 0},
        )
        return BugReport.model_validate_json(response.message.content)
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

@app.post("/chat-with-tools", response_model=ToolChatResponse)
def chat_with_tools(request: ToolChatRequest):
    """Answer one message, calling ``lookup_user`` when the model asks for it.

    Args:
        request: Tool-chat request containing the latest user message.

    Returns:
        The final assistant response plus the list of tools invoked during the turn.
    """
    messages = [
        {
            "role": "system",
            "content": "You are a helpful assistant. Use the lookup_user tool when the user asks about a person.",
        },
        {"role": "user", "content": request.message},
    ]

    try:
        # First call — model may request a tool
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=TOOL_DEFINITIONS,
            temperature=0,
        )

        msg = response.choices[0].message
        tools_called = []

        # If the model requested a tool call, execute it
        if msg.tool_calls:
            # Add the assistant's tool-call message to history
            messages.append(msg)

            for tool_call in msg.tool_calls:
                if tool_call.function.name == "lookup_user":
                    args = json.loads(tool_call.function.arguments)
                    result = lookup_user(args["user_id"])
                    tools_called.append("lookup_user")

                    # Add the tool result to history
                    messages.append({
                        "role": "tool",
                        "tool_call_id": tool_call.id,
                        "content": json.dumps(result),
                    })

            # Second call — model uses the tool result to answer
            response = client.chat.completions.create(
                model="gpt-4o-mini",
                messages=messages,
                tools=TOOL_DEFINITIONS,
                temperature=0,
            )
            msg = response.choices[0].message

        return ToolChatResponse(
            response=msg.content,
            tools_called=tools_called,
        )
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

from google import genai
from google.genai import types

client = genai.Client()

lookup_user_tool = {
    "name": "lookup_user",
    "description": "Look up a user by their ID and return their profile",
    "parameters": {
        "type": "object",
        "properties": {
            "user_id": {"type": "string"},
        },
        "required": ["user_id"],
    },
}


@app.post("/chat-with-tools", response_model=ToolChatResponse)
def chat_with_tools(request: ToolChatRequest):
    """Answer one message, calling ``lookup_user`` when Gemini requests it.

    Args:
        request: Tool-chat request containing the latest user message.

    Returns:
        The final assistant response plus the list of tools invoked during the turn.
    """
    contents = [types.Content(role="user", parts=[types.Part(text=request.message)])]
    config = types.GenerateContentConfig(
        system_instruction=(
            "You are a helpful assistant. Use the lookup_user tool when the user asks about a person."
        ),
        tools=[types.Tool(function_declarations=[lookup_user_tool])],
        temperature=0,
    )

    try:
        response = client.models.generate_content(
            model="gemini-2.5-flash",
            contents=contents,
            config=config,
        )

        tools_called = []
        tool_call = next(
            (
                part.function_call
                for part in response.candidates[0].content.parts
                if getattr(part, "function_call", None)
            ),
            None,
        )

        if tool_call and tool_call.name == "lookup_user":
            result = lookup_user(tool_call.args["user_id"])
            tools_called.append("lookup_user")

            contents.append(response.candidates[0].content)
            contents.append(
                types.Content(
                    role="user",
                    parts=[
                        types.Part.from_function_response(
                            name=tool_call.name,
                            response={"result": result},
                        )
                    ],
                )
            )

            response = client.models.generate_content(
                model="gemini-2.5-flash",
                contents=contents,
                config=config,
            )

        return ToolChatResponse(
            response=response.text,
            tools_called=tools_called,
        )
    except Exception as e:
        raise HTTPException(status_code=502, detail=f"Model call failed: {e}")

from anthropic import Anthropic

client = Anthropic()

tools = [
    {
        "name": "lookup_user",
        "description": "Look up a user by their ID and return their profile",
        "input_schema": {
            "type": "object",
            "properties": {
                "user_id": {"type": "string"},
            },
            "required": ["user_id"],
        },
    }
]

response = client.messages.create(
    model="claude-sonnet-4-6",
    system="You are a helpful assistant. Use lookup_user when needed.",
    tools=tools,
    messages=[{"role": "user", "content": request.message}],
    max_tokens=1024,
)

tool_block = next(block for block in response.content if block.type == "tool_use")
result = lookup_user(tool_block.input["user_id"])

follow_up = client.messages.create(
    model="claude-sonnet-4-6",
    tools=tools,
    messages=[
        {"role": "user", "content": request.message},
        {"role": "assistant", "content": response.content},
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": tool_block.id,
                    "content": json.dumps(result),
                }
            ],
        },
    ],
    max_tokens=1024,
)

# The main change is client initialization:
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://router.huggingface.co/v1",
    api_key=os.environ["HF_TOKEN"],
)

# The main change is client initialization:
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://models.github.ai/inference",
    api_key=os.environ["GITHUB_TOKEN"],
    default_headers={
        "Accept": "application/vnd.github+json",
        "X-GitHub-Api-Version": "2026-03-10",
    },
)

from ollama import Client

client = Client(host="http://localhost:11434")
# Run `ollama pull qwen3.5:latest` first.

response = client.chat(
    model="qwen3.5:latest",
    messages=messages,
    tools=TOOL_DEFINITIONS,
    stream=False,
)

assistant_message = response.message
messages.append({"role": "assistant", "content": assistant_message.content, "tool_calls": getattr(assistant_message, "tool_calls", None)})

if assistant_message.tool_calls:
    for call in assistant_message.tool_calls:
        if call.function.name == "lookup_user":
            result = lookup_user(call.function.arguments["user_id"])
            messages.append(
                {
                    "role": "tool",
                    "tool_name": call.function.name,
                    "content": json.dumps(result),
                }
            )

    final_response = client.chat(
        model="qwen3.5:latest",
        messages=messages,
        tools=TOOL_DEFINITIONS,
        stream=False,
    )

import os
from ollama import Client

client = Client(
    host="https://ollama.com",
    headers={"Authorization": "Bearer " + os.environ["OLLAMA_API_KEY"]},
)

response = client.chat(
    model="gpt-oss:20b",
    messages=messages,
    tools=TOOL_DEFINITIONS,
    stream=False,
)

assistant_message = response.message
messages.append({"role": "assistant", "content": assistant_message.content, "tool_calls": getattr(assistant_message, "tool_calls", None)})

if assistant_message.tool_calls:
    for call in assistant_message.tool_calls:
        if call.function.name == "lookup_user":
            result = lookup_user(call.function.arguments["user_id"])
            messages.append(
                {
                    "role": "tool",
                    "tool_name": call.function.name,
                    "content": json.dumps(result),
                }
            )

    final_response = client.chat(
        model="gpt-oss:20b",
        messages=messages,
        tools=TOOL_DEFINITIONS,
        stream=False,
    )