Skip to main content
Glama

Read through a secret

use_secret
Read-onlyIdempotent

Send a GET or HEAD request with a secret injected as a header, and return the response. The secret value is never returned to the agent — it is decrypted and used server-side only. Reads the remote API; it cannot change anything there, because only safe methods are accepted. The URL is chosen by the caller, so the target is whichever API the secret belongs to — see that API's own documentation for paths. Requires secrets:read or full permission. Example: use_secret({secret_name: 'OPENAI_API_KEY', url: 'https://api.openai.com/v1/models'}) sends GET with 'Authorization: Bearer '. Use list_secrets to discover names, use_secret_write to send POST/PUT/PATCH/DELETE, and store_secret or rotate_secret to change a stored value. Pass playbook_id as the UUID or GUID of the playbook this call should target.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
urlYesThe URL to send the HTTP request to
methodNoHTTP method (default: GET). For POST/PUT/PATCH/DELETE use use_secret_write.
timeout_msNoRequest timeout in milliseconds (default: 30000, max: 60000)
header_nameNoHeader name to inject the secret into (default: Authorization)
playbook_idYesUUID or GUID of the target playbook
secret_nameYesName of the secret to use (e.g. OPENAI_API_KEY)
extra_headersNoAdditional headers (e.g. {"Accept": "application/json"})
header_prefixNoPrefix before the secret value (default: 'Bearer '). Use empty string for raw value.

TDQS

A4.9/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations, it discloses that the secret is never returned to the agent, is decrypted and used server-side only, and that only safe methods are accepted. It also notes permission requirements and that the caller chooses the URL, which adds meaningful behavioral context not inferable from the annotations alone.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the core action, then adds permissions, an example, sibling alternatives, and the playbook_id note. It is information-dense with no filler; every sentence contributes to correct selection and invocation.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 8 parameters, nested objects, no output schema, and remote-API variability, the description is sufficiently complete. It covers the main mechanics, security behavior, permissions, example usage, and sibling differentiation; the remaining parameter details are already handled by the input schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is already 100%, so the baseline is 3; the description adds value by explaining how secret injection works, showing an example with Authorization: Bearer <key>, and clarifying that method is limited to safe GET/HEAD. This goes beyond the schema without needing to repeat all parameter details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool sends GET or HEAD requests with a secret injected as a header and returns the response. It also distinguishes the tool from its sibling use_secret_write by explicitly limiting methods to GET/HEAD.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit guidance: use list_secrets to discover names, use_secret_write for POST/PUT/PATCH/DELETE, and store_secret or rotate_secret to change values. It also states the required permission (secrets:read or full permission), making invocation context clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

TDQS

A4.5/5.0
Disambiguation5/5

Each tool targets a distinct entity and action (e.g., delete_memory vs delete_skill vs delete_run), and even similar operations like read_memory vs search_memory vs get_memory_context have clearly differentiated purposes. The descriptions are detailed and explicitly cross-reference other tools to avoid confusion.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern (create_*, list_*, update_*, delete_*, read_*, etc.), with plurals used uniformly for list operations (list_playbooks, list_runs, list_secrets). No mixed conventions or ambiguous verbs; the naming is highly predictable and systematic.

Tool Count4/5

With 48 tools, the server covers a broad but coherent set of domains (playbooks, personas, skills, memory, canvas, runs, secrets, MCP servers, and discovery). While this exceeds the typical 3-15 range, each tool serves a distinct and necessary function within the comprehensive playbook management scope, so the count feels justified rather than bloated.

Completeness5/5

The tool surface provides complete CRUD and lifecycle coverage for every entity type: playbooks, personas, skills (including versioning and rollback), memory (including hierarchical tasks and tiering), canvas (with locking and patching), runs, secrets (including rotation and usage), and MCP servers. Additionally, find_tools covers discovery for federated tools, leaving no apparent dead ends.