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

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 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:

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:

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: Contains the registry singleton, discovery logic, and provider_menu_summary() method that collapses raw support data into user-friendly reports
• 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 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 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}