decision-ui 0.1.0__tar.gz

decision_ui-0.1.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.3
+Name: decision-ui
+Version: 0.1.0
+Summary: Add your description here
+Author: panuthept
+Author-email: panuthept <falcon_270394@hotmail.co.th>
+Requires-Dist: fastapi>=0.143.0
+Requires-Dist: openai>=3.29.0
+Requires-Dist: pydantic>=2.14.1
+Requires-Dist: transformers>=5.19.0
+Requires-Dist: typer>=0.27.3
+Requires-Dist: typesafe-sdk>=0.7.4
+Requires-Dist: uvicorn>=0.54.0
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# DecisionUI
+A decision interface server, compatible with SystemOne API and OpenAI's Decisions API.
+
+## Usage
+Install DecisionUI
+```bash
+pip install decision-ui
+```
+
+Deploy the model using any inference engine, e.g., vLLM.
+```bash
+vllm serve google/gemma-4-31B-it --host localhost --port 8000
+```
+
+Start a DecisionUI server
+```bash
+decision-ui serve --base_url http://localhost:8000 --host localhost --port 9000
+```
+
+Use it via TypeSafeClient
+```python
+from typesafe_sdk import Choice, TypeSafeClient
+
+with TypeSafeClient(base_url="http://localhost:9000", api_key="EMPTY") as client:
+    decision = client.system_one(
+        model="google/gemma-4-31B-it",
+        state={"document": "I was charged twice. Please fix this ASAP."},
+        questions={
+            "category": Choice(
+                instructions="What is this ticket about?",
+                criteria={"billing": None, "technical": None, "other": None},
+            ),
+        },
+    )
+print(decision.choices["category"].probabilities)
+```

decision_ui-0.1.0/README.md

@@ -0,0 +1,36 @@
+# DecisionUI
+A decision interface server, compatible with SystemOne API and OpenAI's Decisions API.
+
+## Usage
+Install DecisionUI
+```bash
+pip install decision-ui
+```
+
+Deploy the model using any inference engine, e.g., vLLM.
+```bash
+vllm serve google/gemma-4-31B-it --host localhost --port 8000
+```
+
+Start a DecisionUI server
+```bash
+decision-ui serve --base_url http://localhost:8000 --host localhost --port 9000
+```
+
+Use it via TypeSafeClient
+```python
+from typesafe_sdk import Choice, TypeSafeClient
+
+with TypeSafeClient(base_url="http://localhost:9000", api_key="EMPTY") as client:
+    decision = client.system_one(
+        model="google/gemma-4-31B-it",
+        state={"document": "I was charged twice. Please fix this ASAP."},
+        questions={
+            "category": Choice(
+                instructions="What is this ticket about?",
+                criteria={"billing": None, "technical": None, "other": None},
+            ),
+        },
+    )
+print(decision.choices["category"].probabilities)
+```

decision_ui-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "decision-ui"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "fastapi>=0.143.0",
+    "openai>=3.29.0",
+    "pydantic>=2.14.1",
+    "transformers>=5.19.0",
+    "typer>=0.27.3",
+    "typesafe-sdk>=0.7.4",
+    "uvicorn>=0.54.0",
+]
+
+[[project.authors]]
+name = "panuthept"
+email = "falcon_270394@hotmail.co.th"
+
+[project.scripts]
+decision-ui = "decision_ui.cli.main:entry_point"
+
+[build-system]
+requires = ["uv_build>=0.12.24,<0.13.0"]
+build-backend = "uv_build"

decision_ui-0.1.0/pyproject.toml.orig

@@ -0,0 +1,25 @@
+[project]
+name = "decision-ui"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "panuthept", email = "falcon_270394@hotmail.co.th" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "fastapi>=0.143.0",
+    "openai>=3.29.0",
+    "pydantic>=2.14.1",
+    "transformers>=5.19.0",
+    "typer>=0.27.3",
+    "typesafe-sdk>=0.7.4",
+    "uvicorn>=0.54.0",
+]
+
+[project.scripts]
+decision-ui = "decision_ui.cli.main:entry_point"
+
+[build-system]
+requires = ["uv_build>=0.12.24,<0.13.0"]
+build-backend = "uv_build"

decision_ui-0.1.0/src/decision_ui/__init__.py

@@ -0,0 +1,7 @@
+from .core import (
+    Choice,
+    Noul,
+    Score,
+    SystemOneRequest,
+    SystemOneResponse,
+)

decision_ui-0.1.0/src/decision_ui/backends/__init__.py

@@ -0,0 +1,20 @@
+"""Backend registry."""
+
+from __future__ import annotations
+
+from .base import Backend
+
+
+def get_backend(name: str = "mock", **kwargs) -> Backend:
+    if name == "mock":
+        from decision_ui.backends.mock import MockBackend
+
+        return MockBackend()
+    if name == "vllm":
+        from decision_ui.backends.vllm import VLLMBackend
+
+        return VLLMBackend(**kwargs)
+    raise ValueError(f"Unknown backend '{name}'. Available: mock and vllm.")
+
+
+__all__ = ["Backend", "get_backend"]

decision_ui-0.1.0/src/decision_ui/backends/base.py

@@ -0,0 +1,82 @@
+"""Backend interface.
+
+A backend turns ``(state, question)`` pairs into option logits. Every backend must
+implement :meth:`score_options`, which is the single primitive the rest of OpenJev
+builds on. Choice / Score / Noul are all expressed as "score these labels given this
+prompt", which is exactly one forward pass on any causal LM.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Callable
+from abc import ABC, abstractmethod
+from decision_ui.prompt_renders import get_prompt_render as default_prompt_render
+
+from decision_ui.core.data_types import (
+    Answer,
+    Choice,
+    Noul,
+    Score,
+    SystemOneRequest,
+    SystemOneResponse,
+    Usage,
+)
+from decision_ui.core.utilities import (
+    build_choice_answer,
+    build_noul_answer,
+    build_score_answer,
+)
+
+NOUL_LABELS = ["yes", "no"]
+
+
+class Backend(ABC):
+    def __init__(self, prompt_render: Callable = None, **kwargs):
+        self.prompt_render = prompt_render or default_prompt_render
+
+    @property
+    @abstractmethod
+    def available_models(self) -> list[str]:
+        """Return a list of available model IDs."""
+
+    @abstractmethod
+    def score_options(self, model: str, prompt: str, labels: list[str]) -> tuple[list[float], int]:
+        """Return one logit per label plus the number of input tokens consumed."""
+
+    def decide(self, request: SystemOneRequest, temperature: float = 1.0) -> SystemOneResponse:
+        t0 = time.perf_counter()
+        answers: dict[str, Answer] = {}
+        usage = Usage()
+        for qid, q in request.questions.items():
+            if isinstance(q, Choice):
+                labels = q.option_keys()
+                logits, n_in = self.score_options(
+                    request.model,
+                    self.prompt_render(request.state, q.instructions, labels), 
+                    labels
+                )
+                answers[qid] = build_choice_answer(q, logits, temperature)
+            elif isinstance(q, Score):
+                labels = [f"{lvl} ({q.legend[str(lvl)]})" for lvl in q.levels()]
+                logits, n_in = self.score_options(
+                    request.model,
+                    self.prompt_render(request.state, q.instructions, labels), 
+                    labels
+                )
+                answers[qid] = build_score_answer(q, logits, temperature)
+            elif isinstance(q, Noul):
+                logits, n_in = self.score_options(
+                    request.model,
+                    self.prompt_render(request.state, q.instructions, NOUL_LABELS), 
+                    NOUL_LABELS
+                )
+                answers[qid] = build_noul_answer(logits[0], logits[1], temperature)
+            else:  # pragma: no cover
+                raise TypeError(f"Unknown question type: {type(q)!r}")
+            usage.input_tokens += n_in
+            usage.output_tokens += len(labels) if not isinstance(q, Noul) else 2
+        latency_ms = (time.perf_counter() - t0) * 1000
+        return SystemOneResponse(
+            model=request.model, answers=answers, usage=usage, latency_ms=round(latency_ms, 2)
+        )

decision_ui-0.1.0/src/decision_ui/backends/mock.py

@@ -0,0 +1,28 @@
+"""Deterministic mock backend.
+
+Useful for tests, demos and CI: no model download, sub-millisecond latency, and
+stable outputs derived from a hash of (prompt, label). It exists so the REPL, the
+server and the SDK-compat tests can run anywhere.
+"""
+
+from __future__ import annotations
+
+import hashlib
+
+from decision_ui.backends.base import Backend
+
+
+class MockBackend(Backend):
+    @property
+    def available_models(self) -> list[str]:
+        return ["mock-model"]
+
+    def score_options(self, model: str, prompt: str, labels: list[str]) -> tuple[list[float], int]:
+        logits: list[float] = []
+        for label in labels:
+            h = hashlib.sha256((prompt + "\x00" + label).encode("utf-8")).digest()
+            # map first 4 bytes to a logit in roughly [-3, 3]
+            v = int.from_bytes(h[:4], "big") / 0xFFFFFFFF
+            logits.append((v - 0.5) * 6.0)
+        # crude token estimate: ~4 chars per token
+        return logits, max(1, len(prompt) // 4)

decision_ui-0.1.0/src/decision_ui/backends/vllm.py

@@ -0,0 +1,72 @@
+"""vLLM backend.
+
+One forward pass per (state, question). Logits are read at the last position and
+only the first token of each label is compared, then softmaxed across labels so
+nothing outside the option set can win.
+
+Phase 1 will add: shared-state prefill with KV-cache reuse across questions, and
+multi-token label scoring (sum of log-probs) for labels that are not single tokens.
+"""
+
+from __future__ import annotations
+
+from openai import OpenAI
+from decision_ui.backends.base import Backend
+
+
+class VLLMBackend(Backend):
+    def __init__(self, api_key: str | None = None, base_url: str | None = None, **kwargs):
+        super().__init__(**kwargs)
+        self.api_key = api_key
+        self.base_url = base_url
+        self._model_client = OpenAI(api_key=self.api_key, base_url=self.base_url)
+        self._tokenizer_client = OpenAI(api_key=self.api_key, base_url=self.base_url.replace("/v1", ""))
+
+    @property
+    def available_models(self) -> list[str]:
+        return [model.id for model in self._model_client.models.list().data]
+
+    def _tokenize(self, model: str, text: str) -> list[int]:
+        enc = self._tokenizer_client.post(
+            "/tokenize",
+            cast_to=dict,
+            body={
+                "model": model,
+                "prompt": text,
+            },
+        )
+        return enc["tokens"]
+
+    def _detokenize(self, model: str, token_ids: list[int]) -> str:
+        dec = self._tokenizer_client.post(
+            "/detokenize",
+            cast_to=dict,
+            body={
+                "model": model,
+                "tokens": token_ids,
+            },
+        )
+        return dec["prompt"]
+
+    def _first_token(self, model: str, label: str) -> str:
+        ids = self._tokenize(model, label)
+        return self._detokenize(model, [ids[0]])
+
+    def score_options(self, model: str, prompt: str, labels: list[str]) -> tuple[list[float], int]:
+        token_ids = self._tokenize(model, prompt)
+
+        response = self._model_client.chat.completions.create(
+            model=model,
+            messages=[{"role": "user", "content": prompt}],
+            logprobs=True,
+            top_logprobs=20,
+            extra_body={
+                "chat_template_kwargs": {
+                    "enable_thinking": False
+                }
+            }
+        )
+        pred_tokens = {top_logprob.token: top_logprob.logprob for top_logprob in response.choices[0].logprobs.content[0].top_logprobs}
+        cand_tokens = [self._first_token(model, label) for label in labels]
+        logits = [pred_tokens.get(token, float("-inf")) for token in cand_tokens]
+        return logits, len(token_ids)

decision_ui-0.1.0/src/decision_ui/cli/main.py

@@ -0,0 +1,6 @@
+import typer
+from decision_ui.cli.serve_commands import serve_commands
+
+
+entry_point = typer.Typer()
+entry_point.add_typer(serve_commands)

decision_ui-0.1.0/src/decision_ui/cli/serve_commands.py

@@ -0,0 +1,28 @@
+import typer
+import uvicorn
+from typing import Annotated
+from decision_ui.server import create_app
+
+
+serve_commands = typer.Typer()
+
+@serve_commands.command("serve")
+def serve_command(
+    host: Annotated[str, typer.Option("--host", help="The host to serve on")] = "localhost",
+    port: Annotated[int, typer.Option("--port", help="The port to serve on")] = 8000,
+    timeout: Annotated[int, typer.Option("--timeout", help="The timeout for root.run() in seconds")] = 300,
+    backend: Annotated[str, typer.Option("--backend", help="The backend to use for the RØØT server")] = "vllm",
+    base_url: Annotated[str, typer.Option("--base_url", help="The base URL for the backend")] = "http://localhost:8000",
+    api_key: Annotated[str, typer.Option("--api_key", help="The API key for the backend")] = "EMPTY",
+    mock: Annotated[bool, typer.Option("--mock", help="Enable mock mode for the backend")] = False,
+):  
+    # Create the FastAPI app and run it
+    app = create_app(
+        config={
+            "backend": backend if not mock else "mock",
+            "base_url": base_url if base_url.endswith("/v1") else base_url + "/v1",
+            "api_key": api_key,
+            "timeout": timeout,
+        }
+    )
+    uvicorn.run(app, host=host, port=port, workers=1)

decision_ui-0.1.0/src/decision_ui/core/__init__.py

@@ -0,0 +1,14 @@
+from .data_types import (
+    Choice,
+    Noul,
+    Score,
+    SystemOneRequest,
+    SystemOneResponse
+)
+from .utilities import (
+    softmax,
+    confidence_from_probs,
+    build_choice_answer,
+    build_score_answer,
+    build_noul_answer
+)

decision_ui-0.1.0/src/decision_ui/core/data_types.py

@@ -0,0 +1,126 @@
+"""System One primitives: Choice, Score, Noul.
+
+These models mirror the request / response shape of TypeSafe's ``POST /v1/systemone``
+endpoint so that the official SDKs work against OpenJev by changing only the base URL.
+
+OpenJev reproduces the *interface pattern*, not TypeSafe's undisclosed model or training.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal, Union
+
+from pydantic import BaseModel, Field, model_validator
+
+# --------------------------------------------------------------------------------------
+# Questions (request side)
+# --------------------------------------------------------------------------------------
+
+
+class Choice(BaseModel):
+    """Pick exactly one option from a runtime-defined set (2..255 options)."""
+
+    type: Literal["choice"] = "choice"
+    instructions: str
+    options: list[str] | None = None
+    criteria: dict[str, str | None] | None = None
+
+    @model_validator(mode="after")
+    def _check_options(self) -> Choice:
+        keys = self.option_keys()
+        if len(keys) < 2:
+            raise ValueError("Choice needs at least 2 options (use `options` or `criteria`).")
+        if len(keys) > 255:
+            raise ValueError("Choice supports at most 255 options.")
+        return self
+
+    def option_keys(self) -> list[str]:
+        if self.criteria:
+            return list(self.criteria.keys())
+        return list(self.options or [])
+
+
+class Score(BaseModel):
+    """Grade the state on an ordered scale (2..10 levels). Returns a probability-weighted score.
+
+    Accepts either the official request form ``criteria=["level 0 desc", "level 1 desc", ...]``
+    or the response-style ``legend={"0": "...", "1": "..."}``. ``legend`` is always populated.
+    """
+
+    type: Literal["score"] = "score"
+    instructions: str
+    criteria: list[str] | None = None
+    legend: dict[str, str] | None = None
+
+    @model_validator(mode="after")
+    def _normalise(self) -> "Score":
+        if self.legend is None and self.criteria is not None:
+            self.legend = {str(i): desc for i, desc in enumerate(self.criteria)}
+        if self.legend is None:
+            raise ValueError("Score needs `criteria` (list) or `legend` (dict).")
+        if not (2 <= len(self.legend) <= 10):
+            raise ValueError("Score needs between 2 and 10 levels.")
+        for k in self.legend:
+            int(k)  # raises if not numeric
+        return self
+
+    def levels(self) -> list[int]:
+        return sorted(int(k) for k in self.legend)
+
+
+class Noul(BaseModel):
+    """A yes/no judgement. Returns P(true) in [0, 1]."""
+
+    type: Literal["noul"] = "noul"
+    instructions: str
+
+
+Question = Union[Choice, Score, Noul]
+
+
+class SystemOneRequest(BaseModel):
+    """Body of ``POST /v1/systemone``."""
+
+    state: Any
+    questions: dict[str, Question]
+    model: str = "openjev-latest"
+
+
+# --------------------------------------------------------------------------------------
+# Answers (response side)
+# --------------------------------------------------------------------------------------
+
+
+class ChoiceAnswer(BaseModel):
+    type: Literal["choice"] = "choice"
+    choice: str
+    probabilities: dict[str, float]
+    confidence: float
+
+
+class ScoreAnswer(BaseModel):
+    type: Literal["score"] = "score"
+    score: float
+    legend: dict[str, str]
+    probabilities: dict[str, float]
+    confidence: float
+
+
+class NoulAnswer(BaseModel):
+    type: Literal["noul"] = "noul"
+    noul: float
+
+
+Answer = Union[ChoiceAnswer, ScoreAnswer, NoulAnswer]
+
+
+class Usage(BaseModel):
+    input_tokens: int = 0
+    output_tokens: int = 0
+
+
+class SystemOneResponse(BaseModel):
+    model: str
+    answers: dict[str, Answer]
+    usage: Usage = Field(default_factory=Usage)
+    latency_ms: float | None = None

decision_ui-0.1.0/src/decision_ui/core/utilities.py

@@ -0,0 +1,56 @@
+import math
+from decision_ui.core.data_types import Choice, ChoiceAnswer, Score, ScoreAnswer, NoulAnswer
+
+
+def softmax(logits: list[float], temperature: float = 1.0) -> list[float]:
+    if temperature <= 0:
+        raise ValueError("temperature must be > 0")
+    scaled = [x / temperature for x in logits]
+    m = max(scaled)
+    if m == -math.inf:
+        return [0.0 for _ in logits]
+    
+    exps = [math.exp(x - m) for x in scaled]
+    total = sum(exps)
+    return [e / total for e in exps]
+
+
+def confidence_from_probs(probs: list[float]) -> float:
+    """Confidence in [0, 1] as 1 - normalized entropy.
+
+    TypeSafe does not publish its confidence formula. This is an interpretable
+    approximation: 1.0 when all mass is on one option, 0.0 when uniform.
+    """
+    n = len(probs)
+    if n <= 1:
+        return 1.0
+    ent = -sum(p * math.log(p) for p in probs if p > 0)
+    return max(0.0, min(1.0, 1.0 - ent / math.log(n)))
+
+
+def build_choice_answer(
+    question: Choice, option_logits: list[float], temperature: float = 1.0
+) -> ChoiceAnswer:
+    keys = question.option_keys()
+    probs = softmax(option_logits, temperature)
+    dist = {k: round(p, 4) for k, p in zip(keys, probs)}
+    best = keys[max(range(len(keys)), key=lambda i: probs[i])]
+    return ChoiceAnswer(choice=best, probabilities=dist, confidence=round(confidence_from_probs(probs), 4))
+
+
+def build_score_answer(question: Score, level_logits: list[float], temperature: float = 1.0) -> ScoreAnswer:
+    levels = question.levels()
+    probs = softmax(level_logits, temperature)
+    expectation = sum(l * p for l, p in zip(levels, probs))
+    dist = {str(l): round(p, 4) for l, p in zip(levels, probs)}
+    return ScoreAnswer(
+        score=round(expectation, 4),
+        legend=question.legend,
+        probabilities=dist,
+        confidence=round(confidence_from_probs(probs), 4),
+    )
+
+
+def build_noul_answer(yes_logit: float, no_logit: float, temperature: float = 1.0) -> NoulAnswer:
+    p_yes, _ = softmax([yes_logit, no_logit], temperature)
+    return NoulAnswer(noul=round(p_yes, 4))

decision_ui-0.1.0/src/decision_ui/prompt_renders/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Any
+from .default import render_prompt as default_render_prompt
+
+
+def get_prompt_render(state: Any, instructions: str, labels: list[str], name: str = "default") -> str:
+    if name == "default":
+        return default_render_prompt(state, instructions, labels)
+    raise ValueError(f"Unknown prompt name: {name}")
+
+
+__all__ = ["get_prompt_render"]

decision_ui-0.1.0/src/decision_ui/prompt_renders/default.py

@@ -0,0 +1,19 @@
+import json
+from typing import Any
+
+
+def render_state(state: Any) -> str:
+    if isinstance(state, str):
+        return state
+    return json.dumps(state, ensure_ascii=False, indent=2)
+
+def render_prompt(state: Any, instructions: str, labels: list[str]) -> str:
+    """Chat-style prompt whose next token is expected to be one of ``labels``."""
+    options = "\n".join(f"- {label}" for label in labels)
+    return (
+        "You are a decision engine. Read the state, then answer the question by replying "
+        "with exactly one of the allowed labels and nothing else.\n\n"
+        f"### State\n{render_state(state)}\n\n"
+        f"### Question\n{instructions}\n\n"
+        f"### Allowed labels\n{options}\n"
+    )

decision_ui-0.1.0/src/decision_ui/server/__init__.py

@@ -0,0 +1 @@
+from .server import create_app

decision_ui-0.1.0/src/decision_ui/server/routes/decision.py

@@ -0,0 +1,32 @@
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+from decision_ui import Choice, Noul, Score, SystemOneRequest, SystemOneResponse
+
+router = APIRouter()
+
+
+@router.post("/decision")
+async def decision(request: Request):
+    timeout = request.app.state.timeout
+    backend = request.app.state.backend
+
+    body: dict = await request.json()
+    print(body)
+
+    questions = {}
+    for key, value in body["questions"].items():
+        if value["type"] == "choice":
+            question = Choice(instructions=value["instructions"], options=value.get("options"), criteria=value.get("criteria"))
+        elif value["type"] == "noul":
+            question = Noul(instructions=value["instructions"])
+        elif value["type"] == "score":
+            question = Score(instructions=value["instructions"], criteria=value.get("criteria"), legend=value.get("legend"))
+        questions[key] = question
+
+    response: SystemOneResponse = backend.decide(SystemOneRequest(
+        model=body["model"],
+        state=body["state"],
+        questions=questions,
+    ))
+
+    return JSONResponse(response.model_dump())

decision_ui-0.1.0/src/decision_ui/server/routes/decisions.py

@@ -0,0 +1,67 @@
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+from decision_ui import Choice, Noul, Score, SystemOneRequest, SystemOneResponse
+
+router = APIRouter()
+
+
+@router.post("/decisions")
+async def decisions(request: Request):
+    timeout = request.app.state.timeout
+    backend = request.app.state.backend
+
+    body: dict = await request.json()
+    print(body)
+
+    questions = {}
+    questions_types = {}
+    for value in body["questions"]:
+        key = value["name"]
+        if value["type"] == "choice":
+            criteria = {choice["value"]: choice["description"] for choice in value["choices"]}
+            question = Choice(instructions=value["instructions"], criteria=criteria)
+            questions_types[key] = "choice"
+        elif value["type"] == "predicate":
+            question = Noul(instructions=value["instructions"])
+            questions_types[key] = "predicate"
+        elif value["type"] == "score":
+            legend = {str(i): level["label"] for i, level in enumerate(value["levels"])}
+            question = Score(instructions=value["instructions"], legend=legend)
+            questions_types[key] = "score"
+        questions[key] = question
+
+    response: SystemOneResponse = backend.decide(SystemOneRequest(
+        model=body["model"],
+        state=body["input"],
+        questions=questions,
+    ))
+
+    def format_answer(answer, name: str):
+        if answer.type == "choice":
+            return {
+                "type": "choice",
+                "name": name,
+                "choice": answer.choice,
+                "probabilities": [{"value": value, "probability": prob} for value, prob in answer.probabilities.items()],
+                "confidence": answer.confidence
+            }
+        elif answer.type == "noul":
+            return {
+                "type": "predicate",
+                "name": name,
+                "probability": answer.noul
+            }
+        elif answer.type == "score":
+            return {
+                "type": "score",
+                "name": name,
+                "score": answer.score,
+                "probabilities": [{"value": value, "label": answer.legend[value], "probability": prob} for value, prob in answer.probabilities.items()],
+                "confidence": answer.confidence
+            }
+
+    return JSONResponse({
+        "model": body["model"],
+        "answers": [format_answer(response.answers[value["name"]], value["name"]) for value in body["questions"]],
+        "usage": response.usage.model_dump()
+    })

decision_ui-0.1.0/src/decision_ui/server/routes/systemone.py

@@ -0,0 +1,32 @@
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+from decision_ui import Choice, Noul, Score, SystemOneRequest, SystemOneResponse
+
+router = APIRouter()
+
+
+@router.post("/systemone")
+async def systemone(request: Request):
+    timeout = request.app.state.timeout
+    backend = request.app.state.backend
+
+    body: dict = await request.json()
+    print(body)
+
+    questions = {}
+    for key, value in body["questions"].items():
+        if value["type"] == "choice":
+            question = Choice(instructions=value["instructions"], options=value.get("options"), criteria=value.get("criteria"))
+        elif value["type"] == "noul":
+            question = Noul(instructions=value["instructions"])
+        elif value["type"] == "score":
+            question = Score(instructions=value["instructions"], criteria=value.get("criteria"), legend=value.get("legend"))
+        questions[key] = question
+
+    response: SystemOneResponse = backend.decide(SystemOneRequest(
+        model=body["model"],
+        state=body["state"],
+        questions=questions,
+    ))
+
+    return JSONResponse(response.model_dump())

decision_ui-0.1.0/src/decision_ui/server/server.py

@@ -0,0 +1,34 @@
+from fastapi import FastAPI
+from decision_ui.backends import get_backend
+
+
+def create_app(config: dict) -> FastAPI:
+    app = FastAPI()
+    print(f"Creating FastAPI app with configuration: {config}")
+    app.state.timeout = config.get("timeout")
+    app.state.backend = get_backend(
+        config["backend"],
+        base_url=config.get("base_url"),
+        api_key=config.get("api_key"),
+    )
+    print(f"Available models: {app.state.backend.available_models}")
+
+    # ------------------------------------------------------------------
+    # Inference routers (hooks fire on these)
+    # Registered under both "" and "/v1" so the proxy works regardless
+    # of whether the client sets base_url="http://host:port" or
+    # base_url="http://host:port/v1".
+    # ------------------------------------------------------------------
+    from .routes.systemone import router as systemone_router
+    from .routes.decisions import router as decisions_router
+    from .routes.decision import router as decision_router
+
+    app.include_router(systemone_router)
+    app.include_router(decisions_router)
+    app.include_router(decision_router)
+
+    app.include_router(systemone_router, prefix="/v1")
+    app.include_router(decisions_router, prefix="/v1")
+    app.include_router(decision_router, prefix="/alpha")
+
+    return app