Update .gitignore to exclude Python-related files and directories. Enhance AGENTS.md and README.md with clarifications on documentation structure and product identity. Add technical architecture references and local setup instructions. Revise privacy guardrails and product identity documents for consistency. Remove obsolete memory and context documentation. Expand reflection spaces documentation to define context boundaries and lifecycle. Ensure all changes align with the ongoing development of the Kanshō project.

This commit is contained in:
Lars committed 2026-08-21 15:48:43 +02:00
1 parent 3a367b7bcc
commit d62673e48b
89 files changed
+13463 -241

No files matched your search

+215
View File
@@ -0,0 +1,215 @@
from __future__ import annotations
from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel, Field
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_store import (
StoreError,
append_message,
create_conversation,
create_handoff,
create_space,
create_thread,
get_conversation,
insert_derived,
link_conversation_thread,
link_thread_space,
list_conversations,
list_derived_for_conversation,
list_messages,
start_usage_session,
)
router = APIRouter(prefix="/api/dialogue", tags=["dialogue"])
def _http(exc: StoreError):
raise HTTPException(status_code=exc.status_code, detail={"code": exc.code, "message": exc.message}) from exc
class SessionWrite(BaseModel):
intent: str = ""
class ConversationWrite(BaseModel):
usage_session_id: str | None = None
title: str = ""
class MessageWrite(BaseModel):
body: str = Field(min_length=1)
role: str = "user"
id: str | None = None
class ThreadWrite(BaseModel):
title: str = ""
status: str = "open"
visibility: str = "internal"
class SpaceWrite(BaseModel):
title: str = ""
visibility: str = "internal"
class DerivedWrite(BaseModel):
kind: str
subject_type: str
subject_id: str
source_message_ids: list[str]
body: str = ""
visibility: str = "internal"
confidence: float | None = None
class HandoffWrite(BaseModel):
target: str
source_conversation_id: str | None = None
payload: dict = Field(default_factory=dict)
@router.get("/kinds")
def list_kinds(session: dict = Depends(require_auth)):
return catalog()
@router.post("/sessions")
def create_session(req: SessionWrite, session: dict = Depends(require_auth)):
return start_usage_session(session["profile_id"], req.intent)
@router.post("/sessions/{usage_session_id}/end")
def end_session(usage_session_id: str, session: dict = Depends(require_auth)):
try:
return close_usage_session(session["profile_id"], usage_session_id)
except StoreError as exc:
_http(exc)
@router.post("/sessions/{usage_session_id}/checkpoint")
def checkpoint_session(usage_session_id: str, session: dict = Depends(require_auth)):
try:
return checkpoint_usage_session(session["profile_id"], usage_session_id)
except StoreError as exc:
_http(exc)
@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)
except StoreError as exc:
_http(exc)
@router.get("/conversations")
def get_conversations(session: dict = Depends(require_auth)):
return list_conversations(session["profile_id"])
@router.get("/conversations/{conversation_id}")
def get_one_conversation(conversation_id: str, session: dict = Depends(require_auth)):
try:
conv = get_conversation(session["profile_id"], conversation_id)
conv["messages"] = list_messages(session["profile_id"], conversation_id)
conv["derived"] = list_derived_for_conversation(session["profile_id"], conversation_id)
return conv
except StoreError as exc:
_http(exc)
@router.get("/conversations/{conversation_id}/context")
def get_internal_context(conversation_id: str, session: dict = Depends(require_auth)):
try:
return build_internal_context(session["profile_id"], conversation_id)
except StoreError as exc:
_http(exc)
@router.post("/conversations/{conversation_id}/messages")
def post_message(conversation_id: str, req: MessageWrite, session: dict = Depends(require_auth)):
try:
return append_message(session["profile_id"], conversation_id, req.body, req.role, req.id)
except StoreError as exc:
_http(exc)
@router.get("/conversations/{conversation_id}/messages")
def get_messages(conversation_id: str, session: dict = Depends(require_auth)):
try:
return list_messages(session["profile_id"], conversation_id)
except StoreError as exc:
_http(exc)
@router.post("/threads")
def post_thread(req: ThreadWrite, session: dict = Depends(require_auth)):
try:
return create_thread(session["profile_id"], req.title, req.status, req.visibility)
except StoreError as exc:
_http(exc)
@router.post("/conversations/{conversation_id}/threads/{thread_id}")
def post_conversation_thread(conversation_id: str, thread_id: str, session: dict = Depends(require_auth)):
try:
return link_conversation_thread(session["profile_id"], conversation_id, thread_id)
except StoreError as exc:
_http(exc)
@router.post("/spaces")
def post_space(req: SpaceWrite, session: dict = Depends(require_auth)):
try:
return create_space(session["profile_id"], req.title, req.visibility)
except StoreError as exc:
_http(exc)
@router.post("/threads/{thread_id}/spaces/{space_id}")
def post_thread_space(thread_id: str, space_id: str, confidence: float | None = None, session: dict = Depends(require_auth)):
try:
return link_thread_space(session["profile_id"], thread_id, space_id, confidence)
except StoreError as exc:
_http(exc)
@router.post("/derived")
def post_derived(req: DerivedWrite, session: dict = Depends(require_auth)):
try:
return insert_derived(
session["profile_id"],
req.kind,
req.subject_type,
req.subject_id,
req.source_message_ids,
req.body,
req.visibility,
req.confidence,
)
except StoreError as exc:
_http(exc)
@router.get("/derived/latest")
def get_latest(subject_type: str, subject_id: str, kind: str, session: dict = Depends(require_auth)):
from data_layer import read
return read(
"latest_derived",
profile_id=session["profile_id"],
context={"subject_type": subject_type, "subject_id": subject_id, "kind": kind},
)
@router.post("/handoffs")
def post_handoff(req: HandoffWrite, session: dict = Depends(require_auth)):
try:
return create_handoff(session["profile_id"], req.target, req.source_conversation_id, req.payload)
except StoreError as exc:
_http(exc)