@microsoft/m365-copilot-eval 1.4.0-preview.1 → 1.5.0-preview.1

package/src/clients/cli/api_clients/REST/sydney_client.py

@@ -1,204 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-import os
-import urllib.error
-import urllib.parse
-import urllib.request
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Tuple
-
-from api_clients.base_agent_client import BaseAgentClient
-from cli_logging.console_diagnostics import emit_structured_log
-from cli_logging.logging_utils import Operation
-from response_extractor import extract_enhanced_response
-
-_REQUEST_TIMEOUT_SECS = 120
-
-# int → str used when passing log level to extract_enhanced_response
-_LEVEL_INT_TO_STR: Dict[int, str] = {
-    logging.DEBUG: "debug",
-    logging.INFO: "info",
-    logging.WARNING: "warning",
-    logging.ERROR: "error",
-}
-
-
-class SydneyClient(BaseAgentClient):
-    """REST client for the Microsoft Copilot Sydney chat API."""
-
-    def __init__(
-        self,
-        *,
-        copilot_api_endpoint: str,
-        access_token: str,
-        user_oid: str,
-        logger: Optional[logging.Logger] = None,
-        diagnostic_records: Optional[List[Dict[str, Any]]] = None,
-    ) -> None:
-        """
-        Args:
-            copilot_api_endpoint: Base URL for the Copilot API.
-            access_token: Bearer token for API authentication.
-            user_oid: User object ID included in request payloads.
-            logger: Logger to use for all client logging. Defaults to a module-level
-                logger if not provided.
-            diagnostic_records: List to accumulate structured log entries.
-        """
-        self._endpoint = copilot_api_endpoint
-        self._access_token = access_token
-        self._user_oid = user_oid
-        self._logger = logger or logging.getLogger(__name__)
-        self._diagnostic_records = diagnostic_records
-        self._log_level = _LEVEL_INT_TO_STR.get(self._logger.getEffectiveLevel(), "info")
-
-    # ------------------------------------------------------------------ #
-    #  BaseAgentClient implementation                                     #
-    # ------------------------------------------------------------------ #
-
-    def fetch_available_agents(self) -> List[Dict[str, Any]]:
-        """Fetch agents available to the user from the Copilot API.
-
-        Returns an empty list if the endpoint is unavailable or returns an error.
-        """
-        try:
-            request_data = json.dumps({"participant": {"id": self._user_oid}})
-            query_param = urllib.parse.quote(request_data)
-            agents_url = f"{self._endpoint}/GetGptList?request={query_param}"
-            emit_structured_log(
-                "debug",
-                f"[REST] Fetching available agents from: {agents_url}",
-                Operation.FETCH_AGENTS,
-                logger=self._logger,
-                diagnostic_records=self._diagnostic_records,
-            )
-            req = urllib.request.Request(
-                agents_url,
-                headers=self._build_request_headers(),
-                method="GET",
-            )
-            with urllib.request.urlopen(req, timeout=_REQUEST_TIMEOUT_SECS) as resp:
-                data = json.loads(resp.read().decode("utf-8"))
-                return data.get("gptList", [])
-        except urllib.error.HTTPError as e:
-            emit_structured_log("warning", f"[REST] Unable to fetch agents list (HTTP {e.code}).", Operation.FETCH_AGENTS, logger=self._logger, diagnostic_records=self._diagnostic_records)
-            return []
-        except Exception as e:
-            emit_structured_log("warning", f"[REST] Error fetching agents: {e}", Operation.FETCH_AGENTS, logger=self._logger, diagnostic_records=self._diagnostic_records)
-            return []
-
-    def send_prompt(
-        self,
-        prompt: str,
-        agent_id: str | None = None,
-        conversation_context: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-        """Send a prompt to the Sydney /chat endpoint and return the response with context.
-
-        Args:
-            prompt: Prompt string to send to the agent.
-            agent_id: Optional agent ID to target a specific Copilot agent.
-            conversation_context: Context from a previous turn (contains conversation_id),
-                or None for the first turn / single-turn usage.
-
-        Returns:
-            Tuple of (enhanced_response_dict, conversation_context).
-        """
-        request_headers = self._build_request_headers()
-        conversation_id = conversation_context.get("conversation_id") if conversation_context else None
-
-        emit_structured_log("debug", "[REST] Sending prompt to agent.", Operation.SEND_PROMPT, logger=self._logger, diagnostic_records=self._diagnostic_records)
-
-        payload = self._build_chat_payload(prompt, agent_id, conversation_id)
-        emit_structured_log("debug", f"[REST] Sending payload: {payload.decode('utf-8')[:500]}", Operation.SEND_PROMPT, logger=self._logger, diagnostic_records=self._diagnostic_records)
-
-        req = urllib.request.Request(
-            f"{self._endpoint}/chat",
-            data=payload,
-            headers=request_headers,
-            method="POST",
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=_REQUEST_TIMEOUT_SECS) as resp:
-                raw = resp.read().decode("utf-8", errors="replace")
-        except urllib.error.HTTPError as e:
-            error_body = None
-            try:
-                error_body = e.read().decode("utf-8", errors="replace")
-            except Exception:
-                pass
-            msg = f"[REST] Chat API request failed (HTTP {e.code} {e.reason})."
-            if error_body:
-                msg += f" Body: {error_body[:500]}"
-            raise RuntimeError(msg) from e
-        except urllib.error.URLError as e:
-            raise RuntimeError(
-                f"[REST] Chat API connection error: {getattr(e, 'reason', str(e))}"
-            ) from e
-
-        emit_structured_log("debug", f"[REST] Raw response: {raw[:500]}", Operation.SEND_PROMPT, logger=self._logger, diagnostic_records=self._diagnostic_records)
-
-        enhanced_response = extract_enhanced_response(raw.strip(), self._log_level)
-
-        metadata = enhanced_response.get("metadata", {})
-        emit_structured_log(
-            "debug",
-            "Response IDs for prompt.",
-            Operation.SEND_PROMPT,
-            logger=self._logger,
-            diagnostic_records=self._diagnostic_records,
-            run_context={
-                "operation": Operation.SEND_PROMPT,
-                "request-id": metadata.get("request_id"),
-                "conversation-id": metadata.get("conversation_id"),
-                "message-id": metadata.get("message_id"),
-            },
-        )
-
-        # Build updated context for subsequent turns
-        new_conversation_id = metadata.get("conversation_id") or conversation_id
-        updated_context = {"conversation_id": new_conversation_id} if new_conversation_id else None
-
-        return enhanced_response, updated_context
-
-    # ------------------------------------------------------------------ #
-    #  Private helpers                                                    #
-    # ------------------------------------------------------------------ #
-
-    def _build_request_headers(self) -> Dict[str, str]:
-        headers = {
-            "Content-Type": "application/json",
-            "X-Scenario": os.environ.get("X_SCENARIO_HEADER"),
-            "Authorization": f"Bearer {self._access_token}",
-        }
-        return {k: v for k, v in headers.items() if v is not None}
-
-    def _build_chat_payload(
-        self,
-        prompt: str,
-        agent_id: str | None,
-        conversation_id: str | None = None,
-    ) -> bytes:
-        message: Dict[str, Any] = {
-            "message": {
-                "text": prompt,
-                "author": "user",
-                "messageType": "chat",
-                "timestamp": datetime.now(timezone.utc).isoformat(),
-                "locationInfo": self._get_location_info(),
-                "from": {
-                    "id": self._user_oid,
-                },
-            },
-            "verbosity": "verbose",
-        }
-
-        if agent_id:
-            message["gpts"] = [{"id": agent_id.strip(), "source": "MOS3"}]
-            message["optionsSets"] = ["disable_action_confirmation"]
-
-        if conversation_id:
-            message["conversationId"] = conversation_id
-
-        return json.dumps(message).encode("utf-8")