LLM Utilities

from tenxgraph.core.llm import (
    AnthropicBatch,
    BatchResult,
    DEFAULT_LLM_TIMEOUT_SECONDS,
    OpenAIBatch,
    call_llm,
    create_llm_client,
    detect_provider,
    get_default_llm_timeout,
    resolve_provider_and_model,
    set_default_llm_timeout,
)

async def call_llm(
    model: str,
    prompt: str,
    *,
    system_prompt: str | None = None,
    max_tokens: int = 1024,
    temperature: float = 0.3,
    json_mode: bool = False,
    use_vertex_ai: bool = False,
    api_style: Literal["responses", "chat"] = "responses",
    **llm_kwargs: Any,
) -> tuple[str, int, int, int]

import asyncio

from tenxgraph.core.llm import call_llm


async def main() -> None:
    text, in_tokens, out_tokens, cached = await call_llm(
        "gemini-2.5-flash",
        "Summarise this ticket in one sentence.",
        system_prompt="You are terse.",
        max_tokens=128,
    )
    print(text, in_tokens, out_tokens, cached)


asyncio.run(main())  # needs GEMINI_API_KEY or GOOGLE_API_KEY

def resolve_provider_and_model(
    model: str,
    use_vertex_ai: bool = False,
) -> tuple[str, str]

provider, model = resolve_provider_and_model("gemini/gemini-2.5-flash")
# ("google", "gemini-2.5-flash")

provider, model = resolve_provider_and_model("openai/qwen-2.5-72b")
# ("openai", "qwen-2.5-72b")

provider, model = resolve_provider_and_model("meta-llama/Llama-3-70b")
# ("openai", "meta-llama/Llama-3-70b")  -- unrecognised prefix kept intact

def detect_provider(model: str, use_vertex_ai: bool = False) -> str

detect_provider("gemini-2.5-flash")        # "google"
detect_provider("claude-haiku-4-5")        # "anthropic"
detect_provider("openai/qwen-2.5-72b")     # "openai"
detect_provider("llama-3.3-70b")           # "openai" (fallback, logged)

def create_llm_client(
    provider: str,
    *,
    use_vertex_ai: bool = False,
    base_url: str | None = None,
    api_key: str | None = None,
    anthropic_backend: str | None = None,
    **extra_kwargs: Any,
) -> Any

from tenxgraph.core.llm import create_llm_client

# OpenAI-compatible local server
client = create_llm_client(
    "openai",
    base_url="http://localhost:11434/v1",
    api_key="ollama",
)

# Claude on AWS Bedrock (needs the anthropic-bedrock extra)
client = create_llm_client(
    "anthropic",
    anthropic_backend="bedrock",
)

def get_default_llm_timeout() -> float

def set_default_llm_timeout(seconds: float | None) -> None

from tenxgraph.core.llm import get_default_llm_timeout, set_default_llm_timeout

set_default_llm_timeout(120.0)
get_default_llm_timeout()  # 120.0

set_default_llm_timeout(None)
get_default_llm_timeout()  # 600.0, or AGENTFLOW_LLM_TIMEOUT if set

class OpenAIBatch:
    model: str
    completion_window: str = "24h"
    endpoint: str = "/v1/chat/completions"
    client: Any = None

    def add(
        self,
        custom_id: str,
        messages: list[dict[str, Any]],
        *,
        tools: list[Any] | None = None,
        **params: Any,
    ) -> OpenAIBatch
    async def submit(self) -> str
    async def status(self, batch_id: str) -> str
    async def wait(
        self,
        batch_id: str,
        *,
        poll_interval: float = 30.0,
        timeout: float | None = None,
    ) -> dict[str, BatchResult]
    async def results(self, batch_id: str) -> dict[str, BatchResult]

from tenxgraph.core.llm import OpenAIBatch

import asyncio


async def main() -> None:
    batch = OpenAIBatch(model="gpt-4o-mini")  # needs OPENAI_API_KEY
    batch.add("request-1", [{"role": "user", "content": "Summarise: the meeting ran long."}])
    batch.add("request-2", [{"role": "user", "content": "Translate to French: good morning."}])

    batch_id = await batch.submit()
    print(f"Submitted batch {batch_id}")

    results = await batch.wait(batch_id, timeout=3600.0)
    print(results["request-1"].text)


asyncio.run(main())

class AnthropicBatch:
    model: str
    max_tokens: int = 16000
    anthropic_backend: str | None = None
    client: Any = None

    def add(
        self,
        custom_id: str,
        messages: list[dict[str, Any]],
        *,
        tools: list[Any] | None = None,
        **params: Any,
    ) -> AnthropicBatch
    async def submit(self) -> str
    async def status(self, batch_id: str) -> str
    async def wait(
        self,
        batch_id: str,
        *,
        poll_interval: float = 30.0,
        timeout: float | None = None,
    ) -> dict[str, BatchResult]
    async def results(self, batch_id: str) -> dict[str, BatchResult]

from tenxgraph.core.llm import AnthropicBatch

import asyncio


async def main() -> None:
    batch = AnthropicBatch(model="claude-haiku-4-5")  # needs ANTHROPIC_API_KEY
    batch.add("case-1", [{"role": "user", "content": "Summarise: the meeting ran long."}])
    batch.add("case-2", [{"role": "user", "content": "Classify the sentiment: great product."}])

    batch_id = await batch.submit()
    results = await batch.wait(batch_id)
    for custom_id, result in results.items():
        if result.ok:
            print(f"{custom_id}: {result.text}")
        else:
            print(f"{custom_id} failed: {result.status} {result.error}")


asyncio.run(main())

@dataclass
class BatchResult:
    custom_id: str
    status: str
    text: str = ""
    stop_reason: str | None = None
    input_tokens: int = 0
    output_tokens: int = 0
    error: Any = None
    raw: Any = None

    @property
    def ok(self) -> bool