uriloop 0.3.1__py3-none-any.whl

uriloop/__init__.py

@@ -0,0 +1,2 @@
+"""uriloop — wspólna płaszczyzna URI/URN dla sterowania przeglądarką (CDP) i pulpitem (noVNC) z pętlą zwrotną CQRS+ES."""
+__version__ = "0.3.1"

uriloop/__main__.py

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

uriloop/ai/decision.py

@@ -0,0 +1,305 @@
+"""System One — jednoprzebiegowe decyzje typowane nad katalogiem procesów (NUL-019/020/022).
+
+Pytania (stały kontrakt wellmanifest.system-one-decision/v1):
+  uri_choice         choice  — które Action URI / proc:// realizuje polecenie w bieżącym stanie (2..255 kandydatów)
+  risk_score         score   — ryzyko 1..3 (odczyt / zmiana odwracalna / nieodwracalne lub zewnętrzne)
+  execution_allowed  noul    — czy wolno wykonać bez potwierdzenia (negacja „nie uruchamiaj” => false)
+  + needs_plan       noul    — czy zadanie wymaga wieloetapowego procesu (routing do generatora)
+
+Backendy (kolejność z routera): Liquid d1 przez Ollama `/v1/systemone` (natywnie, 0 tokenów wyjścia,
+opcjonalnie ze zrzutem ekranu), model czatu przez Ollama `/api/chat` z JSON, lokalny skorer zero-gen.
+"""
+from __future__ import annotations
+
+import base64
+import math
+import os
+import re
+import time
+from dataclasses import dataclass
+
+from .. import nl
+from ..uri import ActionUri, UriError
+from . import router
+from .http import post_json
+
+SCHEMA = "wellmanifest.system-one-decision/v1"
+MAX_CANDIDATES = 255
+RISK_LEVELS = ["tylko odczyt, brak zmian stanu",
+               "zmiana stanu ekranu lub zadań, odwracalna",
+               "nieodwracalne, zewnętrzne, finansowe lub dane wrażliwe"]
+AUTONOMY_MAX_RISK = {"suggest": 0, "confirm": 1, "auto": 2, "full": 3}
+_NEG = re.compile(r"\b(nie\s+(uruchamiaj|wykonuj|klikaj|rob|wysylaj|zatwierdzaj|usuwaj)|bez\s+wykonania|"
+                  r"tylko\s+(sprawdz|pokaz|zaplanuj)|don'?t|do\s+not|dry[- ]?run|just\s+plan)\b")
+_MULTI = re.compile(r"\b(a\s+nastepnie|potem|nastepnie|i\s+potem|kolejno|po\s+czym|then|and\s+then|"
+                    r"wszystkie|kazdy|kazda|caly\s+proces|krok\s+po\s+kroku|zaloguj.*i)\b")
+
+
+@dataclass
+class Candidate:
+    uri: str
+    label: str
+    source: str          # element | registry | composite | dockuri
+    effect: str = "write"
+    urn: str | None = None
+
+    @property
+    def prior_risk(self) -> int:
+        return {"read": 1, "write": 2, "external": 3}.get(self.effect, 2)
+
+
+# ---------------- katalog kandydatów ----------------
+def build_candidates(query: str, rt, *, extra: list[Candidate] | None = None) -> list[Candidate]:
+    """Kandydaci: akcje elementów z ostatniej obserwacji + rejestr (z parametrami z NL) + kompozycje + DockURI."""
+    cands: dict[str, Candidate] = {}
+    rest = query
+    for el in list(getattr(rt, "elements", {}).values())[:400]:
+        for a in el.get("actions", [])[:2]:
+            if "text=&" in a or a.endswith("text="):
+                if not (q := nl._QUOTED.search(query)):
+                    continue
+                a = str(rt.registry.validate(a.replace("text=", "text=" + _q(q.group(1))))[0])
+            name = el.get("name") or el.get("selector") or el.get("tag")
+            verb = a.split("://", 1)[1].split("?", 1)[0]
+            cands.setdefault(a, Candidate(a, f"{verb} „{name}” ({el.get('kind')})", "element",
+                                          "write", el.get("urn")))
+    for p in rt.registry.processes.values():
+        if p.uri.startswith(("decide://", "plan://", "loop://")):
+            continue
+        scheme, tail = p.uri.split("://", 1)
+        dom, act = tail.split("/", 1)
+        params = nl._extract(p.params.get("properties", {}), rest)
+        if not nl._QUOTED.search(rest):  # wolny tekst polecenia nie jest parametrem — tylko cytat „…”
+            params.pop("text", None)
+            params.pop("key", None)
+        if p.uri in ("browser://page/click", "browser://page/type") and not (
+                {"urn", "selector", "text"} & set(params) or {"x", "y"} <= set(params)):
+            continue                    # akcja bez celu nie jest wykonalnym kandydatem
+        try:
+            a = str(rt.registry.validate(ActionUri(scheme, dom, act, params))[0])
+        except UriError:
+            continue
+        cands.setdefault(a, Candidate(a, p.title, "registry", p.effect))
+    for comp in getattr(rt, "composites", None).list() if getattr(rt, "composites", None) else []:
+        u = f"proc://uriloop/run?name={comp['name']}"
+        cands.setdefault(u, Candidate(u, f"proces: {comp.get('title', comp['name'])}", "composite",
+                                      comp.get("effect", "write"), comp.get("urn")))
+    for c in extra or []:
+        cands.setdefault(c.uri, c)
+    ranked = sorted(cands.values(), key=lambda c: -affinity(query, c))
+    out = ranked[:MAX_CANDIDATES]
+    if len(out) < 2:
+        out.append(Candidate("log://events/tail?n=5", "pokaż ostatnie zdarzenia (brak lepszej akcji)", "registry", "read"))
+    return out
+
+
+def _q(text: str) -> str:
+    from urllib.parse import quote
+    return quote(text, safe="")
+
+
+# ---------------- skorer zero-gen (NUL-022 §2) ----------------
+def _tokens(s: str) -> set[str]:
+    return {w for w in re.split(r"[^a-z0-9]+", nl.normalize(s)) if len(w) > 2}
+
+
+def affinity(query: str, c: Candidate) -> float:
+    q = _tokens(query)
+    lab = _tokens(c.label) | _tokens(c.uri.replace("://", " ").replace("/", " ").replace("?", " "))
+    if not q:
+        return 0.0
+    overlap = len(q & lab) / len(q)
+    fuzzy = sum(1 for w in q for v in lab if w not in lab and len(w) > 4 and nl.levenshtein(w, v, 2) <= 2) / len(q)
+    nq = nl.normalize(query)
+    name = re.search(r"„([^”]+)”", c.label)
+    exact = 1.0 if name and nl.normalize(name.group(1)) and nl.normalize(name.group(1)) in nq else 0.0
+    alias = 0.0
+    try:
+        hit = nl.dispatch(query, _REG_CACHE.get())
+        if hit and c.uri.startswith(hit.key):
+            alias = 0.6
+    except UriError:
+        pass
+    src = {"element": 0.15, "composite": 0.1, "dockuri": 0.05}.get(c.source, 0.0)
+    return overlap + 0.5 * fuzzy + 1.2 * exact + alias + src * (overlap > 0 or exact > 0)
+
+
+class _RegCache:
+    reg = None
+
+    def get(self):
+        if self.reg is None:
+            from ..registry import Registry
+            self.reg = Registry.load()
+        return self.reg
+
+
+_REG_CACHE = _RegCache()
+
+
+def _softmax(xs: list[float], temp: float = 0.25) -> list[float]:
+    m = max(xs)
+    e = [math.exp((x - m) / temp) for x in xs]
+    s = sum(e)
+    return [v / s for v in e]
+
+
+def zero_gen(query: str, cands: list[Candidate]) -> dict:
+    probs = _softmax([affinity(query, c) for c in cands])
+    best = max(range(len(cands)), key=lambda i: probs[i])
+    nq = nl.normalize(query)
+    neg = bool(_NEG.search(nq))
+    prior = cands[best].prior_risk
+    risk = {str(i): (0.8 if i + 1 == prior else 0.1) for i in range(3)}
+    multi = bool(_MULTI.search(nq)) or nq.count(",") >= 2
+    return {"choice": {c.uri: round(p, 6) for c, p in zip(cands, probs)},
+            "risk": risk, "allowed": 0.05 if neg else 0.9, "needs_plan": 0.85 if multi else 0.15,
+            "usage": {"input_tokens": 0, "output_tokens": 0}}
+
+
+# ---------------- Liquid d1 przez Ollama /v1/systemone ----------------
+def _questions(cands: list[Candidate]) -> dict:
+    return {
+        "uri_choice": {"type": "choice",
+                       "instructions": "Która akcja (Action URI) najlepiej realizuje polecenie użytkownika w obecnym stanie ekranu?",
+                       "criteria": {c.uri: c.label[:500] for c in cands}},
+        "risk_score": {"type": "score",
+                       "instructions": "Jakie jest ryzyko operacyjne wykonania tej akcji?",
+                       "criteria": RISK_LEVELS},
+        "execution_allowed": {"type": "noul",
+                              "instructions": "Czy polecenie pozwala wykonać akcję teraz, bez potwierdzenia "
+                                              "(brak negacji typu 'nie uruchamiaj', 'tylko zaplanuj')?"},
+        "needs_plan": {"type": "noul",
+                       "instructions": "Czy polecenie wymaga wielu kolejnych kroków, których nie zrealizuje jedna akcja?"},
+    }
+
+
+def d1_native(profile: dict, query: str, cands: list[Candidate], state: dict, images: list[bytes] | None,
+              timeout: float = 120) -> dict:
+    body = {"model": profile["model"], "state": {**state, "query": query},
+            "questions": _questions(cands), "keep_alive": int(os.environ.get("URILOOP_KEEP_ALIVE", "90"))}
+    if images:
+        body["images"] = [base64.b64encode(i).decode() for i in images]
+    data = post_json(router.base_url(profile) + "/v1/systemone", body, timeout=timeout)
+    a = data.get("answers") or {}
+    ch = a.get("uri_choice") or {}
+    probs = ch.get("probabilities") or {}
+    if set(probs) != {c.uri for c in cands} or ch.get("choice") not in probs:
+        raise ValueError("d1: choice poza katalogiem kandydatów")
+    risk = (a.get("risk_score") or {}).get("probabilities") or {}
+    if set(risk) != {"0", "1", "2"}:
+        raise ValueError("d1: niepoprawny rozkład score")
+    for k in ("execution_allowed", "needs_plan"):
+        v = (a.get(k) or {}).get("noul")
+        if not isinstance(v, (int, float)) or not 0 <= v <= 1:
+            raise ValueError(f"d1: niepoprawne noul {k}")
+    if (data.get("usage") or {}).get("output_tokens", 0) != 0:
+        raise ValueError("d1: model generował tekst (output_tokens != 0)")
+    return {"choice": probs, "risk": risk, "allowed": a["execution_allowed"]["noul"],
+            "needs_plan": a["needs_plan"]["noul"], "usage": data.get("usage")}
+
+
+# ---------------- model czatu (np. qwen3) przez Ollama /api/chat ----------------
+def ollama_json(profile: dict, query: str, cands: list[Candidate], state: dict, images=None, timeout: float = 120) -> dict:
+    ids = {f"a{i}": c for i, c in enumerate(cands)}
+    schema = {"type": "object", "required": ["choice", "risk", "allowed", "needs_plan"],
+              "properties": {"choice": {"enum": list(ids)}, "risk": {"enum": [1, 2, 3]},
+                             "allowed": {"type": "boolean"}, "needs_plan": {"type": "boolean"}}}
+    catalog = "\n".join(f"{k}: {c.label} -> {c.uri}" for k, c in ids.items())
+    msg = (f"Polecenie: {query}\nStan: {state.get('summary', '')}\nKandydaci:\n{catalog}\n"
+           "Wybierz identyfikator akcji, ryzyko 1-3, czy wolno wykonać bez potwierdzenia "
+           "i czy potrzeba procesu wieloetapowego. Odpowiedz JSON.")
+    data = post_json(router.base_url(profile) + "/api/chat",
+                     {"model": profile["model"], "messages": [{"role": "user", "content": msg}],
+                      "format": schema, "stream": False, "think": False, "options": {"temperature": 0}},
+                     timeout=timeout)
+    import json as _j
+    out = _j.loads(data["message"]["content"])
+    chosen = ids[out["choice"]].uri
+    n = len(cands)
+    hi = 0.84 if n > 1 else 1.0
+    probs = {c.uri: (hi if c.uri == chosen else (1 - hi) / (n - 1)) for c in cands}
+    risk = {str(i): (0.84 if i + 1 == int(out["risk"]) else 0.08) for i in range(3)}
+    return {"choice": probs, "risk": risk, "allowed": 0.9 if out["allowed"] else 0.1,
+            "needs_plan": 0.9 if out["needs_plan"] else 0.1,
+            "usage": {"input_tokens": data.get("prompt_eval_count", 0), "output_tokens": data.get("eval_count", 0)}}
+
+
+BACKENDS = {"ollama-systemone": d1_native, "ollama-json": ollama_json,
+            "zero-gen": lambda p, q, c, s, i=None, timeout=0: zero_gen(q, c)}
+FAMILY = {"ollama-systemone": ("liquid-d1", "system-one", "ollama-systemone"),
+          "ollama-json": ("semif", "token-score", "ollama-json"),
+          "zero-gen": ("jevlike", "candidate-scorer", "local-zero-gen")}
+
+
+# ---------------- polityka (NUL-020) i koperta ----------------
+def apply_policy(raw: dict, cands: list[Candidate], autonomy: str, min_conf: float) -> dict:
+    by_uri = {c.uri: c for c in cands}
+    probs = dict(raw["choice"])
+    total = sum(probs.values()) or 1.0
+    probs = {k: v / total for k, v in probs.items()}
+    selected = max(probs, key=probs.get)
+    rdist = {str(i + 1): float(raw["risk"][str(i)]) for i in range(3)}
+    rs = sum(rdist.values()) or 1.0
+    rdist = {k: round(v / rs, 6) for k, v in rdist.items()}
+    risk = max(int(max(rdist, key=rdist.get)), by_uri[selected].prior_risk if by_uri[selected].effect == "external" else 1)
+    allowed_p = float(raw["allowed"])
+    allowed, constraints = allowed_p >= 0.5, []
+    if not allowed:
+        constraints.append("POLICY-NOUL-NEGATION-BLOCKS-EXECUTION")
+    limit = AUTONOMY_MAX_RISK.get(autonomy, 2)
+    if risk > limit:
+        allowed = False
+        constraints.append(f"POLICY-AUTONOMY-{autonomy.upper()}-GATE")
+    conf = probs[selected]
+    if conf < min_conf:
+        constraints.append("POLICY-LOW-CONFIDENCE-ROUTES-TO-PLANNER")
+    return {"selected": selected, "probs": probs, "risk": risk, "rdist": rdist, "allowed": allowed,
+            "allowed_p": allowed_p, "constraints": constraints, "confidence": conf,
+            "blocked": not allowed and bool(set(constraints) - {"POLICY-LOW-CONFIDENCE-ROUTES-TO-PLANNER"})}
+
+
+def decide(query: str, rt, *, autonomy: str | None = None, images: list[bytes] | None = None,
+           state: dict | None = None, extra: list[Candidate] | None = None, profiles: list[dict] | None = None) -> dict:
+    autonomy = autonomy or os.environ.get("URILOOP_AUTONOMY", "auto")
+    min_conf = float(os.environ.get("URILOOP_DECISION_MIN_CONF", "0.35"))
+    cands = build_candidates(query, rt, extra=extra)
+    state = dict(state or {})
+    errors = []
+    for profile in profiles or router.select("decision"):
+        t0 = time.monotonic()
+        try:
+            raw = BACKENDS[profile["backend"]](profile, query, cands, state,
+                                              images if "image" in profile.get("modalities", []) else None)
+        except Exception as exc:  # noqa: BLE001 — przejście do kolejnego profilu
+            errors.append(f"{profile['id']}: {type(exc).__name__}: {exc}"[:300])
+            continue
+        pol = apply_policy(raw, cands, autonomy, min_conf)
+        fam, wire, transport = FAMILY[profile["backend"]]
+        envelope = {
+            "schema": SCHEMA, "model_profile_id": profile["id"], "family": fam, "wire_format": wire,
+            "state": {"query": query, "autonomy_mode": autonomy, "modality": "multimodal" if images else "text"},
+            "questions": [
+                {"id": "uri_choice", "type": "choice", "question": _questions(cands)["uri_choice"]["instructions"],
+                 "options": [c.uri for c in cands]},
+                {"id": "risk_score", "type": "score", "question": "Ryzyko operacyjne 1..3", "options": ["1", "2", "3"]},
+                {"id": "execution_allowed", "type": "noul", "question": "Wykonanie bez potwierdzenia?",
+                 "options": ["true", "false"]},
+            ],
+            "answers": {"uri_choice": pol["selected"], "risk_score": pol["risk"], "execution_allowed": pol["allowed"]},
+            "probabilities": {"uri_choice": {k: round(v, 6) for k, v in pol["probs"].items()},
+                              "risk_score": pol["rdist"],
+                              "execution_allowed": {"true": round(pol["allowed_p"], 6),
+                                                    "false": round(1 - pol["allowed_p"], 6)}},
+            "selected_uri": pol["selected"], "confidence": round(pol["confidence"], 6),
+            "risk_score": pol["risk"], "execution_allowed": pol["allowed"],
+            "blocked_by_constraint": pol["blocked"], "applied_constraints": pol["constraints"],
+            "latency_ms": round((time.monotonic() - t0) * 1000, 2), "transport": transport,
+        }
+        sel = next(c for c in cands if c.uri == pol["selected"])
+        return {"envelope": envelope, "needs_plan": float(raw["needs_plan"]) >= 0.5 or
+                "POLICY-LOW-CONFIDENCE-ROUTES-TO-PLANNER" in pol["constraints"],
+                "selected": {"uri": sel.uri, "label": sel.label, "source": sel.source, "urn": sel.urn},
+                "top": sorted(({"uri": k, "p": round(v, 4)} for k, v in pol["probs"].items()), key=lambda x: -x["p"])[:5],
+                "usage": raw.get("usage"), "fallback_errors": errors, "candidates": len(cands)}
+    raise RuntimeError("brak dostępnego modelu decyzyjnego: " + "; ".join(errors))

uriloop/ai/generator.py

@@ -0,0 +1,153 @@
+"""Generator procesów URI: cel w NL ─► proces złożony `proc://uriloop/<nazwa>` z katalogu DockURI.
+
+Dostawcy (router, registry/models.json → role generator):
+  ollama    /api/chat z `format` = JSON Schema (lokalnie, np. qwen3:8b na GPU 8 GB, qwen3.8:27b ≥ 20 GB)
+  deepseek  OpenAI-compatible /chat/completions, response_format json_object (deepseek-v4-flash / -pro)
+  subllm    proxy subactor/subllm (OpenAI-compatible) — failover i rozliczanie po stronie subllm
+
+Zamknięta pętla jakości: odpowiedź → walidacja każdego kroku względem rejestru (fail-closed) →
+lista błędów wraca do modelu jako poprawka (max URILOOP_GENERATOR_REPAIRS razy) → zapis z pochodzeniem.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import time
+
+from ..composites import CompositeStore, slug
+from ..uri import UriError
+from . import router
+from .http import post_json
+
+PLAN_SCHEMA = {
+    "type": "object", "required": ["name", "title", "steps"], "additionalProperties": False,
+    "properties": {
+        "name": {"type": "string", "pattern": "^[a-z0-9][a-z0-9-]{1,62}$"},
+        "title": {"type": "string"},
+        "vars": {"type": "object", "additionalProperties": {
+            "type": "object", "properties": {"type": {"type": "string"}, "default": {}, "example": {},
+                                             "description": {"type": "string"}}}},
+        "steps": {"type": "array", "minItems": 1, "maxItems": 40, "items": {
+            "type": "object", "required": ["uri"], "properties": {"uri": {"type": "string"}, "why": {"type": "string"}}}},
+        "expects": {"type": "array", "items": {"type": "string"}},
+    },
+}
+
+SYSTEM = """Jesteś kompilatorem procesów URI (wellmanifest/nl-uri-dsl-llm, POA).
+Zamieniasz cel użytkownika na proces złożony: listę kroków, z których KAŻDY jest kanonicznym Action URI
+z katalogu poniżej (scheme://domain/action?param=wartość, wartości zakodowane procentowo).
+Zasady:
+- Używaj wyłącznie URI z katalogu i wyłącznie zadeklarowanych parametrów. Nie wymyślaj akcji.
+- Gdy znasz URN elementu z bieżącej obserwacji, używaj go (browser://page/click?urn=…); w przeciwnym razie text= lub selector=.
+- Po nawigacji lub zmianie strony dodaj browser://page/analyze, zanim użyjesz URN nowych elementów.
+- Wartości zależne od użytkownika wyrażaj jako ${zmienna} i deklaruj w "vars" (type, example).
+- "expects": warunki weryfikacji końca procesu: text~, url~, title~, element~, request~, changed~.
+- Odpowiadasz WYŁĄCZNIE obiektem JSON: {"name","title","vars","steps":[{"uri","why"}],"expects"}."""
+
+
+def _catalog(rt, limit_elements: int = 80) -> str:
+    lines = ["# Procesy (Action URI → parametry)"]
+    for p in rt.registry.processes.values():
+        if p.uri.startswith(("plan://", "loop://", "decide://")):
+            continue
+        props = p.params.get("properties", {})
+        req = set(p.params.get("required", []))
+        args = ", ".join(f"{k}{'*' if k in req else ''}:{v.get('type') or '|'.join(map(str, v.get('enum', [])))}"
+                         for k, v in props.items())
+        lines.append(f"- {p.uri} ({p.effect}) — {p.title}" + (f" [{args}]" if args else ""))
+    comps = rt.composites.list()
+    if comps:
+        lines.append("# Istniejące procesy złożone (można wywołać jako krok)")
+        lines += [f"- {c['uri']} — {c.get('title')}" for c in comps[:50]]
+    if rt.elements:
+        lines.append("# Elementy bieżącej obserwacji (URN → akcje)")
+        for e in list(rt.elements.values())[:limit_elements]:
+            if e.get("actions"):
+                lines.append(f"- {e['kind']} „{e.get('name', '')[:60]}”: {e['actions'][0]}")
+    return "\n".join(lines)
+
+
+def _extract_json(text: str) -> dict:
+    text = re.sub(r"<think>.*?</think>", "", text or "", flags=re.S).strip()
+    text = re.sub(r"^```(?:json)?|```$", "", text, flags=re.M).strip()
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        a, b = text.find("{"), text.rfind("}")
+        if a != -1 and b > a:
+            return json.loads(text[a:b + 1])
+        raise
+
+
+def _call(profile: dict, messages: list[dict], timeout: float) -> tuple[dict, dict]:
+    if profile["backend"] == "ollama-chat":
+        data = post_json(router.base_url(profile) + "/api/chat",
+                         {"model": profile["model"], "messages": messages, "format": PLAN_SCHEMA, "stream": False,
+                          "think": bool(profile.get("think", False)), "options": {"temperature": 0.1, "num_ctx": 16384}},
+                         timeout=timeout)
+        usage = {"input_tokens": data.get("prompt_eval_count", 0), "output_tokens": data.get("eval_count", 0)}
+        return _extract_json(data["message"]["content"]), usage
+    if profile["backend"] == "openai-chat":
+        headers = {}
+        key = os.environ.get(profile.get("api_key_env", ""), "")
+        if key:
+            headers["Authorization"] = f"Bearer {key}"
+        headers["X-Subactor-Function"] = "process-generate"
+        headers["HTTP-Referer"] = os.environ.get("URILOOP_APP_URL", "https://github.com/wellmanifest/nl-uri-dsl-llm")
+        headers["X-OpenRouter-Title"] = os.environ.get("URILOOP_APP_NAME", "uriloop")
+        body = {"model": profile["model"], "messages": messages, "temperature": 0.1,
+                **({"response_format": profile["response_format"]} if profile.get("response_format") else {}),
+                **(profile.get("extra_body") or {})}
+        data = post_json(router.base_url(profile) + "/chat/completions", body, headers, timeout=timeout)
+        u = data.get("usage") or {}
+        return _extract_json(data["choices"][0]["message"]["content"]), {
+            "input_tokens": u.get("prompt_tokens", 0), "output_tokens": u.get("completion_tokens", 0)}
+    raise ValueError(f"unsupported generator backend {profile['backend']}")
+
+
+def generate(goal: str, rt, *, name: str | None = None, profiles: list[dict] | None = None,
+             observation: str | None = None, save: bool = True, timeout: float = 180) -> dict:
+    store: CompositeStore = rt.composites
+    repairs = int(os.environ.get("URILOOP_GENERATOR_REPAIRS", "2"))
+    profiles = profiles or router.select("generator")
+    if not profiles:
+        raise RuntimeError("brak generatora: uruchom Ollama z modelem qwen3 lub ustaw DEEPSEEK_API_KEY")
+    prompt_hash = hashlib.sha256(goal.encode()).hexdigest()[:16]
+    errors_by_profile = []
+    for profile in profiles:
+        messages = [{"role": "system", "content": SYSTEM + "\n\n" + _catalog(rt)},
+                    {"role": "user", "content": f"Cel: {goal}\n"
+                                                f"Bieżąca obserwacja: {observation or 'brak'}\n"
+                                                f"Nazwa procesu (slug): {name or slug(goal)}"}]
+        usage_total = {"input_tokens": 0, "output_tokens": 0}
+        attempts = []
+        t0 = time.monotonic()
+        try:
+            for attempt in range(repairs + 1):
+                doc, usage = _call(profile, messages, timeout)
+                for k in usage_total:
+                    usage_total[k] += usage.get(k, 0) or 0
+                doc = doc if isinstance(doc, dict) else {}
+                doc["name"] = name or doc.get("name") or slug(goal)
+                if not re.match(r"^[a-z0-9][a-z0-9-]{1,62}$", doc["name"]):
+                    doc["name"] = slug(doc["name"])
+                errs = store.validate(doc)
+                attempts.append({"attempt": attempt, "errors": errs[:10]})
+                if not errs:
+                    doc["goal"] = goal
+                    doc["generated_by"] = {"profile": profile["id"], "provider": profile.get("provider"),
+                                           "model": profile["model"], "prompt_sha256_16": prompt_hash,
+                                           "repairs": attempt, "usage": usage_total,
+                                           "ms": int((time.monotonic() - t0) * 1000)}
+                    saved = store.save(doc) if save else doc
+                    return {"process": saved, "attempts": attempts, "profile": profile["id"],
+                            "fallback_errors": errors_by_profile}
+                messages += [{"role": "assistant", "content": json.dumps(doc, ensure_ascii=False)},
+                             {"role": "user", "content": "Proces jest niepoprawny względem katalogu. Popraw wyłącznie te błędy "
+                                                         "i zwróć cały JSON:\n- " + "\n- ".join(errs[:10])}]
+            errors_by_profile.append(f"{profile['id']}: walidacja nieudana po {repairs} poprawkach: {attempts[-1]['errors'][:3]}")
+        except Exception as exc:  # noqa: BLE001 — failover do kolejnego profilu
+            errors_by_profile.append(f"{profile['id']}: {type(exc).__name__}: {exc}"[:300])
+    raise UriError("generator nie wytworzył poprawnego procesu: " + " | ".join(errors_by_profile))

uriloop/ai/http.py

@@ -0,0 +1,35 @@
+"""Minimalny klient HTTP/JSON (stdlib) — wspólny dla Ollama, DeepSeek i proxy subllm (REUSE-013)."""
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+
+APP_NAME = os.environ.get("URILOOP_APP_NAME", "uriloop")
+
+
+class LlmHttpError(RuntimeError):
+    def __init__(self, status: int, body: str, url: str):
+        super().__init__(f"HTTP {status} from {url}: {body[:300]}")
+        self.status, self.body = status, body
+
+
+def _req(url: str, data: bytes | None, headers: dict | None, timeout: float, method: str):
+    h = {"Content-Type": "application/json", "User-Agent": f"{APP_NAME}/0.2",
+         "X-Subactor-Application": APP_NAME, **(headers or {})}
+    req = urllib.request.Request(url, data=data, headers=h, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:  # noqa: S310 (adresy z konfiguracji operatora)
+            raw = r.read()
+    except urllib.error.HTTPError as exc:
+        raise LlmHttpError(exc.code, exc.read().decode("utf-8", "replace"), url) from None
+    return json.loads(raw or b"{}")
+
+
+def get_json(url: str, headers: dict | None = None, timeout: float = 10) -> dict:
+    return _req(url, None, headers, timeout, "GET")
+
+
+def post_json(url: str, body: dict, headers: dict | None = None, timeout: float = 120) -> dict:
+    return _req(url, json.dumps(body, ensure_ascii=False).encode(), headers, timeout, "POST")

uriloop/ai/router.py

@@ -0,0 +1,129 @@
+"""Router profili modeli (NUL-022, wellmanifest/nohardcode).
+
+Profil wybierany jest z registry/models.json na podstawie:
+  1. zmiennych środowiskowych (URILOOP_DECISION_MODEL, DOCKURI_DECISION_MODEL, URILOOP_GENERATOR_MODEL, …),
+  2. dostawcy (URILOOP_GENERATOR_PROVIDER=ollama|deepseek|subllm),
+  3. telemetrii hosta: VRAM GPU (nvidia-smi lub URILOOP_VRAM_GB), platforma,
+  4. dostępności: klucz API dla zdalnych, zainstalowane modele w Ollama.
+"""
+from __future__ import annotations
+
+import functools
+import json
+import os
+import platform
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .http import get_json
+
+MODELS_PATH = Path(os.environ.get("URILOOP_MODELS") or
+                   Path(__file__).resolve().parents[3] / "registry" / "models.json")
+
+
+@dataclass
+class Telemetry:
+    vram_gb: float = 0.0
+    gpu: str | None = None
+    system: str = platform.system()
+    machine: str = platform.machine()
+    ollama_models: list = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {"vram_gb": self.vram_gb, "gpu": self.gpu, "system": self.system,
+                "machine": self.machine, "ollama_models": self.ollama_models[:50]}
+
+
+@functools.lru_cache(maxsize=1)
+def _nvidia() -> tuple[float, str | None]:
+    if not shutil.which("nvidia-smi"):
+        return 0.0, None
+    try:
+        out = subprocess.run(["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader,nounits"],
+                             capture_output=True, text=True, timeout=5, check=True).stdout.strip().splitlines()
+        name, mem = out[0].rsplit(",", 1)
+        return round(float(mem) / 1024, 1), name.strip()
+    except (OSError, subprocess.SubprocessError, ValueError, IndexError):
+        return 0.0, None
+
+
+def ollama_url() -> str:
+    return (os.environ.get("OLLAMA_URL") or os.environ.get("OLLAMA_HOST") or "http://127.0.0.1:11434").rstrip("/")
+
+
+def telemetry(probe_ollama: bool = True) -> Telemetry:
+    env_vram = os.environ.get("URILOOP_VRAM_GB")
+    vram, gpu = (float(env_vram), "env") if env_vram else _nvidia()
+    t = Telemetry(vram_gb=vram, gpu=gpu)
+    if probe_ollama:
+        try:
+            t.ollama_models = [m["name"] for m in get_json(ollama_url() + "/api/tags", timeout=1.5).get("models", [])]
+        except Exception:  # noqa: BLE001 — brak Ollamy to legalny stan (fallback zero-gen)
+            t.ollama_models = []
+    return t
+
+
+@functools.lru_cache(maxsize=4)
+def _load(path: str) -> dict:
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def load_models(path: str | Path | None = None) -> dict:
+    return _load(str(path or MODELS_PATH))
+
+
+def _installed(model: str, installed: list) -> bool:
+    if not installed:
+        return False
+    names = set(installed) | {n.removesuffix(":latest") for n in installed}
+    return model in names or f"{model}:latest" in names
+
+
+def base_url(profile: dict) -> str:
+    return (os.environ.get(profile.get("base_url_env", "")) or profile.get("default_base_url", "")).rstrip("/")
+
+
+def select(role: str, t: Telemetry | None = None, *, require_installed: bool = True) -> list[dict]:
+    """Zwraca uporządkowaną listę kandydatów-profili (pierwszy = wybrany, reszta = fallback)."""
+    spec = load_models()["roles"][role]
+    profiles = [dict(p) for p in spec["profiles"]]
+    t = t or telemetry()
+    override = next((os.environ[e] for e in spec.get("env_override", []) if os.environ.get(e)), None)
+    provider = os.environ.get(spec.get("provider_env", ""), "") if spec.get("provider_env") else ""
+
+    if override:
+        hit = [p for p in profiles if override in (p["id"], p.get("model"))]
+        if not hit:  # model spoza katalogu: dziedziczy backend pierwszego profilu danego dostawcy
+            tmpl = next((p for p in profiles if not provider or p.get("provider") == provider), profiles[0])
+            hit = [{**tmpl, "id": f"override:{override}", "model": override, "min_vram_gb": 0}]
+        rest = [p for p in profiles if p not in hit]
+        profiles = hit + rest
+
+    def usable(p: dict) -> bool:
+        if provider and p.get("provider") and p["provider"] != provider and not p["id"].startswith("override:"):
+            return False
+        if p.get("api_key_env") and p.get("remote") and not os.environ.get(p["api_key_env"]):
+            return False
+        if p.get("opt_in_env") and not os.environ.get(p["opt_in_env"]) and provider != p.get("provider"):
+            return False
+        if p.get("backend", "").startswith("ollama"):
+            if t.vram_gb and p.get("min_vram_gb", 0) > t.vram_gb and not p["id"].startswith("override:"):
+                return False
+            if require_installed and t.ollama_models is not None and not _installed(p["model"], t.ollama_models):
+                return p["id"].startswith("override:") and bool(t.ollama_models)
+        return True
+
+    ordered = [p for p in profiles if usable(p)]
+    # zawsze zostaw deterministyczny fallback, jeśli rola go ma (NUL-022 §2)
+    for p in profiles:
+        if p.get("backend") == "zero-gen" and p not in ordered:
+            ordered.append(p)
+    return ordered
+
+
+def describe(t: Telemetry | None = None) -> dict:
+    t = t or telemetry()
+    return {"telemetry": t.to_dict(),
+            "selected": {role: [p["id"] for p in select(role, t)] for role in load_models()["roles"]}}