Add inputs and outputs to component definition tool

[mathislucka]

Overview

We need to extend the get_component_definition tool in src/deepset_mcp/tools/haystack_service.py

We also need to fetch component input and outputs. You can do that by passing the component name (last element of the path) into service.get_component_input_output.

Format the input and outputs nicely including descriptions types and defaults.

Update the test in test/unit/tools/test_haystack_service.py to reflect the addition.

This is how the method on the service looks like:

async def get_component_input_output(self, component_name: str) -> dict[str, Any]:
"""Fetch the component input and output schema from the API.

    Args:
        component_name: The name of the component to fetch the input/output schema for

    Returns:
        The component input/output schema as a dictionary
    """
    resp = await self._client.request(
        endpoint=f"v1/haystack/components/input-output?domain=deepset-cloud&names={component_name}",
        method="GET",
        headers={"accept": "application/json"},
        response_type=list[dict[str, Any]],
    )

    raise_for_status(resp)

    if resp.json is None or len(resp.json) == 0:
        raise ResourceNotFoundError(f"Component '{component_name}' not found.")

    return resp.json[0] if resp.json is not None else {}

Any errors or missing inputs and outputs should be reflected in the response.

Example
Here is an example io response:

{'input': {'additionalProperties': False, 'definitions': {'ChatMessage': {'additionalProperties': False, 'properties': {'_content': {}, '_meta': {'properties': {...}, 'type': 'object'}, '_name': {'type': [...]}, '_python_type': {'default': 'dataclass', 'type': 'string'}, '_role': {'enum': [...], 'examples': [...], 'type': 'string'}}, 'required': ['_role', '_content'], 'type': 'object'}}, 'properties': {'messages': {'_annotation': 'typing.List[haystack.dataclasses.chat_message.ChatMessage]', 'description': 'List of chat messages to process', 'items': {'$ref': '#/definitions/ChatMessage'}, 'type': 'array'}, 'streaming_callback': {'_annotation': 'typing.Union[typing.Callable[[haystack.dataclasses.streaming_chunk.StreamingChunk], NoneType], typing.Callable[[haystack.dataclasses.streaming_chunk.StreamingChunk], typing.Awaitable[NoneType]], NoneType]', 'anyOf': [{'description': 'A string representing a Python function path. This string is expected to contain the fully qualified name of a callable object, with each part of the path separated by dots (e.g., 'module.submodule.function'). The function must be locally available.', 'type': 'string'}, {'description': 'A string representing a Python function path. This string is expected to contain the fully qualified name of a callable object, with each part of the path separated by dots (e.g., 'module.submodule.function'). The function must be locally available.', 'type': 'string'}, {'type': 'null'}], 'description': 'A callback that will be invoked when a response is streamed from the LLM.'}}, 'required': ['messages'], 'type': 'object'}, 'name': 'Agent', 'output': {'description': 'No output schema available. Failed to extract since the output decorator is not found.', 'type': 'object'}}

Parse the response defensively to avoid errors.

[mathislucka]

The addition looks fairly good already. The only problem is with the output schema. You are not properly parsing the full schema. Here is an example with a different component that has a full output schema:

{'input': {'additionalProperties': False, 'definitions': {}, 'properties': {'all_terms_must_match': {'_annotation': 'typing.Optional[bool]', 'description': 'If `True`, all terms in the query string must be present in the
        retrieved documents.', 'type': ['boolean', 'null']}, 'custom_query': {'_annotation': 'typing.Optional[typing.Dict[str, typing.Any]]', 'description': 'A custom OpenSearch query. It must include a `$query` and may optionally
        include a `$filters` placeholder.

            **An example custom_query:**

            ```python
            {
                "query": {
                    "bool": {
                        "should": [{"multi_match": {
                            "query": "$query",                 // mandatory query placeholder
                            "type": "most_fields",
                            "fields": ["content", "title"]}}],
                        "filter": "$filters"                  // optional filter placeholder
                    }
                }
            }
            ```

        **For this custom_query, a sample `run()` could be:**

        ```python
        retriever.run(
            query="Why did the revenue increase?",
            filters={
                "operator": "AND",
                "conditions": [
                    {"field": "meta.years", "operator": "==", "value": "2019"},
                    {"field": "meta.quarters", "operator": "in", "value": ["Q1", "Q2"]},
                ],
            },
        )
        ```', 'properties': {'_python_type': {'default': 'dict', 'not': {...}, 'type': 'string'}}, 'type': ['object', 'null']}, 'filters': {'_annotation': 'typing.Optional[typing.Dict[str, typing.Any]]', 'description': 'Filters applied to the retrieved documents. The way runtime filters are applied depends on
                        the `filter_policy` specified at Retriever's initialization.', 'properties': {'_python_type': {'default': 'dict', 'not': {...}, 'type': 'string'}}, 'type': ['object', 'null']}, 'fuzziness': {'_annotation': 'typing.Union[str, int, NoneType]', 'anyOf': [{'type': 'string'}, {'type': [...]}, {'type': 'null'}], 'description': 'Fuzziness parameter for full-text queries to apply approximate string matching.
        For more information, see [OpenSearch fuzzy query](https://opensearch.org/docs/latest/query-dsl/term/fuzzy/).'}, 'query': {'_annotation': '<class 'str'>', 'description': 'The query string.', 'type': 'string'}, 'scale_score': {'_annotation': 'typing.Optional[bool]', 'description': 'If `True`, scales the score of retrieved documents to a range between 0 and 1.
            This is useful when comparing documents across different indexes.', 'type': ['boolean', 'null']}, 'top_k': {'_annotation': 'typing.Optional[int]', 'description': 'Maximum number of documents to return.', 'type': ['integer', 'null']}}, 'required': ['query'], 'type': 'object'}, 'name': 'OpenSearchBM25Retriever', 'output': {'additionalProperties': False, 'definitions': {'ByteStream': {'additionalProperties': False, 'properties': {'_python_type': {'default': 'dataclass', 'type': 'string'}, 'data': {'contentEncoding': 'base64', 'type': 'string'}, 'meta': {'properties': {...}, 'type': 'object'}, 'mime_type': {'type': [...]}}, 'required': ['data'], 'type': 'object'}, 'Document': {'additionalProperties': False, 'properties': {'_python_type': {'default': 'dataclass', 'type': 'string'}, 'blob': {'anyOf': [...]}, 'content': {'type': [...]}, 'embedding': {'items': {...}, 'type': [...]}, 'id': {'type': 'string'}, 'meta': {'properties': {...}, 'type': 'object'}, 'score': {'type': [...]}, 'sparse_embedding': {'anyOf': [...]}}, 'required': [], 'type': 'object'}, 'SparseEmbedding': {'additionalProperties': False, 'properties': {'_python_type': {'default': 'dataclass', 'type': 'string'}, 'indices': {'items': {...}, 'type': 'array'}, 'values': {'items': {...}, 'type': 'array'}}, 'required': ['indices', 'values'], 'type': 'object'}}, 'properties': {'documents': {'_annotation': 'typing.List[haystack.dataclasses.document.Document]', 'items': {'$ref': '#/definitions/Document'}, 'type': 'array'}}, 'required': ['documents'], 'type': 'object'}}