edgeone 1.6.24 → 1.6.26

package/edgeone-dist/pages/templates/agent-python/context.py

@@ -307,7 +307,11 @@ class AgentContext:
                 "通常是因为运行时未设置 store。"
             )
         from .memory import ConversationMemory
-        instance = ConversationMemory(self._store_blob, self.run_id)
+        instance = ConversationMemory(
+            self._store_blob,
+            self.run_id,
+            self.conversation_id,
+        )
         object.__setattr__(self, '_store_cached', instance)
         return instance
 

package/edgeone-dist/pages/templates/agent-python/memory.py

@@ -67,6 +67,11 @@ class MemoryStorageError(MemoryError):
     pass
 
 
+class MemoryCorruptError(MemoryError):
+    """Persisted framework state is malformed or incompatible."""
+    pass
+
+
 # ─── Data Model ───
 
 
@@ -170,6 +175,48 @@ _MAX_SAFE_INTEGER = 9007199254740991  # JS Number.MAX_SAFE_INTEGER
 # update_message 用它来判断 content / metadata 是否被传，对齐 Node 的
 # `input.content === undefined` 判断。
 _UNSET: Any = object()
+_STATE_PREFIX = "state"
+_MAX_STATE_KEY_LEN = 256
+
+
+def _validate_state_key(key: str) -> None:
+    if not isinstance(key, str) or not key:
+        raise MemoryValidationError("state key must be a non-empty string")
+    if len(key) > _MAX_STATE_KEY_LEN:
+        raise MemoryValidationError(
+            f"state key exceeds maximum of {_MAX_STATE_KEY_LEN} characters"
+        )
+
+
+def _validate_state_value(value: Any, path: str = "state value", seen=None) -> None:
+    if value is None or isinstance(value, (str, bool)):
+        return
+    if isinstance(value, (int, float)):
+        if isinstance(value, float) and (value != value or value in (float("inf"), float("-inf"))):
+            raise MemoryValidationError(f"{path} must contain only JSON values")
+        return
+    if seen is None:
+        seen = set()
+    if isinstance(value, (list, dict)):
+        identity = id(value)
+        if identity in seen:
+            raise MemoryValidationError(f"{path} must not contain circular references")
+        seen.add(identity)
+        if isinstance(value, list):
+            for index, item in enumerate(value):
+                _validate_state_value(item, f"{path}[{index}]", seen)
+        else:
+            for key, item in value.items():
+                if not isinstance(key, str):
+                    raise MemoryValidationError(f"{path} keys must be strings")
+                _validate_state_value(item, f"{path}.{key}", seen)
+        seen.remove(identity)
+        return
+    raise MemoryValidationError(f"{path} must be JSON serializable")
+
+
+def _state_key(conversation_id: str, key: str) -> str:
+    return f"{_STATE_PREFIX}/{_encode_cid(conversation_id)}/{_encode_segment(key)}"
 
 
 def _json_default(obj: Any) -> Any:
@@ -310,6 +357,52 @@ def _cursor_sort_key(last_message_at: int, conversation_id: str) -> str:
 # ─── ConversationMemory ───
 
 
+class _ConversationState:
+    """Conversation-bound state facade persisted under the state/ prefix."""
+
+    def __init__(self, memory: "ConversationMemory") -> None:
+        self._memory = memory
+
+    def _conversation_id(self) -> str:
+        conversation_id = self._memory._conversation_id
+        if not conversation_id:
+            raise MemoryValidationError(
+                "State operations require a bound conversation_id"
+            )
+        self._memory._validate_conversation_id(conversation_id)
+        return conversation_id
+
+    async def get(self, key: str) -> Any:
+        _validate_state_key(key)
+        conversation_id = self._conversation_id()
+        raw = await self._memory._blob_get_text(_state_key(conversation_id, key))
+        if raw is None:
+            return None
+        try:
+            return json.loads(raw)
+        except (json.JSONDecodeError, TypeError, ValueError) as exc:
+            raise MemoryStorageError("Stored state value is invalid JSON") from exc
+
+    async def set(self, key: str, value: Any) -> None:
+        _validate_state_key(key)
+        conversation_id = self._conversation_id()
+        _validate_state_value(value)
+        try:
+            payload = json.dumps(
+                value, ensure_ascii=False, separators=(",", ":"), allow_nan=False
+            )
+            await self._memory._blob.set(_state_key(conversation_id, key), payload)
+        except MemoryValidationError:
+            raise
+        except Exception as exc:
+            raise MemoryStorageError("Failed to write state value") from exc
+
+    async def delete(self, key: str) -> None:
+        _validate_state_key(key)
+        conversation_id = self._conversation_id()
+        await self._memory._blob_delete(_state_key(conversation_id, key))
+
+
 class ConversationMemory:
     """Conversation message history CRUD, accessed as ctx.store.
 
@@ -317,16 +410,24 @@ class ConversationMemory:
     All core methods are async.
     """
 
-    def __init__(self, blob_store: Any, run_id: str) -> None:
+    def __init__(
+        self,
+        blob_store: Any,
+        run_id: str,
+        conversation_id: Optional[str] = None,
+    ) -> None:
         """
         Args:
             blob_store: Raw blob store instance (pages_blob.Store or LocalFileBlobStore).
                         Must implement: get(key, type=), set(key, value), delete(key),
                         list(prefix=) returning object with .blobs list of objects with .key.
             run_id: Current run ID, auto-injected into message metadata.
+            conversation_id: Optional bound conversation for state and default sessions.
         """
         self._blob = blob_store
         self._run_id = run_id
+        self._conversation_id = conversation_id
+        self._state_cached = _ConversationState(self)
 
     # ─── Validation Helpers ───
 
@@ -400,6 +501,22 @@ class ConversationMemory:
         except Exception as e:
             raise MemoryStorageError(f"Failed to read key '{key}': {e}") from e
 
+    async def _blob_get_json_strict(self, key: str, **kwargs) -> Optional[dict]:
+        """Read JSON and distinguish corrupt state from a missing key."""
+        try:
+            raw = await self._blob.get(key, type="text", **kwargs)
+            if raw is None:
+                return None
+            return json.loads(raw)
+        except (json.JSONDecodeError, TypeError, ValueError) as exc:
+            raise MemoryCorruptError(
+                f"Persisted framework state is corrupt for key '{key}'"
+            ) from exc
+        except MemoryStorageError:
+            raise
+        except Exception as e:
+            raise MemoryStorageError(f"Failed to read key '{key}': {e}") from e
+
     async def _blob_set_json(self, key: str, data: Any) -> None:
         """Serialize value to JSON and write to blob store.
 
@@ -1196,6 +1313,9 @@ class ConversationMemory:
         )
 
         if meta_data is None:
+            await self._delete_bound_state(conversation_id)
+            await self._delete_claude_session_for_conversation(conversation_id)
+            await self.langgraph_checkpointer.adelete_thread(conversation_id)
             raise MemoryNotFoundError(f"Conversation '{conversation_id}' not found")
 
         meta = ConversationMeta.from_dict(meta_data)
@@ -1215,6 +1335,12 @@ class ConversationMemory:
 
         await asyncio.gather(*delete_ops)
 
+        # Keep LangGraph Store items intact while removing checkpoints and
+        # conversation-bound state for the current bound conversation.
+        await self._delete_bound_state(conversation_id)
+        await self._delete_claude_session_for_conversation(conversation_id)
+        await self.langgraph_checkpointer.adelete_thread(conversation_id)
+
     async def update_conversation(
         self, conversation_id: str, metadata: dict
     ) -> ConversationMeta:
@@ -1271,6 +1397,46 @@ class ConversationMemory:
 
     # ─── Framework Helpers ───
 
+    @property
+    def state(self) -> _ConversationState:
+        """Conversation-bound JSON state facade."""
+        return self._state_cached
+
+    async def _delete_bound_state(self, conversation_id: str) -> None:
+        if self._conversation_id != conversation_id:
+            return
+        keys = await self._blob_list_keys(
+            f"{_STATE_PREFIX}/{_encode_cid(conversation_id)}/",
+            consistency="strong",
+        )
+        for key in keys:
+            await self._blob_delete(key)
+
+    async def _delete_claude_session_for_conversation(self, conversation_id: str) -> None:
+        mapping_key = _claude_session_mapping_key(conversation_id)
+        mapping = await self._blob_get_json_strict(mapping_key)
+        session_id: Optional[str] = None
+        if isinstance(mapping, str) and mapping:
+            session_id = mapping
+        elif isinstance(mapping, dict) and isinstance(mapping.get("session_id"), str):
+            session_id = mapping["session_id"]
+        elif isinstance(mapping, dict) and isinstance(mapping.get("sessionId"), str):
+            session_id = mapping["sessionId"]
+        if not session_id:
+            session_id = _normalize_claude_uuid(conversation_id)
+
+        await self._blob_delete(mapping_key)
+        if not session_id:
+            return
+
+        keys = await self._blob_list_keys(f"{_CLAUDE_SESSION_PREFIX}/")
+        encoded_session_id = _encode_segment(session_id)
+        for key in keys:
+            remainder = key[len(f"{_CLAUDE_SESSION_PREFIX}/"):]
+            segments = remainder.split("/")
+            if len(segments) >= 3 and segments[1] == encoded_session_id:
+                await self._blob_delete(key)
+
     @staticmethod
     def to_openai_input(messages: List[Message]) -> List[dict]:
         """Convert Messages to OpenAI-compatible format.
@@ -1326,7 +1492,7 @@ class ConversationMemory:
         self._langgraph_store_cached = adapter
         return adapter
 
-    def openai_session(self, session_id: str, *, max_items: int = 100) -> "_EdgeOneMemorySession":
+    def openai_session(self, session_id: Optional[str] = None, *, max_items: int = 100) -> "_EdgeOneMemorySession":
         """Create an OpenAI Agents SDK Session backed by ctx.store.
 
         Usage with OpenAI Agents SDK::
@@ -1350,12 +1516,50 @@ class ConversationMemory:
             session_id: Conversation/session identifier (typically ctx.conversation_id).
             max_items: Maximum items to retrieve per get_items() call (default 100).
         """
-        return _EdgeOneMemorySession(self, session_id, max_items=max_items)
+        resolved_session_id = (
+            session_id if session_id is not None else self._conversation_id
+        )
+        if not resolved_session_id:
+            raise MemoryValidationError(
+                "openai_session requires a session_id or bound conversation_id"
+            )
+        if session_id is None:
+            self._validate_conversation_id(resolved_session_id)
+        return _EdgeOneMemorySession(self, resolved_session_id, max_items=max_items)
 
-    def session(self, session_id: str, *, max_items: int = 100) -> "_EdgeOneMemorySession":
+    def session(self, session_id: Optional[str] = None, *, max_items: int = 100) -> "_EdgeOneMemorySession":
         """Alias for :meth:`openai_session` (backward compatibility)."""
         return self.openai_session(session_id, max_items=max_items)
 
+    async def claude_session_binding(self, conversation_id: Optional[str] = None) -> str:
+        """Return a stable Claude SDK UUID for a conversation identifier."""
+        resolved_conversation_id = (
+            conversation_id if conversation_id is not None else self._conversation_id
+        )
+        if not resolved_conversation_id:
+            raise MemoryValidationError(
+                "claude_session_binding requires a conversation_id or bound conversation_id"
+            )
+        self._validate_conversation_id(resolved_conversation_id)
+        mapping_key = _claude_session_mapping_key(resolved_conversation_id)
+        mapping = await self._blob_get_json_strict(mapping_key)
+        if isinstance(mapping, str) and mapping:
+            return mapping
+        if isinstance(mapping, dict):
+            mapped_session_id = mapping.get("session_id") or mapping.get("sessionId")
+            if isinstance(mapped_session_id, str) and mapped_session_id:
+                return mapped_session_id
+
+        session_id = _normalize_claude_uuid(resolved_conversation_id) or str(uuid.uuid4())
+        await self._blob_set_json(
+            mapping_key,
+            {
+                "conversation_id": resolved_conversation_id,
+                "session_id": session_id,
+            },
+        )
+        return session_id
+
     def claude_session_store(self) -> "EdgeOneSessionStore":
         """Create a Claude Agent SDK SessionStore backed by EdgeOne blob storage.
 
@@ -1878,7 +2082,7 @@ class _LangGraphCheckpointerAdapter(_BaseCheckpointSaver):
         if not checkpoint_id:
             return None
 
-        data = await self._memory._blob_get_json(
+        data = await self._memory._blob_get_json_strict(
             self._checkpoint_key(thread_id, str(checkpoint_id), checkpoint_ns),
             consistency="strong",
         )
@@ -1926,13 +2130,10 @@ class _LangGraphCheckpointerAdapter(_BaseCheckpointSaver):
 
         # Concurrent read all writes
         async def _read_write(key: str):
-            try:
-                raw = await self._memory._blob.get(key, type="text", consistency="strong")
-                if raw is None:
-                    return None
-                return json.loads(raw)
-            except Exception:
-                return None
+            return await self._memory._blob_get_json_strict(
+                key,
+                consistency="strong",
+            )
 
         results = await asyncio.gather(*[_read_write(k) for k in keys])
 
@@ -1950,14 +2151,24 @@ class _LangGraphCheckpointerAdapter(_BaseCheckpointSaver):
                     for channel_name, channel_value in writes:
                         pending_writes.append((task_id, channel_name, channel_value))
                     continue
-                except Exception:
-                    pass
+                except Exception as exc:
+                    raise MemoryCorruptError(
+                        "LangGraph pending writes are corrupt or incompatible"
+                    ) from exc
 
             # Legacy format: writes stored as plain JSON
             writes_legacy = wd.get("writes")
             if writes_legacy:
-                for channel_name, channel_value in writes_legacy:
-                    pending_writes.append((task_id, channel_name, channel_value))
+                if not isinstance(writes_legacy, list):
+                    raise MemoryCorruptError(
+                        "LangGraph pending writes are corrupt or incompatible"
+                    )
+                for write in writes_legacy:
+                    if not isinstance(write, (list, tuple)) or len(write) < 2:
+                        raise MemoryCorruptError(
+                            "LangGraph pending writes are corrupt or incompatible"
+                        )
+                    pending_writes.append((task_id, write[0], write[1]))
 
         return pending_writes
 
@@ -2062,7 +2273,7 @@ class _LangGraphCheckpointerAdapter(_BaseCheckpointSaver):
             keys = keys[:limit]
         tuples = []
         for key in keys:
-            data = await self._memory._blob_get_json(key)
+            data = await self._memory._blob_get_json_strict(key)
             if data is not None:
                 tuples.append(_to_checkpoint_tuple(data))
         return tuples
@@ -2280,6 +2491,18 @@ class _EdgeOneMemorySession:
 
 
 _CLAUDE_SESSION_PREFIX = "claude_sessions"
+_CLAUDE_SESSION_MAPPING_PREFIX = "claude_session_mapping"
+
+
+def _claude_session_mapping_key(conversation_id: str) -> str:
+    return f"{_CLAUDE_SESSION_MAPPING_PREFIX}/{_encode_segment(conversation_id)}"
+
+
+def _normalize_claude_uuid(value: str) -> Optional[str]:
+    try:
+        return str(uuid.UUID(value)).lower()
+    except (TypeError, ValueError, AttributeError):
+        return None
 
 
 class EdgeOneSessionStore:
@@ -2387,14 +2610,20 @@ class EdgeOneSessionStore:
         entries: list = []
         for k in keys:
             raw = await self._blob.get(k, type="text")
+            if raw is not None and not isinstance(raw, str):
+                raise MemoryCorruptError(
+                    f"Claude session part '{k}' is not valid JSONL text"
+                )
             if raw:
                 for line in raw.split("\n"):
                     line = line.strip()
                     if line:
                         try:
                             entries.append(json.loads(line))
-                        except (json.JSONDecodeError, ValueError):
-                            continue
+                        except (json.JSONDecodeError, ValueError) as exc:
+                            raise MemoryCorruptError(
+                                f"Claude session part '{k}' contains malformed JSONL"
+                            ) from exc
         return entries if entries else None
 
     # ─── Optional Methods ───

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edgeone",
-  "version": "1.6.24",
+  "version": "1.6.26",
   "description": "Command-line interface for TencentCloud Pages Functions",
   "bin": {
     "edgeone": "./edgeone-bin/edgeone.js"