minifmt 1.3.3__py3-none-any.whl

minifmt/__init__.py

@@ -0,0 +1,58 @@
+""".mini — forkable, token-efficient notation for LLM structured outputs.
+
+Public API
+----------
+>>> from minifmt import Registry, parse, dumps, roundtrip_ok
+>>> reg = Registry.load()             # discovers forks/*/contract.json
+>>> doc = parse(text, reg.get("a"))   # -> Document (canonical JSON via .to_canonical())
+>>> text2 = dumps(doc.to_canonical(), reg.get("a"))
+"""
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from .contract import Contract, Field
+from .errors import MiniError, MiniValidationError
+from .parser import Document, detect_prefix, parse
+from .prompt import parser_prompt, spec_block
+from .registry import Registry
+from .schema import from_json_schema, from_pydantic, to_json_schema
+from .serializer import dumps
+from .stream import Reader, ReaderResult, StreamRecord, create_reader, read_records
+from .values import scalar_equal
+
+__version__ = "1.3.3"
+SPEC_VERSION = "1.1"
+
+__all__ = ["Contract", "Field", "MiniError", "MiniValidationError", "Document", "parse",
+           "dumps", "detect_prefix", "Registry", "spec_block", "parser_prompt",
+           "canonical_equal", "roundtrip_ok", "Reader", "ReaderResult", "StreamRecord", "create_reader",
+           "read_records", "from_json_schema", "to_json_schema", "from_pydantic", "__version__", "SPEC_VERSION"]
+
+
+def canonical_equal(a: Any, b: Any) -> bool:
+    """Structural equality tolerant to int/float representation differences."""
+    if isinstance(a, dict) and isinstance(b, dict):
+        return a.keys() == b.keys() and all(canonical_equal(a[k], b[k]) for k in a)
+    if isinstance(a, list) and isinstance(b, list):
+        return len(a) == len(b) and all(canonical_equal(x, y) for x, y in zip(a, b))
+    return scalar_equal(a, b)
+
+
+def roundtrip_ok(obj: Dict[str, Any], contract: Contract) -> bool:
+    """obj -> .mini -> obj' must equal obj (and text -> obj -> text must be stable)."""
+    text = dumps(obj, contract)
+    back = parse(text, contract).to_canonical()
+    ref = {"prefix": contract.prefix, "header": dict(obj.get("header", {})),
+           contract.records_key: obj.get(contract.records_key, obj.get("records", []))}
+    ref["header"]["n"] = len(ref[contract.records_key])
+    ref["header"].setdefault("v", contract.header_keys["v"].default if "v" in contract.header_keys else 1)
+    # extension fields omitted in obj are None in back
+    for r in ref[contract.records_key]:
+        for f in contract.extensions:
+            if f.type == "mlist":
+                r.setdefault(f.json_items, None)
+                r.setdefault(f.json_selected, None)
+            else:
+                r.setdefault(f.name, None)
+    return canonical_equal(back, ref) and dumps(back, contract) == text

minifmt/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+import sys
+sys.exit(main())

minifmt/ai/__init__.py

@@ -0,0 +1,15 @@
+"""AI-facing helpers for .mini: selective repair and generation adapters.
+
+>>> from minifmt.ai import repair_request, merge_repair
+>>> req = repair_request(model_answer, contract, "es")
+>>> if req.needed:
+...     answer = adapter.generate(req.system, req.user, max_tokens=req.max_tokens_hint * 2, temperature=0)
+...     merged = merge_repair(model_answer, answer["text"], contract, req)
+"""
+from __future__ import annotations
+
+from .repair import (MergeResult, RepairItem, RepairRequest, extract_document, invalid_items, lenient_parse,
+                     merge_repair, repair_request)
+
+__all__ = ["repair_request", "merge_repair", "extract_document", "invalid_items", "lenient_parse",
+           "RepairRequest", "RepairItem", "MergeResult"]

minifmt/ai/adapters/__init__.py

@@ -0,0 +1,27 @@
+"""Generation adapters with a common interface (see :mod:`.base`)."""
+from __future__ import annotations
+
+from typing import Any
+
+from .anthropic_adapter import AnthropicAdapter
+from .base import Adapter, AdapterError, MissingKeyError, redact, redact_headers
+from .deepseek_adapter import DeepSeekAdapter
+from .groq_adapter import GroqAdapter
+from .openai_adapter import OpenAIAdapter
+from .simulated import DEFAULT_PROFILE, PROFILES, SimTarget, SimulatedAdapter
+
+ADAPTERS = {"openai": OpenAIAdapter, "anthropic": AnthropicAdapter, "groq": GroqAdapter,
+            "deepseek": DeepSeekAdapter, "simulado": SimulatedAdapter, "simulated": SimulatedAdapter}
+
+
+def get_adapter(provider: str, model: str, **options: Any) -> Adapter:
+    try:
+        cls = ADAPTERS[provider.lower()]
+    except KeyError:
+        raise AdapterError(f"unknown provider '{provider}' (known: {', '.join(sorted(ADAPTERS))})") from None
+    return cls(model, **options)
+
+
+__all__ = ["Adapter", "AdapterError", "MissingKeyError", "OpenAIAdapter", "AnthropicAdapter", "GroqAdapter",
+           "DeepSeekAdapter",
+           "SimulatedAdapter", "SimTarget", "DEFAULT_PROFILE", "PROFILES", "get_adapter", "redact", "redact_headers"]

minifmt/ai/adapters/anthropic_adapter.py

@@ -0,0 +1,72 @@
+"""Anthropic Messages API adapter over plain HTTPS (no SDK dependency).
+
+Endpoint ``POST https://api.anthropic.com/v1/messages`` with headers
+``x-api-key`` and ``anthropic-version: 2023-06-01``.  Structured output uses
+``output_config.format = {"type": "json_schema", "schema": ...}``.  Some
+recent models reject sampling parameters; set ``send_temperature=False`` for
+them in the experiment configuration.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .base import Adapter, AdapterError, api_key, result
+from .http import Transport, post_json
+
+ANTHROPIC_URL = "https://api.anthropic.com/v1/messages"
+ANTHROPIC_VERSION = "2023-06-01"
+
+
+class AnthropicAdapter(Adapter):
+    provider = "anthropic"
+    env_var = "ANTHROPIC_API_KEY"
+
+    def __init__(self, model: str, *, structured: bool = True, send_temperature: bool = True,
+                 transport: Optional[Transport] = None, timeout: float = 300.0, retries: int = 3,
+                 url: str = ANTHROPIC_URL, extra_body: Optional[Dict[str, Any]] = None, **options: Any):
+        super().__init__(model, **options)
+        self.supports_structured = structured
+        self.send_temperature = send_temperature
+        self.transport = transport
+        self.timeout = timeout
+        self.retries = retries
+        self.url = url
+        self.extra_body = dict(extra_body or {})
+
+    def build_payload(self, system: str, user: str, *, max_tokens: int, temperature: Optional[float],
+                      response_format: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "model": self.model,
+            "max_tokens": int(max_tokens),
+            "system": system,
+            "messages": [{"role": "user", "content": user}],
+        }
+        if temperature is not None and self.send_temperature:
+            payload["temperature"] = temperature
+        if response_format is not None:
+            if response_format.get("type") != "json_schema":
+                raise AdapterError(f"unsupported response_format type {response_format.get('type')}")
+            payload["output_config"] = {"format": {"type": "json_schema", "schema": response_format["schema"]}}
+        for k, v in self.extra_body.items():
+            if k == "output_config" and "output_config" in payload:
+                payload["output_config"] = {**v, **payload["output_config"]}
+            else:
+                payload[k] = v
+        return payload
+
+    def generate(self, system: str, user: str, *, max_tokens: int, temperature: Optional[float],
+                 response_format: Optional[Dict[str, Any]] = None, seed: Optional[int] = None) -> Dict[str, Any]:
+        self._check_format(response_format)  # the Messages API has no seed parameter
+        payload = self.build_payload(system, user, max_tokens=max_tokens, temperature=temperature,
+                                     response_format=response_format)
+        headers = {"x-api-key": api_key(self.env_var), "anthropic-version": ANTHROPIC_VERSION}
+        t0 = self._clock()
+        raw = post_json(self.url, headers, payload, timeout=self.timeout, retries=self.retries, transport=self.transport)
+        latency = (self._clock() - t0) * 1000
+        text = "".join(b.get("text", "") for b in raw.get("content", []) if b.get("type") == "text")
+        usage = raw.get("usage") or {}
+        inp = usage.get("input_tokens")
+        if inp is not None:
+            inp += int(usage.get("cache_creation_input_tokens") or 0) + int(usage.get("cache_read_input_tokens") or 0)
+        return result(text, inp, usage.get("output_tokens"), latency, raw, stop_reason=raw.get("stop_reason"),
+                      model=raw.get("model", self.model), provider=self.provider)

minifmt/ai/adapters/base.py

@@ -0,0 +1,107 @@
+"""Common interface of the generation adapters.
+
+Every adapter exposes::
+
+    generate(system, user, *, max_tokens, temperature, response_format=None, seed=None)
+        -> {"text", "input_tokens", "output_tokens", "latency_ms", "raw",
+            "stop_reason", "model", "provider"}
+
+``response_format`` is provider-neutral::
+
+    {"type": "json_schema", "name": "<name>", "schema": {...JSON Schema...}}
+
+and each adapter translates it to its provider's native structured-output
+mode.  Adapters whose provider/model does not support it declare
+``supports_structured = False``; callers must then skip the condition rather
+than silently falling back to unconstrained generation.
+
+API keys are read only from environment variables, are never returned,
+logged or written anywhere; :func:`redact` masks them (and any header that
+carries credentials) in every message that may reach a log.
+"""
+from __future__ import annotations
+
+import os
+import re
+import time
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Mapping, Optional
+
+KEY_ENV_VARS = ("OPENAI_API_KEY", "ANTHROPIC_API_KEY", "GROQ_API_KEY", "DEEPSEEK_API_KEY")
+SENSITIVE_HEADERS = {"authorization", "x-api-key", "api-key", "proxy-authorization", "cookie"}
+_KEY_PATTERNS = [
+    re.compile(r"sk-[A-Za-z0-9_\-]{8,}"),
+    re.compile(r"gsk_[A-Za-z0-9]{8,}"),
+    re.compile(r"(?i)(bearer\s+)[A-Za-z0-9_\-\.=]{8,}"),
+]
+
+
+class AdapterError(RuntimeError):
+    """Generation failed (network, HTTP status, malformed answer...). Message is redacted."""
+
+    def __init__(self, message: str, *, status: Optional[int] = None, retryable: bool = False):
+        super().__init__(redact(message))
+        self.status = status
+        self.retryable = retryable
+
+
+class MissingKeyError(AdapterError):
+    pass
+
+
+def redact(text: Any) -> str:
+    """Mask API keys and credential-looking substrings in ``text``."""
+    s = str(text)
+    for var in KEY_ENV_VARS:
+        val = os.environ.get(var)
+        if val and len(val) >= 6:
+            s = s.replace(val, "***")
+    for pat in _KEY_PATTERNS:
+        s = pat.sub(lambda m: (m.group(1) if m.groups() else "") + "***", s)
+    return s
+
+
+def redact_headers(headers: Mapping[str, str]) -> Dict[str, str]:
+    """Copy of ``headers`` safe to log (credential headers replaced by ***)."""
+    return {k: ("***" if k.lower() in SENSITIVE_HEADERS else redact(v)) for k, v in headers.items()}
+
+
+def api_key(env_var: str) -> str:
+    """Read an API key from the environment; raises without revealing anything."""
+    val = os.environ.get(env_var, "").strip()
+    if not val:
+        raise MissingKeyError(f"environment variable {env_var} is not set")
+    return val
+
+
+def result(text: str, input_tokens: Optional[int], output_tokens: Optional[int], latency_ms: float,
+           raw: Any, *, stop_reason: Optional[str] = None, model: str = "", provider: str = "") -> Dict[str, Any]:
+    return {"text": text or "", "input_tokens": input_tokens, "output_tokens": output_tokens,
+            "latency_ms": round(float(latency_ms), 1), "raw": raw, "stop_reason": stop_reason,
+            "model": model, "provider": provider}
+
+
+class Adapter(ABC):
+    provider: str = "base"
+    supports_structured: bool = False
+
+    def __init__(self, model: str, **options: Any):
+        self.model = model
+        self.options = options
+
+    @abstractmethod
+    def generate(self, system: str, user: str, *, max_tokens: int, temperature: Optional[float],
+                 response_format: Optional[Dict[str, Any]] = None, seed: Optional[int] = None) -> Dict[str, Any]:
+        """Run one generation and return the common result dict."""
+
+    # helpers ---------------------------------------------------------------
+    @staticmethod
+    def _clock() -> float:
+        return time.perf_counter()
+
+    def _check_format(self, response_format: Optional[Dict[str, Any]]) -> None:
+        if response_format is not None and not self.supports_structured:
+            raise AdapterError(f"{self.provider}:{self.model} does not support structured output")
+
+    def __repr__(self) -> str:  # never includes credentials
+        return f"<{type(self).__name__} {self.provider}:{self.model}>"

minifmt/ai/adapters/deepseek_adapter.py

@@ -0,0 +1,29 @@
+"""DeepSeek adapter over plain HTTPS (OpenAI-compatible Chat Completions endpoint).
+
+DeepSeek publishes the OpenAI Chat Completions API, so the transport of
+:class:`~minifmt.ai.adapters.groq_adapter.GroqAdapter` is reused; only the
+endpoint, the key and the output-limit field differ (``max_tokens`` instead of
+``max_completion_tokens``).
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .groq_adapter import GroqAdapter
+
+DEEPSEEK_URL = "https://api.deepseek.com/chat/completions"
+
+
+class DeepSeekAdapter(GroqAdapter):
+    provider = "deepseek"
+    env_var = "DEEPSEEK_API_KEY"
+
+    def __init__(self, model: str, *, url: str = DEEPSEEK_URL, **options: Any):
+        super().__init__(model, url=url, **options)
+
+    def build_payload(self, system: str, user: str, *, max_tokens: int, temperature: Optional[float],
+                      response_format: Optional[Dict[str, Any]], seed: Optional[int]) -> Dict[str, Any]:
+        payload = super().build_payload(system, user, max_tokens=max_tokens, temperature=temperature,
+                                        response_format=response_format, seed=seed)
+        payload["max_tokens"] = payload.pop("max_completion_tokens")
+        return payload

minifmt/ai/adapters/groq_adapter.py

@@ -0,0 +1,63 @@
+"""Groq adapter over plain HTTPS (OpenAI-compatible Chat Completions endpoint).
+
+Structured output (``response_format`` JSON schema) is available only on some
+Groq-hosted models; declare it per model with ``structured=True``.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .base import Adapter, api_key, result
+from .http import Transport, post_json
+from .openai_adapter import to_openai_format
+
+GROQ_URL = "https://api.groq.com/openai/v1/chat/completions"
+
+
+class GroqAdapter(Adapter):
+    provider = "groq"
+    env_var = "GROQ_API_KEY"
+
+    def __init__(self, model: str, *, structured: bool = False, send_temperature: bool = True,
+                 transport: Optional[Transport] = None, timeout: float = 120.0, retries: int = 3,
+                 url: str = GROQ_URL, extra_body: Optional[Dict[str, Any]] = None, **options: Any):
+        super().__init__(model, **options)
+        self.supports_structured = structured
+        self.send_temperature = send_temperature
+        self.transport = transport
+        self.timeout = timeout
+        self.retries = retries
+        self.url = url
+        self.extra_body = dict(extra_body or {})
+
+    def build_payload(self, system: str, user: str, *, max_tokens: int, temperature: Optional[float],
+                      response_format: Optional[Dict[str, Any]], seed: Optional[int]) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "model": self.model,
+            "messages": [{"role": "system", "content": system}, {"role": "user", "content": user}],
+            "max_completion_tokens": int(max_tokens),
+        }
+        if temperature is not None and self.send_temperature:
+            payload["temperature"] = temperature
+        if seed is not None:
+            payload["seed"] = int(seed) % (2 ** 31)
+        rf = to_openai_format(response_format)
+        if rf is not None:
+            payload["response_format"] = rf
+        payload.update(self.extra_body)
+        return payload
+
+    def generate(self, system: str, user: str, *, max_tokens: int, temperature: Optional[float],
+                 response_format: Optional[Dict[str, Any]] = None, seed: Optional[int] = None) -> Dict[str, Any]:
+        self._check_format(response_format)
+        payload = self.build_payload(system, user, max_tokens=max_tokens, temperature=temperature,
+                                     response_format=response_format, seed=seed)
+        headers = {"authorization": "Bearer " + api_key(self.env_var)}
+        t0 = self._clock()
+        raw = post_json(self.url, headers, payload, timeout=self.timeout, retries=self.retries, transport=self.transport)
+        latency = (self._clock() - t0) * 1000
+        choice = (raw.get("choices") or [{}])[0]
+        text = (choice.get("message") or {}).get("content") or ""
+        usage = raw.get("usage") or {}
+        return result(text, usage.get("prompt_tokens"), usage.get("completion_tokens"), latency, raw,
+                      stop_reason=choice.get("finish_reason"), model=raw.get("model", self.model), provider=self.provider)

minifmt/ai/adapters/http.py

@@ -0,0 +1,80 @@
+"""Minimal JSON-over-HTTPS client: httpx when installed, urllib otherwise.
+
+A ``transport`` callable can be injected for tests; it receives
+``(url, headers, body_bytes, timeout)`` and returns ``(status, body_bytes)``.
+Nothing here logs request headers; errors are redacted.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import random
+import time
+from typing import Any, Callable, Dict, Mapping, Optional, Tuple
+
+from .base import AdapterError, redact, redact_headers
+
+log = logging.getLogger("minifmt.ai.http")
+
+Transport = Callable[[str, Mapping[str, str], bytes, float], Tuple[int, bytes]]
+RETRYABLE = {408, 409, 429, 500, 502, 503, 504, 529}
+USER_AGENT = "mini-format/1.2.0 (+https://mini-format.pmoluna.com)"
+
+
+def _httpx_transport(url: str, headers: Mapping[str, str], body: bytes, timeout: float) -> Tuple[int, bytes]:
+    import httpx  # type: ignore
+    r = httpx.post(url, headers=dict(headers), content=body, timeout=timeout)
+    return r.status_code, r.content
+
+
+def _urllib_transport(url: str, headers: Mapping[str, str], body: bytes, timeout: float) -> Tuple[int, bytes]:
+    import urllib.error
+    import urllib.request
+    req = urllib.request.Request(url, data=body, headers=dict(headers), method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:  # noqa: S310 - fixed https endpoints
+            return resp.status, resp.read()
+    except urllib.error.HTTPError as e:
+        return e.code, e.read()
+
+
+def default_transport() -> Transport:
+    try:
+        import httpx  # noqa: F401
+        return _httpx_transport
+    except ImportError:
+        return _urllib_transport
+
+
+def post_json(url: str, headers: Mapping[str, str], payload: Dict[str, Any], *, timeout: float = 120.0,
+              retries: int = 3, transport: Optional[Transport] = None,
+              sleep: Callable[[float], None] = time.sleep) -> Dict[str, Any]:
+    """POST ``payload`` as JSON; retries retryable statuses with jittered backoff."""
+    tp = transport or default_transport()
+    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    # Sin user-agent algunos proveedores (Cloudflare) rechazan la petición con 403/1010.
+    hdrs = {"content-type": "application/json", "user-agent": USER_AGENT,
+            "accept": "application/json", **headers}
+    last: Optional[AdapterError] = None
+    for attempt in range(retries + 1):
+        try:
+            status, raw = tp(url, hdrs, body, timeout)
+        except Exception as e:  # noqa: BLE001 - network errors of either backend
+            last = AdapterError(f"network error calling {url}: {type(e).__name__}: {e}", retryable=True)
+        else:
+            if 200 <= status < 300:
+                try:
+                    return json.loads(raw.decode("utf-8"))
+                except ValueError as e:
+                    raise AdapterError(f"non-JSON answer from {url}: {e}") from None
+            snippet = raw[:500].decode("utf-8", "replace")
+            last = AdapterError(f"HTTP {status} from {url}: {snippet}", status=status, retryable=status in RETRYABLE)
+            if not last.retryable:
+                raise last
+        if attempt < retries:
+            delay = min(30.0, (2 ** attempt) + random.random())
+            log.warning("retrying %s in %.1fs (%s; headers=%s)", url, delay, redact(last),
+                        redact_headers(hdrs))
+            sleep(delay)
+    assert last is not None
+    raise last

minifmt/ai/adapters/openai_adapter.py

@@ -0,0 +1,79 @@
+"""OpenAI Chat Completions adapter (uses the installed ``openai`` package)."""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .base import Adapter, AdapterError, api_key, result
+
+
+def to_openai_format(response_format: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    """Neutral response_format -> OpenAI ``response_format`` (strict JSON schema)."""
+    if response_format is None:
+        return None
+    if response_format.get("type") != "json_schema":
+        raise AdapterError(f"unsupported response_format type {response_format.get('type')}")
+    return {"type": "json_schema",
+            "json_schema": {"name": response_format.get("name", "salida"), "strict": True,
+                            "schema": response_format["schema"]}}
+
+
+class OpenAIAdapter(Adapter):
+    provider = "openai"
+    env_var = "OPENAI_API_KEY"
+
+    def __init__(self, model: str, *, structured: bool = True, client: Any = None, send_temperature: bool = True,
+                 timeout: float = 120.0, max_retries: int = 3, extra_body: Optional[Dict[str, Any]] = None, **options: Any):
+        super().__init__(model, **options)
+        self.supports_structured = structured
+        self.send_temperature = send_temperature
+        self.extra_body = dict(extra_body or {})
+        self._client = client
+        self._timeout = timeout
+        self._max_retries = max_retries
+
+    @property
+    def client(self) -> Any:
+        if self._client is None:
+            from openai import OpenAI  # installed dependency of the experiment
+            self._client = OpenAI(api_key=api_key(self.env_var), timeout=self._timeout, max_retries=self._max_retries)
+        return self._client
+
+    def build_params(self, system: str, user: str, *, max_tokens: int, temperature: Optional[float],
+                     response_format: Optional[Dict[str, Any]], seed: Optional[int]) -> Dict[str, Any]:
+        params: Dict[str, Any] = {
+            "model": self.model,
+            "messages": [{"role": "system", "content": system}, {"role": "user", "content": user}],
+            "max_completion_tokens": int(max_tokens),
+        }
+        if temperature is not None and self.send_temperature:
+            params["temperature"] = temperature
+        if seed is not None:
+            params["seed"] = int(seed) % (2 ** 31)
+        rf = to_openai_format(response_format)
+        if rf is not None:
+            params["response_format"] = rf
+        params.update(self.extra_body)
+        return params
+
+    def generate(self, system: str, user: str, *, max_tokens: int, temperature: Optional[float],
+                 response_format: Optional[Dict[str, Any]] = None, seed: Optional[int] = None) -> Dict[str, Any]:
+        self._check_format(response_format)
+        params = self.build_params(system, user, max_tokens=max_tokens, temperature=temperature,
+                                   response_format=response_format, seed=seed)
+        t0 = self._clock()
+        try:
+            resp = self.client.chat.completions.create(**params)
+        except AdapterError:
+            raise
+        except Exception as e:  # noqa: BLE001 - openai.* exceptions
+            status = getattr(e, "status_code", None)
+            raise AdapterError(f"OpenAI error: {type(e).__name__}: {e}", status=status,
+                               retryable=status in (408, 429, 500, 502, 503, 504)) from None
+        latency = (self._clock() - t0) * 1000
+        raw = resp.model_dump() if hasattr(resp, "model_dump") else resp
+        choice = raw["choices"][0]
+        msg = choice.get("message") or {}
+        text = msg.get("content") or msg.get("refusal") or ""
+        usage = raw.get("usage") or {}
+        return result(text, usage.get("prompt_tokens"), usage.get("completion_tokens"), latency, raw,
+                      stop_reason=choice.get("finish_reason"), model=raw.get("model", self.model), provider=self.provider)