flock-core 0.4.539__py3-none-any.whl → 0.4.541__py3-none-any.whl

flock/core/logging/live_capture.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import io
+import re
+import sys
+import threading
+import time
+from collections import deque
+from typing import Deque, List, Literal, MutableMapping
+
+__all__ = [
+    "enable_live_log_capture",
+    "get_live_log_store",
+    "LiveLogStore",
+]
+
+AnsiSource = Literal["stdout", "stderr"]
+ANSI_ESCAPE_PATTERN = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+
+class LiveLogStore:
+    """Thread-safe ring buffer that keeps recent CLI log lines."""
+
+    def __init__(self, max_lines: int = 800) -> None:
+        self._lines: Deque[dict[str, object]] = deque(maxlen=max_lines)
+        self._buffers: MutableMapping[AnsiSource, str] = {"stdout": "", "stderr": ""}
+        self._lock = threading.Lock()
+
+    def append_chunk(self, chunk: str, source: AnsiSource) -> None:
+        """Append raw stream data, splitting into sanitized log lines."""
+        if not chunk:
+            return
+        normalized = chunk.replace("\r\n", "\n").replace("\r", "\n")
+        with self._lock:
+            combined = self._buffers[source] + normalized
+            parts = combined.split("\n")
+            if combined.endswith("\n"):
+                complete, remainder = parts[:-1], ""
+            else:
+                complete, remainder = parts[:-1], parts[-1]
+            self._buffers[source] = remainder
+
+            timestamp = time.time()
+            for raw_line in complete:
+                cleaned = ANSI_ESCAPE_PATTERN.sub("", raw_line).rstrip("\r")
+                # Preserve deliberate blank lines but normalise whitespace-only strings
+                if cleaned and cleaned.strip() == "":
+                    cleaned = ""
+                self._lines.append(
+                    {
+                        "timestamp": timestamp,
+                        "stream": source,
+                        "text": cleaned,
+                    }
+                )
+                timestamp += 1e-6  # keep ordering stable for same chunk
+
+    def get_entries(self, *, limit: int | None = None) -> List[dict[str, object]]:
+        """Return a copy of the most recent log entries (oldest first)."""
+        with self._lock:
+            snapshot = list(self._lines)
+        if limit is None:
+            return snapshot
+        if limit <= 0:
+            return []
+        return snapshot[-limit:]
+
+    def clear(self) -> None:
+        """Clear buffered log lines and pending chunks."""
+        with self._lock:
+            self._lines.clear()
+            self._buffers = {"stdout": "", "stderr": ""}
+
+
+class _TeeStream(io.TextIOBase):
+    """Duplicate writes to the original stream and the live log store."""
+
+    def __init__(self, wrapped: io.TextIOBase, source: AnsiSource, store: LiveLogStore) -> None:
+        self._wrapped = wrapped
+        self._source = source
+        self._store = store
+
+    def write(self, data: str) -> int:  # type: ignore[override]
+        self._store.append_chunk(data, self._source)
+        return self._wrapped.write(data)
+
+    def flush(self) -> None:  # type: ignore[override]
+        self._wrapped.flush()
+
+    def isatty(self) -> bool:  # type: ignore[override]
+        return self._wrapped.isatty()
+
+    def fileno(self) -> int:  # type: ignore[override]
+        return self._wrapped.fileno()
+
+    def readable(self) -> bool:  # type: ignore[override]
+        return False
+
+    def writable(self) -> bool:  # type: ignore[override]
+        return True
+
+    def seekable(self) -> bool:  # type: ignore[override]
+        return False
+
+    def close(self) -> None:  # type: ignore[override]
+        self._wrapped.close()
+
+    @property
+    def closed(self) -> bool:  # type: ignore[override]
+        return self._wrapped.closed
+
+    @property
+    def encoding(self) -> str | None:  # type: ignore[override]
+        return getattr(self._wrapped, "encoding", None)
+
+    def __getattr__(self, item: str):
+        return getattr(self._wrapped, item)
+
+
+_live_log_store = LiveLogStore()
+_capture_enabled = False
+
+
+def enable_live_log_capture() -> None:
+    """Wrap stdout/stderr so CLI output is mirrored into the live log store."""
+    global _capture_enabled
+    if _capture_enabled:
+        return
+
+    sys.stdout = _TeeStream(sys.stdout, "stdout", _live_log_store)
+    sys.stderr = _TeeStream(sys.stderr, "stderr", _live_log_store)
+    _capture_enabled = True
+
+
+def get_live_log_store() -> LiveLogStore:
+    """Expose the singleton live log store for dependency injection."""
+    return _live_log_store

flock/tools/zendesk_tools.py

@@ -5,17 +5,27 @@ import os
 import httpx
 from mcp.server.fastmcp import FastMCP
 
-mcp = FastMCP("ZendeskTools")
-
-
+from flock.core.logging.logging import get_logger
 
+mcp = FastMCP("ZendeskTools")
+logger = get_logger(__name__)
 
 def _get_headers() -> dict:
+    logger.debug("Preparing headers for Zendesk API request")
+
     token = os.getenv("ZENDESK_BEARER_TOKEN")
     if not token:
+        logger.error("ZENDESK_BEARER_TOKEN environment variable is not set")
         raise ValueError(
             "ZENDESK_BEARER_TOKEN environment variable is not set"
         )
+
+    logger.debug("Successfully retrieved bearer token from environment")
+    # Log a masked version of the token for debugging
+    masked_token = f"{token[:10]}...{token[-4:] if len(token) > 14 else 'short'}"
+    logger.debug(f"Using bearer token: {masked_token}")
+    logger.debug("Headers prepared successfully")
+
     return {
         "Authorization": f"Bearer {token}",
         "Accept": "application/json",
@@ -25,69 +35,169 @@ def _get_headers() -> dict:
 @mcp.tool()
 def zendesk_get_tickets(number_of_tickets: int = 10) -> list[dict]:
     """Get all tickets."""
+    logger.info(f"Starting zendesk_get_tickets with number_of_tickets: {number_of_tickets}")
+
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
+    logger.debug(f"Using Zendesk subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = f"{BASE_URL}/api/v2/tickets.json"
+    logger.debug(f"Initial URL: {url}")
+
     all_tickets = []
+    page_count = 0
+
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
+        logger.debug("Created HTTP client for Zendesk API")
+
         while url and len(all_tickets) < number_of_tickets:
-            response = client.get(url)
-            response.raise_for_status()
+            page_count += 1
+            logger.debug(f"Fetching page {page_count} from URL: {url}")
 
-            data = response.json()
-            tickets = data.get("tickets", [])
-            all_tickets.extend(tickets)
+            try:
+                response = client.get(url)
+                response.raise_for_status()
+                logger.debug(f"Successfully received response with status: {response.status_code}")
 
-            url = data.get("next_page")
+                data = response.json()
+                tickets = data.get("tickets", [])
+                logger.debug(f"Retrieved {len(tickets)} tickets from page {page_count}")
+
+                all_tickets.extend(tickets)
+                logger.debug(f"Total tickets collected so far: {len(all_tickets)}")
+
+                url = data.get("next_page")
+                if url:
+                    logger.debug(f"Next page URL: {url}")
+                else:
+                    logger.debug("No more pages available")
+
+            except Exception as e:
+                logger.error(f"Error fetching tickets on page {page_count}: {e}")
+                raise
+
+    logger.info(f"Successfully retrieved {len(all_tickets)} tickets across {page_count} pages")
     return all_tickets
 
 @mcp.tool()
 def zendesk_get_ticket_by_id(ticket_id: str) -> dict:
     """Get a ticket by ID."""
+    logger.info(f"Starting zendesk_get_ticket_by_id for ticket_id: {ticket_id}")
+
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
+    logger.debug(f"Using Zendesk subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = f"{BASE_URL}/api/v2/tickets/{ticket_id}"
+    logger.debug(f"Request URL: {url}")
+
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
-        response = client.get(url)
-        response.raise_for_status()
-        return response.json()["ticket"]
+        logger.debug("Created HTTP client for Zendesk API")
+
+        try:
+            logger.debug(f"Making GET request for ticket {ticket_id}")
+            response = client.get(url)
+            response.raise_for_status()
+            logger.debug(f"Successfully received response with status: {response.status_code}")
+
+            ticket_data = response.json()["ticket"]
+            logger.info(f"Successfully retrieved ticket {ticket_id} with subject: {ticket_data.get('subject', 'N/A')}")
+            return ticket_data
+
+        except Exception as e:
+            logger.error(f"Error fetching ticket {ticket_id}: {e}")
+            raise
 
 @mcp.tool()
 def zendesk_get_comments_by_ticket_id(ticket_id: str) -> list[dict]:
     """Get all comments for a ticket."""
+    logger.info(f"Starting zendesk_get_comments_by_ticket_id for ticket_id: {ticket_id}")
+
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
+    logger.debug(f"Using Zendesk subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = f"{BASE_URL}/api/v2/tickets/{ticket_id}/comments"
+    logger.debug(f"Request URL: {url}")
+
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
-        response = client.get(url)
-        response.raise_for_status()
-        return response.json()["comments"]
+        logger.debug("Created HTTP client for Zendesk API")
+
+        try:
+            logger.debug(f"Making GET request for comments of ticket {ticket_id}")
+            response = client.get(url)
+            response.raise_for_status()
+            logger.debug(f"Successfully received response with status: {response.status_code}")
+
+            comments = response.json()["comments"]
+            logger.info(f"Successfully retrieved {len(comments)} comments for ticket {ticket_id}")
+            return comments
+
+        except Exception as e:
+            logger.error(f"Error fetching comments for ticket {ticket_id}: {e}")
+            raise
 
 @mcp.tool()
 def zendesk_get_article_by_id(article_id: str) -> dict:
     """Get an article by ID."""
+    logger.info(f"Starting zendesk_get_article_by_id for article_id: {article_id}")
+
     ZENDESK_LOCALE = os.getenv("ZENDESK_ARTICLE_LOCALE")
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_ARTICLE")
+    logger.debug(f"Using locale: {ZENDESK_LOCALE}, subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = (
         f"{BASE_URL}/api/v2/help_center/{ZENDESK_LOCALE}/articles/{article_id}"
     )
+    logger.debug(f"Request URL: {url}")
+
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
-        response = client.get(url)
-        response.raise_for_status()
-        return response.json()["article"]
+        logger.debug("Created HTTP client for Zendesk API")
+
+        try:
+            logger.debug(f"Making GET request for article {article_id}")
+            response = client.get(url)
+            response.raise_for_status()
+            logger.debug(f"Successfully received response with status: {response.status_code}")
+
+            article = response.json()["article"]
+            logger.info(f"Successfully retrieved article {article_id} with title: {article.get('title', 'N/A')}")
+            return article
+
+        except Exception as e:
+            logger.error(f"Error fetching article {article_id}: {e}")
+            raise
 
 @mcp.tool()
 def zendesk_get_articles() -> list[dict]:
     """Get all articles."""
+    logger.info("Starting zendesk_get_articles")
+
     ZENDESK_LOCALE = os.getenv("ZENDESK_ARTICLE_LOCALE")
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_ARTICLE")
+    logger.debug(f"Using locale: {ZENDESK_LOCALE}, subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = f"{BASE_URL}/api/v2/help_center/{ZENDESK_LOCALE}/articles.json"
+    logger.debug(f"Request URL: {url}")
+
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
-        response = client.get(url)
-        response.raise_for_status()
-        return response.json()["articles"]
+        logger.debug("Created HTTP client for Zendesk API")
+
+        try:
+            logger.debug("Making GET request for articles")
+            response = client.get(url)
+            response.raise_for_status()
+            logger.debug(f"Successfully received response with status: {response.status_code}")
+
+            articles = response.json()["articles"]
+            logger.info(f"Successfully retrieved {len(articles)} articles")
+            return articles
+
+        except Exception as e:
+            logger.error(f"Error fetching articles: {e}")
+            raise
 
 @mcp.tool()
 def zendesk_get_articles_count() -> int:
@@ -129,10 +239,15 @@ def zendesk_get_articles_count() -> int:
 @mcp.tool()
 def zendesk_search_articles(query: str) -> list[dict]:
     """Search Zendesk Help Center articles using a query string."""
+    logger.info(f"Starting zendesk_search_articles with query: '{query}'")
+
     ZENDESK_LOCALE = os.getenv("ZENDESK_ARTICLE_LOCALE")  # e.g., "en-us"
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_ARTICLE")
+    logger.debug(f"Using locale: {ZENDESK_LOCALE}, subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = f"{BASE_URL}/api/v2/help_center/articles/search.json"
+    logger.debug(f"Search URL: {url}")
 
     params = {
         "query": query,
@@ -140,11 +255,24 @@ def zendesk_search_articles(query: str) -> list[dict]:
         "sort_by": "updated_at",
         "sort_order": "desc",
     }
+    logger.debug(f"Search parameters: {params}")
 
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
-        response = client.get(url, params=params)
-        response.raise_for_status()
-        return response.json().get("results", [])
+        logger.debug("Created HTTP client for Zendesk API")
+
+        try:
+            logger.debug(f"Making GET request to search articles with query: '{query}'")
+            response = client.get(url, params=params)
+            response.raise_for_status()
+            logger.debug(f"Successfully received response with status: {response.status_code}")
+
+            results = response.json().get("results", [])
+            logger.info(f"Search completed successfully, found {len(results)} articles matching query: '{query}'")
+            return results
+
+        except Exception as e:
+            logger.error(f"Error searching articles with query '{query}': {e}")
+            raise
 
 @mcp.tool()
 def zendesk_add_comment_to_ticket(ticket_id: str, comment_body: str, public: bool = False) -> dict:
@@ -153,9 +281,15 @@ def zendesk_add_comment_to_ticket(ticket_id: str, comment_body: str, public: boo
     Updates the ticket with a new comment via Zendesk Ticketing API:
     PUT /api/v2/tickets/{ticket_id}.json
     """
+    logger.info(f"Starting zendesk_add_comment_to_ticket for ticket_id: {ticket_id}, public: {public}")
+    logger.debug(f"Comment body length: {len(comment_body)} characters")
+
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
+    logger.debug(f"Using Zendesk subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = f"{BASE_URL}/api/v2/tickets/{ticket_id}.json"
+    logger.debug(f"Request URL: {url}")
 
     payload = {
         "ticket": {
@@ -165,12 +299,25 @@ def zendesk_add_comment_to_ticket(ticket_id: str, comment_body: str, public: boo
             }
         }
     }
+    logger.debug(f"Payload prepared for ticket {ticket_id}")
 
     import httpx
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
-        response = client.put(url, json=payload)
-        response.raise_for_status()
-        return response.json()["ticket"]
+        logger.debug("Created HTTP client for Zendesk API")
+
+        try:
+            logger.debug(f"Making PUT request to add comment to ticket {ticket_id}")
+            response = client.put(url, json=payload)
+            response.raise_for_status()
+            logger.debug(f"Successfully received response with status: {response.status_code}")
+
+            ticket_data = response.json()["ticket"]
+            logger.info(f"Successfully added comment to ticket {ticket_id}")
+            return ticket_data
+
+        except Exception as e:
+            logger.error(f"Error adding comment to ticket {ticket_id}: {e}")
+            raise
 
 @mcp.tool()
 def zendesk_set_ticket_custom_field(
@@ -181,11 +328,19 @@ def zendesk_set_ticket_custom_field(
     Uses Zendesk's Update Ticket API to set a custom field value:
     PUT /api/v2/tickets/{ticket_id}.json
     """#
+    logger.info(f"Starting zendesk_set_ticket_custom_field for ticket_id: {ticket_id}, field_id: {custom_field_id}")
+    logger.debug(f"Custom field value: {custom_field_value}, is_multi_option: {is_multi_option}")
+
     if is_multi_option:
         custom_field_value = [custom_field_value]
+        logger.debug("Converted custom field value to list for multi-option field")
+
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
+    logger.debug(f"Using Zendesk subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = f"{BASE_URL}/api/v2/tickets/{ticket_id}.json"
+    logger.debug(f"Request URL: {url}")
 
     payload = {
         "ticket": {
@@ -197,48 +352,99 @@ def zendesk_set_ticket_custom_field(
             ]
         }
     }
+    logger.debug(f"Payload prepared for ticket {ticket_id} with custom field {custom_field_id}")
 
     import httpx
 
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
-        response = client.put(url, json=payload)
-        response.raise_for_status()
-        return response.json()["ticket"]
+        logger.debug("Created HTTP client for Zendesk API")
+
+        try:
+            logger.debug(f"Making PUT request to set custom field {custom_field_id} on ticket {ticket_id}")
+            response = client.put(url, json=payload)
+            response.raise_for_status()
+            logger.debug(f"Successfully received response with status: {response.status_code}")
+
+            ticket_data = response.json()["ticket"]
+            logger.info(f"Successfully set custom field {custom_field_id} on ticket {ticket_id}")
+            return ticket_data
+
+        except Exception as e:
+            logger.error(f"Error setting custom field {custom_field_id} on ticket {ticket_id}: {e}")
+            raise
 
 
 
 @mcp.tool()
 def zendesk_set_ticket_tags(ticket_id: str, tags: list[str]) -> list[str]:
     """Set the complete tag list for a ticket (overwrites existing tags)."""
+    logger.info(f"Starting zendesk_set_ticket_tags for ticket_id: {ticket_id}")
+    logger.debug(f"Setting tags: {tags} (total: {len(tags)} tags)")
+
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
+    logger.debug(f"Using Zendesk subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = f"{BASE_URL}/api/v2/tickets/{ticket_id}/tags.json"
+    logger.debug(f"Request URL: {url}")
 
     payload = {"tags": tags}
+    logger.debug(f"Payload prepared for ticket {ticket_id}")
 
     import httpx
 
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
-        resp = client.put(url, json=payload)
-        resp.raise_for_status()
-        return resp.json().get("tags", [])
+        logger.debug("Created HTTP client for Zendesk API")
+
+        try:
+            logger.debug(f"Making PUT request to set tags on ticket {ticket_id}")
+            resp = client.put(url, json=payload)
+            resp.raise_for_status()
+            logger.debug(f"Successfully received response with status: {resp.status_code}")
+
+            result_tags = resp.json().get("tags", [])
+            logger.info(f"Successfully set {len(result_tags)} tags on ticket {ticket_id}")
+            return result_tags
+
+        except Exception as e:
+            logger.error(f"Error setting tags on ticket {ticket_id}: {e}")
+            raise
 
 
 @mcp.tool()
 def zendesk_add_ticket_tags(ticket_id: str, tags: list[str]) -> list[str]:
     """Add tags to a ticket (preserves existing tags)."""
+    logger.info(f"Starting zendesk_add_ticket_tags for ticket_id: {ticket_id}")
+    logger.debug(f"Adding tags: {tags} (total: {len(tags)} tags)")
+
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
+    logger.debug(f"Using Zendesk subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = f"{BASE_URL}/api/v2/tickets/{ticket_id}/tags.json"
+    logger.debug(f"Request URL: {url}")
 
     payload = {"tags": tags}
+    logger.debug(f"Payload prepared for ticket {ticket_id}")
 
     import httpx
 
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
-        resp = client.post(url, json=payload)
-        resp.raise_for_status()
-        return resp.json().get("tags", [])
+        logger.debug("Created HTTP client for Zendesk API")
+
+        try:
+            logger.debug(f"Making POST request to add tags to ticket {ticket_id}")
+            resp = client.post(url, json=payload)
+            resp.raise_for_status()
+            logger.debug(f"Successfully received response with status: {resp.status_code}")
+
+            result_tags = resp.json().get("tags", [])
+            logger.info(f"Successfully added tags to ticket {ticket_id}, total tags now: {len(result_tags)}")
+            return result_tags
+
+        except Exception as e:
+            logger.error(f"Error adding tags to ticket {ticket_id}: {e}")
+            raise
 
 
 @mcp.tool()
@@ -250,23 +456,42 @@ def zendesk_get_ticket_field_type(field_id: int) -> dict:
     Returns a dict containing at least:
     { "type": str, "custom_field_options": list }
     """
+    logger.info(f"Starting zendesk_get_ticket_field_type for field_id: {field_id}")
+
     ZENDESK_SUBDOMAIN = os.getenv("ZENDESK_SUBDOMAIN_TICKET")
+    logger.debug(f"Using Zendesk subdomain: {ZENDESK_SUBDOMAIN}")
+
     BASE_URL = f"https://{ZENDESK_SUBDOMAIN}.zendesk.com"
     url = f"{BASE_URL}/api/v2/ticket_fields/{field_id}.json"
+    logger.debug(f"Request URL: {url}")
 
     import httpx
 
     with httpx.Client(headers=_get_headers(), timeout=30.0) as client:
-        resp = client.get(url)
-        resp.raise_for_status()
-        field = resp.json().get("ticket_field", {})
-        return {
-            "id": field.get("id"),
-            "type": field.get("type"),
-            "title": field.get("title"),
-            "required": field.get("required"),
-            "custom_field_options": field.get("custom_field_options", []),
-        }
+        logger.debug("Created HTTP client for Zendesk API")
+
+        try:
+            logger.debug(f"Making GET request for ticket field {field_id}")
+            resp = client.get(url)
+            resp.raise_for_status()
+            logger.debug(f"Successfully received response with status: {resp.status_code}")
+
+            field = resp.json().get("ticket_field", {})
+            result = {
+                "id": field.get("id"),
+                "type": field.get("type"),
+                "title": field.get("title"),
+                "required": field.get("required"),
+                "custom_field_options": field.get("custom_field_options", []),
+            }
+
+            logger.info(f"Successfully retrieved field info for {field_id}: type={result['type']}, title='{result['title']}'")
+            logger.debug(f"Field has {len(result['custom_field_options'])} custom options")
+            return result
+
+        except Exception as e:
+            logger.error(f"Error fetching ticket field {field_id}: {e}")
+            raise