edgeone 1.6.40 → 1.6.41

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import importlib
 import json
 import os
@@ -414,14 +415,83 @@ if _failed_routes:
     )
 
 
+# --- MCP server bootstrap (Agent as MCP Server) ---
+# 开关与配置由构建期注入的环境变量提供（对齐 Node agent-node.ts 的 MCP_ENABLED / MCP_CONFIG）。
+#   AGENT_MCP_ENABLED: "true"/"false"
+#   AGENT_MCP_CONFIG:  JSON，形如
+#       {"name": ..., "tools": [{"route", "toolName", "description", "parameters", "required"}]}
+# tools 由构建期依据路由注释声明生成；平台级鉴权由中控完成，本层不做 token 校验。
+_mcp_enabled = os.environ.get("AGENT_MCP_ENABLED", "").lower() == "true"
+try:
+    _mcp_config = json.loads(os.environ.get("AGENT_MCP_CONFIG", "{}")) or {}
+except (json.JSONDecodeError, ValueError):
+    _mcp_config = {}
+
+_mcp_server = None
+_mcp_session_manager = None
+_mcp_exit_stack = None
+
+if _mcp_enabled and _mcp_config.get("tools"):
+    try:
+        from .mcp_handler import create_mcp_server
+        _mcp_server = create_mcp_server(_mcp_config, _runtime)
+        # 必须先调 streamable_http_app() 触发 session_manager 惰性创建。
+        _mcp_server.streamable_http_app()
+        _mcp_session_manager = _mcp_server.session_manager
+        print("[agent-python] MCP server enabled at /mcp", file=sys.stderr, flush=True)
+    except Exception as _mcp_err:
+        print(f"[agent-python] MCP server init failed: {type(_mcp_err).__name__}: {_mcp_err}", file=sys.stderr, flush=True)
+        _mcp_enabled = False
+else:
+    _mcp_enabled = False
+
+
+def _mcp_pick_identity_context(headers: dict) -> dict:
+    """从入站请求头提取中控注入的身份态，供 MCP tool 转发与主键裁决使用。
+
+    ``makers-user-id`` 由中控在 JWT 验签后无条件 delete + set，客户端无法伪造；
+    它存在即表示本请求已过平台身份校验 —— 此时 ``makers-conversation-id`` 也由中控
+    按已验证身份稳定派生（覆盖客户端传值），是唯一权威的会话主键。
+
+    不透传客户端原始 Authorization（平台不需要业务再验一次）。
+
+    """
+    user_id = str(headers.get("makers-user-id") or "").strip()
+    if not user_id:
+        return {"headers": {}, "authenticated": False, "conversation_id": ""}
+    return {
+        "headers": {"makers-user-id": user_id},
+        "authenticated": True,
+        "conversation_id": str(headers.get("makers-conversation-id") or "").strip(),
+    }
+
+
 # --- ASGI app ---
 async def app(scope: dict, receive, send) -> None:
     if scope["type"] == "lifespan":
         msg = await receive()
         if msg["type"] == "lifespan.startup":
+            # 启动 MCP session manager 的 task group（stateful 模式，跨请求长驻）。
+            # stateful 下 session 由服务端分配并回传 Mcp-Session-Id，客户端后续回带，
+            # 中控据此稳定派生 conversation-id（详见 mcp_handler.create_mcp_server）。
+            global _mcp_exit_stack
+            if _mcp_enabled and _mcp_session_manager is not None:
+                try:
+                    _mcp_exit_stack = contextlib.AsyncExitStack()
+                    await _mcp_exit_stack.enter_async_context(_mcp_session_manager.run())
+                    print("[agent-python] MCP session manager started", file=sys.stderr, flush=True)
+                except Exception as _mcp_start_err:
+                    print(f"[agent-python] MCP session manager start failed: {_mcp_start_err}", file=sys.stderr, flush=True)
+                    _mcp_exit_stack = None
             await send({"type": "lifespan.startup.complete"})
         msg = await receive()
         if msg["type"] == "lifespan.shutdown":
+            # 关闭 MCP session manager task group。
+            if _mcp_exit_stack is not None:
+                try:
+                    await _mcp_exit_stack.aclose()
+                except Exception:
+                    pass
             # Flush telemetry before process exits
             try:
                 from _platform._observability.telemetry import get_telemetry
@@ -436,6 +506,40 @@ async def app(scope: dict, receive, send) -> None:
     if scope["type"] != "http":
         return
 
+    # --- MCP endpoint：拦截 /mcp（及 /mcp/*），交给 MCP session manager 处理 JSON-RPC。---
+    # 对齐 Node agent-node.ts 的 requestHandler /mcp 拦截。透传 ASGI 三件套即可，
+    # 无需自己读body（StreamableHTTPSessionManager 内部处理）。
+    # /mcp 端点：鉴权由中控完成，本层不做 token 校验，直接交给 session manager 处理。
+    _mcp_path = scope.get("path", "/")
+    if _mcp_enabled and _mcp_session_manager is not None and (_mcp_path == "/mcp" or _mcp_path.startswith("/mcp/")):
+        # OPTIONS 预检直接放行（CORS）。
+        if scope.get("method", "").upper() == "OPTIONS":
+            await send({
+                "type": "http.response.start",
+                "status": 204,
+                "headers": [
+                    (b"access-control-allow-origin", b"*"),
+                    (b"access-control-allow-methods", b"POST, GET, OPTIONS"),
+                    (b"access-control-allow-headers", b"Content-Type, Authorization"),
+                ],
+            })
+            await send({"type": "http.response.body", "body": b""})
+            return
+        # 把中控注入的身份态存入 request-scoped contextvar，供 mcp_handler 转发时
+        # 并入 runtime headers、并裁决权威会话主键（tool 函数拿不到 scope）。
+        _mcp_headers = {
+            (k.decode("utf-8") if isinstance(k, bytes) else k).lower(): (v.decode("utf-8") if isinstance(v, bytes) else v)
+            for k, v in scope.get("headers", [])
+        }
+        try:
+            from .mcp_handler import mcp_identity_context as _id_var
+        except ImportError:
+            _id_var = None
+        if _id_var is not None:
+            _id_var.set(_mcp_pick_identity_context(_mcp_headers))
+        await _mcp_session_manager.handle_request(scope, receive, send)
+        return
+
     # Read body
     body_parts = []
     while True:
@@ -485,6 +589,13 @@ async def app(scope: dict, receive, send) -> None:
         k.decode("utf-8") if isinstance(k, bytes) else k: v.decode("utf-8") if isinstance(v, bytes) else v
         for k, v in scope.get("headers", [])
     }
+    # 平台身份头：中控在 JWT 验签后无条件 delete + set 注入 makers-user-id，
+    # 客户端伪造值在边缘即被剥离，到不了这里 —— 故直接信任、无需二次映射。
+    _user_id = str(headers.get("makers-user-id") or "").strip()
+    if _user_id:
+        headers["makers-user-id"] = _user_id
+    else:
+        headers.pop("makers-user-id", None)
 
     # 计算完整请求路径和 scfRequestId（日志合并到 response 后统一打印）
     _pages_host = headers.get("eo-pages-host", "") or headers.get("host", "")

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

@@ -0,0 +1,393 @@
+# src/pages/builder/templates/agent-python/mcp_handler.py
+"""Agent as MCP Server — 把 agent 路由暴露为 MCP tools（对齐 Node agent-mcp-wrap.ts）。
+
+基于官方 `mcp` 包（FastMCP + StreamableHTTPSessionManager，stateful HTTP）：
+  - stateful：服务端分配 Mcp-Session-Id 并在 initialize 响应中回传，客户端后续
+    回带，中控据此稳定派生 conversation-id（详见 create_mcp_server 内说明）；
+  - tool 列表由构建期依据路由 docstring 声明生成（AGENT_MCP_CONFIG.tools），
+    运行时只负责注册；平台不再注册任何内置 tool（cancel_run / get_sessions /
+    get_session_runs 均已移除）；
+  - tool 调用转发到 runtime.handle，消费流式 StreamResponse，解析 agent 私有 SSE
+    的 text_delta，聚合成纯文本返回；
+  - 客户端带 progressToken 时逐 delta 调ctx.report_progress 流式推送
+    （report_progress 内部自动判断有无 token，无 token 时静默跳过，天然实现 B/C 分流）。
+
+鉴权：平台级身份校验统一由中控（边缘）完成，本层不做任何 token 校验。
+设计对齐 Node 侧：executeRoute 转发 runtime.handle；聚合纯文本兜底 + 可选 progress 流式。
+"""
+from __future__ import annotations
+
+import contextvars
+import inspect
+import json
+import os
+import sys
+from typing import Any, Callable, Optional
+from uuid import uuid4
+
+from mcp.server.fastmcp import Context, FastMCP
+from mcp.types import CallToolResult, TextContent
+
+
+# 请求作用域的身份上下文。MCP session manager 跨请求长驻，FastMCP tool 签名不能加
+# '_' 前缀参数、也拿不到原始 ASGI scope，故用 contextvar 传递本次请求的身份态。
+# 结构：{"headers": {...}, "authenticated": bool, "conversation_id": str}
+#   · headers          —— 转发给业务 handler 的身份头（仅 makers-user-id）
+#   · authenticated    —— 是否已过中控身份校验
+#   · conversation_id  —— 中控按已验证身份稳定派生的权威会话主键
+# 只承载中控注入的身份态，不承载客户端原始 Authorization。
+# 由 adapter.py 在进入 session manager 前设置。
+mcp_identity_context: "contextvars.ContextVar[dict]" = contextvars.ContextVar(
+    "mcp_identity_context", default={}
+)
+
+
+def _identity() -> dict:
+    """读取本次请求的身份态；不在请求作用域内时返回空 dict。"""
+    try:
+        return mcp_identity_context.get() or {}
+    except Exception:
+        return {}
+
+
+def _identity_headers() -> dict:
+    """转发给业务 handler 的内部身份头。"""
+    headers = _identity().get("headers")
+    return headers if isinstance(headers, dict) else {}
+
+
+def _resolve_conversation_id(ai_session_id: Any) -> str:
+    """裁决本次 tool 调用的会话主键（安全关键）。
+
+    鉴权开启时**必须**用中控派生值并忽略 AI 传参：中控在 route-upstream 阶段对
+    makers-conversation-id 做的覆盖（防止 A 填 B 的 id 读 B 的记忆），会被 tool
+    参数里的 session_id 绕过 —— MCP 转发是新造 headers，不继承那次覆盖。
+
+    Python 侧为 stateful_http，传输层有 session，但中控值仍是权威主键（它
+    由身份绑定派生、且防止 A 填 B 的 id 读 B 的记忆）。中控值缺失时（异常）
+    才新生成，绝不采信 AI 传参。
+    """
+    identity = _identity()
+    if identity.get("authenticated"):
+        return str(identity.get("conversation_id") or "") or _gen_session_id()
+    ai_session = str(ai_session_id or "")
+    return ai_session if ai_session else _gen_session_id()
+
+
+def _log(msg: str) -> None:
+    print(msg, file=sys.stderr, flush=True)
+
+
+def _normalize_tool_configs(raw_tools: Any) -> list[dict]:
+    """归一构建期注入的 tool 列表（AGENT_MCP_CONFIG.tools）。
+
+    构建期已完成「哪些路由暴露 / tool 名 / 参数 schema」的判定（见 agent-mcp-tools.ts），
+    这里只做防御性校验：缺 route / toolName 的条目直接丢弃，不再自行推导路由。
+    """
+    tools: list[dict] = []
+    for item in raw_tools or []:
+        if not isinstance(item, dict):
+            continue
+        route = str(item.get("route") or "")
+        tool_name = str(item.get("toolName") or item.get("tool_name") or "")
+        if not route or not tool_name:
+            continue
+        parameters = item.get("parameters")
+        required = item.get("required")
+        tools.append({
+            "route": route,
+            "tool_name": tool_name,
+            "description": str(item.get("description") or ("Agent route: " + route)),
+            "parameters": parameters if isinstance(parameters, dict) else {},
+            "required": required if isinstance(required, list) else [],
+        })
+    return tools
+
+
+def _gen_session_id() -> str:
+    return str(uuid4())
+
+
+def _parse_sse_text(raw_text: str) -> str:
+    """解析 agent 私有 SSE（event: text_delta\\ndata: {"delta":"..."}），聚合纯文本。
+
+    跳过 done/[DONE] 控制事件。用于非流式 body 的一次性解析（流式路径走 _parse_and_notify）。
+    对齐 Node __mcpParseSseText。
+    """
+    full_text = ""
+    for block in str(raw_text or "").split("\n\n"):
+        if not block:
+            continue
+        event_name = ""
+        data_lines = []
+        for line in block.split("\n"):
+            if line.startswith("event:"):
+                event_name = line[6:].strip()
+            elif line.startswith("data:"):
+                data_lines.append(line[5:].strip())
+        if not data_lines:
+            continue
+        data_str = "\n".join(data_lines)
+        if event_name == "done" or data_str == "[DONE]":
+            continue
+        delta = ""
+        try:
+            parsed = json.loads(data_str)
+            if isinstance(parsed, str):
+                delta = parsed
+            elif isinstance(parsed, dict):
+                if isinstance(parsed.get("delta"), str):
+                    delta = parsed["delta"]
+                elif isinstance(parsed.get("text"), str):
+                    delta = parsed["text"]
+        except (ValueError, TypeError):
+            delta = data_str
+        if delta:
+            full_text += delta
+    return full_text
+
+
+def _decode_chunk(chunk: Any) -> str:
+    """把 StreamResponse 产出的 chunk 归一成str（对齐 adapter._encode_stream_chunk 的逆向）。"""
+    if chunk is None:
+        return ""
+    if isinstance(chunk, (bytes, bytearray, memoryview)):
+        try:
+            return bytes(chunk).decode("utf-8", errors="replace")
+        except Exception:
+            return ""
+    if isinstance(chunk, str):
+        return chunk
+    try:
+        return json.dumps(chunk, ensure_ascii=False)
+    except (TypeError, ValueError):
+        return str(chunk)
+
+
+async def _consume_agent_result(result: Any, on_delta: Optional[Callable[[str], Any]] = None) -> str:
+    """消费 runtime.handle 返回的 RuntimeResult，解析 SSE 聚合纯文本。
+
+    - 流式（result.is_streaming）：async for 迭代 StreamResponse.body，逐帧 decode +解析；
+    - 非流式：body 为 str/dict/None，直接归一。
+    对齐 Node __mcpConsumeAgentStream（含半包 buffer 处理）。
+    """
+    if result is None:
+        return ""
+
+    if getattr(result, "is_streaming", False):
+        stream = result.body
+        buffer = ""
+        full_text = ""
+        agen = stream.body.__aiter__()
+        try:
+            async for chunk in _aiter(agen):
+                buffer += _decode_chunk(chunk)
+                # 按完整 SSE event 边界（\n\n）切分，保留半包到 buffer。
+                while "\n\n" in buffer:
+                    idx = buffer.index("\n\n")
+                    block = buffer[:idx]
+                    buffer = buffer[idx + 2:]
+                    full_text += await _parse_and_notify(block, on_delta)
+        except Exception:
+            # 流中断（网络错误 / 超时 / 上游异常）时优雅降级：返回已聚合的部分文本，
+            # 而非让异常冒泡丢弃全部已读内容（对齐 Node __mcpConsumeAgentStream）。
+            pass
+        if buffer:
+            full_text += await _parse_and_notify(buffer, on_delta)
+        return full_text
+
+    # 非流式
+    body = result.body
+    if body is None:
+        return ""
+    if isinstance(body, str):
+        return _parse_sse_text(body)
+    try:
+        return json.dumps(body, ensure_ascii=False)
+    except (TypeError, ValueError):
+        return str(body)
+
+
+async def _aiter(agen):
+    """把已取得的 __aiter__ 迭代器包装成 async for 可用形式。"""
+    while True:
+        try:
+            item = await agen.__anext__()
+        except StopAsyncIteration:
+            return
+        yield item
+
+
+async def _parse_and_notify(block: str, on_delta: Optional[Callable[[str], Any]]) -> str:
+    """解析单个 SSE block，逐 delta 触发（可为 async 的）on_delta，返回该 block 的纯文本。"""
+    if not block:
+        return ""
+    event_name = ""
+    data_lines = []
+    for line in block.split("\n"):
+        if line.startswith("event:"):
+            event_name = line[6:].strip()
+        elif line.startswith("data:"):
+            data_lines.append(line[5:].strip())
+    if not data_lines:
+        return ""
+    data_str = "\n".join(data_lines)
+    if event_name == "done" or data_str == "[DONE]":
+        return ""
+    delta = ""
+    try:
+        parsed = json.loads(data_str)
+        if isinstance(parsed, str):
+            delta = parsed
+        elif isinstance(parsed, dict):
+            if isinstance(parsed.get("delta"), str):
+                delta = parsed["delta"]
+            elif isinstance(parsed.get("text"), str):
+                delta = parsed["text"]
+    except (ValueError, TypeError):
+        delta = data_str
+    if delta and on_delta is not None:
+        try:
+            res = on_delta(delta)
+            if hasattr(res, "__await__"):
+                await res
+        except Exception:
+            pass
+    return delta
+
+
+async def _execute_route(runtime, route_path: str, body: dict, conversation_id: str) -> Any:
+    """转发到 runtime.handle（对齐 Node __mcpExecuteRoute）。
+
+    把中控注入的身份头（makers-user-id）并入转发 headers，业务侧从
+    ctx.request.headers['makers-user-id'] 读取。
+    """
+    headers = {
+        "content-type": "application/json",
+        "makers-conversation-id": conversation_id,
+    }
+    identity = _identity_headers()
+    if identity:
+        headers.update(identity)
+    return await runtime.handle(
+        path=route_path,
+        method="POST",
+        headers=headers,
+        query={},
+        body=body or {},
+    )
+
+
+def create_mcp_server(mcp_config: dict, runtime) -> FastMCP:
+    """构建 FastMCP server：注册构建期声明的路由 tool + 平台内置 tool，stateful HTTP。"""
+    name = mcp_config.get("name") or "Makers Agent"
+    # 关闭 DNS rebinding 保护：生产环境 host 非 localhost，平台级鉴权由中控完成，
+    # 本层不依赖 Host/Origin 校验。
+    from mcp.server.transport_security import TransportSecuritySettings
+    _security = TransportSecuritySettings(enable_dns_rebinding_protection=False)
+    #注意：FastMCP.__init__ 无 version 参数，仅 name。
+    # stateful：必须让服务端分配并回传 Mcp-Session-Id。
+    mcp = FastMCP(
+        name=name,
+        stateless_http=False,
+        json_response=False,
+        transport_security=_security,
+    )
+
+    # tool 列表完全来自构建期（路由注释声明），运行时不再推导。
+    route_tools = _normalize_tool_configs(mcp_config.get("tools"))
+
+    def _make_tool_fn(bound_route: str, tool_params: dict, tool_required: list):
+        # 工厂捕获 route + 参数配置，避免 late-binding。tool 函数用 **kwargs 接收所有
+        # 参数，再通过 __signature__ 告诉 FastMCP 真实参数列表 —— 这样既能动态适配
+        # mcp_parameters，又能让 FastMCP.func_metadata 生成正确的 inputSchema。
+        # 约束：FastMCP 不允许 '_' 前缀参数；参数名已在采集端用正则约束为合法标识符。
+        param_names = list(tool_params.keys())
+        required_set = set(tool_required or [])
+
+        async def tool_fn(**kwargs: Any) -> CallToolResult:
+            # session_id 是平台统一注入参数（非业务参数），单独取出。
+            session_id = kwargs.pop("session_id", "") or ""
+            ctx = kwargs.pop("__ctx__", None)
+            # 会话主键统一由 _resolve_conversation_id 裁决：鉴权开启时以中控派生值为准，
+            # 忽略 AI 传入的 session_id（否则可越权读写他人会话记忆）。
+            conversation_id = _resolve_conversation_id(session_id)
+            # 仅转发已声明的业务参数（过滤掉 None 的可选项，避免污染 body）。
+            body = {k: v for k, v in kwargs.items() if v is not None}
+            result = await _execute_route(runtime, bound_route, body, conversation_id)
+
+            async def _on_delta(delta: str) -> None:
+                if ctx is not None:
+                    try:
+                        await ctx.report_progress(progress=len(delta), total=None, message=delta)
+                    except Exception:
+                        pass
+
+            full_text = await _consume_agent_result(result, _on_delta)
+            # 提取不到文本时给出可诊断提示，而非静默返回空串（与 Node 侧对齐）：
+            # 否则调用方只看到 session_id，无从判断是 SSE 增量格式不匹配
+            # （data 需含 delta / text 字段）还是 Agent 确实没有产出。
+            if not full_text:
+                full_text = '(No text content could be extracted from the response. Make sure the route returns an SSE stream and that each text delta carries a "delta" or "text" field, e.g. data: {"delta":"..."})'
+            # structuredContent 带 route，供调用方定位对应 store。
+            return CallToolResult(
+                content=[TextContent(type="text", text=full_text)],
+                structuredContent={
+                    "session_id": conversation_id,
+                    "route": bound_route,
+                    "status": "completed",
+                },
+            )
+
+        # 动态构造签名：每个业务参数 + session_id(可选) + ctx(FastMCP 注入)。
+        _type_map = {"string": str, "number": float, "boolean": bool}
+        sig_params = []
+        annotations: dict = {}
+        for name in param_names:
+            schema = tool_params.get(name) or {}
+            py_type = _type_map.get(schema.get("type"), str)
+            is_required = name in required_set
+            default = inspect.Parameter.empty if is_required else None
+            sig_params.append(
+                inspect.Parameter(
+                    name,
+                    inspect.Parameter.KEYWORD_ONLY,
+                    default=default,
+                    annotation=py_type if is_required else Optional[py_type],
+                )
+            )
+            annotations[name] = py_type if is_required else Optional[py_type]
+        # session_id：可选，续接会话。
+        sig_params.append(
+            inspect.Parameter("session_id", inspect.Parameter.KEYWORD_ONLY, default="", annotation=str)
+        )
+        annotations["session_id"] = str
+        # ctx：FastMCP 依据类型注解自动注入 Context，不进 inputSchema。
+        sig_params.append(
+            inspect.Parameter("ctx", inspect.Parameter.KEYWORD_ONLY, default=None, annotation=Context)
+        )
+        annotations["ctx"] = Context
+        annotations["return"] = CallToolResult
+
+        # kwargs 里 ctx 需转成内部约定的 __ctx__ 传给闭包（因 tool_fn 用 **kwargs）。
+        async def tool_fn_wrapper(**kwargs: Any) -> CallToolResult:
+            if "ctx" in kwargs:
+                kwargs["__ctx__"] = kwargs.pop("ctx")
+            return await tool_fn(**kwargs)
+
+        tool_fn_wrapper.__signature__ = inspect.Signature(sig_params)  # type: ignore[attr-defined]
+        tool_fn_wrapper.__annotations__ = annotations
+        return tool_fn_wrapper
+
+    for tool in route_tools:
+        mcp.add_tool(
+            _make_tool_fn(tool["route"], tool.get("parameters") or {}, tool.get("required") or []),
+            name=tool["tool_name"],
+            description=tool["description"],
+            # tool_fn 直接返回 CallToolResult（自带 content + structuredContent），
+            # 关闭自动结构化输出，让 FastMCP 原样透传我们构造的结果（含 route 字段）。
+            structured_output=False,
+        )
+
+    # MCP 工具集完全等于路由 docstring 声明的 tool 列表，平台不额外注入能力。
+    return mcp

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edgeone",
-  "version": "1.6.40",
+  "version": "1.6.41",
   "description": "Command-line interface for TencentCloud Pages Functions",
   "bin": {
     "edgeone": "./edgeone-bin/edgeone.js"
@@ -57,7 +57,7 @@
     "@babel/traverse": "^7.28.0",
     "@babel/types": "^7.28.0",
     "@edgeone/nuxt-pages": "1.1.2-beta.1",
-    "@edgeone/opennextjs-pages": "0.2.10-beta.8",
+    "@edgeone/opennextjs-pages": "0.2.10-beta.9",
     "@edgeone/pages-agent-toolkit": "0.1.38",
     "@edgeone/pages-blob": "^0.0.16",
     "chokidar": "^4.0.1",
@@ -73,7 +73,8 @@
     "@e2b/code-interpreter": "2.4.2",
     "@edgeone/framework-detect": "^0.0.2",
     "@edgeone/is-spa": "^0.0.3",
-    "@edgeone/types": "^1.0.1",
+    "@edgeone/types": "^1.0.2",
+    "@modelcontextprotocol/sdk": "1.29.0",
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/core": "^1.30.1",
     "@opentelemetry/exporter-metrics-otlp-http": "^0.55.0",
@@ -89,6 +90,7 @@
     "@types/http-proxy": "^1.17.12",
     "@types/inquirer": "^9.0.8",
     "@types/ip": "^1.1.0",
+    "@types/js-yaml": "^4.0.9",
     "@types/lodash": "^4.14.198",
     "@types/prompts": "^2.4.4",
     "@types/react": "^17.0.2",
@@ -114,6 +116,7 @@
     "ink-table": "^3.1.0",
     "inquirer": "^8.2.4",
     "ip": "^2.0.1",
+    "js-yaml": "^4.3.1",
     "json5": "^2.2.3",
     "lint-staged": "^15.2.0",
     "lodash": "^4.17.21",