otari-cli 0.1.0__py3-none-any.whl

otari_cli/commands/completion.py

@@ -0,0 +1,83 @@
+"""``otari completion`` - create a chat completion."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import typer
+
+from otari_cli import _client
+from otari_cli._errors import handle_errors
+from otari_cli._output import console, print_json
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from otari_cli._context import AppContext
+
+
+def completion(
+    ctx: typer.Context,
+    prompt: str = typer.Argument(..., help="The user prompt to send to the model."),
+    model: str = typer.Option(..., "--model", "-m", help="Model id, e.g. 'openai:gpt-4o-mini'."),
+    system: str | None = typer.Option(None, "--system", "-s", help="Optional system prompt."),
+    stream: bool = typer.Option(False, "--stream", help="Stream tokens as they are generated."),
+    temperature: float | None = typer.Option(None, "--temperature", help="Sampling temperature."),
+    max_tokens: int | None = typer.Option(None, "--max-tokens", help="Maximum tokens to generate."),
+) -> None:
+    """Create a chat completion and print the assistant's reply."""
+    app_ctx: AppContext = ctx.obj
+
+    messages: list[dict[str, str]] = []
+    if system is not None:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+
+    kwargs: dict[str, Any] = {}
+    if temperature is not None:
+        kwargs["temperature"] = temperature
+    if max_tokens is not None:
+        kwargs["max_tokens"] = max_tokens
+
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        if stream:
+            chunks = client.completion(model=model, messages=messages, stream=True, **kwargs)
+            _render_stream(chunks, output_json=app_ctx.output_json)
+        else:
+            result = client.completion(model=model, messages=messages, **kwargs)
+            _render_completion(result, output_json=app_ctx.output_json)
+
+
+def _render_completion(result: Any, *, output_json: bool) -> None:
+    if output_json:
+        print_json(result)
+        return
+    console().print(_completion_text(result))
+
+
+def _render_stream(chunks: Iterable[Any], *, output_json: bool) -> None:
+    for chunk in chunks:
+        if output_json:
+            print_json(chunk)
+            continue
+        delta = _chunk_text(chunk)
+        if delta:
+            console().print(delta, end="")
+    if not output_json:
+        console().print()
+
+
+def _completion_text(result: Any) -> str:
+    choices = getattr(result, "choices", None) or []
+    if not choices:
+        return ""
+    message = getattr(choices[0], "message", None)
+    return getattr(message, "content", "") or ""
+
+
+def _chunk_text(chunk: Any) -> str:
+    choices = getattr(chunk, "choices", None) or []
+    if not choices:
+        return ""
+    delta = getattr(choices[0], "delta", None)
+    return getattr(delta, "content", "") or ""

otari_cli/commands/embedding.py

@@ -0,0 +1,53 @@
+"""``otari embedding`` - create embeddings for one or more inputs."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import typer
+
+from otari_cli import _client
+from otari_cli._errors import handle_errors
+from otari_cli._output import print_json, render_records
+
+if TYPE_CHECKING:
+    from otari_cli._context import AppContext
+
+_PREVIEW = 4
+
+
+def embedding(
+    ctx: typer.Context,
+    inputs: list[str] = typer.Argument(..., help="One or more input strings to embed."),
+    model: str = typer.Option(..., "--model", "-m", help="Model id, e.g. 'openai:text-embedding-3-small'."),
+) -> None:
+    """Create embeddings. Human output is a summary; use --json for the vectors."""
+    app_ctx: AppContext = ctx.obj
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.embedding(model=model, input=inputs)
+    if app_ctx.output_json:
+        print_json(result)
+        return
+    render_records(
+        _summary_rows(result),
+        output_json=False,
+        title="Embeddings",
+        empty_message="No embeddings returned.",
+        columns=["index", "dimensions", "preview"],
+    )
+
+
+def _summary_rows(result: Any) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for item in getattr(result, "data", None) or []:
+        vector = getattr(item, "embedding", None) or []
+        preview = ", ".join(f"{value:.4f}" for value in vector[:_PREVIEW])
+        suffix = ", ..." if len(vector) > _PREVIEW else ""
+        rows.append(
+            {
+                "index": getattr(item, "index", None),
+                "dimensions": len(vector),
+                "preview": f"[{preview}{suffix}]",
+            }
+        )
+    return rows

otari_cli/commands/health.py

@@ -0,0 +1,50 @@
+"""``otari health`` - check gateway connectivity via ``GET /health``.
+
+The SDK does not expose a health method, so this command issues a direct
+unauthenticated request to the gateway's ``/health`` endpoint using the
+resolved base URL.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import httpx
+import typer
+
+from otari_cli._errors import EXIT_ERROR
+from otari_cli._output import console, error_console, print_json
+
+if TYPE_CHECKING:
+    from otari_cli._context import AppContext
+
+_HEALTH_TIMEOUT = 10.0
+
+
+def health(ctx: typer.Context) -> None:
+    """Report whether the configured gateway is reachable and healthy."""
+    app_ctx: AppContext = ctx.obj
+    base = app_ctx.config.api_base
+    if not base:
+        error_console().print(
+            "[bold red]Error:[/] no gateway URL configured; set --api-base or GATEWAY_API_BASE."
+        )
+        raise typer.Exit(EXIT_ERROR)
+
+    url = base.rstrip("/") + "/health"
+    try:
+        response = httpx.get(url, timeout=_HEALTH_TIMEOUT)
+    except httpx.HTTPError as exc:
+        error_console().print(f"[bold red]Error:[/] could not reach gateway at {url}: {exc}")
+        raise typer.Exit(EXIT_ERROR) from exc
+
+    ok = response.status_code == 200
+    if app_ctx.output_json:
+        print_json({"url": url, "status_code": response.status_code, "ok": ok})
+    elif ok:
+        console().print(f"[bold green]OK[/] {url} ({response.status_code})")
+    else:
+        error_console().print(f"[bold red]Unhealthy[/] {url} ({response.status_code})")
+
+    if not ok:
+        raise typer.Exit(EXIT_ERROR)

otari_cli/commands/keys.py

@@ -0,0 +1,120 @@
+"""``otari keys`` - manage gateway virtual API keys (control plane).
+
+These commands hit the gateway control plane and therefore require an admin
+credential (``--admin-key`` / ``GATEWAY_ADMIN_KEY``, or the platform token in
+platform mode). They are only available against a self-hosted/standalone
+gateway.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import typer
+from otari._client import CreateKeyRequest, UpdateKeyRequest
+
+from otari_cli import _client
+from otari_cli._errors import handle_errors
+from otari_cli._output import console, print_json, render_records
+from otari_cli._params import drop_none, parse_datetime, parse_json_object
+
+if TYPE_CHECKING:
+    from otari_cli._context import AppContext
+
+app = typer.Typer(
+    name="keys",
+    help="Manage gateway virtual API keys (admin / self-hosted only).",
+    no_args_is_help=True,
+)
+
+
+@app.command("list")
+def list_keys(
+    ctx: typer.Context,
+    skip: int | None = typer.Option(None, "--skip", help="Number of keys to skip."),
+    limit: int | None = typer.Option(None, "--limit", help="Maximum number of keys to return."),
+) -> None:
+    """List virtual API keys."""
+    app_ctx: AppContext = ctx.obj
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.control_plane.keys.list(skip=skip, limit=limit)
+    render_records(
+        list(result),
+        output_json=app_ctx.output_json,
+        title="API keys",
+        empty_message="No API keys found.",
+    )
+
+
+@app.command("get")
+def get_key(
+    ctx: typer.Context,
+    key_id: str = typer.Argument(..., help="Identifier of the key to retrieve."),
+) -> None:
+    """Show details for a single virtual API key."""
+    app_ctx: AppContext = ctx.obj
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.control_plane.keys.get(key_id)
+    print_json(result)
+
+
+@app.command("create")
+def create_key(
+    ctx: typer.Context,
+    key_name: str | None = typer.Option(None, "--name", help="Optional name for the key."),
+    user_id: str | None = typer.Option(None, "--user", help="User id to associate with the key."),
+    expires_at: str | None = typer.Option(None, "--expires-at", help="Expiration (ISO-8601)."),
+    metadata: str | None = typer.Option(None, "--metadata", help="Metadata as a JSON object."),
+) -> None:
+    """Create a virtual API key. The response includes the new key value."""
+    app_ctx: AppContext = ctx.obj
+    request = CreateKeyRequest(
+        **drop_none(
+            key_name=key_name,
+            user_id=user_id,
+            expires_at=parse_datetime(expires_at, flag="--expires-at"),
+            metadata=parse_json_object(metadata, flag="--metadata"),
+        )
+    )
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.control_plane.keys.create(request)
+    print_json(result)
+
+
+@app.command("update")
+def update_key(
+    ctx: typer.Context,
+    key_id: str = typer.Argument(..., help="Identifier of the key to update."),
+    key_name: str | None = typer.Option(None, "--name", help="New name for the key."),
+    active: bool | None = typer.Option(None, "--active/--inactive", help="Enable or disable the key."),
+    expires_at: str | None = typer.Option(None, "--expires-at", help="New expiration (ISO-8601)."),
+    metadata: str | None = typer.Option(None, "--metadata", help="Metadata as a JSON object."),
+) -> None:
+    """Update a virtual API key. Only the provided fields are changed."""
+    app_ctx: AppContext = ctx.obj
+    request = UpdateKeyRequest(
+        **drop_none(
+            key_name=key_name,
+            is_active=active,
+            expires_at=parse_datetime(expires_at, flag="--expires-at"),
+            metadata=parse_json_object(metadata, flag="--metadata"),
+        )
+    )
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.control_plane.keys.update(key_id, request)
+    print_json(result)
+
+
+@app.command("delete")
+def delete_key(
+    ctx: typer.Context,
+    key_id: str = typer.Argument(..., help="Identifier of the key to delete."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+) -> None:
+    """Delete a virtual API key."""
+    app_ctx: AppContext = ctx.obj
+    if not yes:
+        typer.confirm(f"Delete API key {key_id!r}?", abort=True)
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        client.control_plane.keys.delete(key_id)
+    console().print(f"[bold green]Deleted[/] API key {key_id!r}.")

otari_cli/commands/message.py

@@ -0,0 +1,82 @@
+"""``otari message`` - create an Anthropic-style message via ``/messages``."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import typer
+
+from otari_cli import _client
+from otari_cli._errors import handle_errors
+from otari_cli._output import console, print_json
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from otari_cli._context import AppContext
+
+
+def message(
+    ctx: typer.Context,
+    prompt: str = typer.Argument(..., help="The user prompt to send to the model."),
+    model: str = typer.Option(..., "--model", "-m", help="Model id, e.g. 'anthropic:claude-3-5-sonnet'."),
+    max_tokens: int = typer.Option(1024, "--max-tokens", help="Maximum tokens to generate (required by /messages)."),
+    system: str | None = typer.Option(None, "--system", "-s", help="Optional system prompt."),
+    stream: bool = typer.Option(False, "--stream", help="Stream the response as it is generated."),
+    temperature: float | None = typer.Option(None, "--temperature", help="Sampling temperature."),
+) -> None:
+    """Create an Anthropic-style message and print the reply."""
+    app_ctx: AppContext = ctx.obj
+
+    messages = [{"role": "user", "content": prompt}]
+    kwargs: dict[str, Any] = {}
+    if system is not None:
+        kwargs["system"] = system
+    if temperature is not None:
+        kwargs["temperature"] = temperature
+
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        if stream:
+            events = client.message(model=model, messages=messages, max_tokens=max_tokens, stream=True, **kwargs)
+            _render_stream(events, output_json=app_ctx.output_json)
+        else:
+            result = client.message(model=model, messages=messages, max_tokens=max_tokens, **kwargs)
+            _render_message(result, output_json=app_ctx.output_json)
+
+
+def _render_message(result: Any, *, output_json: bool) -> None:
+    if output_json:
+        print_json(result)
+        return
+    console().print(_message_text(result))
+
+
+def _render_stream(events: Iterable[Any], *, output_json: bool) -> None:
+    # The /messages stream yields raw event dicts with no single typed chunk
+    # model, so non-JSON mode prints text deltas and JSON mode prints events.
+    for event in events:
+        if output_json:
+            print_json(event)
+            continue
+        delta = _event_text(event)
+        if delta:
+            console().print(delta, end="")
+    if not output_json:
+        console().print()
+
+
+def _message_text(result: Any) -> str:
+    blocks = getattr(result, "content", None) or []
+    parts = [getattr(block, "text", "") or "" for block in blocks if getattr(block, "type", None) == "text"]
+    return "".join(parts)
+
+
+def _event_text(event: Any) -> str:
+    # content_block_delta events carry {"delta": {"type": "text_delta", "text": ...}}.
+    if not isinstance(event, dict):
+        return ""
+    delta = event.get("delta")
+    if isinstance(delta, dict) and delta.get("type") == "text_delta":
+        text = delta.get("text", "")
+        return text if isinstance(text, str) else ""
+    return ""

otari_cli/commands/models.py

@@ -0,0 +1,28 @@
+"""``otari models`` - list models available through the gateway."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import typer  # noqa: TC002  (Typer resolves the Context annotation at runtime)
+
+from otari_cli import _client
+from otari_cli._errors import handle_errors
+from otari_cli._output import render_records
+
+if TYPE_CHECKING:
+    from otari_cli._context import AppContext
+
+
+def models(ctx: typer.Context) -> None:
+    """List the models the gateway can route to."""
+    app_ctx: AppContext = ctx.obj
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.list_models()
+    render_records(
+        list(result),
+        output_json=app_ctx.output_json,
+        title="Models",
+        empty_message="No models available.",
+        columns=["id", "owned_by", "created"],
+    )

otari_cli/commands/moderation.py

@@ -0,0 +1,32 @@
+"""``otari moderation`` - classify text against the moderation endpoint."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import typer
+
+from otari_cli import _client
+from otari_cli._errors import handle_errors
+from otari_cli._output import render_records
+
+if TYPE_CHECKING:
+    from otari_cli._context import AppContext
+
+
+def moderation(
+    ctx: typer.Context,
+    inputs: list[str] = typer.Argument(..., help="One or more input strings to classify."),
+    model: str = typer.Option(..., "--model", "-m", help="Model id, e.g. 'openai:omni-moderation-latest'."),
+) -> None:
+    """Classify text and report the moderation results."""
+    app_ctx: AppContext = ctx.obj
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.moderation(model=model, input=inputs)
+    results = getattr(result, "results", None) or []
+    render_records(
+        list(results),
+        output_json=app_ctx.output_json,
+        title="Moderation",
+        empty_message="No moderation results returned.",
+    )

otari_cli/commands/pricing.py

@@ -0,0 +1,108 @@
+"""``otari pricing`` - manage per-model pricing (control plane).
+
+Requires an admin credential and a self-hosted/standalone gateway.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import typer
+from otari._client import SetPricingRequest
+
+from otari_cli import _client
+from otari_cli._errors import handle_errors
+from otari_cli._output import console, print_json, render_records
+from otari_cli._params import drop_none, parse_datetime
+
+if TYPE_CHECKING:
+    from otari_cli._context import AppContext
+
+app = typer.Typer(
+    name="pricing",
+    help="Manage per-model pricing (admin / self-hosted only).",
+    no_args_is_help=True,
+)
+
+
+@app.command("list")
+def list_pricing(
+    ctx: typer.Context,
+    skip: int | None = typer.Option(None, "--skip", help="Number of entries to skip."),
+    limit: int | None = typer.Option(None, "--limit", help="Maximum number of entries to return."),
+) -> None:
+    """List model pricing entries."""
+    app_ctx: AppContext = ctx.obj
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.control_plane.pricing.list(skip=skip, limit=limit)
+    render_records(
+        list(result),
+        output_json=app_ctx.output_json,
+        title="Pricing",
+        empty_message="No pricing entries found.",
+    )
+
+
+@app.command("get")
+def get_pricing(
+    ctx: typer.Context,
+    model_key: str = typer.Argument(..., help="Model identifier, e.g. 'openai:gpt-4o-mini'."),
+) -> None:
+    """Show the current pricing for a model."""
+    app_ctx: AppContext = ctx.obj
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.control_plane.pricing.get(model_key)
+    print_json(result)
+
+
+@app.command("set")
+def set_pricing(
+    ctx: typer.Context,
+    model_key: str = typer.Argument(..., help="Model identifier, e.g. 'openai:gpt-4o-mini'."),
+    input_price: float = typer.Option(..., "--input-price", help="Price per 1M input tokens."),
+    output_price: float = typer.Option(..., "--output-price", help="Price per 1M output tokens."),
+    effective_at: str | None = typer.Option(None, "--effective-at", help="When the price applies (ISO-8601)."),
+) -> None:
+    """Set the pricing for a model."""
+    app_ctx: AppContext = ctx.obj
+    request = SetPricingRequest(
+        model_key=model_key,
+        input_price_per_million=input_price,
+        output_price_per_million=output_price,
+        **drop_none(effective_at=parse_datetime(effective_at, flag="--effective-at")),
+    )
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.control_plane.pricing.set(request)
+    print_json(result)
+
+
+@app.command("history")
+def pricing_history(
+    ctx: typer.Context,
+    model_key: str = typer.Argument(..., help="Model identifier, e.g. 'openai:gpt-4o-mini'."),
+) -> None:
+    """Show the pricing history for a model."""
+    app_ctx: AppContext = ctx.obj
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.control_plane.pricing.get_history(model_key)
+    render_records(
+        list(result),
+        output_json=app_ctx.output_json,
+        title=f"Pricing history for {model_key}",
+        empty_message="No pricing history found.",
+    )
+
+
+@app.command("delete")
+def delete_pricing(
+    ctx: typer.Context,
+    model_key: str = typer.Argument(..., help="Model identifier to delete pricing for."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+) -> None:
+    """Delete the pricing for a model."""
+    app_ctx: AppContext = ctx.obj
+    if not yes:
+        typer.confirm(f"Delete pricing for {model_key!r}?", abort=True)
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        client.control_plane.pricing.delete(model_key)
+    console().print(f"[bold green]Deleted[/] pricing for {model_key!r}.")

otari_cli/commands/rerank.py

@@ -0,0 +1,33 @@
+"""``otari rerank`` - rerank documents by relevance to a query."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import typer
+
+from otari_cli import _client
+from otari_cli._errors import handle_errors
+from otari_cli._output import render_records
+
+if TYPE_CHECKING:
+    from otari_cli._context import AppContext
+
+
+def rerank(
+    ctx: typer.Context,
+    documents: list[str] = typer.Argument(..., help="Documents to rerank."),
+    model: str = typer.Option(..., "--model", "-m", help="Model id, e.g. 'cohere:rerank-v3.5'."),
+    query: str = typer.Option(..., "--query", "-q", help="The query to rank documents against."),
+) -> None:
+    """Rerank documents by relevance to the query."""
+    app_ctx: AppContext = ctx.obj
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        result = client.rerank(model=model, query=query, documents=documents)
+    results = getattr(result, "results", None) or []
+    render_records(
+        list(results),
+        output_json=app_ctx.output_json,
+        title="Rerank",
+        empty_message="No rerank results returned.",
+    )

otari_cli/commands/response.py

@@ -0,0 +1,74 @@
+"""``otari response`` - create a response via the OpenAI-style Responses API."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import typer
+
+from otari_cli import _client
+from otari_cli._errors import handle_errors
+from otari_cli._output import console, print_json
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from otari_cli._context import AppContext
+
+
+def response(
+    ctx: typer.Context,
+    text: str = typer.Argument(..., help="The input text to send to the model."),
+    model: str = typer.Option(..., "--model", "-m", help="Model id, e.g. 'openai:gpt-4o-mini'."),
+    stream: bool = typer.Option(False, "--stream", help="Stream the response as it is generated."),
+    temperature: float | None = typer.Option(None, "--temperature", help="Sampling temperature."),
+) -> None:
+    """Create a response and print the model output."""
+    app_ctx: AppContext = ctx.obj
+
+    kwargs: dict[str, Any] = {}
+    if temperature is not None:
+        kwargs["temperature"] = temperature
+
+    with handle_errors(), _client.session(app_ctx.config) as client:
+        if stream:
+            events = client.response(model=model, input=text, stream=True, **kwargs)
+            _render_stream(events, output_json=app_ctx.output_json)
+        else:
+            result = client.response(model=model, input=text, **kwargs)
+            _render_response(result, output_json=app_ctx.output_json)
+
+
+def _render_response(result: Any, *, output_json: bool) -> None:
+    if output_json:
+        print_json(result)
+        return
+    # The Responses API exposes an `output_text` convenience when available;
+    # otherwise fall back to the full JSON so nothing is silently dropped.
+    output_text = getattr(result, "output_text", None)
+    if isinstance(output_text, str) and output_text:
+        console().print(output_text)
+    else:
+        print_json(result)
+
+
+def _render_stream(events: Iterable[Any], *, output_json: bool) -> None:
+    for event in events:
+        if output_json:
+            print_json(event)
+            continue
+        delta = _event_text(event)
+        if delta:
+            console().print(delta, end="")
+    if not output_json:
+        console().print()
+
+
+def _event_text(event: Any) -> str:
+    # response.output_text.delta events carry {"delta": "..."}.
+    if not isinstance(event, dict):
+        return ""
+    if str(event.get("type", "")).endswith("output_text.delta"):
+        delta = event.get("delta", "")
+        return delta if isinstance(delta, str) else ""
+    return ""