refactor: 重构 AgentScope 运行时模块并优化前端附件展示
This commit is contained in:
qzl
@@ -1,133 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
from typing import Any
|
||||
|
||||
from storage3.exceptions import StorageApiError
|
||||
|
||||
from core.config.settings import config
|
||||
from services.base.supabase import supabase_service
|
||||
|
||||
|
||||
class AgentAttachmentStorage:
|
||||
def _validate_bucket(self, *, bucket: str) -> None:
|
||||
expected = config.storage.bucket
|
||||
if bucket != expected:
|
||||
raise RuntimeError("Invalid attachment bucket")
|
||||
|
||||
def _bucket_client(self, *, bucket: str) -> Any:
|
||||
self._validate_bucket(bucket=bucket)
|
||||
client = supabase_service.get_admin_client()
|
||||
storage = getattr(client, "storage", None)
|
||||
if storage is None:
|
||||
raise RuntimeError("Supabase storage client unavailable")
|
||||
from_bucket = getattr(storage, "from_", None)
|
||||
if not callable(from_bucket):
|
||||
raise RuntimeError("Supabase storage bucket accessor unavailable")
|
||||
return from_bucket(bucket)
|
||||
|
||||
async def upload_bytes(
|
||||
self,
|
||||
*,
|
||||
bucket: str,
|
||||
path: str,
|
||||
content: bytes,
|
||||
content_type: str,
|
||||
) -> str:
|
||||
def _upload() -> object:
|
||||
bucket_client = self._bucket_client(bucket=bucket)
|
||||
upload = getattr(bucket_client, "upload", None)
|
||||
if not callable(upload):
|
||||
raise RuntimeError("Supabase storage upload is unavailable")
|
||||
return upload(
|
||||
path,
|
||||
content,
|
||||
{
|
||||
"content-type": content_type,
|
||||
"upsert": "true",
|
||||
},
|
||||
)
|
||||
|
||||
try:
|
||||
await asyncio.to_thread(_upload)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
if not _is_bucket_not_found_error(exc):
|
||||
raise
|
||||
await self._ensure_bucket_exists(bucket=bucket)
|
||||
await asyncio.to_thread(_upload)
|
||||
return path
|
||||
|
||||
async def _ensure_bucket_exists(self, *, bucket: str) -> None:
|
||||
def _ensure() -> None:
|
||||
client = supabase_service.get_admin_client()
|
||||
storage = getattr(client, "storage", None)
|
||||
if storage is None:
|
||||
raise RuntimeError("Supabase storage client unavailable")
|
||||
get_bucket = getattr(storage, "get_bucket", None)
|
||||
if not callable(get_bucket):
|
||||
raise RuntimeError("Supabase storage get_bucket is unavailable")
|
||||
try:
|
||||
get_bucket(bucket)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
msg = str(exc).lower()
|
||||
if "bucket" in msg and "not found" in msg:
|
||||
raise RuntimeError(f"Storage bucket '{bucket}' does not exist")
|
||||
raise
|
||||
|
||||
await asyncio.to_thread(_ensure)
|
||||
|
||||
async def download_bytes(self, *, bucket: str, path: str) -> bytes:
|
||||
def _download() -> object:
|
||||
bucket_client = self._bucket_client(bucket=bucket)
|
||||
download = getattr(bucket_client, "download", None)
|
||||
if not callable(download):
|
||||
raise RuntimeError("Supabase storage download is unavailable")
|
||||
return download(path)
|
||||
|
||||
raw = await asyncio.to_thread(_download)
|
||||
if isinstance(raw, bytes):
|
||||
return raw
|
||||
if isinstance(raw, bytearray):
|
||||
return bytes(raw)
|
||||
if isinstance(raw, memoryview):
|
||||
return raw.tobytes()
|
||||
raise RuntimeError("Invalid attachment payload")
|
||||
|
||||
async def create_signed_url(
|
||||
self,
|
||||
*,
|
||||
bucket: str,
|
||||
path: str,
|
||||
expires_in_seconds: int,
|
||||
) -> str:
|
||||
def _create_signed_url() -> object:
|
||||
bucket_client = self._bucket_client(bucket=bucket)
|
||||
signer = getattr(bucket_client, "create_signed_url", None)
|
||||
if not callable(signer):
|
||||
raise RuntimeError("Supabase storage signed url is unavailable")
|
||||
return signer(path, expires_in_seconds)
|
||||
|
||||
raw = await asyncio.to_thread(_create_signed_url)
|
||||
if isinstance(raw, str):
|
||||
return raw
|
||||
if isinstance(raw, dict):
|
||||
signed_url = raw.get("signedURL") or raw.get("signedUrl") or raw.get("url")
|
||||
if isinstance(signed_url, str) and signed_url:
|
||||
return signed_url
|
||||
raise RuntimeError("Invalid signed url payload")
|
||||
|
||||
|
||||
def create_attachment_storage() -> AgentAttachmentStorage | None:
|
||||
try:
|
||||
supabase_service.get_admin_client()
|
||||
except Exception:
|
||||
return None
|
||||
return AgentAttachmentStorage()
|
||||
|
||||
|
||||
def _is_bucket_not_found_error(exc: Exception) -> bool:
|
||||
if isinstance(exc, StorageApiError):
|
||||
message = str(exc).lower()
|
||||
return "bucket" in message and "not found" in message
|
||||
message = str(exc).lower()
|
||||
return "bucket" in message and "not found" in message
|
||||
@@ -19,8 +19,8 @@ from core.agentscope.tools.tool_result_storage import (
|
||||
from core.config.settings import config
|
||||
from core.db import get_db
|
||||
from services.base.redis import get_or_init_redis_client
|
||||
from services.base.supabase import supabase_service
|
||||
from v1.agent.repository import AgentRepository
|
||||
from v1.agent.attachment_storage import create_attachment_storage
|
||||
from v1.agent.service import AgentService
|
||||
|
||||
DEDUP_WAIT_RETRIES = 20
|
||||
@@ -118,10 +118,9 @@ class RedisEventStream:
|
||||
|
||||
def get_agent_service(session: AsyncSession = Depends(get_db)) -> AgentService:
|
||||
tool_result_storage = create_tool_result_storage()
|
||||
attachment_storage = create_attachment_storage()
|
||||
return AgentService(
|
||||
repository=AgentRepository(session, tool_result_storage=tool_result_storage),
|
||||
queue=TaskiqQueueClient(),
|
||||
stream=RedisEventStream(),
|
||||
attachment_storage=attachment_storage,
|
||||
attachment_storage=supabase_service,
|
||||
)
|
||||
|
||||
@@ -12,6 +12,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
|
||||
from core.config.settings import config
|
||||
from models.agent_chat_message import AgentChatMessage, AgentChatMessageRole
|
||||
from models.agent_chat_session import AgentChatSession
|
||||
from services.base.supabase import supabase_service
|
||||
|
||||
|
||||
class ToolResultPayloadStorage(Protocol):
|
||||
@@ -201,61 +202,6 @@ class AgentRepository:
|
||||
return None
|
||||
return str(latest_id)
|
||||
|
||||
async def get_message_attachment_reference(
|
||||
self,
|
||||
*,
|
||||
session_id: str,
|
||||
message_id: str,
|
||||
attachment_index: int,
|
||||
) -> dict[str, str] | None:
|
||||
try:
|
||||
session_uuid = UUID(session_id)
|
||||
message_uuid = UUID(message_id)
|
||||
except ValueError as exc:
|
||||
raise HTTPException(
|
||||
status_code=422, detail="Invalid message/session id"
|
||||
) from exc
|
||||
|
||||
stmt = (
|
||||
select(AgentChatMessage)
|
||||
.where(AgentChatMessage.id == message_uuid)
|
||||
.where(AgentChatMessage.session_id == session_uuid)
|
||||
.where(AgentChatMessage.deleted_at.is_(None))
|
||||
)
|
||||
message = (await self._session.execute(stmt)).scalar_one_or_none()
|
||||
if message is None:
|
||||
return None
|
||||
|
||||
metadata = (
|
||||
message.metadata_json if isinstance(message.metadata_json, dict) else {}
|
||||
)
|
||||
attachments_raw = metadata.get("attachments")
|
||||
if not isinstance(attachments_raw, list):
|
||||
return None
|
||||
if attachment_index < 0 or attachment_index >= len(attachments_raw):
|
||||
return None
|
||||
|
||||
attachment = attachments_raw[attachment_index]
|
||||
if not isinstance(attachment, dict):
|
||||
return None
|
||||
bucket = attachment.get("bucket")
|
||||
path = attachment.get("path")
|
||||
mime_type = attachment.get("mimeType")
|
||||
if (
|
||||
not isinstance(bucket, str)
|
||||
or not bucket
|
||||
or not isinstance(path, str)
|
||||
or not path
|
||||
or not isinstance(mime_type, str)
|
||||
or not mime_type
|
||||
):
|
||||
return None
|
||||
return {
|
||||
"bucket": bucket,
|
||||
"path": path,
|
||||
"mimeType": mime_type,
|
||||
}
|
||||
|
||||
async def _to_snapshot_message(
|
||||
self, message: AgentChatMessage
|
||||
) -> dict[str, object]:
|
||||
@@ -350,29 +296,45 @@ class AgentRepository:
|
||||
payload["content"] = display_content
|
||||
else:
|
||||
payload["content"] = message.content
|
||||
metadata = message.metadata_json or {}
|
||||
attachments = (
|
||||
metadata.get("attachments") if isinstance(metadata, dict) else None
|
||||
)
|
||||
if isinstance(attachments, list):
|
||||
rendered: list[dict[str, object]] = []
|
||||
for index, item in enumerate(attachments):
|
||||
if not isinstance(item, dict):
|
||||
continue
|
||||
mime_type = item.get("mimeType")
|
||||
if not isinstance(mime_type, str) or not mime_type:
|
||||
continue
|
||||
rendered.append(
|
||||
{
|
||||
"mimeType": mime_type,
|
||||
"previewPath": (
|
||||
f"/api/v1/agent/runs/{message.session_id}/attachments/"
|
||||
f"{message.id}/{index}"
|
||||
),
|
||||
}
|
||||
)
|
||||
if rendered:
|
||||
payload["attachments"] = rendered
|
||||
|
||||
if role == AgentChatMessageRole.USER.value:
|
||||
metadata = message.metadata_json or {}
|
||||
user_attachments = metadata.get("user_message_attachments")
|
||||
if isinstance(user_attachments, dict):
|
||||
bucket = user_attachments.get("bucket")
|
||||
path = user_attachments.get("path")
|
||||
mime_type = user_attachments.get("mime_type")
|
||||
if (
|
||||
isinstance(bucket, str)
|
||||
and isinstance(path, str)
|
||||
and isinstance(mime_type, str)
|
||||
):
|
||||
try:
|
||||
signed_url = await supabase_service.create_signed_url(
|
||||
bucket=bucket,
|
||||
path=path,
|
||||
expires_in_seconds=3600,
|
||||
)
|
||||
attachment_block = {
|
||||
"type": "binary",
|
||||
"mimeType": mime_type,
|
||||
"url": signed_url,
|
||||
}
|
||||
existing_content = message.content
|
||||
if (
|
||||
isinstance(existing_content, str)
|
||||
and existing_content.strip()
|
||||
):
|
||||
content_blocks = [
|
||||
{"type": "text", "text": existing_content}
|
||||
]
|
||||
content_blocks.append(attachment_block)
|
||||
payload["content"] = content_blocks
|
||||
else:
|
||||
payload["content"] = [attachment_block]
|
||||
except Exception: # noqa: BLE001
|
||||
pass
|
||||
|
||||
return payload
|
||||
|
||||
|
||||
|
||||
@@ -28,7 +28,7 @@ from fastapi import (
|
||||
status,
|
||||
)
|
||||
from fastapi.responses import JSONResponse, StreamingResponse
|
||||
from schemas.agent.agui_input import (
|
||||
from core.agentscope.schemas.agui_input import (
|
||||
extract_latest_tool_result,
|
||||
parse_run_input,
|
||||
validate_run_request_messages_contract,
|
||||
@@ -318,31 +318,6 @@ async def get_history_snapshot(
|
||||
)
|
||||
|
||||
|
||||
@router.get("/runs/{thread_id}/attachments/{message_id}/{attachment_index}")
|
||||
async def get_attachment_preview(
|
||||
thread_id: str,
|
||||
message_id: str,
|
||||
attachment_index: int,
|
||||
service: Annotated[AgentService, Depends(get_agent_service)],
|
||||
current_user: Annotated[CurrentUser, Depends(get_current_user)],
|
||||
) -> StreamingResponse:
|
||||
if attachment_index < 0:
|
||||
raise HTTPException(status_code=422, detail="Invalid attachment index")
|
||||
payload, mime_type = await service.get_attachment_preview(
|
||||
thread_id=thread_id,
|
||||
message_id=message_id,
|
||||
attachment_index=attachment_index,
|
||||
current_user=current_user,
|
||||
)
|
||||
return StreamingResponse(
|
||||
iter([payload]),
|
||||
media_type=mime_type,
|
||||
headers={
|
||||
"Cache-Control": "private, max-age=300",
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
@router.get("/history")
|
||||
async def get_user_history_snapshot(
|
||||
service: Annotated[AgentService, Depends(get_agent_service)],
|
||||
|
||||
+40
-192
@@ -114,6 +114,8 @@ class AttachmentStorageLike(Protocol):
|
||||
expires_in_seconds: int,
|
||||
) -> str: ...
|
||||
|
||||
def parse_signed_url(self, url: str) -> tuple[str, str]: ...
|
||||
|
||||
|
||||
def ensure_session_owner(*, owner_id: str, current_user: CurrentUser) -> None:
|
||||
if owner_id != str(current_user.id):
|
||||
@@ -204,122 +206,47 @@ class AgentService:
|
||||
run_input: RunAgentInput,
|
||||
current_user: CurrentUser,
|
||||
) -> tuple[str, dict[str, object] | None]:
|
||||
text, _ = extract_latest_user_payload(run_input)
|
||||
content_blocks = _extract_latest_user_content_blocks(run_input)
|
||||
attachments: list[dict[str, object]] = []
|
||||
binary_blocks = [
|
||||
block
|
||||
for block in content_blocks
|
||||
if isinstance(block, dict) and block.get("type") == "binary"
|
||||
]
|
||||
if binary_blocks:
|
||||
from schemas.messages.chat_message import UserMessageAttachments
|
||||
|
||||
text, content_blocks = extract_latest_user_payload(run_input)
|
||||
|
||||
user_attachments: UserMessageAttachments | None = None
|
||||
for block in content_blocks:
|
||||
if not isinstance(block, dict):
|
||||
continue
|
||||
block_type = block.get("type")
|
||||
if block_type != "binary":
|
||||
continue
|
||||
|
||||
url = block.get("url")
|
||||
mime_type = block.get("mimeType")
|
||||
if not isinstance(url, str) or not url:
|
||||
continue
|
||||
if not isinstance(mime_type, str):
|
||||
mime_type = "application/octet-stream"
|
||||
|
||||
if self._attachment_storage is None:
|
||||
raise HTTPException(
|
||||
status_code=503,
|
||||
detail="Attachment storage unavailable",
|
||||
)
|
||||
forwarded_props = (
|
||||
run_input.forwarded_props
|
||||
if isinstance(run_input.forwarded_props, dict)
|
||||
else {}
|
||||
)
|
||||
raw_attachments = forwarded_props.get("attachments")
|
||||
if not isinstance(raw_attachments, list):
|
||||
raise HTTPException(
|
||||
status_code=422, detail="Invalid attachments payload"
|
||||
)
|
||||
if len(raw_attachments) != len(binary_blocks):
|
||||
raise HTTPException(
|
||||
status_code=422, detail="Invalid attachments payload"
|
||||
)
|
||||
continue
|
||||
|
||||
total_attachment_bytes = 0
|
||||
expected_prefix = f"agent-inputs/{current_user.id}/{run_input.thread_id}/"
|
||||
for index, raw_attachment in enumerate(raw_attachments):
|
||||
if not isinstance(raw_attachment, dict):
|
||||
raise HTTPException(
|
||||
status_code=422,
|
||||
detail="Invalid attachment reference",
|
||||
)
|
||||
bucket = raw_attachment.get("bucket")
|
||||
path = raw_attachment.get("path")
|
||||
mime_type = raw_attachment.get("mimeType")
|
||||
if (
|
||||
not isinstance(bucket, str)
|
||||
or not isinstance(path, str)
|
||||
or not isinstance(mime_type, str)
|
||||
):
|
||||
raise HTTPException(
|
||||
status_code=422,
|
||||
detail="Invalid attachment reference",
|
||||
)
|
||||
if bucket != config.storage.bucket:
|
||||
raise HTTPException(status_code=403, detail="Forbidden")
|
||||
if not _is_safe_attachment_path(path, expected_prefix=expected_prefix):
|
||||
raise HTTPException(status_code=403, detail="Forbidden")
|
||||
if mime_type.lower() not in _ALLOWED_ATTACHMENT_MIME_TYPES:
|
||||
raise HTTPException(
|
||||
status_code=422,
|
||||
detail="Unsupported attachment type",
|
||||
)
|
||||
|
||||
binary_block = binary_blocks[index]
|
||||
binary_mime = binary_block.get("mimeType")
|
||||
binary_url = binary_block.get("url")
|
||||
if (
|
||||
not isinstance(binary_mime, str)
|
||||
or binary_mime != mime_type
|
||||
or not isinstance(binary_url, str)
|
||||
or not binary_url
|
||||
):
|
||||
raise HTTPException(
|
||||
status_code=422,
|
||||
detail="Invalid attachments payload",
|
||||
)
|
||||
|
||||
try:
|
||||
payload = await self._attachment_storage.download_bytes(
|
||||
bucket=bucket,
|
||||
path=path,
|
||||
)
|
||||
except Exception: # noqa: BLE001
|
||||
logger.exception(
|
||||
"Attachment validation download failed",
|
||||
extra={
|
||||
"bucket": bucket,
|
||||
"path": path,
|
||||
"thread_id": run_input.thread_id,
|
||||
"run_id": run_input.run_id,
|
||||
},
|
||||
)
|
||||
raise HTTPException(
|
||||
status_code=502,
|
||||
detail="Failed to fetch attachment",
|
||||
)
|
||||
payload_size = len(payload)
|
||||
if payload_size > _MAX_ATTACHMENT_BYTES:
|
||||
raise HTTPException(
|
||||
status_code=413,
|
||||
detail="Attachment too large",
|
||||
)
|
||||
total_attachment_bytes += payload_size
|
||||
if total_attachment_bytes > _MAX_TOTAL_ATTACHMENT_BYTES:
|
||||
raise HTTPException(
|
||||
status_code=413,
|
||||
detail="Attachments too large",
|
||||
)
|
||||
|
||||
attachments.append(
|
||||
{
|
||||
"bucket": bucket,
|
||||
"path": path,
|
||||
"mimeType": mime_type,
|
||||
}
|
||||
try:
|
||||
bucket, path = self._attachment_storage.parse_signed_url(url)
|
||||
user_attachments = UserMessageAttachments(
|
||||
bucket=bucket,
|
||||
path=path,
|
||||
mime_type=mime_type,
|
||||
)
|
||||
metadata: dict[str, object] = {}
|
||||
if attachments:
|
||||
metadata["attachments"] = attachments
|
||||
return text, metadata or None
|
||||
break
|
||||
except Exception: # noqa: BLE001
|
||||
logger.warning("Failed to parse signed URL", url=url)
|
||||
continue
|
||||
|
||||
metadata: dict[str, object] | None = None
|
||||
if user_attachments is not None:
|
||||
metadata = {
|
||||
"user_message_attachments": user_attachments.model_dump(by_alias=True),
|
||||
}
|
||||
|
||||
return text, metadata
|
||||
|
||||
async def upload_attachment(
|
||||
self,
|
||||
@@ -501,63 +428,6 @@ class AgentService:
|
||||
current_user=current_user,
|
||||
)
|
||||
|
||||
async def get_attachment_preview(
|
||||
self,
|
||||
*,
|
||||
thread_id: str,
|
||||
message_id: str,
|
||||
attachment_index: int,
|
||||
current_user: CurrentUser,
|
||||
) -> tuple[bytes, str]:
|
||||
owner = await self._repository.get_session_owner(session_id=thread_id)
|
||||
ensure_session_owner(owner_id=owner, current_user=current_user)
|
||||
if self._attachment_storage is None:
|
||||
raise HTTPException(
|
||||
status_code=503, detail="Attachment storage unavailable"
|
||||
)
|
||||
|
||||
ref = await self._repository.get_message_attachment_reference(
|
||||
session_id=thread_id,
|
||||
message_id=message_id,
|
||||
attachment_index=attachment_index,
|
||||
)
|
||||
if ref is None:
|
||||
raise HTTPException(status_code=404, detail="Attachment not found")
|
||||
|
||||
bucket = ref.get("bucket")
|
||||
path = ref.get("path")
|
||||
mime_type = ref.get("mimeType")
|
||||
if (
|
||||
not isinstance(bucket, str)
|
||||
or not isinstance(path, str)
|
||||
or not isinstance(mime_type, str)
|
||||
):
|
||||
raise HTTPException(status_code=404, detail="Attachment not found")
|
||||
if bucket != config.storage.bucket:
|
||||
raise HTTPException(status_code=403, detail="Forbidden")
|
||||
|
||||
expected_prefix = f"agent-inputs/{current_user.id}/{thread_id}/"
|
||||
if not _is_safe_attachment_path(path, expected_prefix=expected_prefix):
|
||||
raise HTTPException(status_code=403, detail="Forbidden")
|
||||
|
||||
try:
|
||||
payload = await self._attachment_storage.download_bytes(
|
||||
bucket=bucket,
|
||||
path=path,
|
||||
)
|
||||
except Exception: # noqa: BLE001
|
||||
logger.exception(
|
||||
"Attachment download failed",
|
||||
extra={
|
||||
"thread_id": thread_id,
|
||||
"message_id": message_id,
|
||||
"attachment_index": attachment_index,
|
||||
"bucket": bucket,
|
||||
},
|
||||
)
|
||||
raise HTTPException(status_code=502, detail="Failed to fetch attachment")
|
||||
return payload, mime_type
|
||||
|
||||
|
||||
class AsrService:
|
||||
def __init__(self) -> None:
|
||||
@@ -667,28 +537,6 @@ class AsrService:
|
||||
asr_service = AsrService()
|
||||
|
||||
|
||||
def _extract_latest_user_content_blocks(
|
||||
run_input: RunAgentInput,
|
||||
) -> list[dict[str, Any]]:
|
||||
if not run_input.messages:
|
||||
return []
|
||||
latest = run_input.messages[-1]
|
||||
content = getattr(latest, "content", None)
|
||||
if not isinstance(content, list):
|
||||
return []
|
||||
blocks: list[dict[str, Any]] = []
|
||||
for item in content:
|
||||
if isinstance(item, dict):
|
||||
blocks.append(item)
|
||||
continue
|
||||
model_dump = getattr(item, "model_dump", None)
|
||||
if callable(model_dump):
|
||||
dumped = model_dump(mode="json", by_alias=True, exclude_none=True)
|
||||
if isinstance(dumped, dict):
|
||||
blocks.append(dumped)
|
||||
return blocks
|
||||
|
||||
|
||||
def _mime_to_suffix(mime_type: str) -> str:
|
||||
mapping = {
|
||||
"image/png": "png",
|
||||
|
||||
Reference in New Issue
Block a user