98 lines
4.3 KiB
Python
98 lines
4.3 KiB
Python
"""Ausführung einer RouteDecision auf Stufe 0–3 und Erkennung von Laufzeit-Signalen."""
|
||
|
||
from __future__ import annotations
|
||
|
||
from typing import Any
|
||
|
||
from pydantic import BaseModel, Field
|
||
|
||
from . import programs
|
||
from .classifier import EmbeddingClassifier
|
||
from .embeddings import Embedder
|
||
from .llm import ChatClient, ContextOverflowError, LLMError
|
||
from .problems import Signal, extract_json, is_degenerate
|
||
from .router import RouteDecision, system_prompt
|
||
from .skills import Skill, SkillLibrary
|
||
|
||
|
||
class ExecutionResult(BaseModel):
|
||
ok: bool
|
||
output: str = ""
|
||
signals: list[Signal] = Field(default_factory=list)
|
||
messages: list[dict[str, str]] = Field(default_factory=list)
|
||
finish_reason: str | None = None
|
||
usage: dict[str, Any] = Field(default_factory=dict)
|
||
error: str | None = None
|
||
label: str | None = None
|
||
confidence: float | None = None
|
||
|
||
|
||
def build_messages(skill: Skill | None, decision: RouteDecision, text: str) -> list[dict[str, str]]:
|
||
system = system_prompt(skill, decision.prompt_variant)
|
||
messages = []
|
||
if system:
|
||
messages.append({"role": "system", "content": system})
|
||
messages.append({"role": "user", "content": text})
|
||
return messages
|
||
|
||
|
||
class Executor:
|
||
def __init__(self, library: SkillLibrary, chat: ChatClient, embedder: Embedder,
|
||
classifiers: dict[str, EmbeddingClassifier] | None = None):
|
||
self.library = library
|
||
self.chat = chat
|
||
self.embedder = embedder
|
||
self.classifiers = classifiers or {}
|
||
|
||
def execute(self, decision: RouteDecision, text: str) -> ExecutionResult:
|
||
if decision.status != "routed":
|
||
return ExecutionResult(ok=False, error=f"Entscheidung nicht ausführbar: {decision.status}")
|
||
skill = self.library.get(decision.skill) if decision.skill else None
|
||
if decision.stage == 3:
|
||
return self._classify(skill, text)
|
||
if decision.stage == 2:
|
||
return self._program(skill, text)
|
||
return self._llm(skill, decision, text)
|
||
|
||
def _classify(self, skill: Skill | None, text: str) -> ExecutionResult:
|
||
assert skill and skill.meta.classifier
|
||
clf = self.classifiers.get(skill.meta.classifier)
|
||
if clf is None:
|
||
return ExecutionResult(ok=False, signals=[Signal.PROGRAM_ERROR],
|
||
error=f"Classifier {skill.meta.classifier} nicht geladen")
|
||
label, confidence = clf.predict(self.embedder.embed([text])[0])
|
||
if confidence < skill.meta.min_confidence:
|
||
return ExecutionResult(ok=False, output=label, label=label, confidence=confidence,
|
||
signals=[Signal.CLASSIFIER_LOW_CONFIDENCE])
|
||
return ExecutionResult(ok=True, output=label, label=label, confidence=confidence)
|
||
|
||
def _program(self, skill: Skill | None, text: str) -> ExecutionResult:
|
||
assert skill and skill.meta.program
|
||
try:
|
||
output = programs.get(skill.meta.program)(text)
|
||
except Exception as exc: # noqa: BLE001 – Programmfehler sind ein Signal, kein Absturz
|
||
return ExecutionResult(ok=False, signals=[Signal.PROGRAM_ERROR], error=f"{type(exc).__name__}: {exc}")
|
||
return ExecutionResult(ok=True, output=output)
|
||
|
||
def _llm(self, skill: Skill | None, decision: RouteDecision, text: str) -> ExecutionResult:
|
||
messages = build_messages(skill, decision, text)
|
||
try:
|
||
res = self.chat.chat(decision.model or "", messages, max_tokens=decision.max_output_tokens)
|
||
except ContextOverflowError as exc:
|
||
return ExecutionResult(ok=False, messages=messages, signals=[Signal.CONTEXT_OVERFLOW], error=str(exc))
|
||
except LLMError as exc:
|
||
return ExecutionResult(ok=False, messages=messages, signals=[Signal.ENDPOINT_ERROR], error=str(exc))
|
||
|
||
signals: list[Signal] = []
|
||
if res.finish_reason == "length":
|
||
signals.append(Signal.OUTPUT_TRUNCATED)
|
||
if is_degenerate(res.content):
|
||
signals.append(Signal.DEGENERATE_OUTPUT)
|
||
if skill is not None and skill.meta.output.format == "json":
|
||
try:
|
||
extract_json(res.content)
|
||
except ValueError:
|
||
signals.append(Signal.INVALID_FORMAT)
|
||
return ExecutionResult(ok=not signals, output=res.content, signals=signals, messages=messages,
|
||
finish_reason=res.finish_reason, usage=res.usage)
|