Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

fix(tasks): 兼容并保留历史任务记录中的扩展字段 (#4832)

Axiomotha5166386faf9
diff --git a/openviking/service/task_store.py b/openviking/service/task_store.py
index 0522961eb..9110b07dd 100644
--- a/openviking/service/task_store.py
+++ b/openviking/service/task_store.py
@@ -174,6 +174,7 @@ class PersistentTaskStore:
def _task_to_payload(task: Any) -> Dict[str, Any]:
status = getattr(task, "status", None)
return {
+ **deepcopy(getattr(task, "_extra_fields", {})),
"task_id": task.task_id,
"task_type": task.task_type,
"status": status.value if hasattr(status, "value") else status,
diff --git a/openviking/service/task_tracker.py b/openviking/service/task_tracker.py
index 130229fc5..3ea7911ef 100644
--- a/openviking/service/task_tracker.py
+++ b/openviking/service/task_tracker.py
@@ -19,7 +19,7 @@ import re
import threading
import time
from copy import deepcopy
-from dataclasses import asdict, dataclass, field
+from dataclasses import dataclass, field, fields
from datetime import datetime, timezone
from enum import Enum
from typing import Any, Dict, List, Optional
@@ -82,19 +82,26 @@ class TaskRecord:
result: Optional[Dict[str, Any]] = None
error: Optional[str] = None
auth: Dict[str, Any] = field(default_factory=dict, repr=False)
+ _extra_fields: Dict[str, Any] = field(
+ default_factory=dict, init=False, repr=False, compare=False
+ )
def to_dict(self) -> Dict[str, Any]:
"""Serialize for JSON response."""
- d = asdict(self)
- d["status"] = self.status.value
- d["created_at_iso"] = datetime.fromtimestamp(self.created_at, tz=timezone.utc).isoformat()
- d["updated_at_iso"] = datetime.fromtimestamp(self.updated_at, tz=timezone.utc).isoformat()
- d["result"] = _sanitize_task_result(d.get("result"))
- d["meta"] = _sanitize_task_result(d.get("meta"))
- d.pop("auth", None)
- d.pop("account_id", None)
- d.pop("user_id", None)
- return d
+ return {
+ "task_id": self.task_id,
+ "task_type": self.task_type,
+ "status": self.status.value,
+ "created_at": self.created_at,
+ "updated_at": self.updated_at,
+ "resource_id": self.resource_id,
+ "meta": _sanitize_task_result(deepcopy(self.meta)),
+ "stage": self.stage,
+ "result": _sanitize_task_result(deepcopy(self.result)),
+ "error": self.error,
+ "created_at_iso": datetime.fromtimestamp(self.created_at, tz=timezone.utc).isoformat(),
+ "updated_at_iso": datetime.fromtimestamp(self.updated_at, tz=timezone.utc).isoformat(),
+ }
# ── Singleton ──
@@ -1083,9 +1090,15 @@ class TaskTracker:
@staticmethod
def _record_from_payload(payload: Dict[str, Any]) -> TaskRecord:
- data = dict(payload)
+ known_fields = {item.name for item in fields(TaskRecord) if item.init}
+ data = {key: deepcopy(value) for key, value in payload.items() if key in known_fields}
data["status"] = TaskStatus(data["status"])
- return TaskRecord(**data)
+ record = TaskRecord(**data)
+ # Keep fields from other writers for the next persistence update.
+ record._extra_fields = {
+ key: deepcopy(value) for key, value in payload.items() if key not in known_fields
+ }
+ return record
async def _load_from_store(
self,
diff --git a/tests/test_task_tracker.py b/tests/test_task_tracker.py
index 3e71e774b..e8000aadd 100644
--- a/tests/test_task_tracker.py
+++ b/tests/test_task_tracker.py
@@ -5,13 +5,14 @@
import json
import time
+from copy import deepcopy
import pytest
from openviking.pyagfs.exceptions import AGFSAlreadyExistsError
from openviking.server.identity import RequestContext, Role
from openviking.service.session_service import SessionService
-from openviking.service.task_store import PersistentTaskStore
+from openviking.service.task_store import PersistentTaskStore, _task_to_payload
from openviking.service.task_tracker import (
TaskStatus,
TaskTracker,
@@ -455,6 +456,43 @@ async def test_to_dict(tracker: TaskTracker):
assert (await tracker.list_tasks(**_owner_kwargs()))[0].auth == {}
+async def test_public_serialization_skips_private_payloads(tracker: TaskTracker):
+ class PrivatePayload(dict):
+ def items(self):
+ raise AssertionError("Private payload was traversed")
+
+ def __deepcopy__(self, memo):
+ raise AssertionError("Private payload was copied")
+
+ task = await tracker.create("session_commit", **_owner_kwargs())
+ task.auth = PrivatePayload()
+ task._extra_fields = PrivatePayload()
+ task.meta = {"nested": [{"user_key": "secret", "values": [1]}]}
+ task.result = {"nested": [{"user_key": "secret", "values": [2]}]}
+
+ public = task.to_dict()
+ assert set(public) == {
+ "task_id",
+ "task_type",
+ "status",
+ "created_at",
+ "updated_at",
+ "resource_id",
+ "meta",
+ "stage",
+ "result",
+ "error",
+ "created_at_iso",
+ "updated_at_iso",
+ }
+ assert public["meta"] == {"nested": [{"values": [1]}]}
+ assert public["result"] == {"nested": [{"values": [2]}]}
+ public["meta"]["nested"][0]["values"].append(3)
+ public["result"]["nested"][0]["values"].append(4)
+ assert task.meta["nested"][0]["values"] == [1]
+ assert task.result["nested"][0]["values"] == [2]
+
+
# ── Sanitization ──
@@ -579,6 +617,78 @@ async def test_persistent_store_cross_tracker_visibility():
assert loaded.result == {"ok": True}
+ "extra",
+ [
+ {
+ "operation_id": "operation-1",
+ "parent_task_id": "parent-1",
+ "attempt_number": 2,
+ "error_info": {"category": "network", "retryable": True},
+ },
+ {"future_field": {"values": [1, 2]}, "_extra_fields": {"reserved": True}},
+ ],
+)
+async def test_persistent_task_extensions_survive_updates(extra):
+ agfs = _FakeAgfs()
+ store = PersistentTaskStore(agfs)
+ writer = TaskTracker(store=store)
+ task = await writer.create("session_commit", **_owner_kwargs())
+ path = f"/local/acme/_system/tasks/alice/{task.task_id}.json"
+ payload = json.loads(agfs.files[path])
+ payload.update(extra)
+ agfs.files[path] = json.dumps(payload).encode()
+ original = agfs.files[path]
+
+ reader = TaskTracker(store=store)
+ loaded = await reader.get(task.task_id, **_owner_kwargs())
+ assert loaded is not None
+ assert loaded.status == TaskStatus.PENDING
+ assert not (set(extra) & set(loaded.to_dict()))
+ assert len(await reader.list_tasks(**_owner_kwargs())) == 1
+ assert await reader.get(task.task_id, account_id="acme", user_id="bob") is None
+ assert agfs.files[path] == original
+
+ await reader.start(task.task_id, **_owner_kwargs())
+ await reader.complete(task.task_id, {"ok": True}, **_owner_kwargs())
+ saved = json.loads(agfs.files[path])
+ assert saved["status"] == "completed"
+ assert saved["result"] == {"ok": True}
+ assert {key: saved[key] for key in extra} == extra
+ reloaded = await TaskTracker(store=store).get(task.task_id, **_owner_kwargs())
+ assert reloaded is not None
+ assert reloaded.status == TaskStatus.COMPLETED
+ assert {key: _task_to_payload(reloaded)[key] for key in extra} == extra
+
+
+async def test_task_extension_payload_is_defensively_copied():
+ payload = {
+ "task_id": "task-1",
+ "task_type": "session_commit",
+ "status": "pending",
+ "future_field": {"values": [1]},
+ "meta": {"values": [2]},
+ }
+ original = deepcopy(payload)
+ record = TaskTracker._record_from_payload(payload)
+ record._extra_fields["future_field"]["values"].append(3)
+ record.meta["values"].append(4)
+ assert payload == original
+ saved = _task_to_payload(record)
+ saved["future_field"]["values"].append(5)
+ assert record._extra_fields["future_field"]["values"] == [1, 3]
+ record._extra_fields["status"] = "failed"
+ assert _task_to_payload(record)["status"] == "pending"
+
+
[email protected]("status", ["unknown", None])
+async def test_task_extensions_do_not_hide_invalid_status(status):
+ with pytest.raises(ValueError):
+ TaskTracker._record_from_payload(
+ {"task_id": "task-1", "task_type": "session_commit", "status": status, "extra": 1}
+ )
+
+
async def test_persistent_store_writes_task_record_json():
agfs = _FakeAgfs()
store = PersistentTaskStore(agfs)