chuk-tool-processor 0.17__tar.gz → 0.19__tar.gz

{chuk_tool_processor-0.17 → chuk_tool_processor-0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.17
+Version: 0.19
 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>
@@ -208,6 +208,32 @@ results = await processor.process(json_output)
 | **SchedulerPolicy** | DAG-based scheduling with dependencies, deadlines, pool limits |
 | **GreedyDagScheduler** | Built-in scheduler with topological sort and deadline-aware skipping |
 
+### Runtime Guards (Constitution Layer)
+
+| Guard | Description |
+|-------|-------------|
+| **SchemaStrictnessGuard** | Validates arguments against JSON schemas, optional type coercion |
+| **SensitiveDataGuard** | Detects and blocks/redacts secrets (API keys, JWTs, private keys) |
+| **NetworkPolicyGuard** | SSRF defense — blocks private IPs, metadata endpoints, enforces HTTPS |
+| **SideEffectGuard** | Labels tools as read_only/write/destructive, enforces policies |
+| **ConcurrencyGuard** | Limits simultaneous in-flight calls (global, per-tool, per-namespace) |
+| **TimeoutBudgetGuard** | Enforces wall-clock time budgets with soft/hard limits |
+| **OutputSizeGuard** | Prevents pathological payloads from blowing up context |
+| **RetrySafetyGuard** | Guards retry behavior (backoff, idempotency keys, non-retryable errors) |
+| **ProvenanceGuard** | Tracks output attribution and lineage |
+| **PlanShapeGuard** | Detects pathological patterns (fan-out explosions, long chains) |
+| **SaturationGuard** | Detects degenerate statistical outputs (extreme Z-scores, saturated CDFs) |
+
+### Dynamic Tool Discovery
+
+| Feature | Description |
+|---------|-------------|
+| **Intelligent Search** | Natural language queries find tools ("gaussian" → "normal_cdf") |
+| **Synonym Expansion** | Built-in synonyms for math, statistics, file ops, networking |
+| **Fuzzy Matching** | Typo tolerance ("multipley" finds "multiply") |
+| **Session Boosting** | Recently used tools rank higher in search results |
+| **Dynamic Provider** | Base class for LLM-driven tool discovery and execution |
+
 ### Integration & Observability
 
 | Feature | Description |
@@ -434,6 +460,95 @@ See [examples/02_production_features/distributed_config_demo.py](examples/02_pro
 
 ---
 
+## Runtime Guards
+
+Protect your tool execution with composable guards that enforce safety policies:
+
+```python
+from chuk_tool_processor.guards import (
+    GuardChain,
+    SchemaStrictnessGuard,
+    SensitiveDataGuard,
+    NetworkPolicyGuard,
+    ConcurrencyGuard,
+)
+
+# Create individual guards
+schema_guard = SchemaStrictnessGuard(get_schema=my_schema_getter)
+sensitive_guard = SensitiveDataGuard()  # Detects API keys, JWTs, etc.
+network_guard = NetworkPolicyGuard(block_private_ips=True)
+concurrency_guard = ConcurrencyGuard(global_max=50, per_tool_max={"heavy_api": 2})
+
+# Compose into a chain
+chain = GuardChain([schema_guard, sensitive_guard, network_guard, concurrency_guard])
+
+# Check before execution
+result = await chain.check_all_async("api.fetch", {"url": "https://example.com"})
+if result.blocked:
+    print(f"Blocked by {result.stopped_at}: {result.reason}")
+```
+
+**Key Guards:**
+- **SchemaStrictnessGuard** — Validate args against JSON schemas, auto-coerce types
+- **SensitiveDataGuard** — Block or redact secrets (API keys, JWTs, private keys)
+- **NetworkPolicyGuard** — SSRF defense (block localhost, private IPs, metadata endpoints)
+- **SideEffectGuard** — Enforce read-only mode, block destructive ops in production
+- **ConcurrencyGuard** — Limit in-flight calls globally, per-tool, or per-namespace
+- **TimeoutBudgetGuard** — Enforce wall-clock budgets with soft/hard limits
+- **OutputSizeGuard** — Prevent pathological payloads (size, depth, array length)
+- **SaturationGuard** — Detect degenerate statistical outputs (extreme Z-scores, saturated CDFs)
+
+See [GUARDS.md](docs/GUARDS.md) for complete documentation and examples.
+
+---
+
+## Dynamic Tool Discovery
+
+When you have hundreds of tools, LLMs can't load all schemas upfront. The discovery module provides intelligent search and on-demand tool loading:
+
+```python
+from chuk_tool_processor.discovery import ToolSearchEngine, BaseDynamicToolProvider
+
+# Create a search engine for your tools
+engine = ToolSearchEngine()
+engine.set_tools(my_tools)
+
+# Natural language search with synonym expansion
+results = engine.search("gaussian distribution")  # Finds "normal_cdf"
+results = engine.search("find the average")       # Finds "calculate_mean"
+results = engine.search("multipley")              # Finds "multiply" (typo tolerance)
+
+# Session boosting - recently used tools rank higher
+engine.record_tool_use("calculate_mean", success=True)
+engine.advance_turn()
+results = engine.search("calculate")  # "calculate_mean" now boosted
+```
+
+**Dynamic Provider Pattern** — give LLMs meta-tools for discovery:
+
+```python
+class MyToolProvider(BaseDynamicToolProvider):
+    async def get_all_tools(self) -> list[Tool]:
+        return self._tools
+
+    async def execute_tool(self, name: str, args: dict) -> dict:
+        return await self._tools[name].execute(**args)
+
+provider = MyToolProvider()
+
+# LLM gets 4 meta-tools: list_tools, search_tools, get_tool_schema, call_tool
+tools_for_llm = provider.get_dynamic_tools()
+
+# LLM workflow: search → get schema → call
+results = await provider.search_tools("calculate average")
+schema = await provider.get_tool_schema("calculate_mean")
+result = await provider.call_tool("calculate_mean", {"values": [1, 2, 3]})
+```
+
+See [DISCOVERY.md](docs/DISCOVERY.md) for complete documentation.
+
+---
+
 ## Observability
 
 One-line setup for production monitoring:
@@ -491,6 +606,8 @@ See [ERRORS.md](docs/ERRORS.md) for complete error taxonomy.
 | [**GETTING_STARTED.md**](docs/GETTING_STARTED.md) | Creating tools, using the processor, ValidatedTool, StreamingTool |
 | [**CORE_CONCEPTS.md**](docs/CORE_CONCEPTS.md) | Registry, strategies, wrappers, parsers, MCP overview |
 | [**PRODUCTION_PATTERNS.md**](docs/PRODUCTION_PATTERNS.md) | Bulkheads, scoped registries, ExecutionContext, parallel execution |
+| [**DISCOVERY.md**](docs/DISCOVERY.md) | Dynamic tool discovery, intelligent search, synonym expansion |
+| [**GUARDS.md**](docs/GUARDS.md) | Runtime guards for safety, validation, and resource management |
 | [**MCP_INTEGRATION.md**](docs/MCP_INTEGRATION.md) | HTTP Streamable, STDIO, SSE, OAuth, Middleware Stack |
 | [**ADVANCED_TOPICS.md**](docs/ADVANCED_TOPICS.md) | Deferred loading, code sandbox, isolated strategy, testing |
 | [**CONFIGURATION.md**](docs/CONFIGURATION.md) | All config options and environment variables |
@@ -505,6 +622,9 @@ See [ERRORS.md](docs/ERRORS.md) for complete error taxonomy.
 # Getting started
 python examples/01_getting_started/hello_tool.py
 
+# Dynamic tool discovery (search, synonyms, fuzzy matching)
+python examples/07_discovery/dynamic_tools_demo.py
+
 # Hero demo: 8 tools, 5-second deadline, 3 pools (DAG + bulkheads + context)
 python examples/02_production_features/hero_runtime_demo.py
 
@@ -517,6 +637,9 @@ python examples/02_production_features/runtime_features_demo.py
 # Structured error handling for planners
 python examples/02_production_features/structured_errors_demo.py
 
+# Runtime guards (validation, security, resource limits)
+python examples/guards_demo.py
+
 # Redis registry for distributed deployments
 python examples/02_production_features/redis_registry_demo.py
 

{chuk_tool_processor-0.17 → chuk_tool_processor-0.19}/README.md

@@ -171,6 +171,32 @@ results = await processor.process(json_output)
 | **SchedulerPolicy** | DAG-based scheduling with dependencies, deadlines, pool limits |
 | **GreedyDagScheduler** | Built-in scheduler with topological sort and deadline-aware skipping |
 
+### Runtime Guards (Constitution Layer)
+
+| Guard | Description |
+|-------|-------------|
+| **SchemaStrictnessGuard** | Validates arguments against JSON schemas, optional type coercion |
+| **SensitiveDataGuard** | Detects and blocks/redacts secrets (API keys, JWTs, private keys) |
+| **NetworkPolicyGuard** | SSRF defense — blocks private IPs, metadata endpoints, enforces HTTPS |
+| **SideEffectGuard** | Labels tools as read_only/write/destructive, enforces policies |
+| **ConcurrencyGuard** | Limits simultaneous in-flight calls (global, per-tool, per-namespace) |
+| **TimeoutBudgetGuard** | Enforces wall-clock time budgets with soft/hard limits |
+| **OutputSizeGuard** | Prevents pathological payloads from blowing up context |
+| **RetrySafetyGuard** | Guards retry behavior (backoff, idempotency keys, non-retryable errors) |
+| **ProvenanceGuard** | Tracks output attribution and lineage |
+| **PlanShapeGuard** | Detects pathological patterns (fan-out explosions, long chains) |
+| **SaturationGuard** | Detects degenerate statistical outputs (extreme Z-scores, saturated CDFs) |
+
+### Dynamic Tool Discovery
+
+| Feature | Description |
+|---------|-------------|
+| **Intelligent Search** | Natural language queries find tools ("gaussian" → "normal_cdf") |
+| **Synonym Expansion** | Built-in synonyms for math, statistics, file ops, networking |
+| **Fuzzy Matching** | Typo tolerance ("multipley" finds "multiply") |
+| **Session Boosting** | Recently used tools rank higher in search results |
+| **Dynamic Provider** | Base class for LLM-driven tool discovery and execution |
+
 ### Integration & Observability
 
 | Feature | Description |
@@ -397,6 +423,95 @@ See [examples/02_production_features/distributed_config_demo.py](examples/02_pro
 
 ---
 
+## Runtime Guards
+
+Protect your tool execution with composable guards that enforce safety policies:
+
+```python
+from chuk_tool_processor.guards import (
+    GuardChain,
+    SchemaStrictnessGuard,
+    SensitiveDataGuard,
+    NetworkPolicyGuard,
+    ConcurrencyGuard,
+)
+
+# Create individual guards
+schema_guard = SchemaStrictnessGuard(get_schema=my_schema_getter)
+sensitive_guard = SensitiveDataGuard()  # Detects API keys, JWTs, etc.
+network_guard = NetworkPolicyGuard(block_private_ips=True)
+concurrency_guard = ConcurrencyGuard(global_max=50, per_tool_max={"heavy_api": 2})
+
+# Compose into a chain
+chain = GuardChain([schema_guard, sensitive_guard, network_guard, concurrency_guard])
+
+# Check before execution
+result = await chain.check_all_async("api.fetch", {"url": "https://example.com"})
+if result.blocked:
+    print(f"Blocked by {result.stopped_at}: {result.reason}")
+```
+
+**Key Guards:**
+- **SchemaStrictnessGuard** — Validate args against JSON schemas, auto-coerce types
+- **SensitiveDataGuard** — Block or redact secrets (API keys, JWTs, private keys)
+- **NetworkPolicyGuard** — SSRF defense (block localhost, private IPs, metadata endpoints)
+- **SideEffectGuard** — Enforce read-only mode, block destructive ops in production
+- **ConcurrencyGuard** — Limit in-flight calls globally, per-tool, or per-namespace
+- **TimeoutBudgetGuard** — Enforce wall-clock budgets with soft/hard limits
+- **OutputSizeGuard** — Prevent pathological payloads (size, depth, array length)
+- **SaturationGuard** — Detect degenerate statistical outputs (extreme Z-scores, saturated CDFs)
+
+See [GUARDS.md](docs/GUARDS.md) for complete documentation and examples.
+
+---
+
+## Dynamic Tool Discovery
+
+When you have hundreds of tools, LLMs can't load all schemas upfront. The discovery module provides intelligent search and on-demand tool loading:
+
+```python
+from chuk_tool_processor.discovery import ToolSearchEngine, BaseDynamicToolProvider
+
+# Create a search engine for your tools
+engine = ToolSearchEngine()
+engine.set_tools(my_tools)
+
+# Natural language search with synonym expansion
+results = engine.search("gaussian distribution")  # Finds "normal_cdf"
+results = engine.search("find the average")       # Finds "calculate_mean"
+results = engine.search("multipley")              # Finds "multiply" (typo tolerance)
+
+# Session boosting - recently used tools rank higher
+engine.record_tool_use("calculate_mean", success=True)
+engine.advance_turn()
+results = engine.search("calculate")  # "calculate_mean" now boosted
+```
+
+**Dynamic Provider Pattern** — give LLMs meta-tools for discovery:
+
+```python
+class MyToolProvider(BaseDynamicToolProvider):
+    async def get_all_tools(self) -> list[Tool]:
+        return self._tools
+
+    async def execute_tool(self, name: str, args: dict) -> dict:
+        return await self._tools[name].execute(**args)
+
+provider = MyToolProvider()
+
+# LLM gets 4 meta-tools: list_tools, search_tools, get_tool_schema, call_tool
+tools_for_llm = provider.get_dynamic_tools()
+
+# LLM workflow: search → get schema → call
+results = await provider.search_tools("calculate average")
+schema = await provider.get_tool_schema("calculate_mean")
+result = await provider.call_tool("calculate_mean", {"values": [1, 2, 3]})
+```
+
+See [DISCOVERY.md](docs/DISCOVERY.md) for complete documentation.
+
+---
+
 ## Observability
 
 One-line setup for production monitoring:
@@ -454,6 +569,8 @@ See [ERRORS.md](docs/ERRORS.md) for complete error taxonomy.
 | [**GETTING_STARTED.md**](docs/GETTING_STARTED.md) | Creating tools, using the processor, ValidatedTool, StreamingTool |
 | [**CORE_CONCEPTS.md**](docs/CORE_CONCEPTS.md) | Registry, strategies, wrappers, parsers, MCP overview |
 | [**PRODUCTION_PATTERNS.md**](docs/PRODUCTION_PATTERNS.md) | Bulkheads, scoped registries, ExecutionContext, parallel execution |
+| [**DISCOVERY.md**](docs/DISCOVERY.md) | Dynamic tool discovery, intelligent search, synonym expansion |
+| [**GUARDS.md**](docs/GUARDS.md) | Runtime guards for safety, validation, and resource management |
 | [**MCP_INTEGRATION.md**](docs/MCP_INTEGRATION.md) | HTTP Streamable, STDIO, SSE, OAuth, Middleware Stack |
 | [**ADVANCED_TOPICS.md**](docs/ADVANCED_TOPICS.md) | Deferred loading, code sandbox, isolated strategy, testing |
 | [**CONFIGURATION.md**](docs/CONFIGURATION.md) | All config options and environment variables |
@@ -468,6 +585,9 @@ See [ERRORS.md](docs/ERRORS.md) for complete error taxonomy.
 # Getting started
 python examples/01_getting_started/hello_tool.py
 
+# Dynamic tool discovery (search, synonyms, fuzzy matching)
+python examples/07_discovery/dynamic_tools_demo.py
+
 # Hero demo: 8 tools, 5-second deadline, 3 pools (DAG + bulkheads + context)
 python examples/02_production_features/hero_runtime_demo.py
 
@@ -480,6 +600,9 @@ python examples/02_production_features/runtime_features_demo.py
 # Structured error handling for planners
 python examples/02_production_features/structured_errors_demo.py
 
+# Runtime guards (validation, security, resource limits)
+python examples/guards_demo.py
+
 # Redis registry for distributed deployments
 python examples/02_production_features/redis_registry_demo.py
 

{chuk_tool_processor-0.17 → chuk_tool_processor-0.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chuk-tool-processor"
-version = "0.17"
+version = "0.19"
 description = "Async-native framework for registering, discovering, and executing tools referenced in LLM responses"
 readme = "README.md"
 requires-python = ">=3.11"

{chuk_tool_processor-0.17 → chuk_tool_processor-0.19}/src/chuk_tool_processor/__init__.py

@@ -44,6 +44,20 @@ from chuk_tool_processor.core.context import (
 )
 from chuk_tool_processor.core.processor import ToolProcessor
 
+# Discovery (tool search and dynamic providers)
+from chuk_tool_processor.discovery import (
+    BaseDynamicToolProvider,
+    DynamicToolName,
+    SearchableTool,
+    SearchResult,
+    SessionToolStats,
+    ToolSearchEngine,
+    find_tool_by_alias,
+    find_tool_exact,
+    get_search_engine,
+    search_tools,
+)
+
 # Execution strategies and bulkhead
 from chuk_tool_processor.execution.bulkhead import (
     Bulkhead,
@@ -56,6 +70,75 @@ from chuk_tool_processor.execution.strategies.inprocess_strategy import InProces
 from chuk_tool_processor.execution.strategies.subprocess_strategy import SubprocessStrategy
 from chuk_tool_processor.execution.strategies.subprocess_strategy import SubprocessStrategy as IsolatedStrategy
 
+# Guards
+from chuk_tool_processor.guards import (
+    BaseGuard,
+    BudgetGuard,
+    BudgetGuardConfig,
+    BudgetState,
+    BudgetStatus,
+    ConcurrencyConfig,
+    ConcurrencyGuard,
+    ConcurrencyLimitExceeded,
+    ConcurrencyState,
+    DegradeAction,
+    EnforcementLevel,
+    Environment,
+    ErrorClass,
+    ExecutionMode,
+    Guard,
+    GuardChain,
+    GuardChainResult,
+    GuardResult,
+    GuardVerdict,
+    NetworkPolicyConfig,
+    NetworkPolicyGuard,
+    NetworkViolation,
+    NetworkViolationType,
+    OutputSizeConfig,
+    OutputSizeGuard,
+    PerToolGuard,
+    PerToolGuardConfig,
+    PlanShapeConfig,
+    PlanShapeGuard,
+    PlanShapeState,
+    PlanShapeViolation,
+    PlanShapeViolationType,
+    PreconditionGuard,
+    PreconditionGuardConfig,
+    ProvenanceConfig,
+    ProvenanceGuard,
+    ProvenanceRecord,
+    RedactMode,
+    RetrySafetyConfig,
+    RetrySafetyGuard,
+    RetryState,
+    RunawayGuard,
+    RunawayGuardConfig,
+    SchemaStrictnessConfig,
+    SchemaStrictnessGuard,
+    SchemaValidationResult,
+    SchemaViolation,
+    SchemaViolationType,
+    SensitiveDataConfig,
+    SensitiveDataGuard,
+    SensitiveDataType,
+    SensitiveMatch,
+    SideEffectClass,
+    SideEffectConfig,
+    SideEffectGuard,
+    SizeViolation,
+    SizeViolationType,
+    TimeoutBudgetConfig,
+    TimeoutBudgetGuard,
+    TimeoutBudgetState,
+    ToolClassification,
+    TruncatedResult,
+    TruncationMode,
+    UnresolvedReferenceGuard,
+    UnresolvedReferenceGuardConfig,
+)
+
 # MCP setup helpers
 from chuk_tool_processor.mcp import (
     setup_mcp_http_streamable,
@@ -165,6 +248,95 @@ __all__ = [
     "RegistryConfig",
     "ResilienceBackend",
     "create_executor",
+    # Guards - Base
+    "BaseGuard",
+    "Guard",
+    "GuardResult",
+    "GuardVerdict",
+    "EnforcementLevel",
+    "ToolClassification",
+    # Guards - Chain
+    "GuardChain",
+    "GuardChainResult",
+    # Guards - Original
+    "BudgetGuard",
+    "BudgetGuardConfig",
+    "BudgetState",
+    "PerToolGuard",
+    "PerToolGuardConfig",
+    "PreconditionGuard",
+    "PreconditionGuardConfig",
+    "RunawayGuard",
+    "RunawayGuardConfig",
+    "UnresolvedReferenceGuard",
+    "UnresolvedReferenceGuardConfig",
+    # Guards - Schema Strictness
+    "SchemaStrictnessGuard",
+    "SchemaStrictnessConfig",
+    "SchemaValidationResult",
+    "SchemaViolation",
+    "SchemaViolationType",
+    # Guards - Output Size
+    "OutputSizeGuard",
+    "OutputSizeConfig",
+    "SizeViolation",
+    "SizeViolationType",
+    "TruncatedResult",
+    "TruncationMode",
+    # Guards - Sensitive Data
+    "SensitiveDataGuard",
+    "SensitiveDataConfig",
+    "SensitiveDataType",
+    "SensitiveMatch",
+    "RedactMode",
+    # Guards - Concurrency
+    "ConcurrencyGuard",
+    "ConcurrencyConfig",
+    "ConcurrencyState",
+    "ConcurrencyLimitExceeded",
+    # Guards - Network Policy
+    "NetworkPolicyGuard",
+    "NetworkPolicyConfig",
+    "NetworkViolation",
+    "NetworkViolationType",
+    # Guards - Side Effect
+    "SideEffectGuard",
+    "SideEffectConfig",
+    "SideEffectClass",
+    "ExecutionMode",
+    "Environment",
+    # Guards - Timeout Budget
+    "TimeoutBudgetGuard",
+    "TimeoutBudgetConfig",
+    "TimeoutBudgetState",
+    "BudgetStatus",
+    "DegradeAction",
+    # Guards - Retry Safety
+    "RetrySafetyGuard",
+    "RetrySafetyConfig",
+    "RetryState",
+    "ErrorClass",
+    # Guards - Provenance
+    "ProvenanceGuard",
+    "ProvenanceConfig",
+    "ProvenanceRecord",
+    # Guards - Plan Shape
+    "PlanShapeGuard",
+    "PlanShapeConfig",
+    "PlanShapeState",
+    "PlanShapeViolation",
+    "PlanShapeViolationType",
+    # Discovery
+    "BaseDynamicToolProvider",
+    "DynamicToolName",
+    "ToolSearchEngine",
+    "SearchResult",
+    "SearchableTool",
+    "SessionToolStats",
+    "get_search_engine",
+    "search_tools",
+    "find_tool_exact",
+    "find_tool_by_alias",
 ]
 
 # Type checking exports (documentation only)

chuk_tool_processor-0.19/src/chuk_tool_processor/discovery/__init__.py

@@ -0,0 +1,77 @@
+# chuk_tool_processor/discovery/__init__.py
+"""Tool discovery and search capabilities.
+
+This module provides intelligent tool search with:
+- Tokenized OR semantics (any matching keyword scores)
+- Synonym expansion ("gaussian" finds "normal", "cdf" finds "cumulative")
+- Fuzzy matching fallback for typos
+- Namespace aliasing ("math.normal_cdf" finds "normal_cdf")
+- Always returns results (fallback to popular tools)
+- Session boosting (recently used tools rank higher)
+
+It also provides a base class for dynamic tool providers that allow LLMs
+to discover and execute tools on-demand.
+"""
+
+from chuk_tool_processor.discovery.dynamic_provider import (
+    BaseDynamicToolProvider,
+    DynamicToolName,
+)
+from chuk_tool_processor.discovery.search import (
+    SearchResult,
+    SessionToolStats,
+    ToolSearchEngine,
+    extract_keywords,
+    find_tool_by_alias,
+    find_tool_exact,
+    fuzzy_score,
+    get_search_engine,
+    levenshtein_distance,
+    normalize_tool_name,
+    score_token_match,
+    search_tools,
+    tokenize,
+)
+from chuk_tool_processor.discovery.searchable import SearchableTool
+from chuk_tool_processor.discovery.synonyms import (
+    DOMAIN_INDICATORS,
+    STOPWORDS,
+    SYNONYMS,
+    compute_domain_penalty,
+    detect_query_domain,
+    detect_tool_domain,
+    expand_with_synonyms,
+)
+
+__all__ = [
+    # Dynamic provider
+    "BaseDynamicToolProvider",
+    "DynamicToolName",
+    # Core search
+    "ToolSearchEngine",
+    "SearchResult",
+    "SessionToolStats",
+    "get_search_engine",
+    "search_tools",
+    "find_tool_exact",
+    # Protocol
+    "SearchableTool",
+    # Token processing
+    "tokenize",
+    "extract_keywords",
+    "expand_with_synonyms",
+    # Scoring
+    "score_token_match",
+    "fuzzy_score",
+    "levenshtein_distance",
+    # Name aliasing
+    "normalize_tool_name",
+    "find_tool_by_alias",
+    # Synonyms and domain detection
+    "SYNONYMS",
+    "DOMAIN_INDICATORS",
+    "STOPWORDS",
+    "detect_query_domain",
+    "detect_tool_domain",
+    "compute_domain_penalty",
+]