Merge branch 'main' into dependabot/pip/pip-6e802688c2

Author: liuooo

.github/workflows/docker-image.yml renamed to .github/workflows/docker-image-api.yml

@@ -1,7 +1,9 @@
-name: Docker Image CI
+name: API Docker Image CI
 
 on:
   push:
+    paths-ignore:
+      - 'playground-ui/**'
     branches:
       - 'main'
   release:

.github/workflows/docker-image-playground-ui.yml

@@ -0,0 +1,60 @@
+name: Playground UI Docker Image CI
+
+on:
+  push:
+    paths:
+      - 'playground-ui/**'
+    branches:
+      - 'main'
+  release:
+    types: [ published ]
+
+env:
+  IMAGE_NAME: 'samepaage/open-assistant-playground-ui'
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USER }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.IMAGE_NAME }}
+          tags: |
+            type=raw,value=latest,enable=${{ startsWith(github.ref, 'refs/tags/') }}
+            type=ref,event=branch
+            type=sha,enable=true,priority=100,prefix=,suffix=,format=long
+            type=raw,value=${{ github.ref_name }},enable=${{ startsWith(github.ref, 'refs/tags/') }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: ./playground-ui
+          platforms: |
+            linux/amd64
+            linux/arm64
+          build-args: |
+            COMMIT_SHA=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.revision'] }}
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

Dockerfile

@@ -13,7 +13,7 @@ RUN pip install --no-cache-dir poetry \
 COPY poetry.lock /env/poetry.lock
 COPY pyproject.toml /env/pyproject.toml
 
-RUN cd /env && poetry install --no-dev
+RUN cd /env && poetry lock --no-update && poetry install --only main
 
 EXPOSE 8086
 

README.md

@@ -49,7 +49,7 @@ assistant = client.beta.assistants.create(
 | Built-in Tool            | Extendable            | Not Extendable       |
 | Code Interpreter         | Under Development     | Supported            |
 | LLM Support              | Supports More LLMs    | Only GPT             |
-| Message Streaming Output | Supports              | Not Supported        |
+| Message Streaming Output | Supports              | Supported        |
 | Local Deployment         | Supported             | Not Supported        |
 
 - **LLM Support**: Compared to the official OpenAI version, more models can be supported by integrating with One API.
@@ -92,15 +92,17 @@ Interface documentation address: http://127.0.0.1:8086/docs
 
 ### Complete Usage Example
 
-In this example, an AI assistant is created and run using the official OpenAI client library, including two built-in
-tools, web_search and retrieval, and a custom function.
+In this example, an AI assistant is created and run using the official OpenAI client library. If you need to explore other usage methods, 
+such as streaming output, tools (web_search, retrieval, function), etc., you can find the corresponding code under the examples directory.
 Before running, you need to run `pip install openai` to install the Python `openai` library.
 
 ```sh
 # !pip install openai
-python tests/e2e/index.py
+export PYTHONPATH=$(pwd) 
+python examples/run_assistant.py 
 ```
 
+
 ### Permissions
 Simple user isolation is provided based on tokens to meet SaaS deployment requirements. It can be enabled by configuring `APP_AUTH_ENABLE`.
 

README_CN.md

@@ -48,7 +48,7 @@ assistant = client.beta.assistants.create(
 | 内置 Tool          | 支持扩展               | 不支持扩展                |
 | Code Interpreter | 待开发                | 支持                   |
 | LLM 支持           | 支持更多的 LLM          | 仅 GPT                |
-| Message 流式输出     | 支持                 | 不支持                  |
+| Message 流式输出     | 支持                 | 支持                  |
 | 本地部署             | 支持                 | 不支持                  |
 
 - **LLM 支持**: 相较于 OpenAI 官方版本，可以通过接入 One API 来支持更多的模型。
@@ -89,12 +89,14 @@ Api Base URL: http://127.0.0.1:8086/api/v1
 
 ### 完整使用示例
 
-此示例中使用 OpenAI 官方的 client 库创建并运行了一个 AI 助手，包含了 web_search 和 retrieval 两个内置 tool 和一个自定义 function。
+此示例中使用 OpenAI 官方的 client 库创建并运行了一个 AI 助手。如果需要查看其它使用方式，如流式输出、工具（web_search、retrieval、function)的使用等，
+可以在 examples 查看对应示例。
 运行之前需要运行 `pip install openai` 安装 Python `openai` 库。
 
 ```sh
 # !pip install openai
-python tests/e2e/index.py
+export PYTHONPATH=$(pwd) 
+python examples/run_assistant.py 
 ```
 
 ### 权限

app/api/v1/action.py

@@ -6,7 +6,7 @@
 
 from app.api.deps import get_async_session, get_token_id
 from app.libs.paginate import cursor_page, CommonPage
-from app.models.action import Action
+from app.models.action import Action, ActionRead
 from app.models.token_relation import RelationType
 from app.providers.auth_provider import auth_policy
 from app.schemas.common import DeleteResponse, BaseSuccessDataResponse
@@ -16,44 +16,50 @@
 router = APIRouter()
 
 
-@router.get("", response_model=CommonPage[Action])
+@router.get("", response_model=CommonPage[ActionRead])
 async def list_actions(*, session: AsyncSession = Depends(get_async_session), token_id=Depends(get_token_id)):
     """
     Returns a list of Actions.
     """
     statement = auth_policy.token_filter(
         select(Action), field=Action.id, relation_type=RelationType.Action, token_id=token_id
     )
-    return await cursor_page(statement, session)
+    page = await cursor_page(statement, session)
+    page.data = [ast.model_dump(by_alias=True) for ast in page.data]
+    return page.model_dump(by_alias=True)
 
 
-@router.post("", response_model=List[Action])
+@router.post("", response_model=List[ActionRead])
 async def create_actions(
     *, session: AsyncSession = Depends(get_async_session), body: ActionBulkCreateRequest, token_id=Depends(get_token_id)
-) -> List[Action]:
+):
     """
     Create an action with openapi schema.
     """
 
-    return await ActionService.create_actions(session=session, body=body, token_id=token_id)
+    actions = await ActionService.create_actions(session=session, body=body, token_id=token_id)
+    actions = [item.model_dump(by_alias=True) for item in actions]
+    return actions
 
 
-@router.get("/{action_id}", response_model=Action)
-async def get_action(*, session: AsyncSession = Depends(get_async_session), action_id: str) -> Action:
+@router.get("/{action_id}", response_model=ActionRead)
+async def get_action(*, session: AsyncSession = Depends(get_async_session), action_id: str):
     """
     Retrieves an action.
     """
-    return await ActionService.get_action(session=session, action_id=action_id)
+    action = await ActionService.get_action(session=session, action_id=action_id)
+    return action.model_dump(by_alias=True)
 
 
-@router.post("/{action_id}", response_model=Action)
+@router.post("/{action_id}", response_model=ActionRead)
 async def modify_action(
     *, session: AsyncSession = Depends(get_async_session), action_id: str, body: ActionUpdateRequest
-) -> Action:
+):
     """
     Modifies an action.
     """
-    return await ActionService.modify_action(session=session, action_id=action_id, body=body)
+    action = await ActionService.modify_action(session=session, action_id=action_id, body=body)
+    return action.model_dump(by_alias=True)
 
 
 @router.delete("/{action_id}", response_model=DeleteResponse)

app/api/v1/assistant.py

@@ -3,7 +3,7 @@
 from sqlmodel import select
 
 from app.api.deps import get_token_id, get_async_session
-from app.models.assistant import Assistant, AssistantUpdate, AssistantCreate
+from app.models.assistant import Assistant, AssistantUpdate, AssistantCreate, AssistantRead
 from app.libs.paginate import cursor_page, CommonPage
 from app.models.token_relation import RelationType
 from app.providers.auth_provider import auth_policy
@@ -13,43 +13,48 @@
 router = APIRouter()
 
 
-@router.get("", response_model=CommonPage[Assistant])
+@router.get("", response_model=CommonPage[AssistantRead])
 async def list_assistants(*, session: AsyncSession = Depends(get_async_session), token_id=Depends(get_token_id)):
     """
     Returns a list of assistants.
     """
     statement = auth_policy.token_filter(
         select(Assistant), field=Assistant.id, relation_type=RelationType.Assistant, token_id=token_id
     )
-    return await cursor_page(statement, session)
+    asts_page = await cursor_page(statement, session)
+    asts_page.data = [ast.model_dump(by_alias=True) for ast in asts_page.data]
+    return asts_page
 
 
-@router.post("", response_model=Assistant)
+@router.post("", response_model=AssistantRead)
 async def create_assistant(
     *, session: AsyncSession = Depends(get_async_session), body: AssistantCreate, token_id=Depends(get_token_id)
-) -> Assistant:
+):
     """
     Create an assistant with a model and instructions.
     """
-    return await AssistantService.create_assistant(session=session, body=body, token_id=token_id)
+    ast = await AssistantService.create_assistant(session=session, body=body, token_id=token_id)
+    return ast.model_dump(by_alias=True)
 
 
-@router.get("/{assistant_id}", response_model=Assistant)
-async def get_assistant(*, session: AsyncSession = Depends(get_async_session), assistant_id: str) -> Assistant:
+@router.get("/{assistant_id}", response_model=AssistantRead)
+async def get_assistant(*, session: AsyncSession = Depends(get_async_session), assistant_id: str):
     """
     Retrieves an assistant.
     """
-    return await AssistantService.get_assistant(session=session, assistant_id=assistant_id)
+    ast = await AssistantService.get_assistant(session=session, assistant_id=assistant_id)
+    return ast.model_dump(by_alias=True)
 
 
-@router.post("/{assistant_id}", response_model=Assistant)
+@router.post("/{assistant_id}", response_model=AssistantRead)
 async def modify_assistant(
     *, session: AsyncSession = Depends(get_async_session), assistant_id: str, body: AssistantUpdate
-) -> Assistant:
+):
     """
     Modifies an assistant.
     """
-    return await AssistantService.modify_assistant(session=session, assistant_id=assistant_id, body=body)
+    ast = await AssistantService.modify_assistant(session=session, assistant_id=assistant_id, body=body)
+    return ast.model_dump(by_alias=True)
 
 
 @router.delete("/{assistant_id}", response_model=DeleteResponse)

app/api/v1/message.py

@@ -1,10 +1,12 @@
+from typing import Optional
 from fastapi import APIRouter, Depends
+from fastapi.params import Query
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlmodel import select
 
 from app.api.deps import get_async_session
 from app.models import MessageFile
-from app.models.message import Message, MessageCreate, MessageUpdate
+from app.models.message import Message, MessageCreate, MessageUpdate, MessageRead
 from app.libs.paginate import cursor_page, CommonPage
 from app.services.message.message import MessageService
 
@@ -13,57 +15,68 @@
 
 @router.get(
     "/{thread_id}/messages",
-    response_model=CommonPage[Message],
+    response_model=CommonPage[MessageRead],
 )
 async def list_messages(
     *,
     session: AsyncSession = Depends(get_async_session),
     thread_id: str,
+    run_id: Optional[str] = Query(None, description="Filter messages by the run ID that generated them."),
 ):
     """
     Returns a list of messages for a given thread.
     """
-    return await cursor_page(select(Message).where(Message.thread_id == thread_id), session)
+    statement = select(Message).where(Message.thread_id == thread_id)
+    if run_id:
+        # 根据 run_id 进行过滤
+        statement = statement.where(Message.run_id == run_id)
 
+    page = await cursor_page(statement, session)
+    page.data = [ast.model_dump(by_alias=True) for ast in page.data]
+    return page
 
-@router.post("/{thread_id}/messages", response_model=Message)
+
+@router.post("/{thread_id}/messages", response_model=MessageRead)
 async def create_message(
     *, session: AsyncSession = Depends(get_async_session), thread_id: str, body: MessageCreate
-) -> Message:
+):
     """
     Create a message.
     """
-    return await MessageService.create_message(session=session, thread_id=thread_id, body=body)
+    message = await MessageService.create_message(session=session, thread_id=thread_id, body=body)
+    return message.model_dump(by_alias=True)
 
 
 @router.get(
     "/{thread_id}/messages/{message_id}",
-    response_model=Message,
+    response_model=MessageRead,
 )
 async def get_message(
     *, session: AsyncSession = Depends(get_async_session), thread_id: str, message_id: str
-) -> Message:
+):
     """
     Retrieve a message.
     """
-    return await MessageService.get_message(session=session, thread_id=thread_id, message_id=message_id)
+    message = await MessageService.get_message(session=session, thread_id=thread_id, message_id=message_id)
+    return message.model_dump(by_alias=True)
 
 
 @router.post(
     "/{thread_id}/messages/{message_id}",
-    response_model=Message,
+    response_model=MessageRead,
 )
 async def modify_message(
     *,
     session: AsyncSession = Depends(get_async_session),
     thread_id: str,
     message_id: str = ...,
     body: MessageUpdate = ...,
-) -> Message:
+):
     """
     Modifies a message.
     """
-    return await MessageService.modify_message(session=session, thread_id=thread_id, message_id=message_id, body=body)
+    message = await MessageService.modify_message(session=session, thread_id=thread_id, message_id=message_id, body=body)
+    return message.model_dump(by_alias=True)
 
 
 @router.get(