491 lines
13 KiB
Python
491 lines
13 KiB
Python
from collections.abc import AsyncIterator
|
|
from datetime import datetime, timezone
|
|
|
|
from fastapi import APIRouter, Query
|
|
from fastapi.responses import StreamingResponse
|
|
|
|
from app.contracts import (
|
|
AgentEvent,
|
|
AgentEventType,
|
|
AgentRun,
|
|
AgentRunCreateRequest,
|
|
AgentRunListResponse,
|
|
ChatRequest,
|
|
ErrorResponse,
|
|
ExtensionInstallRequest,
|
|
IndexJob,
|
|
IndexRebuildRequest,
|
|
IndexStatus,
|
|
ModelEvent,
|
|
ModelEventType,
|
|
Note,
|
|
NoteCreateRequest,
|
|
NoteListResponse,
|
|
NoteMoveRequest,
|
|
NoteUpdateRequest,
|
|
OperationResponse,
|
|
PageMeta,
|
|
PermissionDecisionRequest,
|
|
Plugin,
|
|
PluginListResponse,
|
|
ProviderConfig,
|
|
ProviderCreateRequest,
|
|
ProviderListResponse,
|
|
ProviderModelsResponse,
|
|
ProviderTestRequest,
|
|
ProviderTestResponse,
|
|
ProviderUpdateRequest,
|
|
SearchRequest,
|
|
SearchResponse,
|
|
Skill,
|
|
SkillListResponse,
|
|
Task,
|
|
TaskCreateRequest,
|
|
TaskListResponse,
|
|
TaskUpdateRequest,
|
|
ToolListResponse,
|
|
TranscriptionJob,
|
|
TranscriptionRequest,
|
|
)
|
|
from app.errors import not_implemented
|
|
|
|
router = APIRouter(prefix="/api")
|
|
not_implemented_response = {501: {"model": ErrorResponse, "description": "业务服务尚未实现"}}
|
|
|
|
|
|
def utc_now() -> datetime:
|
|
return datetime.now(timezone.utc)
|
|
|
|
|
|
def as_sse(event: str, payload: str) -> str:
|
|
return f"event: {event}\ndata: {payload}\n\n"
|
|
|
|
|
|
# Notes
|
|
@router.get("/notes", response_model=NoteListResponse, tags=["Notes"])
|
|
async def list_notes(
|
|
limit: int = Query(default=50, ge=1, le=100),
|
|
offset: int = Query(default=0, ge=0),
|
|
folder: str | None = None,
|
|
tag: str | None = None,
|
|
) -> NoteListResponse:
|
|
return NoteListResponse(page=PageMeta(limit=limit, offset=offset))
|
|
|
|
|
|
@router.post(
|
|
"/notes", response_model=Note, responses=not_implemented_response, tags=["Notes"]
|
|
)
|
|
async def create_note(_: NoteCreateRequest) -> Note:
|
|
not_implemented("notes.create")
|
|
|
|
|
|
@router.get(
|
|
"/notes/{note_id}", response_model=Note, responses=not_implemented_response, tags=["Notes"]
|
|
)
|
|
async def get_note(note_id: str) -> Note:
|
|
not_implemented(f"notes.read:{note_id}")
|
|
|
|
|
|
@router.patch(
|
|
"/notes/{note_id}", response_model=Note, responses=not_implemented_response, tags=["Notes"]
|
|
)
|
|
async def update_note(note_id: str, _: NoteUpdateRequest) -> Note:
|
|
not_implemented(f"notes.update:{note_id}")
|
|
|
|
|
|
@router.delete(
|
|
"/notes/{note_id}",
|
|
response_model=OperationResponse,
|
|
responses=not_implemented_response,
|
|
tags=["Notes"],
|
|
)
|
|
async def delete_note(note_id: str) -> OperationResponse:
|
|
not_implemented(f"notes.delete:{note_id}")
|
|
|
|
|
|
@router.post(
|
|
"/notes/{note_id}/move", response_model=Note, responses=not_implemented_response, tags=["Notes"]
|
|
)
|
|
async def move_note(note_id: str, _: NoteMoveRequest) -> Note:
|
|
not_implemented(f"notes.move:{note_id}")
|
|
|
|
|
|
# Retrieval and chat
|
|
@router.post("/search", response_model=SearchResponse, tags=["Search"])
|
|
async def search_notes(request: SearchRequest) -> SearchResponse:
|
|
return SearchResponse(
|
|
query=request.query,
|
|
mode=request.mode,
|
|
page=PageMeta(limit=request.limit, offset=request.offset),
|
|
)
|
|
|
|
|
|
@router.post(
|
|
"/chat",
|
|
response_class=StreamingResponse,
|
|
responses={
|
|
200: {
|
|
"description": "ModelEvent Server-Sent Events stream",
|
|
"content": {"text/event-stream": {}},
|
|
}
|
|
},
|
|
tags=["Chat"],
|
|
)
|
|
async def chat(_: ChatRequest) -> StreamingResponse:
|
|
async def stream() -> AsyncIterator[str]:
|
|
error = ModelEvent(
|
|
event=ModelEventType.error,
|
|
data={"code": "NOT_IMPLEMENTED", "message": "Chat runtime is not implemented."},
|
|
timestamp=utc_now(),
|
|
)
|
|
done = ModelEvent(event=ModelEventType.done, sequence=1, timestamp=utc_now())
|
|
yield as_sse(error.event.value, error.model_dump_json())
|
|
yield as_sse(done.event.value, done.model_dump_json())
|
|
|
|
return StreamingResponse(stream(), media_type="text/event-stream")
|
|
|
|
|
|
# Agent
|
|
@router.get("/agent/runs", response_model=AgentRunListResponse, tags=["Agent"])
|
|
async def list_agent_runs(
|
|
limit: int = Query(default=50, ge=1, le=100), offset: int = Query(default=0, ge=0)
|
|
) -> AgentRunListResponse:
|
|
return AgentRunListResponse(page=PageMeta(limit=limit, offset=offset))
|
|
|
|
|
|
@router.post(
|
|
"/agent/runs",
|
|
response_model=AgentRun,
|
|
status_code=202,
|
|
responses=not_implemented_response,
|
|
tags=["Agent"],
|
|
)
|
|
async def create_agent_run(_: AgentRunCreateRequest) -> AgentRun:
|
|
not_implemented("agent.runs.create")
|
|
|
|
|
|
@router.get(
|
|
"/agent/runs/{run_id}",
|
|
response_model=AgentRun,
|
|
responses=not_implemented_response,
|
|
tags=["Agent"],
|
|
)
|
|
async def get_agent_run(run_id: str) -> AgentRun:
|
|
not_implemented(f"agent.runs.read:{run_id}")
|
|
|
|
|
|
@router.post(
|
|
"/agent/runs/{run_id}/cancel",
|
|
response_model=OperationResponse,
|
|
responses=not_implemented_response,
|
|
tags=["Agent"],
|
|
)
|
|
async def cancel_agent_run(run_id: str) -> OperationResponse:
|
|
not_implemented(f"agent.runs.cancel:{run_id}")
|
|
|
|
|
|
@router.get(
|
|
"/agent/runs/{run_id}/events",
|
|
response_class=StreamingResponse,
|
|
responses={
|
|
200: {
|
|
"description": "AgentEvent Server-Sent Events stream",
|
|
"content": {"text/event-stream": {}},
|
|
}
|
|
},
|
|
tags=["Agent"],
|
|
)
|
|
async def agent_events(run_id: str) -> StreamingResponse:
|
|
async def stream() -> AsyncIterator[str]:
|
|
event = AgentEvent(
|
|
event=AgentEventType.run_failed,
|
|
run_id=run_id,
|
|
sequence=0,
|
|
data={"code": "NOT_IMPLEMENTED", "message": "Agent runtime is not implemented."},
|
|
timestamp=utc_now(),
|
|
)
|
|
yield as_sse(event.event.value, event.model_dump_json())
|
|
|
|
return StreamingResponse(stream(), media_type="text/event-stream")
|
|
|
|
|
|
@router.post(
|
|
"/agent/runs/{run_id}/permissions/{request_id}",
|
|
response_model=OperationResponse,
|
|
responses=not_implemented_response,
|
|
tags=["Agent"],
|
|
)
|
|
async def decide_agent_permission(
|
|
run_id: str, request_id: str, _: PermissionDecisionRequest
|
|
) -> OperationResponse:
|
|
not_implemented(f"agent.permissions:{run_id}:{request_id}")
|
|
|
|
|
|
@router.get("/tools", response_model=ToolListResponse, tags=["Agent"])
|
|
async def list_tools() -> ToolListResponse:
|
|
return ToolListResponse()
|
|
|
|
|
|
# Skills
|
|
@router.get("/skills", response_model=SkillListResponse, tags=["Skills"])
|
|
async def list_skills() -> SkillListResponse:
|
|
return SkillListResponse()
|
|
|
|
|
|
@router.get(
|
|
"/skills/{skill_id}", response_model=Skill, responses=not_implemented_response, tags=["Skills"]
|
|
)
|
|
async def get_skill(skill_id: str) -> Skill:
|
|
not_implemented(f"skills.read:{skill_id}")
|
|
|
|
|
|
@router.post(
|
|
"/skills/install",
|
|
response_model=Skill,
|
|
status_code=202,
|
|
responses=not_implemented_response,
|
|
tags=["Skills"],
|
|
)
|
|
async def install_skill(_: ExtensionInstallRequest) -> Skill:
|
|
not_implemented("skills.install")
|
|
|
|
|
|
@router.post(
|
|
"/skills/{skill_id}/enable",
|
|
response_model=Skill,
|
|
responses=not_implemented_response,
|
|
tags=["Skills"],
|
|
)
|
|
async def enable_skill(skill_id: str) -> Skill:
|
|
not_implemented(f"skills.enable:{skill_id}")
|
|
|
|
|
|
@router.post(
|
|
"/skills/{skill_id}/disable",
|
|
response_model=Skill,
|
|
responses=not_implemented_response,
|
|
tags=["Skills"],
|
|
)
|
|
async def disable_skill(skill_id: str) -> Skill:
|
|
not_implemented(f"skills.disable:{skill_id}")
|
|
|
|
|
|
@router.delete(
|
|
"/skills/{skill_id}",
|
|
response_model=OperationResponse,
|
|
responses=not_implemented_response,
|
|
tags=["Skills"],
|
|
)
|
|
async def uninstall_skill(skill_id: str) -> OperationResponse:
|
|
not_implemented(f"skills.uninstall:{skill_id}")
|
|
|
|
|
|
# Plugins
|
|
@router.get("/plugins", response_model=PluginListResponse, tags=["Plugins"])
|
|
async def list_plugins() -> PluginListResponse:
|
|
return PluginListResponse()
|
|
|
|
|
|
@router.get(
|
|
"/plugins/{plugin_id}",
|
|
response_model=Plugin,
|
|
responses=not_implemented_response,
|
|
tags=["Plugins"],
|
|
)
|
|
async def get_plugin(plugin_id: str) -> Plugin:
|
|
not_implemented(f"plugins.read:{plugin_id}")
|
|
|
|
|
|
@router.post(
|
|
"/plugins/install",
|
|
response_model=Plugin,
|
|
status_code=202,
|
|
responses=not_implemented_response,
|
|
tags=["Plugins"],
|
|
)
|
|
async def install_plugin(_: ExtensionInstallRequest) -> Plugin:
|
|
not_implemented("plugins.install")
|
|
|
|
|
|
@router.post(
|
|
"/plugins/{plugin_id}/enable",
|
|
response_model=Plugin,
|
|
responses=not_implemented_response,
|
|
tags=["Plugins"],
|
|
)
|
|
async def enable_plugin(plugin_id: str) -> Plugin:
|
|
not_implemented(f"plugins.enable:{plugin_id}")
|
|
|
|
|
|
@router.post(
|
|
"/plugins/{plugin_id}/disable",
|
|
response_model=Plugin,
|
|
responses=not_implemented_response,
|
|
tags=["Plugins"],
|
|
)
|
|
async def disable_plugin(plugin_id: str) -> Plugin:
|
|
not_implemented(f"plugins.disable:{plugin_id}")
|
|
|
|
|
|
@router.delete(
|
|
"/plugins/{plugin_id}",
|
|
response_model=OperationResponse,
|
|
responses=not_implemented_response,
|
|
tags=["Plugins"],
|
|
)
|
|
async def uninstall_plugin(plugin_id: str) -> OperationResponse:
|
|
not_implemented(f"plugins.uninstall:{plugin_id}")
|
|
|
|
|
|
# Providers
|
|
@router.get("/providers", response_model=ProviderListResponse, tags=["Providers"])
|
|
async def list_providers() -> ProviderListResponse:
|
|
return ProviderListResponse()
|
|
|
|
|
|
@router.get(
|
|
"/providers/{provider_id}",
|
|
response_model=ProviderConfig,
|
|
responses=not_implemented_response,
|
|
tags=["Providers"],
|
|
)
|
|
async def get_provider(provider_id: str) -> ProviderConfig:
|
|
not_implemented(f"providers.read:{provider_id}")
|
|
|
|
|
|
@router.post(
|
|
"/providers",
|
|
response_model=ProviderConfig,
|
|
responses=not_implemented_response,
|
|
tags=["Providers"],
|
|
)
|
|
async def create_provider(_: ProviderCreateRequest) -> ProviderConfig:
|
|
not_implemented("providers.create")
|
|
|
|
|
|
@router.patch(
|
|
"/providers/{provider_id}",
|
|
response_model=ProviderConfig,
|
|
responses=not_implemented_response,
|
|
tags=["Providers"],
|
|
)
|
|
async def update_provider(provider_id: str, _: ProviderUpdateRequest) -> ProviderConfig:
|
|
not_implemented(f"providers.update:{provider_id}")
|
|
|
|
|
|
@router.delete(
|
|
"/providers/{provider_id}",
|
|
response_model=OperationResponse,
|
|
responses=not_implemented_response,
|
|
tags=["Providers"],
|
|
)
|
|
async def delete_provider(provider_id: str) -> OperationResponse:
|
|
not_implemented(f"providers.delete:{provider_id}")
|
|
|
|
|
|
@router.get(
|
|
"/providers/{provider_id}/models",
|
|
response_model=ProviderModelsResponse,
|
|
responses=not_implemented_response,
|
|
tags=["Providers"],
|
|
)
|
|
async def list_provider_models(provider_id: str) -> ProviderModelsResponse:
|
|
not_implemented(f"providers.models:{provider_id}")
|
|
|
|
|
|
@router.post(
|
|
"/providers/test",
|
|
response_model=ProviderTestResponse,
|
|
responses=not_implemented_response,
|
|
tags=["Providers"],
|
|
)
|
|
async def test_provider(_: ProviderTestRequest) -> ProviderTestResponse:
|
|
not_implemented("providers.test")
|
|
|
|
|
|
# Tasks
|
|
@router.get("/tasks", response_model=TaskListResponse, tags=["Tasks"])
|
|
async def list_tasks(
|
|
limit: int = Query(default=50, ge=1, le=100), offset: int = Query(default=0, ge=0)
|
|
) -> TaskListResponse:
|
|
return TaskListResponse(page=PageMeta(limit=limit, offset=offset))
|
|
|
|
|
|
@router.post(
|
|
"/tasks", response_model=Task, responses=not_implemented_response, tags=["Tasks"]
|
|
)
|
|
async def create_task(_: TaskCreateRequest) -> Task:
|
|
not_implemented("tasks.create")
|
|
|
|
|
|
@router.get(
|
|
"/tasks/{task_id}", response_model=Task, responses=not_implemented_response, tags=["Tasks"]
|
|
)
|
|
async def get_task(task_id: str) -> Task:
|
|
not_implemented(f"tasks.read:{task_id}")
|
|
|
|
|
|
@router.patch(
|
|
"/tasks/{task_id}", response_model=Task, responses=not_implemented_response, tags=["Tasks"]
|
|
)
|
|
async def update_task(task_id: str, _: TaskUpdateRequest) -> Task:
|
|
not_implemented(f"tasks.update:{task_id}")
|
|
|
|
|
|
@router.delete(
|
|
"/tasks/{task_id}",
|
|
response_model=OperationResponse,
|
|
responses=not_implemented_response,
|
|
tags=["Tasks"],
|
|
)
|
|
async def delete_task(task_id: str) -> OperationResponse:
|
|
not_implemented(f"tasks.delete:{task_id}")
|
|
|
|
|
|
# Media and index
|
|
@router.post(
|
|
"/media/transcriptions",
|
|
response_model=TranscriptionJob,
|
|
status_code=202,
|
|
responses=not_implemented_response,
|
|
tags=["Media"],
|
|
)
|
|
async def create_transcription(_: TranscriptionRequest) -> TranscriptionJob:
|
|
not_implemented("media.transcriptions.create")
|
|
|
|
|
|
@router.get(
|
|
"/media/transcriptions/{job_id}",
|
|
response_model=TranscriptionJob,
|
|
responses=not_implemented_response,
|
|
tags=["Media"],
|
|
)
|
|
async def get_transcription(job_id: str) -> TranscriptionJob:
|
|
not_implemented(f"media.transcriptions.read:{job_id}")
|
|
|
|
|
|
@router.get("/index/status", response_model=IndexStatus, tags=["Index"])
|
|
async def get_index_status() -> IndexStatus:
|
|
return IndexStatus()
|
|
|
|
|
|
@router.post(
|
|
"/index/rebuild",
|
|
response_model=IndexJob,
|
|
status_code=202,
|
|
responses=not_implemented_response,
|
|
tags=["Index"],
|
|
)
|
|
async def rebuild_index(_: IndexRebuildRequest) -> IndexJob:
|
|
not_implemented("index.rebuild")
|
|
|
|
|
|
@router.get(
|
|
"/index/jobs/{job_id}",
|
|
response_model=IndexJob,
|
|
responses=not_implemented_response,
|
|
tags=["Index"],
|
|
)
|
|
async def get_index_job(job_id: str) -> IndexJob:
|
|
not_implemented(f"index.jobs.read:{job_id}")
|