This commit is contained in:
Lars committed 2026-08-25 13:57:23 +02:00
1 parent a8caeb0dd4
commit fd7102e3b3
95 files changed
+16520 -193

No files matched your search

+41
View File
@@ -1,8 +1,10 @@
from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel, Field
from auth import require_admin_dep
from db import get_db
from dialogue_store import StoreError, get_conversation, inventory, list_conversations, list_derived_for_conversation, list_messages
from provider_settings import ROLES, SettingsError, public_status, set_role_key, upsert_setting
from version import APP_VERSION, BUILD_DATE, MODULE_VERSIONS
router = APIRouter(prefix="/api/admin", tags=["admin"])
@@ -15,6 +17,7 @@ def admin_health(session: dict = Depends(require_admin_dep)):
prompts = conn.execute("SELECT COUNT(*) AS n FROM ai_prompts").fetchone()["n"]
features = conn.execute("SELECT COUNT(*) AS n FROM features").fetchone()["n"]
dialogue = inventory()
providers = public_status()
return {
"ok": True,
"service": "kansho",
@@ -26,6 +29,10 @@ def admin_health(session: dict = Depends(require_admin_dep)):
"prompts": prompts,
"features": features,
"dialogue": dialogue,
"providers": {
role["role"]: {"ready": role["ready"], "key_present": role["key_present"]}
for role in providers["roles"]
},
},
"session": {
"profile_id": session["profile_id"],
@@ -54,3 +61,37 @@ def admin_conversation(conversation_id: str, session: dict = Depends(require_adm
}
except StoreError as exc:
raise HTTPException(status_code=exc.status_code, detail={"code": exc.code, "message": exc.message}) from exc
class ProviderUpdate(BaseModel):
name: str = ""
url: str = ""
model: str = ""
zdr: bool = True
no_train: bool = True
key: str | None = Field(default=None, description="Write-only. Never returned.")
@router.get("/providers")
def admin_providers(session: dict = Depends(require_admin_dep)):
return public_status()
@router.put("/providers/{role}")
def admin_update_provider(role: str, body: ProviderUpdate, session: dict = Depends(require_admin_dep)):
if role not in ROLES:
raise HTTPException(status_code=404, detail={"code": "unknown_provider_role", "message": "Unbekannte Provider-Rolle."})
try:
upsert_setting(
role,
name=body.name,
url=body.url,
model=body.model,
zdr=body.zdr,
no_train=body.no_train,
)
if body.key is not None and body.key.strip():
set_role_key(role, body.key)
except SettingsError as exc:
raise HTTPException(status_code=exc.status_code, detail={"code": exc.code, "message": exc.message}) from exc
return public_status()
+34 -2
View File
@@ -7,10 +7,13 @@ from auth import require_auth
from context_builder import build_internal_context
from continuity import checkpoint_usage_session, close_usage_session
from derived_kinds import catalog
from dialogue_turn import run_turn, visible_for_role
from engine import EngineError
from dialogue_store import (
StoreError,
append_message,
create_conversation,
delete_conversation,
create_handoff,
create_space,
create_thread,
@@ -27,7 +30,7 @@ from dialogue_store import (
router = APIRouter(prefix="/api/dialogue", tags=["dialogue"])
def _http(exc: StoreError):
def _http(exc: StoreError | EngineError):
raise HTTPException(status_code=exc.status_code, detail={"code": exc.code, "message": exc.message}) from exc
@@ -38,6 +41,7 @@ class SessionWrite(BaseModel):
class ConversationWrite(BaseModel):
usage_session_id: str | None = None
title: str = ""
space_id: str | None = None
class MessageWrite(BaseModel):
@@ -102,7 +106,12 @@ def checkpoint_session(usage_session_id: str, session: dict = Depends(require_au
@router.post("/conversations")
def post_conversation(req: ConversationWrite, session: dict = Depends(require_auth)):
try:
return create_conversation(session["profile_id"], req.usage_session_id, req.title)
return create_conversation(
session["profile_id"],
req.usage_session_id,
req.title,
space_id=req.space_id,
)
except StoreError as exc:
_http(exc)
@@ -112,6 +121,18 @@ def get_conversations(session: dict = Depends(require_auth)):
return list_conversations(session["profile_id"])
@router.delete("/conversations/{conversation_id}")
def remove_conversation(conversation_id: str, session: dict = Depends(require_auth)):
try:
from writing_profile_store import remember_dialogue_style
result = delete_conversation(session["profile_id"], conversation_id)
remember_dialogue_style(session["profile_id"])
return result
except StoreError as exc:
_http(exc)
@router.get("/conversations/{conversation_id}")
def get_one_conversation(conversation_id: str, session: dict = Depends(require_auth)):
try:
@@ -139,6 +160,17 @@ def post_message(conversation_id: str, req: MessageWrite, session: dict = Depend
_http(exc)
@router.post("/conversations/{conversation_id}/turn")
def conversation_turn(conversation_id: str, req: MessageWrite, session: dict = Depends(require_auth)):
try:
return visible_for_role(
run_turn(session["profile_id"], conversation_id, req.body, message_id=req.id),
session.get("role"),
)
except (StoreError, EngineError) as exc:
_http(exc)
@router.get("/conversations/{conversation_id}/messages")
def get_messages(conversation_id: str, session: dict = Depends(require_auth)):
try:
+604
View File
@@ -0,0 +1,604 @@
from __future__ import annotations
from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
from fastapi.responses import FileResponse
from pydantic import BaseModel, Field
from auth import require_auth
from dialogue_store import StoreError, delete_conversation, get_conversation, list_messages
from dialogue_turn import run_turn, visible_for_role
from privacy_gateway import GatewayRequest, inspect
from engine import EngineError
from journal_generate import generate_draft
from journal_policy import PolicyError
from journal_store import (
create_day_conversation,
create_user_space,
day_payload,
get_day,
get_entry,
get_or_create_day,
get_user_space,
list_days,
list_user_spaces,
list_versions,
rename_user_space,
restore_entry,
save_day_scratch,
save_entry,
soft_delete_entry,
)
from media_store import delete_media, get_media, list_media, save_media
from writing_profile_store import (
accept_suggestion as accept_writing_suggestion,
export_document as export_writing_document,
get_profile,
import_corpus,
list_corpus,
rebuild_brief,
reject_suggestion as reject_writing_suggestion,
remember_dialogue_style,
remember_journal_entry,
restore_document as restore_writing_document,
set_governance as set_writing_governance,
update_facet,
update_trait,
)
from profile_review import (
ingest_import,
ingest_journal,
import_result as import_review_result,
open_paste_review,
review_status,
run_api_review,
)
from interaction_profile_store import (
accept_suggestion as accept_interaction_suggestion,
export_document as export_interaction_document,
get_profile as get_interaction_profile,
reject_suggestion as reject_interaction_suggestion,
restore_document as restore_interaction_document,
set_governance as set_interaction_governance,
upsert_preference,
)
from profile_documents import export_bundle, restore_bundle
router = APIRouter(prefix="/api/journal", tags=["journal"])
def _http(exc: StoreError | PolicyError | EngineError):
raise HTTPException(status_code=exc.status_code, detail={"code": exc.code, "message": exc.message}) from exc
class SpaceWrite(BaseModel):
title: str = Field(min_length=1)
class DayWrite(BaseModel):
calendar_date: str = Field(min_length=10, max_length=10)
class ConversationWrite(BaseModel):
title: str = ""
class TurnWrite(BaseModel):
body: str = Field(min_length=1)
id: str | None = None
class GenerateWrite(BaseModel):
conversation_ids: list[str] | None = None
include_existing: bool = False
class EntryWrite(BaseModel):
journal_day_id: str
title: str = ""
body: str = ""
entry_id: str | None = None
origin: str = "user_edit"
source_conversation_ids: list[str] = Field(default_factory=list)
source_message_ids: list[str] = Field(default_factory=list)
class RestoreWrite(BaseModel):
version_id: str
class ScratchItem(BaseModel):
id: str | None = None
text: str = ""
done: bool = False
class ScratchWrite(BaseModel):
items: list[ScratchItem] = Field(default_factory=list)
class ImportWrite(BaseModel):
body: str = Field(min_length=1)
occurred_at: str | None = None
context_hint: str | None = None
class CorpusWrite(BaseModel):
items: list[dict]
class TraitWrite(BaseModel):
statement: str | None = None
locked: bool | None = None
facet_key: str | None = None
label: str | None = None
class GovernanceWrite(BaseModel):
governance: str
class FacetWrite(BaseModel):
value: str | None = None
locked: bool | None = None
class PreferenceWrite(BaseModel):
scope: str = "global"
pref_key: str
value: str
locked: bool | None = None
origin: str = "manual"
class ReviewImportWrite(BaseModel):
result: dict | str
review_id: str | None = None
@router.get("/spaces")
def spaces(session: dict = Depends(require_auth)):
return list_user_spaces(session["profile_id"])
@router.post("/spaces")
def create_space(body: SpaceWrite, session: dict = Depends(require_auth)):
try:
return create_user_space(session["profile_id"], body.title)
except StoreError as exc:
_http(exc)
@router.get("/spaces/{space_id}")
def space_detail(space_id: str, session: dict = Depends(require_auth)):
try:
space = get_user_space(session["profile_id"], space_id)
return {"space": space, "days": list_days(session["profile_id"], space_id)}
except StoreError as exc:
_http(exc)
@router.patch("/spaces/{space_id}")
def space_rename(space_id: str, body: SpaceWrite, session: dict = Depends(require_auth)):
try:
return rename_user_space(session["profile_id"], space_id, body.title)
except StoreError as exc:
_http(exc)
@router.post("/spaces/{space_id}/days")
def open_day(space_id: str, body: DayWrite, session: dict = Depends(require_auth)):
try:
day = get_or_create_day(session["profile_id"], space_id, body.calendar_date)
return day_payload(session["profile_id"], day["id"])
except StoreError as exc:
_http(exc)
@router.get("/days/{journal_day_id}")
def read_day(journal_day_id: str, session: dict = Depends(require_auth)):
try:
return day_payload(session["profile_id"], journal_day_id)
except StoreError as exc:
_http(exc)
@router.patch("/days/{journal_day_id}/scratch")
def write_scratch(journal_day_id: str, body: ScratchWrite, session: dict = Depends(require_auth)):
try:
return {
"scratch": save_day_scratch(
session["profile_id"],
journal_day_id,
[{"id": item.id, "text": item.text, "done": item.done} for item in body.items],
)
}
except StoreError as exc:
_http(exc)
@router.post("/days/{journal_day_id}/conversations")
def start_conversation(journal_day_id: str, body: ConversationWrite, session: dict = Depends(require_auth)):
try:
return create_day_conversation(session["profile_id"], journal_day_id, body.title)
except StoreError as exc:
_http(exc)
@router.delete("/conversations/{conversation_id}")
def remove_conversation(conversation_id: str, session: dict = Depends(require_auth)):
try:
result = delete_conversation(session["profile_id"], conversation_id)
remember_dialogue_style(session["profile_id"])
return result
except StoreError as exc:
_http(exc)
@router.get("/conversations/{conversation_id}")
def read_conversation(conversation_id: str, session: dict = Depends(require_auth)):
try:
conv = get_conversation(session["profile_id"], conversation_id)
return {"conversation": conv, "messages": list_messages(session["profile_id"], conversation_id)}
except StoreError as exc:
_http(exc)
@router.get("/egress-status")
def egress_status(session: dict = Depends(require_auth)):
result = inspect(GatewayRequest(prompt_id=None, purpose="dialogue_turn", data_class="B"))
return {"ready": result.allowed, "reason": result.reason, "provider": result.provider}
@router.post("/conversations/{conversation_id}/turn")
def conversation_turn(conversation_id: str, body: TurnWrite, session: dict = Depends(require_auth)):
try:
return visible_for_role(
run_turn(session["profile_id"], conversation_id, body.body, message_id=body.id),
session.get("role"),
)
except (StoreError, EngineError) as exc:
_http(exc)
@router.post("/days/{journal_day_id}/generate")
def generate(journal_day_id: str, body: GenerateWrite, session: dict = Depends(require_auth)):
try:
return visible_for_role(
generate_draft(
session["profile_id"],
journal_day_id,
conversation_ids=body.conversation_ids,
include_existing=body.include_existing,
explicit=True,
),
session.get("role"),
)
except (StoreError, PolicyError, EngineError) as exc:
_http(exc)
@router.post("/entries")
def write_entry(body: EntryWrite, session: dict = Depends(require_auth)):
try:
get_day(session["profile_id"], body.journal_day_id)
entry = save_entry(
session["profile_id"],
body.journal_day_id,
body.title,
body.body,
origin=body.origin,
entry_id=body.entry_id,
source_conversation_ids=body.source_conversation_ids,
source_message_ids=body.source_message_ids,
)
remember_journal_entry(
session["profile_id"],
entry["id"],
entry.get("body") or "",
origin=body.origin,
)
ingest_journal(
session["profile_id"],
entry["id"],
entry.get("body") or "",
origin=body.origin,
)
return entry
except (StoreError, PolicyError) as exc:
_http(exc)
@router.get("/entries/{entry_id}")
def read_entry(entry_id: str, session: dict = Depends(require_auth)):
try:
entry = get_entry(session["profile_id"], entry_id)
entry["media"] = list_media(session["profile_id"], entry_id)
entry["versions"] = list_versions(session["profile_id"], entry_id)
return entry
except StoreError as exc:
_http(exc)
@router.get("/entries/{entry_id}/versions")
def entry_versions(entry_id: str, session: dict = Depends(require_auth)):
try:
return list_versions(session["profile_id"], entry_id)
except StoreError as exc:
_http(exc)
@router.post("/entries/{entry_id}/restore")
def entry_restore(entry_id: str, body: RestoreWrite, session: dict = Depends(require_auth)):
try:
entry = restore_entry(session["profile_id"], entry_id, body.version_id)
remember_journal_entry(
session["profile_id"],
entry["id"],
entry.get("body") or "",
origin=entry.get("origin"),
)
ingest_journal(
session["profile_id"],
entry["id"],
entry.get("body") or "",
origin=entry.get("origin"),
)
return entry
except StoreError as exc:
_http(exc)
@router.delete("/entries/{entry_id}")
def entry_delete(entry_id: str, session: dict = Depends(require_auth)):
try:
return soft_delete_entry(session["profile_id"], entry_id)
except StoreError as exc:
_http(exc)
@router.post("/entries/{entry_id}/media")
async def entry_media(entry_id: str, file: UploadFile = File(...), session: dict = Depends(require_auth)):
try:
data = await file.read()
return save_media(
session["profile_id"],
entry_id,
file.filename or "media",
file.content_type or "",
data,
)
except StoreError as exc:
_http(exc)
@router.get("/media/{media_id}")
def read_media(media_id: str, session: dict = Depends(require_auth)):
try:
row, path = get_media(session["profile_id"], media_id)
return FileResponse(path, media_type=row["content_type"], filename=row["filename"])
except StoreError as exc:
_http(exc)
@router.delete("/media/{media_id}")
def remove_media(media_id: str, session: dict = Depends(require_auth)):
try:
return delete_media(session["profile_id"], media_id)
except StoreError as exc:
_http(exc)
@router.get("/writing-profile")
def writing_profile(session: dict = Depends(require_auth)):
return get_profile(session["profile_id"])
@router.patch("/writing-profile")
def writing_patch(body: GovernanceWrite, session: dict = Depends(require_auth)):
try:
return set_writing_governance(session["profile_id"], body.governance)
except StoreError as exc:
_http(exc)
@router.patch("/writing-profile/facets/{facet_key}")
def writing_facet(facet_key: str, body: FacetWrite, session: dict = Depends(require_auth)):
try:
return update_facet(
session["profile_id"],
facet_key,
value=body.value,
locked=body.locked,
)
except StoreError as exc:
_http(exc)
@router.patch("/writing-profile/traits/{slug}")
def writing_trait(slug: str, body: TraitWrite, session: dict = Depends(require_auth)):
try:
return update_trait(
session["profile_id"],
slug,
statement=body.statement,
locked=body.locked,
facet_key=body.facet_key,
label=body.label,
)
except StoreError as exc:
_http(exc)
@router.post("/writing-profile/suggestions/{suggestion_id}/accept")
def writing_accept(suggestion_id: str, session: dict = Depends(require_auth)):
try:
return accept_writing_suggestion(session["profile_id"], suggestion_id)
except StoreError as exc:
_http(exc)
@router.post("/writing-profile/suggestions/{suggestion_id}/reject")
def writing_reject(suggestion_id: str, session: dict = Depends(require_auth)):
try:
return reject_writing_suggestion(session["profile_id"], suggestion_id)
except StoreError as exc:
_http(exc)
@router.post("/writing-profile/import")
def writing_import(body: ImportWrite, session: dict = Depends(require_auth)):
try:
return ingest_import(
session["profile_id"],
body.body,
occurred_at=body.occurred_at,
context_hint=body.context_hint,
)
except StoreError as exc:
_http(exc)
@router.post("/writing-profile/corpus")
def writing_corpus(body: CorpusWrite, session: dict = Depends(require_auth)):
try:
return import_corpus(session["profile_id"], body.items)
except StoreError as exc:
_http(exc)
@router.get("/writing-profile/corpus")
def writing_corpus_list(session: dict = Depends(require_auth)):
return {"items": list_corpus(session["profile_id"])}
@router.post("/writing-profile/rebuild")
def writing_rebuild(session: dict = Depends(require_auth)):
return rebuild_brief(session["profile_id"])
@router.get("/writing-profile/review")
def writing_review_status(session: dict = Depends(require_auth)):
return review_status(session["profile_id"])
@router.post("/writing-profile/review/paste")
def writing_review_paste(session: dict = Depends(require_auth)):
try:
return open_paste_review(session["profile_id"])
except StoreError as exc:
_http(exc)
@router.post("/writing-profile/initial-build/paste")
def writing_initial_build_paste(session: dict = Depends(require_auth)):
try:
return open_paste_review(session["profile_id"], mode="initial_build")
except StoreError as exc:
_http(exc)
@router.post("/writing-profile/review/api")
def writing_review_api(session: dict = Depends(require_auth)):
try:
return run_api_review(session["profile_id"])
except (StoreError, EngineError) as exc:
_http(exc)
@router.post("/writing-profile/initial-build/api")
def writing_initial_build_api(session: dict = Depends(require_auth)):
try:
return run_api_review(session["profile_id"], mode="initial_build")
except (StoreError, EngineError) as exc:
_http(exc)
@router.post("/writing-profile/review/import")
def writing_review_import(body: ReviewImportWrite, session: dict = Depends(require_auth)):
try:
return import_review_result(session["profile_id"], body.result, review_id=body.review_id)
except StoreError as exc:
_http(exc)
@router.get("/writing-profile/export")
def writing_export(session: dict = Depends(require_auth)):
return export_writing_document(session["profile_id"])
@router.post("/writing-profile/restore")
def writing_restore(body: dict, session: dict = Depends(require_auth)):
try:
return restore_writing_document(session["profile_id"], body)
except StoreError as exc:
_http(exc)
@router.get("/interaction-profile")
def interaction_profile(session: dict = Depends(require_auth)):
return get_interaction_profile(session["profile_id"])
@router.patch("/interaction-profile")
def interaction_patch(body: GovernanceWrite, session: dict = Depends(require_auth)):
try:
return set_interaction_governance(session["profile_id"], body.governance)
except StoreError as exc:
_http(exc)
@router.patch("/interaction-profile/preferences")
def interaction_pref(body: PreferenceWrite, session: dict = Depends(require_auth)):
try:
return upsert_preference(
session["profile_id"],
scope=body.scope,
pref_key=body.pref_key,
value=body.value,
origin=body.origin if body.origin in {"explicit", "manual"} else "manual",
locked=body.locked,
)
except StoreError as exc:
_http(exc)
@router.post("/interaction-profile/suggestions/{suggestion_id}/accept")
def interaction_accept(suggestion_id: str, session: dict = Depends(require_auth)):
try:
return accept_interaction_suggestion(session["profile_id"], suggestion_id)
except StoreError as exc:
_http(exc)
@router.post("/interaction-profile/suggestions/{suggestion_id}/reject")
def interaction_reject(suggestion_id: str, session: dict = Depends(require_auth)):
try:
return reject_interaction_suggestion(session["profile_id"], suggestion_id)
except StoreError as exc:
_http(exc)
@router.get("/interaction-profile/export")
def interaction_export(session: dict = Depends(require_auth)):
return export_interaction_document(session["profile_id"])
@router.post("/interaction-profile/restore")
def interaction_restore(body: dict, session: dict = Depends(require_auth)):
try:
return restore_interaction_document(session["profile_id"], body)
except StoreError as exc:
_http(exc)
@router.get("/profiles/export")
def profiles_export(session: dict = Depends(require_auth)):
return export_bundle(session["profile_id"])
@router.post("/profiles/restore")
def profiles_restore(body: dict, session: dict = Depends(require_auth)):
try:
return restore_bundle(session["profile_id"], body)
except StoreError as exc:
_http(exc)
+1
View File
@@ -3,6 +3,7 @@ from __future__ import annotations
from fastapi import APIRouter, Depends
from auth import require_auth
import placeholder_mvp # noqa: F401
import placeholder_system # noqa: F401
from placeholders import list_placeholders
from privacy_placeholders import catalog as privacy_catalog
+13
View File
@@ -117,6 +117,19 @@ def update_prompt(prompt_id: str, req: PromptWrite, session: dict = Depends(requ
current = row_to_dict(conn.execute("SELECT id FROM ai_prompts WHERE id = ?", (prompt_id,)).fetchone())
if not current:
raise HTTPException(404, "Prompt nicht gefunden")
if req.prompt_type == "base" and req.template:
try:
preview_prompt(
{
"id": prompt_id,
"slug": req.slug.strip(),
"prompt_type": req.prompt_type,
"template": req.template,
},
{},
)
except EngineError as exc:
_http(exc)
conn.execute(
"""
UPDATE ai_prompts