Skip to main content
Glama

send_input

Types text into a Detour terminal session so agents can interact with live programs, then read the result using read_screen.

Instructions

Type into the session's terminal, as the person would: for interactive programs. Read the result with read_screen.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "session_id": "<session_id>",
      "text": "<text>"
    },
    "name": "send_input"
  }
}

Input Schema

NameRequiredDescriptionDefault
textYesWhat to type. Control keys as characters: "\u0003" is Ctrl+C, "\u001b" is Esc.
enterNoPress Enter after the text (default true).
session_idYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A3.8/5.0
Behavior3/5

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

With no annotations, the description carries the full disclosure burden. It usefully reveals the human-emulation semantics and, by pointing at read_screen, implies the typed text's output is not returned here — an important behavioral fact. It says nothing about what happens on a non-existent or closed session, whether input is buffered, or whether typing returns any status beyond the call itself.

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?

Two short sentences, zero padding, with the core action and the interactive-program scope front-loaded ahead of the pointer to read_screen. Nothing could be cut without losing information.

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

Completeness4/5

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

For a three-parameter write-into-terminal tool with no output schema, the description covers the essential loop: type here, read there. The absence of any note about session validity, blocking behavior, or failure modes keeps it short of fully complete against a no-annotation tool.

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

Parameters3/5

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

Schema coverage is 67%: the schema already documents the string contents including control-key escapes ("\u0003" for Ctrl+C, "\u001b" for Esc) and the enter default of true. The description's "as the person would" reinforces that text is raw keystrokes rather than a command string, but it adds nothing for session_id, which is undocumented in both places. Baseline 3 fits given the schema does most of the work.

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

Purpose4/5

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

States a specific verb (type) and resource (the session's terminal), and adds the qualifier "for interactive programs" that separates it from the sibling run_command, which handles non-interactive execution. What it does not do is name that sibling explicitly, so the contrast must be inferred from context.

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

Usage Guidelines4/5

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

"for interactive programs" is a genuine when-to-use condition, and "Read the result with read_screen" tells the agent the required follow-up call rather than leaving it to guess. There is no explicit when-not clause (e.g., prefer run_command for one-shot commands) and no note about waiting for access or session state.

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