ecadlib 0.3.0__py3-none-any.whl

ecadlib/llm/run.py

@@ -0,0 +1,126 @@
+"""One read of a datasheet by any model, with the rails its plan names (used by datasheet.Reader).
+
+    info(ref, rules)         endpoint + profile + rail plan for a model reference (cached, registered for pricing)
+    ask(job, info, send, judge, client)   -> a Messages-shaped answer with an "ecadlib" record of what ran
+
+A frontier model with PDF input and JSON-schema output on Anthropic gets job["body"] exactly as datasheet.build_request
+made it (the same bytes as before this module existed); the only support it may add is a second turn after an answer
+that fails datasheet's checks (feedback_retry), sent as the same request with the answer and the errors appended."""
+from . import _ai, endpoint, key_for, register, profiles as PR, rails as R, sampling as SM
+
+_INFO = {}
+
+
+def _rules_key(rules):
+    """The cache key for a rules table: its content. Not id(rules): a freed table's id is reused by the next one, which
+    then got the old table's plan (seen as an extra feedback turn with feedback_retry = false, Windows CI)."""
+    import json
+    try:
+        return json.dumps(rules, sort_keys=True, default=str)
+    except (TypeError, ValueError):
+        return repr(rules)
+
+
+def info(ref, rules=None, section="datasheet", key=None, get=None, post=None):
+    k = (ref, section, _rules_key(rules))
+    if k not in _INFO:
+        ep = endpoint(rules, section, ref)
+        prof = PR.resolve(ep, rules, key_for(ep, key) if ep["provider"] != "anthropic" else None, get, post)
+        plan = R.plan(prof, ep["assist"], ep["feedback_retry"])
+        register(ep["ref"], ep, prof)
+        _INFO[k] = {"ep": ep, "prof": prof, "plan": plan, "sampling": SM.params(ep, prof, _ai(rules).get("temperature"))}
+    return _INFO[k]
+
+
+def plain(inf):
+    """Anthropic, and nothing beyond the support layer: the request goes out exactly as built."""
+    return inf["ep"]["provider"] == "anthropic" and not inf["plan"]["guided"]
+
+
+def _synth(ext, usage, model, served=None):
+    import json
+    return {"id": "ecadlib-steps", "type": "message", "role": "assistant", "model": served or model,
+            "content": [{"type": "text", "text": json.dumps(ext)}], "stop_reason": "end_turn", "stop_details": None,
+            "usage": usage}
+
+
+def _better(k1, w1, k2, w2):
+    return R.rank(k2) < R.rank(k1) or (R.rank(k2) == R.rank(k1) and len(w2) <= len(w1))
+
+
+def ask(job, inf, send, judge, client=None, allow_feedback=True):
+    """send(body) -> answer for this endpoint (Messages shape; a parse failure is still returned as the answer).
+    judge(msg) -> (ok | incomplete | failed | refused | truncated, reasons)."""
+    p, prof = inf["plan"], inf["prof"]
+    schema = job["body"]["output_config"]["format"]["schema"]
+    notes, rec = [], {"tier": p["tier"], "assist": p["assist"], "profile": {k: prof.get(k) for k in
+                      ("tier", "pdf", "vision", "json_schema", "context", "source", "detect") if prof.get(k) is not None},
+                      "rails": list(p["rails"]), "endpoint": inf["ep"]["name"], "provider": inf["ep"]["provider"]}
+    fb = allow_feedback and "feedback_retry" in p["rails"]
+    smp = inf.get("sampling") or {}
+    if smp:                                           # temperature / seed where the model takes them (llm.sampling)
+        send = (lambda b, _send=send: _send({**b, **smp}))
+        rec["sampling"] = dict(smp)
+    if "split_steps" in p["rails"]:
+        ext, usage, steps, ctx = R.run_steps(client, job["body"], prof, p, job["part"], job["package"], notes)
+        served = next((s.get("model_served") for s in steps if s.get("model_served")), None)
+        msg = _synth(ext, usage, job["body"]["model"], served)
+        kind, why = judge(msg)
+        if kind == "failed" and fb:
+            from ..datasheet import DatasheetError
+            try:
+                ext2, u2 = R.redo_step(client, job["body"], prof, p, ctx, steps, ext, why, notes)
+                msg2 = _synth(ext2, R.add_usage(usage, u2), job["body"]["model"], served)
+                kind2, why2 = judge(msg2)
+                rec["feedback"] = {"errors": why[:15], "before": kind, "after": kind2, "kept": "retry" if _better(kind, why, kind2, why2) else "first"}
+                msg = msg2 if _better(kind, why, kind2, why2) else dict(msg, usage=msg2["usage"])
+            except DatasheetError as e:
+                rec["feedback"] = {"errors": why[:15], "before": kind, "after": f"error: {e}", "kept": "first"}
+        rec["steps"] = [{k: v for k, v in s.items() if k != "model_served"} for s in steps]
+    else:
+        body = R.adapt_body(job["body"], prof, p, notes) if p["guided"] else job["body"]
+        msg = R.repair_message(send(body), schema, p)
+        if fb:
+            kind, why = judge(msg)
+            if kind == "failed":
+                msg2 = R.repair_message(send(R.feedback_body(body, msg, why)), schema, p)
+                kind2, why2 = judge(msg2)
+                keep = _better(kind, why, kind2, why2)
+                rec["feedback"] = {"errors": why[:15], "before": kind, "after": kind2, "kept": "retry" if keep else "first"}
+                usage = R.add_usage(msg.get("usage"), msg2.get("usage"))
+                msg = dict(msg2 if keep else msg, usage=usage)
+    if notes:
+        rec["notes"] = notes
+    if msg.get("ecadlib", {}).get("repair"):
+        rec["repair"] = msg["ecadlib"]["repair"]
+    if p["guided"] or rec.get("feedback") or smp:
+        msg = dict(msg, ecadlib=rec)
+    return msg
+
+
+def provenance(inf, msg=None, route=None, pages_picked=False):
+    """The sidecar's "ai" record: which model, profile and rails produced this part, and which support rails ran."""
+    rec = dict((msg or {}).get("ecadlib") or {})
+    if not rec:
+        p = inf["plan"]
+        rec = {"tier": p["tier"], "assist": p["assist"], "rails": list(p["rails"]), "endpoint": inf["ep"]["name"],
+               "provider": inf["ep"]["provider"],
+               "profile": {k: inf["prof"].get(k) for k in ("tier", "pdf", "vision", "json_schema", "context", "source")}}
+    ran = ["checks_gate", "units_in_code", "geometry_in_code", "provenance"]
+    if pages_picked:
+        ran.append("page_picking")
+    if rec.get("feedback"):
+        ran.append("feedback_retry")
+    if route and len(route.get("attempts") or []) > 1:
+        ran.append("escalation")
+    rec["support_ran"] = ran
+    rec["model"] = inf["ep"]["ref"]
+    return rec
+
+
+def wants(rules, rail, section="datasheet"):
+    """Does the configured model's plan include this rail? (False when the setup can't be resolved.)"""
+    try:
+        return rail in info(endpoint(rules, section)["ref"], rules, section)["plan"]["rails"]
+    except Exception:
+        return False

ecadlib/llm/sampling.py

@@ -0,0 +1,49 @@
+"""Repeatable answers: sampling settings where a provider takes them ([ai] temperature).
+
+    [ai]
+    temperature = "auto"     # auto | off | a number from 0 to 2
+
+auto: temperature 0 (and a fixed seed on OpenAI-compatible servers, which most of them honour) for models that accept
+a temperature; nothing for models that reject it. Rejected (claude-api skill, Thinking & Effort table, 2026-10): every
+Claude model from Opus 4.7 / Sonnet 5 / Haiku 5.5 on (temperature removed or only the default accepted: a 400
+otherwise), OpenAI's reasoning models (gpt-5*, o1/o3/o4) and DeepSeek's reasoner. So a request to the default model
+(Claude Opus 5.5) is byte-identical with and without this setting; older Claude models (Opus/Sonnet 4.5-4.6,
+Haiku 4.5) get temperature 0. [ai.profiles."<model>"] sampling = true | false overrides the table for one model.
+off: never send a sampling parameter. A number: that temperature, where the model takes one.
+
+Repeat runs give the same answer mainly through the result cache (PDF hash + model + pages + prompt/schema version +
+rails): a second run replays the cached answer and pays nothing. The sampling settings are not part of the cache key,
+so changing them never throws away answers already paid for."""
+import re
+
+SEED = 7351
+REJECTS = re.compile(r"claude-(?!(opus|sonnet)-4-[56]$|haiku-4-5$).*|gpt-5.*|o[134](-.*)?|.*reasoner.*")
+
+
+def takes_sampling(model, prof=None):
+    if prof and prof.get("sampling") is not None:
+        return bool(prof["sampling"])
+    from .profiles import bare
+    return not REJECTS.fullmatch(bare(model))
+
+
+def params(ep, prof, setting="auto"):
+    """-> {} or {"temperature": t[, "seed": SEED]} for one endpoint + profile."""
+    if setting in (None, "", "off") or isinstance(setting, bool):
+        return {}
+    if not takes_sampling(ep["model"], prof):
+        return {}
+    t = 0.0 if setting == "auto" else float(setting)
+    out = {"temperature": t}
+    if ep["provider"] != "anthropic":
+        out["seed"] = SEED
+    return out
+
+
+def check(v):
+    """Validation message for [ai] temperature, or None."""
+    if v in ("auto", "off"):
+        return None
+    if isinstance(v, (int, float)) and not isinstance(v, bool) and 0 <= v <= 2:
+        return None
+    return "must be \"auto\", \"off\" or a number from 0 to 2"