llm-dev-core 0.3.0__py3-none-any.whl

llm_client/__init__.py

@@ -0,0 +1,18 @@
+from .cache import ResponseCache
+from .client import CostCapExceeded, LlmClient, StreamInterrupted
+from .models import CompletionRequest, CompletionResult, TokenUsage, ValidationResult
+from .replay import ReplayProvider
+from .span import Span
+
+__all__ = [
+    "CostCapExceeded",
+    "LlmClient",
+    "ReplayProvider",
+    "ResponseCache",
+    "CompletionRequest",
+    "CompletionResult",
+    "TokenUsage",
+    "ValidationResult",
+    "Span",
+    "StreamInterrupted",
+]

llm_client/cache.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+from .models import CompletionRequest, CompletionResult
+
+
+def cache_key(request: CompletionRequest, prompt_version: str) -> str:
+    payload = {
+        "prompt_id": request.prompt_id,
+        "prompt_version": prompt_version,
+        "model_alias": request.model_alias,
+        "variables": request.variables,
+    }
+    raw = json.dumps(payload, sort_keys=True, default=str)
+    return hashlib.sha256(raw.encode()).hexdigest()
+
+
+class ResponseCache:
+    def __init__(self, path: str | Path | None = None) -> None:
+        self._store: dict[str, CompletionResult] = {}
+        self._path = Path(path) if path else None
+        if self._path and self._path.is_file():
+            self._load()
+
+    def _load(self) -> None:
+        for line in self._path.read_text().splitlines():
+            if not line.strip():
+                continue
+            data = json.loads(line)
+            self._store[data["key"]] = CompletionResult.model_validate(data["result"])
+
+    def get(self, key: str) -> CompletionResult | None:
+        return self._store.get(key)
+
+    def put(self, key: str, result: CompletionResult) -> None:
+        self._store[key] = result
+        if self._path:
+            self._path.parent.mkdir(parents=True, exist_ok=True)
+            with self._path.open("a") as handle:
+                entry = json.dumps({"key": key, "result": result.model_dump()}, default=str)
+                handle.write(entry + "\n")

llm_client/client.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+import json
+import random
+import time
+from decimal import Decimal
+from typing import Any, Callable
+
+from .cache import ResponseCache, cache_key
+from .models import CompletionRequest, CompletionResult, ValidationResult
+from .pricing import cost_usd, resolve_model
+from .provider import Provider, ProviderRequest
+from .span import Span
+
+Validator = Callable[[str, str | None], ValidationResult]
+Renderer = Callable[[str, str, dict[str, Any]], list[dict]]
+Emitter = Callable[[Span, CompletionResult | None], None]
+
+
+class CostCapExceeded(Exception):
+    def __init__(self, cost: Decimal, cap: Decimal, span_id: str) -> None:
+        super().__init__(f"cost {cost} usd > cap {cap} usd")
+        self.cost = cost
+        self.cap = cap
+        self.span_id = span_id
+
+
+class StreamInterrupted(Exception):
+    def __init__(self, partial_text: str) -> None:
+        super().__init__("stream interrumpido tras entregar texto")
+        self.partial_text = partial_text
+
+
+def _noop_emitter(_span: Span, _result: CompletionResult | None) -> None:
+    return None
+
+
+class LlmClient:
+    def __init__(
+        self,
+        provider: Provider,
+        *,
+        consumer_repo: str = "",
+        model_aliases: dict[str, str] | None = None,
+        retries: int = 3,
+        repair_cap: int = 2,
+        retry_base_ms: int = 300,
+        retry_jitter_ms: int = 150,
+        cache: ResponseCache | None = None,
+        emitter: Emitter | None = None,
+        cost_cap_usd: Decimal | None = None,
+        cost_fn: Callable[[str, int | None, int | None], Decimal] = cost_usd,
+        validator: Validator | None = None,
+        renderer: Renderer | None = None,
+    ) -> None:
+        self.provider = provider
+        self.consumer_repo = consumer_repo
+        self.model_aliases = model_aliases
+        self.retries = retries
+        self.repair_cap = repair_cap
+        self.retry_base_ms = retry_base_ms
+        self.retry_jitter_ms = retry_jitter_ms
+        self.cache = cache
+        self.emitter = emitter or _noop_emitter
+        self.cost_cap_usd = cost_cap_usd
+        self.cost_fn = cost_fn
+        self.validator = validator or (lambda _text, _schema: ValidationResult(ok=True))
+        self.renderer = renderer or self._default_renderer
+
+    @staticmethod
+    def _default_renderer(prompt_id: str, prompt_version: str, variables: dict[str, Any]) -> list[dict]:
+        body = {"prompt_id": prompt_id, "prompt_version": prompt_version, "variables": variables}
+        return [{"role": "user", "content": json.dumps(body, ensure_ascii=False)}]
+
+    def _render(self, request: CompletionRequest, prompt_version: str, errors: list[str] | None = None) -> list[dict]:
+        messages = self.renderer(request.prompt_id, prompt_version, request.variables)
+        if errors:
+            messages.append({"role": "assistant", "content": json.dumps({"validation_errors": errors})})
+            messages.append({"role": "user", "content": "Corrige siguiendo el schema."})
+        return messages
+
+    def complete(self, request: CompletionRequest) -> CompletionResult:
+        return self._execute(request, stream=False)
+
+    def stream(self, request: CompletionRequest) -> CompletionResult:
+        return self._execute(request, stream=True)
+
+    @staticmethod
+    def _collect_stream(stream) -> tuple[str, None]:
+        parts: list[str] = []
+        try:
+            for chunk in stream:
+                parts.append(chunk)
+        except Exception as exc:
+            raise StreamInterrupted("".join(parts)) from exc
+        return "".join(parts), None
+
+    def _execute(self, request: CompletionRequest, stream: bool) -> CompletionResult:
+        start = time.perf_counter()
+        prompt_version = request.prompt_version or "0.0.0"
+        model = resolve_model(request.model_alias, self.model_aliases)
+        span = Span(
+            consumer_repo=self.consumer_repo,
+            prompt_id=request.prompt_id,
+            prompt_version=prompt_version,
+            model_alias=request.model_alias,
+            model=model,
+            provider=self.provider.name,
+        )
+
+        if self.cache is not None:
+            key = cache_key(request, prompt_version)
+            hit = self.cache.get(key)
+            if hit is not None:
+                span.cache_hit = True
+                span.call_skipped = True
+                span.status = "skipped"
+                span.latency_ms = 0
+                self.emitter(span, hit)
+                return hit
+
+        attempts = 0
+        repaired = 0
+        last_error: Exception | None = None
+        earlier_attempt_had_text = False
+        final_path = "validation_failed"
+        final_validation: ValidationResult | None = None
+        final_text = ""
+        final_cost = Decimal("0")
+        final_usage = None
+
+        while True:
+            attempts += 1
+            if attempts > 1 + self.retries + self.repair_cap:
+                break
+
+            errors = final_validation.errors if final_validation is not None and not final_validation.ok else None
+            messages = self._render(request, prompt_version, errors)
+            provider_request = ProviderRequest(
+                model=model,
+                messages=messages,
+                temperature=request.temperature,
+                max_tokens=request.max_tokens,
+            )
+
+            try:
+                if stream:
+                    text, usage = self._collect_stream(self.provider.stream(provider_request))
+                else:
+                    response = self.provider.complete(provider_request)
+                    text, usage = response.text, response.usage
+            except Exception as exc:
+                if isinstance(exc, StreamInterrupted) and exc.partial_text.strip():
+                    earlier_attempt_had_text = True
+                last_error = exc
+                if attempts > 1 + self.retries:
+                    break
+                wait = self.retry_base_ms * (2 ** (attempts - 1)) + random.uniform(0, self.retry_jitter_ms)
+                time.sleep(wait / 1000)
+                continue
+
+            had_text = bool(text.strip())
+            validation = self.validator(text, request.response_schema)
+
+            if validation.ok:
+                span.latency_ms = int((time.perf_counter() - start) * 1000)
+                span.tokens_input = usage.input_tokens if usage else None
+                span.tokens_output = usage.output_tokens if usage else None
+                span.cost_usd = self.cost_fn(model, span.tokens_input, span.tokens_output)
+                span.retry_count = attempts - 1
+                span.repaired_attempts = repaired
+                span.status = "repaired" if repaired else "ok"
+                span.retry_unnecessary = attempts > 1 and earlier_attempt_had_text
+                if (
+                    span.cost_usd is not None
+                    and self.cost_cap_usd is not None
+                    and span.cost_usd > self.cost_cap_usd
+                ):
+                    span.status = "blocked"
+                    span.error_type = "cost_cap_exceeded"
+                    self.emitter(span, None)
+                    raise CostCapExceeded(span.cost_usd, self.cost_cap_usd, span.span_id)
+                result = self._build_result(request, prompt_version, model, span, text, validation, usage)
+                if self.cache is not None:
+                    self.cache.put(key, result)
+                self.emitter(span, result)
+                return result
+
+            earlier_attempt_had_text = earlier_attempt_had_text or had_text
+
+            if repaired < self.repair_cap:
+                repaired += 1
+                final_validation = validation
+                continue
+
+            final_path = "validation_failed"
+            final_validation = validation
+            final_text = text
+            final_usage = usage
+            final_cost = self.cost_fn(model, usage.input_tokens if usage else None, usage.output_tokens if usage else None)
+            break
+
+        span.latency_ms = int((time.perf_counter() - start) * 1000)
+        span.retry_count = attempts - 1
+        span.repaired_attempts = repaired
+        span.cost_usd = final_cost
+        span.tokens_input = final_usage.input_tokens if final_usage else None
+        span.tokens_output = final_usage.output_tokens if final_usage else None
+        span.status = "failed"
+        span.error_type = type(last_error).__name__ if last_error is not None else "validation"
+        result = self._build_result(
+            request,
+            prompt_version,
+            model,
+            span,
+            final_text,
+            final_validation or ValidationResult(ok=False, errors=["sin respuesta"]),
+            final_usage,
+        )
+        self.emitter(span, result)
+        return result
+
+    def _build_result(
+        self,
+        request: CompletionRequest,
+        prompt_version: str,
+        model: str,
+        span: Span,
+        text: str,
+        validation: ValidationResult,
+        usage: Any,
+    ) -> CompletionResult:
+        return CompletionResult(
+            raw_text=text,
+            parsed=getattr(validation, "parsed", None),
+            validation=validation,
+            usage=usage,
+            cost_usd=span.cost_usd or Decimal("0"),
+            latency_ms=span.latency_ms or 0,
+            prompt_id=request.prompt_id,
+            prompt_version=prompt_version,
+            model_alias=request.model_alias,
+            model=model,
+            provider=self.provider.name,
+            span_id=span.span_id,
+        )

llm_client/models.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class TokenUsage(BaseModel):
+    input_tokens: int
+    output_tokens: int
+
+
+class ValidationResult(BaseModel):
+    ok: bool
+    errors: list[str] = Field(default_factory=list)
+    parsed: Any = None
+
+
+class CompletionRequest(BaseModel):
+    prompt_id: str
+    variables: dict[str, Any] = Field(default_factory=dict)
+    model_alias: str
+    prompt_version: str | None = None
+    response_schema: str | None = None
+    temperature: float | None = None
+    max_tokens: int | None = None
+    tags: list[str] = Field(default_factory=list)
+
+
+class CompletionResult(BaseModel):
+    raw_text: str
+    parsed: Any = None
+    validation: ValidationResult
+    usage: TokenUsage | None = None
+    cost_usd: Decimal
+    latency_ms: int
+    prompt_id: str
+    prompt_version: str
+    model_alias: str
+    model: str
+    provider: str
+    span_id: str

llm_client/pricing.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from decimal import Decimal
+
+MODEL_PRICES_USD_PER_1K: dict[str, tuple[float, float]] = {
+    "big-pickle": (0.0, 0.0),
+}
+
+DEFAULT_ALIASES: dict[str, str] = {"fast": "big-pickle"}
+
+
+def resolve_model(model_alias: str, aliases: dict[str, str] | None = None) -> str:
+    table = DEFAULT_ALIASES if aliases is None else aliases
+    return table.get(model_alias, model_alias)
+
+
+def cost_usd(model: str, input_tokens: int | None, output_tokens: int | None) -> Decimal:
+    if input_tokens is None or output_tokens is None:
+        return Decimal("0")
+    in_price, out_price = MODEL_PRICES_USD_PER_1K.get(model, (0.0, 0.0))
+    value = input_tokens / 1000 * in_price + output_tokens / 1000 * out_price
+    return Decimal(str(round(value, 6)))

llm_client/provider.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Iterator, Protocol
+
+from pydantic import BaseModel, Field
+
+from .models import TokenUsage
+
+
+class ProviderRequest(BaseModel):
+    model: str
+    messages: list[dict] = Field(default_factory=list)
+    temperature: float | None = None
+    max_tokens: int | None = None
+
+
+class ProviderResponse(BaseModel):
+    text: str
+    model: str
+    usage: TokenUsage | None = None
+
+
+class Provider(Protocol):
+    name: str
+
+    def complete(self, request: ProviderRequest) -> ProviderResponse: ...
+
+    def stream(self, request: ProviderRequest) -> Iterator[str]: ...

llm_client/providers/__init__.py

@@ -0,0 +1,4 @@
+from .openai_compat import OpenAICompatible
+from .opencode_cli import OpenCodeCLI
+
+__all__ = ["OpenAICompatible", "OpenCodeCLI"]

llm_client/providers/openai_compat.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import Iterator
+
+import httpx
+
+from ..models import TokenUsage
+from ..provider import ProviderRequest, ProviderResponse
+
+
+class OpenAICompatible:
+    name = "openai-compatible"
+
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        api_key: str | None = None,
+        model: str = "gpt-4o-mini",
+        client: httpx.Client | None = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+        self._client = client or httpx.Client(timeout=60)
+
+    def _headers(self) -> dict:
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+    def _payload(self, request: ProviderRequest, stream: bool) -> dict:
+        payload = {
+            "model": request.model or self.model,
+            "messages": request.messages,
+            "stream": stream,
+        }
+        if request.temperature is not None:
+            payload["temperature"] = request.temperature
+        if request.max_tokens is not None:
+            payload["max_tokens"] = request.max_tokens
+        return payload
+
+    def complete(self, request: ProviderRequest) -> ProviderResponse:
+        response = self._client.post(
+            f"{self.base_url}/chat/completions",
+            headers=self._headers(),
+            json=self._payload(request, stream=False),
+        )
+        response.raise_for_status()
+        data = response.json()
+        text = data["choices"][0]["message"]["content"] or ""
+        usage = data.get("usage")
+        tokens = (
+            TokenUsage(
+                input_tokens=usage["prompt_tokens"],
+                output_tokens=usage["completion_tokens"],
+            )
+            if usage
+            else None
+        )
+        return ProviderResponse(
+            text=text,
+            model=data.get("model", request.model),
+            usage=tokens,
+        )
+
+    def stream(self, request: ProviderRequest) -> Iterator[str]:
+        with self._client.stream(
+            "POST",
+            f"{self.base_url}/chat/completions",
+            headers=self._headers(),
+            json=self._payload(request, stream=True),
+        ) as response:
+            response.raise_for_status()
+            for line in response.iter_lines():
+                if not line or not line.startswith("data: "):
+                    continue
+                chunk = line[6:]
+                if chunk == "[DONE]":
+                    break
+                data = __import__("json").loads(chunk)
+                delta = data["choices"][0]["delta"].get("content")
+                if delta:
+                    yield delta

llm_client/providers/opencode_cli.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import json
+import subprocess
+from typing import Iterator
+
+from ..models import TokenUsage
+from ..provider import ProviderRequest, ProviderResponse
+
+
+class OpenCodeCLI:
+    name = "opencode"
+
+    def __init__(self, model: str, *, cwd: str | None = None, binary: str = "opencode") -> None:
+        self.model = model
+        self.cwd = cwd
+        self.binary = binary
+
+    @staticmethod
+    def _render_prompt(request: ProviderRequest) -> str:
+        return "\n\n".join(f"{m['role']}:\n{m['content']}" for m in request.messages)
+
+    def _spawn(self, prompt: str) -> subprocess.Popen:
+        cmd = [self.binary, "run", "--format", "json", "--model", self.model, prompt]
+        return subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            cwd=self.cwd,
+        )
+
+    @staticmethod
+    def _parse(line: str) -> tuple[str, int | None, str | None]:
+        try:
+            event = json.loads(line)
+        except (json.JSONDecodeError, TypeError):
+            return "", None, None
+        event_type = event.get("type")
+        part = event.get("part") or {}
+        if part.get("type") == "text":
+            return part.get("text", ""), None, None
+        if event_type in ("step-finish", "step_finish"):
+            tokens = part.get("tokens") or {}
+            input_tokens = tokens.get("input")
+            output_tokens = tokens.get("output")
+            if input_tokens is not None and output_tokens is not None:
+                usage = {"input": input_tokens, "output": output_tokens}
+                return "", usage, part.get("cost")
+        return "", None, None
+
+    def complete(self, request: ProviderRequest) -> ProviderResponse:
+        proc = self._spawn(self._render_prompt(request))
+        text_parts: list[str] = []
+        usage: TokenUsage | None = None
+        for line in iter(proc.stdout.readline, ""):
+            current, usage_data, _ = self._parse(line)
+            if current:
+                text_parts.append(current)
+            if usage_data:
+                usage = TokenUsage(input_tokens=usage_data["input"], output_tokens=usage_data["output"])
+        proc.wait()
+        return ProviderResponse(text="".join(text_parts), model=self.model, usage=usage)
+
+    def stream(self, request: ProviderRequest) -> Iterator[str]:
+        proc = self._spawn(self._render_prompt(request))
+        try:
+            for line in proc.stdout:
+                current, _, _ = self._parse(line)
+                if current:
+                    yield current
+        finally:
+            proc.wait()

llm_client/replay.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .provider import Provider, ProviderRequest, ProviderResponse
+
+
+class ReplayProvider:
+    name = "replay"
+
+    def __init__(
+        self,
+        cassette_dir: str | Path,
+        *,
+        record: bool = False,
+        inner: Provider | None = None,
+    ) -> None:
+        self.dir = Path(cassette_dir)
+        self.dir.mkdir(parents=True, exist_ok=True)
+        self.record = record
+        self.inner = inner
+
+    def _cassette(self, request: ProviderRequest, stream: bool) -> Path:
+        safe_model = request.model.replace("/", "--")
+        slug = f"{'stream' if stream else 'complete'}-{safe_model}-{len(request.messages)}"
+        return self.dir / f"{slug}.jsonl"
+
+    def complete(self, request: ProviderRequest) -> ProviderResponse:
+        if not self.record:
+            entry = self._read(self._cassette(request, stream=False), request)
+            return ProviderResponse.model_validate(entry["response"])
+        if self.inner is None:
+            raise RuntimeError("ReplayProvider en modo record requiere inner")
+        response = self.inner.complete(request)
+        self._append(self._cassette(request, stream=False), request, response)
+        return response
+
+    def stream(self, request: ProviderRequest) -> list[str]:
+        if not self.record:
+            entry = self._read(self._cassette(request, stream=True), request)
+            return list(entry["chunks"])
+        if self.inner is None:
+            raise RuntimeError("ReplayProvider en modo record requiere inner")
+        chunks = list(self.inner.stream(request))
+        self._append_chunks(self._cassette(request, stream=True), request, chunks)
+        return chunks
+
+    def _read(self, path: Path, request: ProviderRequest) -> dict:
+        if not path.is_file():
+            raise FileNotFoundError(f"cassette no encontrado: {path}")
+        for line in path.read_text().splitlines():
+            if not line.strip():
+                continue
+            entry = json.loads(line)
+            if entry["request"] == request.messages and entry.get("model") == request.model:
+                return entry
+        raise KeyError(f"cassette sin entrada para el request: {path}")
+
+    def _append(self, path: Path, request: ProviderRequest, response: ProviderResponse) -> None:
+        with path.open("a") as handle:
+            entry = {"model": request.model, "request": request.messages, "response": response.model_dump()}
+            handle.write(json.dumps(entry, default=str) + "\n")
+
+    def _append_chunks(self, path: Path, request: ProviderRequest, chunks: list[str]) -> None:
+        with path.open("a") as handle:
+            entry = {"model": request.model, "request": request.messages, "chunks": chunks}
+            handle.write(json.dumps(entry, default=str) + "\n")

llm_client/span.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from datetime import datetime
+from decimal import Decimal
+from uuid import uuid4
+
+from pydantic import BaseModel, Field
+
+
+class Span(BaseModel):
+    span_id: str = Field(default_factory=lambda: uuid4().hex)
+    trace_id: str = Field(default_factory=lambda: uuid4().hex)
+    consumer_repo: str
+    prompt_id: str
+    prompt_version: str
+    model_alias: str
+    model: str
+    provider: str
+    tokens_input: int | None = None
+    tokens_output: int | None = None
+    latency_ms: int | None = None
+    cost_usd: Decimal | None = None
+    retry_count: int = 0
+    cache_hit: bool = False
+    status: str = "ok"
+    call_skipped: bool = False
+    retry_unnecessary: bool = False
+    error_type: str | None = None
+    repaired_attempts: int = 0
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+    def as_jsonl(self) -> str:
+        return self.model_dump_json()

llm_dev_core-0.3.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.5
+Name: llm-dev-core
+Version: 0.3.0
+Summary: Núcleo versionado del que dependen 52 proyectos en 52 semanas: un solo sistema acumulativo.
+Author-email: binahco <binahco.sas@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pyyaml<7,>=6.0

llm_dev_core-0.3.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+llm_client/__init__.py,sha256=ZjQwe1sJ_x0xmcBQ3656NZuF7SVwBApJNr3rn5hndxU,468
+llm_client/cache.py,sha256=D6pMfz6gnDV4_laSfUUPFjgGcO-aUilrUowcBHTdmjI,1512
+llm_client/client.py,sha256=xB1yYtBreswGxKTXaa1SKLN9ZYNL-SMfFnC_McIED1w,9565
+llm_client/models.py,sha256=QjLj5Uo0Jluv9UJ2MxtDP6Y2-7Fc94elEFxBGPi4jfI,965
+llm_client/pricing.py,sha256=-heWiPQzVlYyI7g9FlZGv43-l0IMaft5vZcMPoaRYe8,772
+llm_client/provider.py,sha256=j4xmOdg0AGfmt7yOJ9fyTsMOelRJl4oLsZNzGzYOf6U,610
+llm_client/replay.py,sha256=oiqRgmK4Q4hO78wHef7D2AJGQ20VZIVvWIg7ax7cXos,2847
+llm_client/span.py,sha256=uBf6W2zWLrZ2ZcgqbdDc2EhP8Ox0cCAOm9ip323eY5s,908
+llm_client/providers/__init__.py,sha256=7tt8Cb71CPrizUQTKomAFxGa1qfhwEJAoWWfUd3V8zc,128
+llm_client/providers/openai_compat.py,sha256=C_s0KfQIFfjncGetHbnFjE-Yi2yNm9hWOj0AzZcsrSE,2756
+llm_client/providers/opencode_cli.py,sha256=FA4DOoxrVMej-6XO5AxkfHJKABmHXUXLR0Y_CG_Iros,2646
+schema_validate/__init__.py,sha256=kM6of60n3UYD0-QBi3jeTbpIONSP0YEu7fmN7GDK0aE,350
+schema_validate/registry.py,sha256=DkdDaKyRPUWvuB2Pb4oej2yzT3wuIWha2iBazKRMRVw,1238
+schema_validate/validate.py,sha256=RREk7wUVDTHelH_R6bVdXUzzD4bt3BUwUkZxS0rH6rE,2219
+llm_dev_core-0.3.0.dist-info/METADATA,sha256=Jmud1jPeLl6oBEdpLrINgno1aX1Uxa92nvOjwuqnDew,314
+llm_dev_core-0.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+llm_dev_core-0.3.0.dist-info/RECORD,,

llm_dev_core-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

schema_validate/__init__.py

@@ -0,0 +1,13 @@
+from .registry import SchemaRegistry, default_registry, make_validator, register
+from .validate import SchemaNotFound, extract_json, strip_json_fence, validate_text
+
+__all__ = [
+    "SchemaNotFound",
+    "SchemaRegistry",
+    "default_registry",
+    "extract_json",
+    "make_validator",
+    "register",
+    "strip_json_fence",
+    "validate_text",
+]

schema_validate/registry.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from llm_client import ValidationResult
+from pydantic import BaseModel
+
+from .validate import M, SchemaNotFound, validate_text
+
+Validator = Callable[[str, str | None], ValidationResult]
+
+
+class SchemaRegistry:
+    def __init__(self) -> None:
+        self._schemas: dict[str, type[BaseModel]] = {}
+
+    def register(self, schema_id: str, model: type[M]) -> None:
+        self._schemas[schema_id] = model
+
+    def get(self, schema_id: str) -> type[BaseModel]:
+        try:
+            return self._schemas[schema_id]
+        except KeyError:
+            raise SchemaNotFound(schema_id) from None
+
+    def make_validator(self, schema_id: str) -> Validator:
+        """Devuelve un callable válido para el hook `validator` de llm-client."""
+        model = self.get(schema_id)
+
+        def validator(text: str, schema: str | None = None) -> ValidationResult:
+            return validate_text(model, text)
+
+        return validator
+
+
+default_registry = SchemaRegistry()
+
+
+def register(schema_id: str, model: type[M]) -> None:
+    default_registry.register(schema_id, model)
+
+
+def make_validator(schema_id: str) -> Validator:
+    return default_registry.make_validator(schema_id)

schema_validate/validate.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, TypeVar
+
+from llm_client import ValidationResult
+from pydantic import BaseModel, ValidationError
+
+M = TypeVar("M", bound=BaseModel)
+
+
+class SchemaNotFound(KeyError):
+    def __init__(self, schema_id: str) -> None:
+        super().__init__(f"schema no registrado: {schema_id!r}")
+        self.schema_id = schema_id
+
+
+def strip_json_fence(text: str) -> str:
+    """Quita caretas ```json … ``` cuando el modelo las añade (JSON mode no las garantiza)."""
+    match = re.search(r"```(?:json)?\s*(.*?)```", text, re.DOTALL)
+    return match.group(1).strip() if match else text.strip()
+
+
+def extract_json(text: str) -> Any:
+    """Parsea JSON: con fences, sin fences, o recortando al primer/last '{'/'['."""
+    candidate = strip_json_fence(text)
+    try:
+        return json.loads(candidate)
+    except json.JSONDecodeError:
+        pass
+    start = min(
+        (candidate.find(ch) for ch in "{[" if candidate.find(ch) != -1),
+        default=-1,
+    )
+    end = max(
+        (candidate.rfind(ch) for ch in "}]" if candidate.rfind(ch) != -1),
+        default=-1,
+    )
+    if start == -1 or end <= start:
+        raise ValueError("no se encontró JSON en la respuesta")
+    return json.loads(candidate[start : end + 1])
+
+
+def _describe_errors(exc: ValidationError) -> list[str]:
+    errors: list[str] = []
+    for entry in exc.errors():
+        loc = ".".join(str(part) for part in entry.get("loc", ())) or "<raiz>"
+        errors.append(f"{loc}: {entry.get('msg')}")
+    return errors
+
+
+def validate_text(model: type[M], text: str) -> ValidationResult:
+    """Valida el texto crudo del LLM contra un modelo Pydantic.
+
+    Devuelve un ValidationResult (contrato de llm-client) con `parsed` poblado
+    solo cuando la validación pasa.
+    """
+    try:
+        data = extract_json(text)
+    except (json.JSONDecodeError, ValueError) as exc:
+        return ValidationResult(ok=False, errors=[f"JSON inválido: {exc}"])
+    try:
+        parsed = model.model_validate(data)
+    except ValidationError as exc:
+        return ValidationResult(ok=False, errors=_describe_errors(exc))
+    return ValidationResult(ok=True, errors=[], parsed=parsed)