edgeone 1.6.1 → 1.6.3-beta.1

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

@@ -257,6 +257,18 @@ def _generate_message_id() -> str:
     return f"msg_{uuid.uuid4().hex[:16]}"
 
 
+def _extract_message_id_from_key(key: str) -> str:
+    """Extract messageId from a message key.
+
+    Key format: conversations/{cid}/messages/{created_at}_{message_id}
+    The message_id part starts with 'msg_' so we split on the first '_' after
+    the timestamp to get everything after it.
+    """
+    basename = key.rsplit("/", 1)[-1]  # "{created_at}_{message_id}"
+    parts = basename.split("_", 1)
+    return parts[1] if len(parts) > 1 else ""
+
+
 # ─── Cursor Helpers ───
 
 
@@ -424,10 +436,19 @@ class ConversationMemory:
         except Exception as e:
             raise MemoryStorageError(f"Failed to delete key '{key}': {e}") from e
 
-    async def _blob_list_keys(self, prefix: str, **kwargs) -> List[str]:
-        """List all keys with given prefix, sorted lexicographically."""
+    async def _blob_list_keys(self, prefix: str, *, limit: Optional[int] = None, **kwargs) -> List[str]:
+        """List keys with given prefix, sorted lexicographically.
+
+        Args:
+            prefix: Key prefix to filter.
+            limit: Max keys to return (None = all). Passed to blob SDK.
+        """
         try:
-            result = await self._blob.list(prefix=prefix, **kwargs)
+            list_kwargs = {"prefix": prefix, **kwargs}
+            if limit is not None:
+                list_kwargs["limit"] = limit
+                list_kwargs["paginate"] = False
+            result = await self._blob.list(**list_kwargs)
             return [blob.key for blob in result.blobs]
         except MemoryStorageError:
             raise
@@ -523,46 +544,53 @@ class ConversationMemory:
             metadata=metadata if metadata else None,
         )
 
-        # Write message blob
-        msg_key = _message_key(encoded_cid, now_ms, message_id)
-        await self._blob_set_json(msg_key, message.to_dict())
+        # --- Parallel writes (no data dependency between these) ---
+        import asyncio
 
-        # Write message_index for O(1) lookup by message_id (mirrors Node memory.ts).
-        await self._blob_set_json(
-            _message_index_key(message_id),
-            {
-                "conversationId": conversation_id,
-                "key": msg_key,
-                "messageId": message_id,
-                "createdAt": now_ms,
-            },
-        )
+        msg_key = _message_key(encoded_cid, now_ms, message_id)
+        new_index_key = _index_key(now_ms, encoded_cid)
+        index_entry = {"conversationId": conversation_id, "lastMessageAt": now_ms}
 
-        # Update conversation meta
+        # Update conversation meta (prepare before write)
         meta.last_message_at = now_ms
         meta.message_count += 1
-        await self._blob_set_json(meta_k, meta.to_dict())
-
-        # Update conversation index: write new first, then delete old (safety)
-        new_index_key = _index_key(now_ms, encoded_cid)
-        index_entry = {"conversationId": conversation_id, "lastMessageAt": now_ms}
-        await self._blob_set_json(new_index_key, index_entry)
 
-        if old_last_message_at is not None and old_last_message_at != now_ms:
-            old_index_key = _index_key(old_last_message_at, encoded_cid)
-            await self._blob_delete(old_index_key)
+        # Batch write: message body + message index + meta + conversation index
+        write_tasks = [
+            self._blob_set_json(msg_key, message.to_dict()),
+            self._blob_set_json(
+                _message_index_key(message_id),
+                {
+                    "conversationId": conversation_id,
+                    "key": msg_key,
+                    "messageId": message_id,
+                    "createdAt": now_ms,
+                },
+            ),
+            self._blob_set_json(meta_k, meta.to_dict()),
+            self._blob_set_json(new_index_key, index_entry),
+        ]
 
-        # Update user conversation index (if user_id provided)
+        # User conversation index (if user_id provided)
         if user_id is not None:
             encoded_user_id = _encode_segment(user_id)
             new_user_key = _user_index_key(encoded_user_id, now_ms, encoded_cid)
             index_entry_user = {"conversationId": conversation_id, "lastMessageAt": now_ms}
-            await self._blob_set_json(new_user_key, index_entry_user)
+            write_tasks.append(self._blob_set_json(new_user_key, index_entry_user))
 
-            # Delete old user index key for this user+conversation (if exists and different)
+        await asyncio.gather(*write_tasks)
+
+        # --- Cleanup old index keys (can also be parallel) ---
+        delete_tasks = []
+        if old_last_message_at is not None and old_last_message_at != now_ms:
+            old_index_key = _index_key(old_last_message_at, encoded_cid)
+            delete_tasks.append(self._blob_delete(old_index_key))
+
+        if user_id is not None:
+            encoded_user_id = _encode_segment(user_id)
             if old_last_message_at is not None and old_last_message_at != now_ms:
                 old_user_key = _user_index_key(encoded_user_id, old_last_message_at, encoded_cid)
-                await self._blob_delete(old_user_key)
+                delete_tasks.append(self._blob_delete(old_user_key))
             elif old_last_message_at is None:
                 # First message in this conversation — scan for stale user index
                 # (edge case: conversation was deleted + recreated under same id)
@@ -570,19 +598,121 @@ class ConversationMemory:
                 existing_keys = await self._blob_list_keys(prefix)
                 suffix = f"_{encoded_cid}"
                 for k in existing_keys:
-                    if k.endswith(suffix) and k != new_user_key:
-                        await self._blob_delete(k)
+                    if k.endswith(suffix) and k != _user_index_key(encoded_user_id, now_ms, encoded_cid):
+                        delete_tasks.append(self._blob_delete(k))
+
+        if delete_tasks:
+            await asyncio.gather(*delete_tasks)
 
         return message_id
 
+    async def _bulk_append_messages(
+        self,
+        conversation_id: str,
+        messages_data: List[dict],
+    ) -> List[str]:
+        """Internal bulk append: write N messages with only 1 meta/index update.
+
+        Args:
+            conversation_id: Conversation identifier.
+            messages_data: List of dicts with keys: role, content, metadata.
+
+        Returns:
+            List of generated message_ids.
+        """
+        import asyncio
+
+        if not messages_data:
+            return []
+
+        encoded_cid = _encode_cid(conversation_id)
+        now_ms = int(time.time() * 1000)
+
+        # Load meta once
+        meta_k = _meta_key(encoded_cid)
+        meta_data = await self._blob_get_json(meta_k)
+
+        if meta_data is not None:
+            meta = ConversationMeta.from_dict(meta_data)
+            if meta.message_count + len(messages_data) > _MAX_MESSAGES_PER_CONVERSATION:
+                raise MemoryQuotaExceededError(
+                    f"Conversation '{conversation_id}' would exceed {_MAX_MESSAGES_PER_CONVERSATION} messages"
+                )
+            old_last_message_at = meta.last_message_at
+        else:
+            meta = ConversationMeta(
+                conversation_id=conversation_id,
+                created_at=now_ms,
+                last_message_at=0,
+                message_count=0,
+                metadata=None,
+            )
+            old_last_message_at = None
+
+        # Build all messages and collect write tasks
+        write_tasks = []
+        message_ids = []
+        last_ts = now_ms
+
+        for i, msg_data in enumerate(messages_data):
+            # Increment timestamp by 1ms per message to ensure unique keys + ordering
+            ts = now_ms + i
+            last_ts = ts
+            message_id = _generate_message_id()
+            message_ids.append(message_id)
+
+            msg_metadata = dict(msg_data.get("metadata") or {})
+            if "run_id" not in msg_metadata:
+                msg_metadata["run_id"] = self._run_id
+
+            message = Message(
+                message_id=message_id,
+                role=msg_data["role"],
+                content=msg_data["content"],
+                created_at=ts,
+                metadata=msg_metadata if msg_metadata else None,
+            )
+
+            msg_key = _message_key(encoded_cid, ts, message_id)
+            write_tasks.append(self._blob_set_json(msg_key, message.to_dict()))
+            write_tasks.append(self._blob_set_json(
+                _message_index_key(message_id),
+                {"conversationId": conversation_id, "key": msg_key, "messageId": message_id, "createdAt": ts},
+            ))
+
+        # Update meta once (for all messages)
+        meta.last_message_at = last_ts
+        meta.message_count += len(messages_data)
+        write_tasks.append(self._blob_set_json(meta_k, meta.to_dict()))
+
+        # Update conversation index once
+        new_index_key = _index_key(last_ts, encoded_cid)
+        write_tasks.append(self._blob_set_json(
+            new_index_key, {"conversationId": conversation_id, "lastMessageAt": last_ts}
+        ))
+
+        # Parallel write all
+        await asyncio.gather(*write_tasks)
+
+        # Cleanup old index
+        if old_last_message_at is not None and old_last_message_at != last_ts:
+            await self._blob_delete(_index_key(old_last_message_at, encoded_cid))
+
+        return message_ids
+
     async def _check_idempotency(self, encoded_cid: str, idempotency_key: str) -> Optional[str]:
         """Scan recent messages for matching idempotency_key. Returns message_id if found."""
+        import asyncio
+
         prefix = _messages_prefix(encoded_cid)
         keys = await self._blob_list_keys(prefix)
-        # Scan at most last 50 messages for bounded cost
-        check_count = min(len(keys), 50)
-        for key in keys[-check_count:]:
-            data = await self._blob_get_json(key)
+        # Scan at most last 50 messages — parallel fetch for performance
+        check_keys = keys[-min(len(keys), 50):]
+        if not check_keys:
+            return None
+
+        results = await asyncio.gather(*[self._blob_get_json(k) for k in check_keys])
+        for data in results:
             if data and isinstance(data.get("metadata"), dict):
                 if data["metadata"].get("idempotency_key") == idempotency_key:
                     return data.get("messageId") or data.get("message_id", "")
@@ -766,26 +896,31 @@ class ConversationMemory:
             raise MemoryNotFoundError(f"Conversation '{conversation_id}' not found")
         previous_meta = ConversationMeta.from_dict(meta_data)
 
-        # 删消息本体 + 二级索引
-        await self._blob_delete(msg_key)
-        await self._blob_delete(_message_index_key(message_id))
+        import asyncio
+
+        # 删消息本体 + 二级索引 (parallel)
+        await asyncio.gather(
+            self._blob_delete(msg_key),
+            self._blob_delete(_message_index_key(message_id)),
+        )
 
         # 重算 meta：扫剩余消息得到最新 last_message_at；空则回退到 created_at
         next_meta = await self._recalculate_conversation_meta(encoded_cid, previous_meta)
-        await self._blob_set_json(meta_k, next_meta.to_dict())
 
-        # 更新 conversation_index：写新（如果有变动）+ 删旧
+        # 更新 meta + conversation_index (parallel)
         new_index_key = _index_key(next_meta.last_message_at, encoded_cid)
         old_index_key = _index_key(previous_meta.last_message_at, encoded_cid)
+        write_ops: list = [self._blob_set_json(meta_k, next_meta.to_dict())]
         if new_index_key != old_index_key:
-            await self._blob_set_json(
+            write_ops.append(self._blob_set_json(
                 new_index_key,
                 {
                     "conversationId": conversation_id,
                     "lastMessageAt": next_meta.last_message_at,
                 },
-            )
-            await self._blob_delete(old_index_key)
+            ))
+            write_ops.append(self._blob_delete(old_index_key))
+        await asyncio.gather(*write_ops)
 
     async def _recalculate_conversation_meta(
         self,
@@ -830,6 +965,8 @@ class ConversationMemory:
         Raises:
             MemoryNotFoundError: conversation 不存在。
         """
+        import asyncio
+
         self._validate_conversation_id(conversation_id)
 
         encoded_cid = _encode_cid(conversation_id)
@@ -841,17 +978,21 @@ class ConversationMemory:
 
         previous_meta = ConversationMeta.from_dict(meta_data)
 
-        # 删所有消息正文 + 对应二级索引
+        # Delete all message bodies + message_index entries in parallel.
+        # Extract messageId from key name (no need to read message body).
         prefix = _messages_prefix(encoded_cid)
         keys = await self._blob_list_keys(prefix)
-        for key in keys:
-            data = await self._blob_get_json(key)
-            await self._blob_delete(key)
-            if data and isinstance(data.get("messageId") or data.get("message_id"), str):
-                await self._blob_delete(_message_index_key(data.get("messageId") or data.get("message_id", "")))
 
-        # 重置 meta：保留 conversation_id / created_at / 自定义 metadata，
-        # 把 message_count 置 0，last_message_at 回退到 created_at。
+        delete_ops: list = []
+        for key in keys:
+            delete_ops.append(self._blob_delete(key))
+            msg_id = _extract_message_id_from_key(key)
+            if msg_id:
+                delete_ops.append(self._blob_delete(_message_index_key(msg_id)))
+        if delete_ops:
+            await asyncio.gather(*delete_ops)
+
+        # 重置 meta + 更新 conversation_index in parallel
         next_meta = ConversationMeta(
             conversation_id=previous_meta.conversation_id,
             created_at=previous_meta.created_at,
@@ -859,20 +1000,20 @@ class ConversationMemory:
             message_count=0,
             metadata=previous_meta.metadata,
         )
-        await self._blob_set_json(meta_k, next_meta.to_dict())
-
-        # 更新 conversation_index
         new_index_key = _index_key(next_meta.last_message_at, encoded_cid)
         old_index_key = _index_key(previous_meta.last_message_at, encoded_cid)
+
+        write_ops: list = [self._blob_set_json(meta_k, next_meta.to_dict())]
         if new_index_key != old_index_key:
-            await self._blob_set_json(
+            write_ops.append(self._blob_set_json(
                 new_index_key,
                 {
                     "conversationId": conversation_id,
                     "lastMessageAt": next_meta.last_message_at,
                 },
-            )
-            await self._blob_delete(old_index_key)
+            ))
+            write_ops.append(self._blob_delete(old_index_key))
+        await asyncio.gather(*write_ops)
 
     async def list_conversations(
         self,
@@ -908,9 +1049,19 @@ class ConversationMemory:
         else:
             prefix = _index_prefix()
 
-        # List all index keys (lexicographic ascending = most recent first with revTs)
-        # Use strong consistency to align with Node behavior (avoid CDN stale data)
-        keys = await self._blob_list_keys(prefix, consistency="strong")
+        # Optimization: in the default case (desc order, no before cursor, using after or fresh),
+        # blob list's natural lexicographic order = most-recent-first (reversed timestamp),
+        # so we can pass limit directly to avoid full scan.
+        can_use_sdk_limit = (order == "desc" and before is None)
+
+        if can_use_sdk_limit:
+            # Request limit+1 extra to detect hasMore; if using after cursor,
+            # we can't easily skip via SDK cursor, so fetch more and filter client-side.
+            # For the common first-page case (no after), this is optimal.
+            fetch_limit = limit + 1 if after is None else None
+            keys = await self._blob_list_keys(prefix, consistency="strong", limit=fetch_limit)
+        else:
+            keys = await self._blob_list_keys(prefix, consistency="strong")
 
         # Default order is desc (most recent first). With revTs, ascending lex order
         # already means most-recent-first, so desc = natural order, asc = reversed.
@@ -929,26 +1080,35 @@ class ConversationMemory:
             cursor_sk = _cursor_sort_key(cursor_data["lastMessageAt"], cursor_data["conversationId"])
             keys = self._apply_before_cursor(keys, prefix_len, cursor_sk, order)
 
-        # Fetch up to limit+1 to determine if there's a next page (handles skipped residuals)
-        items: List[ConversationMeta] = []
-        has_more = False
+        # Parse encoded_cids from key basenames, take limit+1 to detect next page
+        import asyncio
+
+        candidate_cids: List[str] = []
         for key in keys:
-            if len(items) >= limit:
-                has_more = True
+            if len(candidate_cids) > limit:
                 break
-            # Parse encoded_cid from key basename: {revTs:016d}_{encoded_cid}
             remainder = key[prefix_len:]
             sep_idx = remainder.find("_")
             if sep_idx < 0:
                 continue
-            encoded_cid = remainder[sep_idx + 1:]
-            meta_data = await self._blob_get_json(_meta_key(encoded_cid), consistency="strong")
+            candidate_cids.append(remainder[sep_idx + 1:])
+
+        # Fetch metas in parallel (aligned with Node Promise.all approach)
+        meta_results = await asyncio.gather(
+            *[self._blob_get_json(_meta_key(cid), consistency="strong") for cid in candidate_cids]
+        )
+
+        items: List[ConversationMeta] = []
+        has_more = False
+        for meta_data in meta_results:
+            if len(items) >= limit:
+                has_more = True
+                break
             if meta_data:
                 try:
                     items.append(ConversationMeta.from_dict(meta_data))
                 except (KeyError, TypeError):
-                    continue  # skip corrupted/incompatible meta entries
-            # else: residual index (conversation deleted), skip silently
+                    continue
 
         # Build cursors
         next_cursor: Optional[str] = None
@@ -1021,32 +1181,39 @@ class ConversationMemory:
         Raises:
             MemoryNotFoundError: Conversation doesn't exist.
         """
+        import asyncio
+
         self._validate_conversation_id(conversation_id)
 
         encoded_cid = _encode_cid(conversation_id)
         meta_k = _meta_key(encoded_cid)
-        meta_data = await self._blob_get_json(meta_k)
+
+        # Read meta + list messages in parallel
+        prefix = _messages_prefix(encoded_cid)
+        meta_data, keys = await asyncio.gather(
+            self._blob_get_json(meta_k),
+            self._blob_list_keys(prefix),
+        )
 
         if meta_data is None:
             raise MemoryNotFoundError(f"Conversation '{conversation_id}' not found")
 
         meta = ConversationMeta.from_dict(meta_data)
 
-        # Delete all message blobs + secondary indices
-        prefix = _messages_prefix(encoded_cid)
-        keys = await self._blob_list_keys(prefix)
+        # Delete all message bodies + message_index entries in parallel.
+        # Extract messageId from key name (no need to read message body).
+        delete_ops: list = []
         for key in keys:
-            data = await self._blob_get_json(key)
-            await self._blob_delete(key)
-            if data and isinstance(data.get("messageId") or data.get("message_id"), str):
-                await self._blob_delete(_message_index_key(data.get("messageId") or data.get("message_id", "")))
+            delete_ops.append(self._blob_delete(key))
+            msg_id = _extract_message_id_from_key(key)
+            if msg_id:
+                delete_ops.append(self._blob_delete(_message_index_key(msg_id)))
 
-        # Delete index entry
-        old_index_key = _index_key(meta.last_message_at, encoded_cid)
-        await self._blob_delete(old_index_key)
+        # Delete meta + conversation index entry
+        delete_ops.append(self._blob_delete(meta_k))
+        delete_ops.append(self._blob_delete(_index_key(meta.last_message_at, encoded_cid)))
 
-        # Delete meta
-        await self._blob_delete(meta_k)
+        await asyncio.gather(*delete_ops)
 
     async def update_conversation(
         self, conversation_id: str, metadata: dict
@@ -1400,13 +1567,13 @@ class _LangGraphStoreAdapter(_LangGraphBaseStore):
                 prefix = self._search_prefix(ns_prefix)
                 listed = await self._memory._blob.list(prefix=prefix, consistency="strong")
                 keys = [blob.key for blob in listed.blobs]
-                items: list[dict] = []
-                for bk in keys:
-                    if f"/{_LANGGRAPH_STORE_KEY_SEPARATOR}/" not in bk:
-                        continue
-                    it = await self._parse_stored_item(bk)
-                    if it and self._namespace_starts_with(it["namespace"], ns_prefix):
-                        items.append(it)
+                # Filter keys that contain the separator, then parallel fetch
+                valid_keys = [bk for bk in keys if f"/{_LANGGRAPH_STORE_KEY_SEPARATOR}/" in bk]
+                items_raw = await asyncio.gather(*[self._parse_stored_item(bk) for bk in valid_keys])
+                items: list[dict] = [
+                    it for it in items_raw
+                    if it and self._namespace_starts_with(it["namespace"], ns_prefix)
+                ]
                 filtered = [it for it in items if self._matches_filter(it, getattr(op, "filter", None))]
                 filtered.sort(key=lambda it: ("/".join(it["namespace"]), it["key"]))
                 offset = getattr(op, "offset", 0) or 0
@@ -1431,11 +1598,12 @@ class _LangGraphStoreAdapter(_LangGraphBaseStore):
                 all_prefix = f"{_LANGGRAPH_STORE_PREFIX}/items/"
                 listed = await self._memory._blob.list(prefix=all_prefix, consistency="strong")
                 keys = [blob.key for blob in listed.blobs]
+                # Filter keys with separator, then parallel fetch
+                valid_keys = [bk for bk in keys if f"/{_LANGGRAPH_STORE_KEY_SEPARATOR}/" in bk]
+                items_raw = await asyncio.gather(*[self._parse_stored_item(bk) for bk in valid_keys])
+
                 namespaces: set[str] = set()
-                for bk in keys:
-                    if f"/{_LANGGRAPH_STORE_KEY_SEPARATOR}/" not in bk:
-                        continue
-                    it = await self._parse_stored_item(bk)
+                for it in items_raw:
                     if not it:
                         continue
                     ns = [str(s) for s in it["namespace"]]
@@ -2031,18 +2199,21 @@ class _EdgeOneMemorySession:
         if not items:
             return
 
+        # Use bulk append for efficiency (1 meta update instead of N)
+        messages_data = []
         for item in items:
             normalized = self._jsonable(item)
             role = self._role_for_item(normalized)
-            await self.memory.append_message(
-                self.session_id,
-                role,
-                normalized,
-                metadata={
+            messages_data.append({
+                "role": role,
+                "content": normalized,
+                "metadata": {
                     **_SESSION_METADATA_MARKER,
                     "item_type": normalized.get("type") if isinstance(normalized, dict) else None,
                 },
-            )
+            })
+
+        await self.memory._bulk_append_messages(self.session_id, messages_data)
 
     async def pop_item(self) -> Optional[dict]:
         """Remove and return the most recent item from the session."""

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

@@ -12,7 +12,7 @@ from dataclasses import dataclass
 from typing import Any, AsyncIterator, Callable, Awaitable, Optional
 from uuid import uuid4
 
-from .context import AgentContext, AbortActiveRunResult, RequestInfo, SandboxRuntimeError, StreamResponse
+from .context import AgentContext, AbortActiveRunResult, EoContext, RequestInfo, SandboxRuntimeError, StreamResponse
 
 
 # LangGraph 通过抛出这些异常实现 graph 暂停 / 控制流跳转，并非业务错误。
@@ -238,10 +238,12 @@ class AgentsApi:
                 headers=_context.request.headers,
                 query=_context.request.query,
                 signal=_context.request.signal,
+                eo=_context.request.eo,
             ),
             env=_context.env,
             kv=self._store_resolver(route_path),
             agents=self,
+            eo=_context.eo,
             # active_run_id 不向 child 传递：child 是「当前 run 内部派生的子调用」，
             # 沿用 parent 的 active_run_id 反而会让业务误以为有冲突。
             active_run_id=None,
@@ -377,6 +379,7 @@ class AgentRuntime:
         headers: dict,
         query: dict,
         body: dict,
+        eo: Optional[EoContext] = None,
     ) -> RuntimeResult:
         # Route match — user handler takes priority
         entry = self._registry.get(path)
@@ -406,18 +409,17 @@ class AgentRuntime:
             return RuntimeResult(404, {"code": "AGENT_NOT_FOUND", "message": f"No handler for {path}"}, {})
 
         # Parse IDs
-        # 与 Node runtime 对齐：当前请求自身的 conversation_id 只从 header 读，
-        # **不再回退** ``body.conversation_id`` —— 否则 /stop 这种请求自然会把
-        # body 里的「目标 conversation_id」当成自己的 conversation，进而覆盖
-        # active_signals 里被取消方的注册，导致 ctx.utils.abortActiveRun 失效。
-        # （body 里的 conversation_id 应该由业务 handler 自行解析作为参数。）
+        # 与 Node runtime 对齐：conversation_id 必须从 header 提供，不自动生成。
+        # 不带 makers-conversation-id header 的请求直接返回 400，与 Node 行为一致。
         header_conversation_id = _header(headers, "makers-conversation-id") or _header(headers, "conversation-id")
-        if header_conversation_id:
-            conversation_id = header_conversation_id
-            conversation_id_source = "makers-conversation-id"
-        else:
-            conversation_id = str(uuid4())
-            conversation_id_source = "generated"
+        if not header_conversation_id:
+            _log(f"Agent error: {path} code=AGENT_CONVERSATION_ID_REQUIRED")
+            return RuntimeResult(400, {
+                "code": "AGENT_CONVERSATION_ID_REQUIRED",
+                "message": "conversationId is required. Pass makers-conversation-id header.",
+            }, {})
+        conversation_id = header_conversation_id
+        conversation_id_source = "makers-conversation-id"
         run_id = str(uuid4())
         start_time = time.monotonic()
 
@@ -442,15 +444,19 @@ class AgentRuntime:
             "makers-run-id": run_id,
         }
 
+        # Normalize eo
+        _eo = eo or EoContext()
+
         # Build context
         context = AgentContext(
             conversation_id=conversation_id,
             run_id=run_id,
             parent_run_id=None,
-            request=RequestInfo(body=body, headers=headers, query=query, signal=cancel_event),
+            request=RequestInfo(body=body, headers=headers, query=query, signal=cancel_event, eo=_eo),
             env=dict(os.environ),
             kv=self._store_resolver(path),
             agents=self._agents_api,
+            eo=_eo,
             active_run_id=existing_active_run_id,
             _store_blob=self._store_blob,
             _tracer=_get_obs_tracer(),