chuk-tool-processor 0.9.1__py3-none-any.whl → 0.9.5__py3-none-any.whl

chuk_tool_processor/mcp/stream_manager.py

@@ -176,17 +176,24 @@ class StreamManager:
             for idx, server_name in enumerate(servers):
                 try:
                     if transport_type == "stdio":
-                        params = await load_config(config_file, server_name)
+                        params, server_timeout = await load_config(config_file, server_name)
+                        # Use per-server timeout if specified, otherwise use global default
+                        effective_timeout = server_timeout if server_timeout is not None else default_timeout
+                        logger.info(
+                            f"Server '{server_name}' using timeout: {effective_timeout}s (per-server: {server_timeout}, default: {default_timeout})"
+                        )
                         # Use initialization_timeout for connection_timeout since subprocess
                         # launch can take time (e.g., uvx downloading packages)
                         transport: MCPBaseTransport = StdioTransport(
-                            params, connection_timeout=initialization_timeout, default_timeout=default_timeout
+                            params, connection_timeout=initialization_timeout, default_timeout=effective_timeout
                         )
                     elif transport_type == "sse":
                         logger.debug(
                             "Using SSE transport in initialize() - consider using initialize_with_sse() instead"
                         )
-                        params = await load_config(config_file, server_name)
+                        params, server_timeout = await load_config(config_file, server_name)
+                        # Use per-server timeout if specified, otherwise use global default
+                        effective_timeout = server_timeout if server_timeout is not None else default_timeout
 
                         if isinstance(params, dict) and "url" in params:
                             sse_url = params["url"]
@@ -199,7 +206,7 @@ class StreamManager:
                             logger.debug("No URL configured for SSE transport, using default: %s", sse_url)
 
                         # Build SSE transport with optional headers
-                        transport_params = {"url": sse_url, "api_key": api_key, "default_timeout": default_timeout}
+                        transport_params = {"url": sse_url, "api_key": api_key, "default_timeout": effective_timeout}
                         if headers:
                             transport_params["headers"] = headers
 
@@ -209,7 +216,9 @@ class StreamManager:
                         logger.debug(
                             "Using HTTP Streamable transport in initialize() - consider using initialize_with_http_streamable() instead"
                         )
-                        params = await load_config(config_file, server_name)
+                        params, server_timeout = await load_config(config_file, server_name)
+                        # Use per-server timeout if specified, otherwise use global default
+                        effective_timeout = server_timeout if server_timeout is not None else default_timeout
 
                         if isinstance(params, dict) and "url" in params:
                             http_url = params["url"]
@@ -227,7 +236,7 @@ class StreamManager:
                         transport_params = {
                             "url": http_url,
                             "api_key": api_key,
-                            "default_timeout": default_timeout,
+                            "default_timeout": effective_timeout,
                             "session_id": session_id,
                         }
                         # Note: headers not added until HTTPStreamableTransport supports them

{chuk_tool_processor-0.9.1.dist-info → chuk_tool_processor-0.9.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.9.1
+Version: 0.9.5
 Summary: Async-native framework for registering, discovering, and executing tools referenced in LLM responses
 Author-email: CHUK Team <chrishayuk@somejunkmailbox.com>
 Maintainer-email: CHUK Team <chrishayuk@somejunkmailbox.com>
@@ -20,7 +20,7 @@ Classifier: Framework :: AsyncIO
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: chuk-mcp>=0.7.1
+Requires-Dist: chuk-mcp>=0.8
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: psutil>=7.0.0
 Requires-Dist: pydantic>=2.11.3
@@ -112,6 +112,25 @@ CHUK Tool Processor uses a **composable stack architecture**:
 
 Each layer is **optional** and **configurable**. Mix and match what you need.
 
+## Compatibility Matrix
+
+| Component | Supported Versions | Notes |
+|-----------|-------------------|-------|
+| **Python** | 3.11, 3.12, 3.13 | Python 3.11+ required |
+| **Operating Systems** | macOS, Linux, Windows | All platforms fully supported |
+| **LLM Providers** | OpenAI, Anthropic, Local models | Any LLM that outputs tool calls |
+| **MCP Transports** | HTTP Streamable, STDIO, SSE | All MCP 1.0 transports |
+| **MCP Servers** | Notion, SQLite, Atlassian, Echo, Custom | Any MCP-compliant server |
+
+**Tested Configurations:**
+- ✅ macOS 14+ (Apple Silicon & Intel)
+- ✅ Ubuntu 20.04+ / Debian 11+
+- ✅ Windows 10+ (native & WSL2)
+- ✅ Python 3.11.0+, 3.12.0+, 3.13.0+
+- ✅ OpenAI GPT-4, GPT-4 Turbo
+- ✅ Anthropic Claude 3 (Opus, Sonnet, Haiku)
+- ✅ Local models (Ollama, LM Studio)
+
 ## Quick Start
 
 ### Installation
@@ -131,6 +150,21 @@ cd chuk-tool-processor
 uv pip install -e .
 ```
 
+## 60-Second Quick Start
+
+**Absolutely minimal example** → See `examples/hello_tool.py`:
+
+```bash
+python examples/hello_tool.py
+```
+
+Single file that demonstrates:
+- Registering a tool
+- Parsing OpenAI & Anthropic formats
+- Executing and getting results
+
+Takes 60 seconds to understand, 3 minutes to master.
+
 ### 3-Minute Example
 
 Copy-paste this into a file and run it:
@@ -176,16 +210,27 @@ asyncio.run(main())
 > **Why not just use OpenAI tool calls?**
 > OpenAI's function calling is great for parsing, but you still need: parsing multiple formats (Anthropic XML, etc.), timeouts, retries, rate limits, caching, subprocess isolation, and connecting to external MCP servers. CHUK Tool Processor **is** that missing middle layer.
 
+## Documentation Quick Reference
+
+| Document | What It Covers |
+|----------|----------------|
+| 📘 [CONFIGURATION.md](docs/CONFIGURATION.md) | **All config knobs & defaults**: ToolProcessor options, timeouts, retry policy, rate limits, circuit breakers, caching, environment variables |
+| 🚨 [ERRORS.md](docs/ERRORS.md) | **Error taxonomy**: All error codes, exception classes, error details structure, handling patterns, retryability guide |
+| 📊 [OBSERVABILITY.md](docs/OBSERVABILITY.md) | **Metrics & tracing**: OpenTelemetry setup, Prometheus metrics, spans reference, PromQL queries |
+| 🔌 [examples/hello_tool.py](examples/hello_tool.py) | **60-second starter**: Single-file, copy-paste-and-run example |
+| 🎯 [examples/](examples/) | **20+ working examples**: MCP integration, OAuth flows, streaming, production patterns |
+
 ## Choose Your Path
 
 | Your Goal | What You Need | Where to Look |
 |-----------|---------------|---------------|
-| ☕ **Just process LLM tool calls** | Basic tool registration + processor | [3-Minute Example](#3-minute-example) |
+| ☕ **Just process LLM tool calls** | Basic tool registration + processor | [60-Second Quick Start](#60-second-quick-start) |
 | 🔌 **Connect to external tools** | MCP integration (HTTP/STDIO/SSE) | [MCP Integration](#5-mcp-integration-external-tools) |
-| 🛡️ **Production deployment** | Timeouts, retries, rate limits, caching | [Production Configuration](#using-the-processor) |
+| 🛡️ **Production deployment** | Timeouts, retries, rate limits, caching | [CONFIGURATION.md](docs/CONFIGURATION.md) |
 | 🔒 **Run untrusted code safely** | Subprocess isolation strategy | [Subprocess Strategy](#using-subprocess-strategy) |
-| 📊 **Monitor and observe** | OpenTelemetry + Prometheus | [Observability](#opentelemetry--prometheus-drop-in-observability) |
+| 📊 **Monitor and observe** | OpenTelemetry + Prometheus | [OBSERVABILITY.md](docs/OBSERVABILITY.md) |
 | 🌊 **Stream incremental results** | StreamingTool pattern | [StreamingTool](#streamingtool-real-time-results) |
+| 🚨 **Handle errors reliably** | Error codes & taxonomy | [ERRORS.md](docs/ERRORS.md) |
 
 ### Real-World Quick Start
 
@@ -1100,24 +1145,29 @@ asyncio.run(main())
 
 #### OpenTelemetry & Prometheus (Drop-in Observability)
 
-**Why Telemetry Matters**: In production, you need to know *what* your tools are doing, *how long* they take, *when* they fail, and *why*. CHUK Tool Processor provides **enterprise-grade telemetry** that operations teams expect—with zero manual instrumentation.
-
-**One function call. Full observability.**
+**3-Line Setup:**
 
 ```python
 from chuk_tool_processor.observability import setup_observability
 
-# Enable everything
 setup_observability(
     service_name="my-tool-service",
-    enable_tracing=True,    # OpenTelemetry distributed tracing
-    enable_metrics=True,    # Prometheus metrics endpoint
-    metrics_port=9090       # HTTP endpoint at :9090/metrics
+    enable_tracing=True,     # → OpenTelemetry traces
+    enable_metrics=True,     # → Prometheus metrics at :9090/metrics
+    metrics_port=9090
 )
-
-# Every tool execution is now automatically traced and metered!
+# That's it! Every tool execution is now automatically traced and metered.
 ```
 
+**What you get automatically:**
+- ✅ Distributed traces (Jaeger, Zipkin, any OTLP collector)
+- ✅ Prometheus metrics (error rate, latency P50/P95/P99, cache hit rate)
+- ✅ Circuit breaker state monitoring
+- ✅ Retry attempt tracking
+- ✅ Zero code changes to your tools
+
+**Why Telemetry Matters**: In production, you need to know *what* your tools are doing, *how long* they take, *when* they fail, and *why*. CHUK Tool Processor provides **enterprise-grade telemetry** that operations teams expect—with zero manual instrumentation.
+
 **What You Get (Automatically)**
 
 ✅ **Distributed Traces** - Understand exactly what happened in each tool call
@@ -1151,6 +1201,8 @@ pip install opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp prom
 uv pip install chuk-tool-processor --group observability
 ```
 
+> **⚠️ SRE Note**: Observability packages are **optional**. If not installed, all observability calls are no-ops—your tools run normally without tracing/metrics. Zero crashes, zero warnings. Safe to deploy without observability dependencies.
+
 **Quick Start: See Your Tools in Action**
 
 ```python
@@ -1612,10 +1664,13 @@ async def create_secure_processor():
 Check out the [`examples/`](examples/) directory for complete working examples:
 
 ### Getting Started
+- **60-second hello**: `examples/hello_tool.py` - Absolute minimal example (copy-paste-run)
 - **Quick start**: `examples/quickstart_demo.py` - Basic tool registration and execution
 - **Execution strategies**: `examples/execution_strategies_demo.py` - InProcess vs Subprocess
 - **Production wrappers**: `examples/wrappers_demo.py` - Caching, retries, rate limiting
 - **Streaming tools**: `examples/streaming_demo.py` - Real-time incremental results
+- **Streaming tool calls**: `examples/streaming_tool_calls_demo.py` - Handle partial tool calls from streaming LLMs
+- **Schema helper**: `examples/schema_helper_demo.py` - Auto-generate schemas from typed tools (Pydantic → OpenAI/Anthropic/MCP)
 - **Observability**: `examples/observability_demo.py` - OpenTelemetry + Prometheus integration
 
 ### MCP Integration (Real-World)
@@ -1696,6 +1751,54 @@ A: InProcess is faster (same process), Subprocess is safer (isolated process). U
   - Use directly if you need protocol-level control
   - Use chuk-tool-processor if you want high-level tool execution
 
+## Development & Publishing
+
+### For Contributors
+
+Development setup:
+
+```bash
+# Clone repository
+git clone https://github.com/chrishayuk/chuk-tool-processor.git
+cd chuk-tool-processor
+
+# Install development dependencies
+uv sync --dev
+
+# Run tests
+make test
+
+# Run all quality checks
+make check
+```
+
+### For Maintainers: Publishing Releases
+
+The project uses **fully automated CI/CD** for releases. Publishing is as simple as:
+
+```bash
+# 1. Bump version
+make bump-patch    # or bump-minor, bump-major
+
+# 2. Commit version change
+git add pyproject.toml
+git commit -m "version X.Y.Z"
+git push
+
+# 3. Create release (automated)
+make publish
+```
+
+This will:
+- Create and push a git tag
+- Trigger GitHub Actions to create a release with auto-generated changelog
+- Run tests across all platforms and Python versions
+- Build and publish to PyPI automatically
+
+For detailed release documentation, see:
+- **[RELEASING.md](RELEASING.md)** - Complete release process guide
+- **[docs/CI-CD.md](docs/CI-CD.md)** - Full CI/CD pipeline documentation
+
 ## Contributing & Support
 
 - **GitHub**: [chrishayuk/chuk-tool-processor](https://github.com/chrishayuk/chuk-tool-processor)

{chuk_tool_processor-0.9.1.dist-info → chuk_tool_processor-0.9.5.dist-info}/RECORD

@@ -23,7 +23,7 @@ chuk_tool_processor/mcp/register_mcp_tools.py,sha256=OyHczwVnqhvBZO9g4I0T56EPMvF
 chuk_tool_processor/mcp/setup_mcp_http_streamable.py,sha256=cXZcaPDYhAZbi92dapHmhbDDnq4Ond8Kj5Igsty2sWM,6478
 chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=ClGKFtSfDxKQKUcyZY4s5xAgtrTycFSbzxGetdZIM_4,5717
 chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=KxCC0BL0C6z5ZHxBzPhWZC9CKrGUACXqx1tkjru-UYI,2922
-chuk_tool_processor/mcp/stream_manager.py,sha256=398j65oGvMMwi_EC9qS2EPHXvGefUDJ4IR9Tkg4jaGY,34781
+chuk_tool_processor/mcp/stream_manager.py,sha256=P_Rkb2j-Cq8_WRQfxtFR1Pz12w6xa8IywaDOz4zHkLs,35653
 chuk_tool_processor/mcp/transport/__init__.py,sha256=od-7f_cYv31_ioZCJu57ozA8IXywMyf-0N4HlM2J_bU,841
 chuk_tool_processor/mcp/transport/base_transport.py,sha256=rG61TlaignbVZbsqdBS38TnFzTVO666ehKEI0IUAJCM,8675
 chuk_tool_processor/mcp/transport/http_streamable_transport.py,sha256=j5Rb6vn-cclYthDRCxnn2ZOCosIWBOtDxwRsqLKitEs,27922
@@ -61,7 +61,7 @@ chuk_tool_processor/registry/providers/__init__.py,sha256=iGc_2JzlYJSBRQ6tFbX781
 chuk_tool_processor/registry/providers/memory.py,sha256=udfboAHH0gRxtnf3GsI3wMshhobJxYnCkMwKjQ_uqkw,5017
 chuk_tool_processor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/utils/validation.py,sha256=jHPO65sB61ynm9P6V3th4pN7j4u0SQhYR-bstj5QjnI,4175
-chuk_tool_processor-0.9.1.dist-info/METADATA,sha256=llfoclt8ntrU2odrZhudQkqgh3AIoYazMwON-vEbSRQ,57514
-chuk_tool_processor-0.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_tool_processor-0.9.1.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.9.1.dist-info/RECORD,,
+chuk_tool_processor-0.9.5.dist-info/METADATA,sha256=eUqgZU-WCkJ9880urwpanL8MTwDbvAGJNcUSMoWzWTk,61364
+chuk_tool_processor-0.9.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_tool_processor-0.9.5.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.9.5.dist-info/RECORD,,