oriora-c2 0.1.0__tar.gz

oriora_c2-0.1.0/.gitignore

@@ -0,0 +1 @@
+.vercel

oriora_c2-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Orioralabs OÜ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

oriora_c2-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: oriora-c2
+Version: 0.1.0
+Summary: Oriora c2 — a local proxy that plugs Oriora's model-routing decision into any OpenAI-style agent. Your vendor key and prompts stay on your machine; only the routing decision crosses.
+Project-URL: Homepage, https://orioralabs.com
+Author: Orioralabs OÜ
+License: MIT
+License-File: LICENSE
+Keywords: agent,ai,byok,litellm,llm,model-routing,openai,proxy,router
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.24
+Requires-Dist: litellm[proxy]>=1.0
+Description-Content-Type: text/markdown
+
+# oriora-c2
+
+**Use Oriora's model-routing decision in any OpenAI-style agent — without your key or prompts ever
+leaving your machine.**
+
+`oriora-c2` runs a tiny **local proxy** on `127.0.0.1`. Your agent points at it; before each call it
+asks Oriora's `/api/select` *"which model is best for this task?"*, then dispatches the call
+**directly to the vendor on your own key**. Only the routing decision (task type + your candidate
+models) crosses to Oriora — never the key, the prompt, or the response.
+
+This is for **off-the-shelf agents** (Cursor, Aider, Continue, the raw `openai` SDK, LangChain
+`ChatOpenAI`, …) that can't easily insert a "ask Oriora first" step. *Writing your own code?* You
+don't need this — call `/api/select` directly (or `pip install oriora` and use `model_select()`).
+
+## Install
+```bash
+pip install oriora-c2
+```
+
+## Run
+```bash
+oriora-c2 init                       # scaffolds config.yaml + .env.oriora-c2.example
+# set your keys:
+export ORIORA_API_KEY=sk_oriora_...  # the decision call only
+export DEEPSEEK_API_KEY=...          # your own vendor keys (the actual call runs on these, locally)
+export MINIMAX_API_KEY=...
+oriora-c2 serve                      # local proxy on http://127.0.0.1:4000
+```
+
+Point any OpenAI client at it:
+```python
+from openai import OpenAI
+c = OpenAI(base_url="http://127.0.0.1:4000/v1", api_key="anything")
+c.chat.completions.create(model="oriora-auto", messages=[{"role":"user","content":"…"}])
+# task type is auto-detected locally (free); or force it: model="oriora-auto:coding"
+```
+
+## How it works
+1. Agent → `http://127.0.0.1:4000` (`model="oriora-auto"`). Prompt never leaves your box.
+2. The pre-call hook classifies the task **locally** (free regex rules, no LLM) → calls
+   `POST /api/select` `{task_type, models}` — the **one** Oriora touch ($0.001/decision).
+3. It rewrites `data["model"]` to the recommended model.
+4. LiteLLM dispatches **direct to the vendor on your local key**; the stream flows vendor → you.
+
+**Privacy / c2 invariant:** the proxy is **customer-hosted** (`127.0.0.1`). Only `{task_type, model
+candidates}` reach Oriora. If a third party ever hosted this, it would no longer be c2.
+
+**Fail-open:** if `/api/select` is slow (>`ORIORA_SELECT_TIMEOUT_S`, default 2.5s) or down, the hook
+falls back to `ORIORA_FALLBACK_MODEL` so your agent is never blocked.
+
+## Configuration (env)
+| Var | Purpose |
+|---|---|
+| `ORIORA_API_KEY` | Oriora key for the decision call (required) |
+| `DEEPSEEK_API_KEY`, `MINIMAX_API_KEY`, … | your own vendor keys (the call runs on these) |
+| `ORIORA_CANDIDATES` | comma-sep catalog ids you hold keys for (sent to `/api/select`) |
+| `ORIORA_FALLBACK_MODEL` | model used if the decision call fails (default `deepseek-v4-flash`) |
+| `ORIORA_SELECT_TIMEOUT_S` | decision-call budget before fail-open (default `2.5`) |
+
+Add a vendor = add its key + a `model_list` entry in `config.yaml` + its catalog id to
+`ORIORA_CANDIDATES`. v1 ships configured for **DeepSeek + MiniMax** (OpenAI-format).
+
+MIT © Orioralabs OÜ · https://orioralabs.com

oriora_c2-0.1.0/README.md

@@ -0,0 +1,63 @@
+# oriora-c2
+
+**Use Oriora's model-routing decision in any OpenAI-style agent — without your key or prompts ever
+leaving your machine.**
+
+`oriora-c2` runs a tiny **local proxy** on `127.0.0.1`. Your agent points at it; before each call it
+asks Oriora's `/api/select` *"which model is best for this task?"*, then dispatches the call
+**directly to the vendor on your own key**. Only the routing decision (task type + your candidate
+models) crosses to Oriora — never the key, the prompt, or the response.
+
+This is for **off-the-shelf agents** (Cursor, Aider, Continue, the raw `openai` SDK, LangChain
+`ChatOpenAI`, …) that can't easily insert a "ask Oriora first" step. *Writing your own code?* You
+don't need this — call `/api/select` directly (or `pip install oriora` and use `model_select()`).
+
+## Install
+```bash
+pip install oriora-c2
+```
+
+## Run
+```bash
+oriora-c2 init                       # scaffolds config.yaml + .env.oriora-c2.example
+# set your keys:
+export ORIORA_API_KEY=sk_oriora_...  # the decision call only
+export DEEPSEEK_API_KEY=...          # your own vendor keys (the actual call runs on these, locally)
+export MINIMAX_API_KEY=...
+oriora-c2 serve                      # local proxy on http://127.0.0.1:4000
+```
+
+Point any OpenAI client at it:
+```python
+from openai import OpenAI
+c = OpenAI(base_url="http://127.0.0.1:4000/v1", api_key="anything")
+c.chat.completions.create(model="oriora-auto", messages=[{"role":"user","content":"…"}])
+# task type is auto-detected locally (free); or force it: model="oriora-auto:coding"
+```
+
+## How it works
+1. Agent → `http://127.0.0.1:4000` (`model="oriora-auto"`). Prompt never leaves your box.
+2. The pre-call hook classifies the task **locally** (free regex rules, no LLM) → calls
+   `POST /api/select` `{task_type, models}` — the **one** Oriora touch ($0.001/decision).
+3. It rewrites `data["model"]` to the recommended model.
+4. LiteLLM dispatches **direct to the vendor on your local key**; the stream flows vendor → you.
+
+**Privacy / c2 invariant:** the proxy is **customer-hosted** (`127.0.0.1`). Only `{task_type, model
+candidates}` reach Oriora. If a third party ever hosted this, it would no longer be c2.
+
+**Fail-open:** if `/api/select` is slow (>`ORIORA_SELECT_TIMEOUT_S`, default 2.5s) or down, the hook
+falls back to `ORIORA_FALLBACK_MODEL` so your agent is never blocked.
+
+## Configuration (env)
+| Var | Purpose |
+|---|---|
+| `ORIORA_API_KEY` | Oriora key for the decision call (required) |
+| `DEEPSEEK_API_KEY`, `MINIMAX_API_KEY`, … | your own vendor keys (the call runs on these) |
+| `ORIORA_CANDIDATES` | comma-sep catalog ids you hold keys for (sent to `/api/select`) |
+| `ORIORA_FALLBACK_MODEL` | model used if the decision call fails (default `deepseek-v4-flash`) |
+| `ORIORA_SELECT_TIMEOUT_S` | decision-call budget before fail-open (default `2.5`) |
+
+Add a vendor = add its key + a `model_list` entry in `config.yaml` + its catalog id to
+`ORIORA_CANDIDATES`. v1 ships configured for **DeepSeek + MiniMax** (OpenAI-format).
+
+MIT © Orioralabs OÜ · https://orioralabs.com

oriora_c2-0.1.0/oriora_c2/__init__.py

@@ -0,0 +1,11 @@
+"""oriora-c2 — a local proxy that plugs Oriora's model-routing decision into any OpenAI-style agent.
+
+Your agent points at the local proxy (`model="oriora-auto"`); a LiteLLM pre-call hook asks Oriora's
+`/api/select` which model to use, then dispatches DIRECT to the vendor on YOUR key. Your vendor key
+and prompts never leave the machine — only the routing decision (task_type + candidate models)
+crosses. The hook also classifies the task locally (free, no LLM) so plain calls get routed well.
+"""
+from .custom_callbacks import OrioraRouter, classify, proxy_handler_instance
+
+__version__ = "0.1.0"
+__all__ = ["OrioraRouter", "classify", "proxy_handler_instance", "__version__"]

oriora_c2-0.1.0/oriora_c2/cli.py

@@ -0,0 +1,104 @@
+"""oriora-c2 CLI — `oriora-c2 init` scaffolds a local config; `oriora-c2 serve` runs the proxy.
+
+The proxy binds 127.0.0.1 by design: c2 means the proxy is CUSTOMER-HOSTED. Your vendor key and
+prompts never leave the machine — only the routing decision (task_type + candidate models) crosses
+to Oriora's /api/select.
+"""
+import argparse
+import os
+import subprocess
+import sys
+from importlib import resources
+from pathlib import Path
+
+# LiteLLM loads proxy callbacks by FILE path relative to the config dir (not by installed-package
+# import). So `init` drops this 1-line shim next to config.yaml; it re-exports the installed hook.
+HOOK_SHIM = (
+    "# Auto-written by `oriora-c2 init`. LiteLLM loads callbacks by local file path, so this shim\n"
+    "# re-exports the installed package's hook for config.yaml to reference.\n"
+    "from oriora_c2.custom_callbacks import proxy_handler_instance  # noqa: F401\n"
+)
+
+ENV_EXAMPLE = """\
+# oriora-c2 environment — fill these, then export (e.g. `set -a; source .env.oriora-c2.example`)
+# before `oriora-c2 serve`.
+ORIORA_API_KEY=sk_oriora_...        # your Oriora key — used ONLY for the /api/select decision call
+DEEPSEEK_API_KEY=                   # your OWN vendor keys — used for the actual AI call, locally
+MINIMAX_API_KEY=
+# Optional tuning:
+# ORIORA_SELECT_URL=https://api.orioralabs.com/api/select
+# ORIORA_CANDIDATES=deepseek/deepseek-v4-pro,deepseek/deepseek-v4-flash,minimax/minimax-m2
+# ORIORA_FALLBACK_MODEL=deepseek-v4-flash
+# ORIORA_SELECT_TIMEOUT_S=2.5
+"""
+
+
+def _template() -> str:
+    return resources.files("oriora_c2").joinpath("config.template.yaml").read_text()
+
+
+def _init(args) -> int:
+    cfg = Path(args.config)
+    if cfg.exists() and not args.force:
+        print(f"{cfg} already exists — pass --force to overwrite.", file=sys.stderr)
+        return 1
+    cfg.write_text(_template())
+    Path("oriora_c2_hook.py").write_text(HOOK_SHIM)  # litellm loads callbacks by local file path
+    env = Path(".env.oriora-c2.example")
+    if not env.exists():
+        env.write_text(ENV_EXAMPLE)
+    print(f"Wrote {cfg}, oriora_c2_hook.py and {env}.")
+    print("Next: set your keys (see the .env example), add the vendors you hold to the model_list,")
+    print("then run: oriora-c2 serve")
+    return 0
+
+
+def _serve(args) -> int:
+    cfg = Path(args.config)
+    if not cfg.exists():
+        print(f"No {cfg} found — run `oriora-c2 init` first.", file=sys.stderr)
+        return 1
+    env = dict(os.environ)
+    env.pop("DATABASE_URL", None)  # DB-less launch — no Prisma at startup
+    # Resolve the litellm console script next to THIS interpreter (the same venv pip installed us
+    # into), so `oriora-c2 serve` works whether or not that venv is "activated" on PATH.
+    litellm_bin = Path(sys.executable).parent / "litellm"
+    cmd = [
+        str(litellm_bin) if litellm_bin.exists() else "litellm",
+        "--config", str(cfg), "--host", args.host, "--port", str(args.port), "--num_workers", "1",
+    ]
+    print(
+        f"oriora-c2: local proxy on http://{args.host}:{args.port}  "
+        f"(point your agent here with base_url + model='oriora-auto')"
+    )
+    try:
+        return subprocess.call(cmd, env=env)
+    except FileNotFoundError:
+        print("litellm not found — reinstall with `pip install oriora-c2` (it pulls litellm[proxy]).", file=sys.stderr)
+        return 1
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(
+        prog="oriora-c2",
+        description="Oriora c2 — local routing proxy. Agent → localhost → /api/select → vendor on your own key.",
+    )
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    pi = sub.add_parser("init", help="scaffold config.yaml + .env example in the current directory")
+    pi.add_argument("--config", default="config.yaml")
+    pi.add_argument("--force", action="store_true", help="overwrite an existing config.yaml")
+    pi.set_defaults(fn=_init)
+
+    ps = sub.add_parser("serve", help="run the local proxy (127.0.0.1:4000 by default)")
+    ps.add_argument("--config", default="config.yaml")
+    ps.add_argument("--host", default="127.0.0.1")
+    ps.add_argument("--port", type=int, default=4000)
+    ps.set_defaults(fn=_serve)
+
+    args = p.parse_args(argv)
+    return args.fn(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

oriora_c2-0.1.0/oriora_c2/config.template.yaml

@@ -0,0 +1,42 @@
+# oriora-c2 — LiteLLM proxy config (basic 2-vendor build: DeepSeek + MiniMax).
+#
+# The agent points at model "oriora-auto"; custom_callbacks rewrites data["model"] to the model
+# Oriora's /api/select recommends, then LiteLLM dispatches DIRECT to the vendor on the LOCAL key.
+# Explicit deployments (NOT wildcard) — proven to fire the pre-call hook. Each is OpenAI-format
+# (openai/<id> + api_base), matching oriora-server/src/router/providers.ts. Keys come from env.
+#
+# Run:  oriora-c2 serve     (or directly: litellm --config config.yaml --host 127.0.0.1 --port 4000)
+# (127.0.0.1 bind is load-bearing: customer-hosted = c2. If Oriora hosts it, it collapses to c1.)
+
+model_list:
+  # Entrypoint the agent calls. The hook rewrites this before dispatch; the litellm_params here are
+  # only a placeholder so the model_name resolves if /api/select fails before the rewrite.
+  - model_name: oriora-auto
+    litellm_params:
+      model: openai/deepseek-v4-flash
+      api_base: https://api.deepseek.com/v1
+      api_key: os.environ/DEEPSEEK_API_KEY
+
+  # DeepSeek (the keys we hold) — native_model strings /api/select returns, dispatched direct.
+  - model_name: deepseek-v4-flash
+    litellm_params:
+      model: openai/deepseek-v4-flash
+      api_base: https://api.deepseek.com/v1
+      api_key: os.environ/DEEPSEEK_API_KEY
+  - model_name: deepseek-v4-pro
+    litellm_params:
+      model: openai/deepseek-v4-pro
+      api_base: https://api.deepseek.com/v1
+      api_key: os.environ/DEEPSEEK_API_KEY
+
+  # MiniMax (OpenAI-compatible endpoint).
+  - model_name: minimax-m2
+    litellm_params:
+      model: openai/minimax-m2
+      api_base: https://api.minimax.io/v1
+      api_key: os.environ/MINIMAX_API_KEY
+
+# LiteLLM resolves callbacks by FILE relative to this config's directory, so `oriora-c2 init`
+# drops a tiny `oriora_c2_hook.py` shim here that re-exports the installed package's hook.
+litellm_settings:
+  callbacks: oriora_c2_hook.proxy_handler_instance

oriora_c2-0.1.0/oriora_c2/custom_callbacks.py

@@ -0,0 +1,143 @@
+"""oriora-c2 — the LiteLLM pre-call hook that makes c2 (decision-only routing) work for ANY agent.
+
+The agent calls model="oriora-auto" against this LOCAL proxy. Before dispatch, this hook fires,
+asks Oriora's /api/select ONCE "which model for this task?", rewrites data["model"] to the
+recommended native model, and LiteLLM then dispatches DIRECT to the vendor on the LOCAL key.
+
+c2 invariant (load-bearing): only the {task_type, candidate models} cross to Oriora — never the
+prompt, never the key, never the response. The proxy is customer-hosted (127.0.0.1). The single
+Oriora touch is the decision call ($0.001). If Oriora is slow/down, we fail OPEN to a default model
+so the agent is never blocked.
+"""
+import os
+import re
+import httpx
+from litellm.integrations.custom_logger import CustomLogger
+
+ORIORA_SELECT_URL = os.environ.get("ORIORA_SELECT_URL", "https://api.orioralabs.com/api/select")
+ORIORA_API_KEY = os.environ.get("ORIORA_API_KEY", "")
+
+# The models this proxy can actually execute (we hold the vendor keys). Sent to /api/select as the
+# `models` candidate filter so the recommendation is always something we can dispatch. Comma-sep env
+# override; defaults to the two vendors we hold (DeepSeek + MiniMax).
+CANDIDATE_MODELS = [
+    m.strip()
+    for m in os.environ.get(
+        "ORIORA_CANDIDATES",
+        "deepseek/deepseek-v4-pro,deepseek/deepseek-v4-flash,minimax/minimax-m2",
+    ).split(",")
+    if m.strip()
+]
+
+# Fail-open target if /api/select errors/times out — must be a model_name in config.yaml.
+FALLBACK_MODEL = os.environ.get("ORIORA_FALLBACK_MODEL", "deepseek-v4-flash")
+
+# Budget for the decision call. Oriora is on every request's critical path, so cap it and fail open
+# past it rather than make the agent wait. Default 2.5s: /api/select runs ~1s (Cloudflare + scoring),
+# so a sub-1s budget would always time out. Lower it only if the endpoint gets faster server-side.
+SELECT_TIMEOUT_S = float(os.environ.get("ORIORA_SELECT_TIMEOUT_S", "2.5"))
+
+# Sentinel model the agent points at. "oriora-auto" or "oriora-auto:coding" (explicit task_type).
+SENTINEL = "oriora-auto"
+
+# When the input exceeds this many chars and no stronger task signal matched, treat it as long_context.
+LONG_CONTEXT_CHARS = int(os.environ.get("ORIORA_LONG_CONTEXT_CHARS", "12000"))
+
+# ── Free LOCAL task classifier ─────────────────────────────────────────────────
+# Maps the prompt to ONE of the router's 16 task_types via ordered regex rules (first match wins).
+# Pure-local, microseconds, $0 — NEVER an LLM. Explicit "oriora-auto:<type>" suffix always overrides.
+#
+# COVERAGE OF ALL 16 ROUTER task_types (no silent gaps — every one has a defined disposition):
+#   RULE-DETECTED (14): coding · code-repair · coding_live · math · math_hard · knowledge ·
+#                       instruction · content-fill · reasoning · research · science · terminal · agentic · hard
+#   SIZE FALLBACK  (1): long_context  (input > LONG_CONTEXT_CHARS and no stronger signal)
+#   DEFAULT        (1): general       (nothing matched)
+# If the router ever adds a new task_type, add it here too — keep this list in sync with
+# GET /api/select/task-types so future-us is never left guessing what's handled.
+# A tiny local embedding model can replace these rules for the fuzzy tail later (still ~$0).
+_CODE_FENCE = re.compile(r"```")
+_FIX_HINT = re.compile(r"\b(fix|debug|broken|stack ?trace|traceback|exception|error[: ]|crash|failing)\b")
+_RULES = [
+    ("math_hard",    re.compile(r"\b(prove|proof|theorem|lemma|derive (the|a)|np-?hard|big-?o)\b")),
+    ("math",         re.compile(r"\b(solve|integral|derivative|equation|factorial|probability|matrix|eigen|calculate|compute)\b|[0-9]\s*[\+\-\*/\^=]\s*[0-9]")),
+    # agentic checked BEFORE coding: strong tool-orchestration intent must beat a stray "api"/"call".
+    ("agentic",      re.compile(r"\b(use (the )?tools?|call (the )?(api|function|tool)|then (do|run|call|fetch)|multi-?step|browse the web|search the web|orchestrat|autonomous|agent loop|plan and (execute|then))\b")),
+    ("coding_live",  re.compile(r"\b(autocomplete|complete (this|the) (code|function|line|snippet)|inline completion|tab completion|as i type)\b")),
+    ("code-repair",  _FIX_HINT),
+    ("coding",       re.compile(r"\b(function|class\b|def |refactor|implement|compile|unit test|regex|api\b|sql|typescript|python|rust|golang|java\b|async|null pointer|code)\b")),
+    ("terminal",     re.compile(r"\b(bash|shell|terminal|cli command|command to|chmod|grep\b|git |docker|kubectl|npm |pip install)\b")),
+    ("research",     re.compile(r"\b(research|cite (sources|references)|literature|state of the art|survey of|sources for)\b")),
+    ("science",      re.compile(r"\b(hypothesis|experiment|molecul|protein|quantum|thermodynamic|reaction|chemistry|physics|biology)\b")),
+    ("instruction",  re.compile(r"\b(summari[sz]e|translate|rewrite|reword|paraphrase|format (this|the)|convert (this|the)|extract the)\b")),
+    ("content-fill", re.compile(r"\b(write (a|an|me)|draft (a|an)|compose|generate (a|an).{0,20}(post|email|caption|tweet|blurb|copy))\b")),
+    ("knowledge",    re.compile(r"\b(what (is|are|was)|who (is|was)|when (did|was)|where (is|are)|define\b|explain|difference between|how does)\b")),
+    ("reasoning",    re.compile(r"\b(step by step|reason through|analy[sz]e|compare|trade-?offs?|pros and cons|strategy|decide)\b")),
+    # hard: prompt explicitly self-declares difficulty (rare; agents should tag instead).
+    ("hard",         re.compile(r"\b(this is (a )?hard|very (difficult|hard|complex)|hard problem|extremely (difficult|complex)|notoriously (hard|difficult)|challenging problem)\b")),
+]
+
+
+def _gather_text(messages) -> str:
+    parts = []
+    for m in (messages or []):
+        c = m.get("content") if isinstance(m, dict) else None
+        if isinstance(c, str):
+            parts.append(c)
+        elif isinstance(c, list):  # OpenAI content-parts (multimodal)
+            for p in c:
+                if isinstance(p, dict) and isinstance(p.get("text"), str):
+                    parts.append(p["text"])
+    return "\n".join(parts)
+
+
+def classify(messages) -> str:
+    text = _gather_text(messages)
+    low = text.lower()
+    if _CODE_FENCE.search(text):
+        return "code-repair" if _FIX_HINT.search(low) else "coding"
+    for task_type, rx in _RULES:
+        if rx.search(low):
+            return task_type
+    return "long_context" if len(text) > LONG_CONTEXT_CHARS else "general"
+
+
+class OrioraRouter(CustomLogger):
+    async def async_pre_call_hook(self, user_api_key_dict, cache, data, call_type):
+        requested = (data.get("model") or "")
+        # Only intercept our sentinel; anything else passes through untouched.
+        if not requested.startswith(SENTINEL):
+            return data
+
+        # task_type: explicit "oriora-auto:coding" suffix wins; otherwise AUTO-CLASSIFY the prompt
+        # locally (free regex rules, no LLM); 'general' only when nothing matches.
+        if ":" in requested:
+            task_type = requested.split(":", 1)[1].strip() or "general"
+        else:
+            task_type = classify(data.get("messages"))
+
+        native = FALLBACK_MODEL
+        try:
+            async with httpx.AsyncClient(timeout=SELECT_TIMEOUT_S) as client:
+                r = await client.post(
+                    ORIORA_SELECT_URL,
+                    headers={"Authorization": f"Bearer {ORIORA_API_KEY}"},
+                    json={"task_type": task_type, "models": CANDIDATE_MODELS},
+                )
+                if r.status_code == 200:
+                    picked = (r.json() or {}).get("native_model")
+                    if picked:
+                        native = picked
+                        print(f"[oriora-c2] /api/select 200 OK: task_type={task_type} -> {native} (ORIORA DECISION)")
+                    else:
+                        print(f"[oriora-c2] /api/select 200 but no native_model; FAIL-OPEN -> {FALLBACK_MODEL}")
+                else:
+                    print(f"[oriora-c2] /api/select HTTP {r.status_code}; FAIL-OPEN -> {FALLBACK_MODEL}")
+        except Exception as e:  # timeout / network — never block the agent
+            print(f"[oriora-c2] /api/select error ({e!r}); FAIL-OPEN -> {FALLBACK_MODEL}")
+
+        data["model"] = native
+        return data
+
+
+# Registered via litellm_settings.callbacks in config.yaml.
+proxy_handler_instance = OrioraRouter()

oriora_c2-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "oriora-c2"
+version = "0.1.0"
+description = "Oriora c2 — a local proxy that plugs Oriora's model-routing decision into any OpenAI-style agent. Your vendor key and prompts stay on your machine; only the routing decision crosses."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Orioralabs OÜ" }]
+keywords = ["llm", "ai", "model-routing", "router", "byok", "openai", "litellm", "proxy", "agent"]
+dependencies = ["litellm[proxy]>=1.0", "httpx>=0.24"]
+
+[project.scripts]
+oriora-c2 = "oriora_c2.cli:main"
+
+[project.urls]
+Homepage = "https://orioralabs.com"
+
+[tool.hatch.build.targets.wheel]
+packages = ["oriora_c2"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"oriora_c2/config.template.yaml" = "oriora_c2/config.template.yaml"
+
+[tool.hatch.build.targets.sdist]
+include = ["oriora_c2", "README.md", "LICENSE", "pyproject.toml"]