1.0.0

UTCP 1.0.0 introduces a modular core with plugin-based communication protocols, new Pydantic data models, and a revamped client architecture. This improves extensibility, testability, and packaging while formalizing auth, variable loading, and post-processing.

New Features
- Core package with Tool, CallTemplate, UtcpManual, Auth, VariableLoader, and serializers.
- Pluggable interfaces: CommunicationProtocol, ConcurrentToolRepository, ToolSearchStrategy, VariableSubstitutor, ToolPostProcessor.
- Implementations: UtcpClient, InMemToolRepository (async RW lock), TagAndDescriptionWordMatchStrategy, filter/limit post-processors.
- Protocol plugins: utcp-http (HTTP, SSE, streamable HTTP + OpenAPI converter), utcp-cli, utcp-mcp; gql/socket scaffolding.
- Packaging split: core (utcp) and per-protocol packages (utcp-http, utcp-cli, utcp-mcp, etc.).
- CI runs tests for core and plugins; coverage paths updated.
- README: provider_type "http_stream" renamed to "streamable_http".

Migration
- Replace provider with call_template in manuals and code; use call_template_type (e.g., "http", "sse", "streamable_http", "cli", "mcp").
- Rename "http_stream" to "streamable_http" in configs.
- Update imports to new modules (e.g., utcp_http., utcp_cli., utcp_mcp.*) and new interfaces.
- Install protocol plugins alongside core (pip install -e core[dev] and desired utcp-xxx packages) to auto-register. (utcp, utcp-xxx for the ones from pip)
- If using tag search, switch to TagAndDescriptionWordMatchStrategy.
- Variables that are substituted in different call_templates are first namespaced with the name of the manual, with the _ duplicated. So a call template called tool_1_template from the manual manual_1 would be converted to manual__1_tool_1_template. (already part of 0.2.0)

Author: h3xxit

.github/workflows/test.yml

@@ -26,11 +26,15 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install -e ".[dev]"
+        pip install -e "core[dev]"
+        pip install -e plugins/communication_protocols/cli[dev]
+        pip install -e plugins/communication_protocols/http[dev]
+        pip install -e plugins/communication_protocols/mcp[dev]
+        pip install -e plugins/communication_protocols/text[dev]
 
     - name: Run tests with pytest
       run: |
-        pytest tests/ --doctest-modules --junitxml=junit/test-results.xml --cov=src/utcp --cov-report=xml --cov-report=html
+        pytest core/tests/ plugins/communication_protocols/cli/tests/ plugins/communication_protocols/http/tests/ plugins/communication_protocols/mcp/tests/ plugins/communication_protocols/text/tests/ --doctest-modules --junitxml=junit/test-results.xml --cov=core/src/utcp --cov-report=xml --cov-report=html
 
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v3

README.md

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "utcp"
+version = "1.0.0"
+authors = [
+  { name = "UTCP Contributors" },
+]
+description = "Universal Tool Calling Protocol (UTCP) client library for Python"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pydantic>=2.0",
+    "python-dotenv>=1.0",
+    "tomli>=2.0",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MPL-2.0"
+
+[project.optional-dependencies]
+dev = [
+    "build",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "coverage",
+    "twine",
+]
+
+[project.urls]
+Homepage = "https://utcp.io"
+Source = "https://github.com/universal-tool-calling-protocol/python-utcp"
+Issues = "https://github.com/universal-tool-calling-protocol/python-utcp/issues"

core/pyproject.toml

@@ -0,0 +1,10 @@
+import logging
+import sys
+
+logger = logging.getLogger("utcp")
+
+if not logger.handlers:  # Only add default handler if user didn't configure logging
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d - %(message)s"))
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)

core/src/utcp/__init__.py

@@ -0,0 +1,33 @@
+"""Authentication schemes for UTCP providers.
+
+This module defines the authentication models supported by UTCP providers,
+including API key authentication, basic authentication, and OAuth2.
+"""
+
+from abc import ABC
+from pydantic import BaseModel
+from utcp.interfaces.serializer import Serializer
+from utcp.exceptions import UtcpSerializerValidationError
+import traceback
+
+class Auth(BaseModel, ABC):
+    """Authentication details for a provider.
+
+    Attributes:
+        auth_type: The authentication type identifier.
+    """
+    auth_type: str
+
+class AuthSerializer(Serializer[Auth]):
+    auth_serializers: dict[str, Serializer[Auth]] = {}
+
+    def to_dict(self, obj: Auth) -> dict:
+        return AuthSerializer.auth_serializers[obj.auth_type].to_dict(obj)
+    
+    def validate_dict(self, obj: dict) -> Auth:
+        try:
+            return AuthSerializer.auth_serializers[obj["auth_type"]].validate_dict(obj)
+        except KeyError:
+            raise ValueError(f"Invalid auth type: {obj['auth_type']}")
+        except Exception as e:
+            raise UtcpSerializerValidationError("Invalid Auth: " + traceback.format_exc()) from e

src/utcp/client/__init__.py core/src/utcp/data/__init__.pysrc/utcp/client/__init__.py renamed to core/src/utcp/data/__init__.py

@@ -0,0 +1,12 @@
+from utcp.data.auth_implementations.api_key_auth import ApiKeyAuth, ApiKeyAuthSerializer
+from utcp.data.auth_implementations.basic_auth import BasicAuth, BasicAuthSerializer
+from utcp.data.auth_implementations.oauth2_auth import OAuth2Auth, OAuth2AuthSerializer
+
+__all__ = [
+    "ApiKeyAuth",
+    "BasicAuth",
+    "OAuth2Auth",
+    "ApiKeyAuthSerializer",
+    "BasicAuthSerializer",
+    "OAuth2AuthSerializer"
+]

core/src/utcp/data/auth.py

@@ -0,0 +1,42 @@
+from utcp.data.auth import Auth
+from utcp.interfaces.serializer import Serializer
+from pydantic import Field, ValidationError
+from typing import Literal
+from utcp.exceptions import UtcpSerializerValidationError
+
+class ApiKeyAuth(Auth):
+    """Authentication using an API key.
+
+    The key can be provided directly or sourced from an environment variable.
+    Supports placement in headers, query parameters, or cookies.
+
+    Attributes:
+        auth_type: The authentication type identifier, always "api_key".
+        api_key: The API key for authentication. Values starting with '$' or formatted as '${}' are
+            treated as an injected variable from environment or configuration.
+        var_name: The name of the header, query parameter, or cookie that
+            contains the API key.
+        location: Where to include the API key (header, query parameter, or cookie).
+    """
+
+    auth_type: Literal["api_key"] = "api_key"
+    api_key: str = Field(..., description="The API key for authentication. Values starting with '$' or formatted as '${}' are treated as an injected variable from environment or configuration. This is the recommended way to provide API keys.")
+    var_name: str = Field(
+        "X-Api-Key", description="The name of the header, query parameter, cookie or other container for the API key."
+    )
+    location: Literal["header", "query", "cookie"] = Field(
+        "header", description="Where to include the API key (header, query parameter, or cookie)."
+    )
+
+
+class ApiKeyAuthSerializer(Serializer[ApiKeyAuth]):
+    def to_dict(self, obj: ApiKeyAuth) -> dict:
+        return obj.model_dump()
+    
+    def validate_dict(self, obj: dict) -> ApiKeyAuth:
+        try:
+            return ApiKeyAuth.model_validate(obj)
+        except ValidationError as e:
+            raise UtcpSerializerValidationError(f"Invalid ApiKeyAuth: {e}") from e
+        except Exception as e:
+            raise UtcpSerializerValidationError("An unexpected error occurred during ApiKeyAuth validation.") from e

core/src/utcp/data/auth_implementations/__init__.py

@@ -0,0 +1,34 @@
+from utcp.data.auth import Auth
+from utcp.interfaces.serializer import Serializer
+from pydantic import Field, ValidationError
+from typing import Literal
+from utcp.exceptions import UtcpSerializerValidationError
+
+class BasicAuth(Auth):
+    """Authentication using HTTP Basic Authentication.
+
+    Uses the standard HTTP Basic Authentication scheme with username and password
+    encoded in the Authorization header.
+
+    Attributes:
+        auth_type: The authentication type identifier, always "basic".
+        username: The username for basic authentication. Recommended to use injected variables.
+        password: The password for basic authentication. Recommended to use injected variables.
+    """
+
+    auth_type: Literal["basic"] = "basic"
+    username: str = Field(..., description="The username for basic authentication.")
+    password: str = Field(..., description="The password for basic authentication.")
+
+
+class BasicAuthSerializer(Serializer[BasicAuth]):
+    def to_dict(self, obj: BasicAuth) -> dict:
+        return obj.model_dump()
+    
+    def validate_dict(self, obj: dict) -> BasicAuth:
+        try:
+            return BasicAuth.model_validate(obj)
+        except ValidationError as e:
+            raise UtcpSerializerValidationError(f"Invalid BasicAuth: {e}") from e
+        except Exception as e:
+            raise UtcpSerializerValidationError("An unexpected error occurred during BasicAuth validation.") from e

core/src/utcp/data/auth_implementations/api_key_auth.py

@@ -0,0 +1,39 @@
+from utcp.data.auth import Auth
+from utcp.interfaces.serializer import Serializer
+from utcp.exceptions import UtcpSerializerValidationError
+from pydantic import Field, ValidationError
+from typing import Literal, Optional
+
+
+class OAuth2Auth(Auth):
+    """Authentication using OAuth2 client credentials flow.
+
+    Implements the OAuth2 client credentials grant type for machine-to-machine
+    authentication. The client automatically handles token acquisition and refresh.
+
+    Attributes:
+        auth_type: The authentication type identifier, always "oauth2".
+        token_url: The URL endpoint to fetch the OAuth2 access token from. Recommended to use injected variables.
+        client_id: The OAuth2 client identifier. Recommended to use injected variables.
+        client_secret: The OAuth2 client secret. Recommended to use injected variables.
+        scope: Optional scope parameter to limit the access token's permissions.
+    """
+
+    auth_type: Literal["oauth2"] = "oauth2"
+    token_url: str = Field(..., description="The URL to fetch the OAuth2 token from.")
+    client_id: str = Field(..., description="The OAuth2 client ID.")
+    client_secret: str = Field(..., description="The OAuth2 client secret.")
+    scope: Optional[str] = Field(None, description="The OAuth2 scope.")
+
+
+class OAuth2AuthSerializer(Serializer[OAuth2Auth]):
+    def to_dict(self, obj: OAuth2Auth) -> dict:
+        return obj.model_dump()
+    
+    def validate_dict(self, obj: dict) -> OAuth2Auth:
+        try:
+            return OAuth2Auth.model_validate(obj)
+        except ValidationError as e:
+            raise UtcpSerializerValidationError(f"Invalid OAuth2Auth: {e}") from e
+        except Exception as e:
+            raise UtcpSerializerValidationError("An unexpected error occurred during OAuth2Auth validation.") from e