# How to View a Human-Ready Summary of Configured Tools in OpenMontage

> Easily view a human-ready summary of configured tools in OpenMontage. Call registry.provider_menu_summary() for a concise JSON report of providers, capabilities, and status.

- Repository: [Calesthio/OpenMontage](https://github.com/calesthio/OpenMontage)
- Tags: how-to-guide
- Published: 2026-08-29

---

**Call `registry.provider_menu_summary()` on the singleton registry imported from `tools/tool_registry` to generate a concise JSON report of all available providers, capabilities, and configuration status.**

OpenMontage maintains an internal **tool registry** that tracks over 100 production tools across multiple AI and media providers. When you need to inspect which capabilities are available without reading raw configuration files, the `provider_menu_summary()` method delivers a structured, human-readable overview of the entire system state according to the OpenMontage source code.

## Understanding the Tool Registry Architecture

The registry is implemented as a singleton in [`tools/tool_registry.py`](https://github.com/calesthio/OpenMontage/blob/main/tools/tool_registry.py) and serves as the central authority for tool discovery and capability management. It automatically catalogs every provider, their supported features, and runtime dependencies when first accessed.

The **auto-discovery mechanism** triggers on the initial call to any registry method, scanning the environment for configured API keys and executable dependencies. This ensures the summary always reflects the current system state without manual initialization steps.

## Generating the Human-Ready Summary

To view the summary, ensure your environment is activated (typically after running `make setup`), then import the registry and call the summary method.

### Interactive Python Session

Use this approach when debugging or building custom workflows:

```python
from tools.tool_registry import registry
import json

# Auto-discovery happens automatically on first use

summary = registry.provider_menu_summary()
print(json.dumps(summary, indent=2))

```

### Command-Line One-Liner

For quick inspections without opening a REPL, run:

```bash
python -c "from tools.tool_registry import registry; import json; \
print(json.dumps(registry.provider_menu_summary(), indent=2))"

```

Both methods return identical JSON structures displaying composition runtimes, capability counts, and missing dependencies.

## Interpreting the JSON Output Structure

The `provider_menu_summary()` method returns a structured dictionary containing four primary sections:

- **composition_runtimes**: Boolean flags for video processing backends like `ffmpeg`, `remotion`, and `hyperframes`
- **capabilities**: Array of objects detailing each feature (e.g., `video_generation`, `image_generation`) with counts of configured versus total providers and lists of available versus unavailable services
- **setup_offers**: Installation instructions for unconfigured tools, such as adding `SUNO_API_KEY` to `.env` for music generation
- **runtime_warnings**: Specific dependency errors, such as missing npm packages for `hyperframes`

This structure allows both human operators and automated agents to assess system readiness at a glance.

## Key Source Files and References

According to the OpenMontage source code, the implementation resides in specific locations:

- **[`tools/tool_registry.py`](https://github.com/calesthio/OpenMontage/blob/main/tools/tool_registry.py)**: Contains the `registry` singleton, discovery logic, and `provider_menu_summary()` method that collapses raw support data into user-friendly reports
- **[`AGENT_GUIDE.md`](https://github.com/calesthio/OpenMontage/blob/main/AGENT_GUIDE.md)**: Documents the agent-first workflow and references the pre-flight provider menu that consumes this summary output

The method is part of the public API surface, making it safe to invoke from production scripts, CI/CD pipelines, or agent initialization routines.

## Summary

- Import the singleton `registry` from `tools/tool_registry` to access the tool catalog
- Call `provider_menu_summary()` to receive a JSON summary of all configured and available tools
- The registry auto-discovers capabilities on first use, ensuring current system state without manual initialization
- The output includes composition runtimes, capability breakdowns, setup instructions, and runtime warnings
- Use either interactive Python or shell one-liners to generate reports for debugging or system verification

## Frequently Asked Questions

### What is the tool registry in OpenMontage?

The **tool registry** is a singleton service defined in [`tools/tool_registry.py`](https://github.com/calesthio/OpenMontage/blob/main/tools/tool_registry.py) that maintains a catalog of over 100 production tools, tracking their providers, capabilities, and configuration status. It serves as the central authority for tool discovery and capability resolution throughout the OpenMontage framework.

### How does the registry auto-discover tools?

The registry triggers automatic discovery (`registry.discover()`) on the first call to any registry method, including `provider_menu_summary()`. This mechanism scans the environment for available API keys, executable binaries, and package dependencies without requiring explicit initialization code.

### Can I use provider_menu_summary() in production code?

Yes. The `provider_menu_summary()` method is part of the public API and is designed for both development debugging and runtime health checks. The method is referenced in [`AGENT_GUIDE.md`](https://github.com/calesthio/OpenMontage/blob/main/AGENT_GUIDE.md) as part of the pre-flight validation workflow for agent initialization.

### Where can I find installation instructions for missing tools?

Missing tool configurations appear in the `setup_offers` array of the JSON output, which includes specific instructions such as "Add SUNO_API_KEY to .env" for the `suno_music` provider. Detailed provider setup documentation is also typically found in the project environment configuration files and README.