Skip to main content
Glama

HTTP transactions

http_transactions
Read-onlyIdempotent

Pair HTTP/1.x requests with responses and follow HTTP/2 or gRPC streams to find slow endpoints, failing status codes, and response sizes per host, method, and path.

Instructions

Which HTTP endpoints are slow or failing, what status codes came back, how big were the responses, what did gRPC return? HTTP/1.x requests paired with their responses by tshark (pipelining included) and HTTP/2 / gRPC followed per stream. view="requests" (default) gives each request with status, sizes, response_ms and gRPC status; view="endpoints" aggregates per host, method and path; summary names issues. Filters: host (the name and its subdomains), path_prefix, method, status (404 or a class such as "5xx"), min_ms (response_ms at least); filter is a display filter ANDed with http || http2. No decryption: HTTPS needs TLS keys tshark already has. More detail: resource schema://tools/http_transactions.

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": {
      "path": "<path>"
    },
    "name": "http_transactions"
  }
}

Input Schema

NameRequiredDescriptionDefault
endNoSame forms as start
hostNoHost name, or part of it
pathYesCapture file (absolute, in an allowed dir) or open_capture handle
viewNorequests (one row each) or endpoints (per method, host and path)requests
limitNoMost rows per page
startNoISO 8601, epoch s, +Ns from start, -Ns from end
filterNoExtra display filter, ANDed
methodNoHTTP method (GET, POST, ...)
min_msNoKeep requests slower than this many ms
offsetNoRows to skip (next_offset)
outputNosummary: all but rows, plus 3 rows (<8 KB)rows
redactNoReplace subscriber identifiers in this result with tokens; ids+ips hides every IP toooff
statusNoStatus code or class: 404, 5xx, 4xx
columnsNoRow keys to keep (frame keys stay)
path_prefixNoRequest path prefix, such as /api
max_output_kbNoLower output cap, KB

Output Schema

NameRequiredDescriptionDefault
viewNo
countNo
errorNo
offsetNo
windowNo
droppedNo
summaryNo
has_moreNo
requestsNorows with keys: frame, response_frame, stream, h2_stream, client, server, version, method, host, uri, query, status, reason, content_type, request_bytes, response_bytes, response_ms, ttfb_ms, response_decoded_from, paired_by, grpc, grpc_status, grpc_status_name, stream_reset_by, reset_error, unanswered, near_capture_end
returnedNo
endpointsNorows with keys: host, method, uri, count, status, unanswered, response_ms, ttfb_ms, response_bytes, grpc_status, servers, slowest_frame, first_frame
next_offsetNo
total_foundNo
total_matchedNo
display_filterNo
packets_matchedNo
packets_scannedNo
undissected_httpNo
total_is_lower_boundNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.4/5.0
Behavior4/5

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely non-obvious behavior: how requests are paired with responses (pipelining included), per-stream handling for HTTP/2/gRPC, and the hard limitation that HTTPS content requires TLS keys tshark already holds. That decryption caveat is the kind of constraint an agent cannot infer from structure; only pagination/truncation mechanics are left to the schema.

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

Conciseness4/5

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

Front-loaded with the diagnostic questions, then modes, then filters, then caveats — a sensible priority order with no filler sentences. It is dense and backtick-heavy, but nearly every clause carries operational information; the pointer to the resource schema for more detail keeps the body itself lean.

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 16-parameter analysis tool with an output schema, this covers the essentials an agent needs: required path source, the two views, the full filter vocabulary, the decryption prerequisite, and where to find deeper documentation. Return contents are delegated to the output schema and the summary view description, which is appropriate.

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 100%, so baseline would be 3, but the description adds real meaning: host matches the name and its subdomains, status accepts a class like "5xx" as well as an exact code, min_ms compares against response_ms, and filter is ANDed with `http || http2`. These sharpen semantics beyond the terse schema strings without restating them.

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?

Opens with the exact questions the tool answers (slow/failing endpoints, status codes, response sizes, gRPC returns) and names the resource and mechanism (tshark pairing of HTTP/1.x requests/responses, HTTP/2 and gRPC per stream). This makes it clearly distinct from siblings like dns_transactions or tcp_connections without needing to open any schema.

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?

Explicitly explains the two modes: view="requests" (default) for per-request rows and view="endpoints" for per host/method/path aggregation, plus summary naming issues. It enumerates the filter set and their semantics, giving a clear picture of when each view applies. It stops short of naming a sibling tool to use instead when the analysis is not HTTP-related.

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