dsh-llm-call-inspector

English | 中文

A local, session-scoped LLM request and response inspector for DeepSeek Harness Web. It adds an LLM Calls view beside Chat and Trajectory so developers can inspect each session-associated normalized llm/stream call without changing what the model receives or what the caller receives.

This is a community plugin, not an official DeepSeek Harness release. Version 0.2.0 declares support for 0.1.0-rc.8, 0.1.1-rc.1, and 0.1.1-rc.2.

[!WARNING]
Request and response bodies can contain prompts, source code, tool arguments, tool results, personal data, or secrets embedded in content. Installing this plugin opts the Host into body capture by default. Read Privacy and data handling before using it with sensitive sessions.

What it shows

• A newest-first list of calls for the active DSH session.
• Provider, model, purpose, status, start time, duration, chunk count, and body-capture state.
• Search plus status and purpose filters.
• A master/detail layout with Request, Response, and API Comparison tabs, expandable JSON, and copy actions.
• Per-session restoration of the selected call, search, filters, detail tab, per-call manual API reference, and list/body scroll positions when you switch away from the view and return.
• A side-by-side semantic comparison selected from call-level pi-ai protocol evidence, with explicit manual references and an exact deepseek-official route fallback, clearly separated from the DSH-normalized data actually observed.
• Live polling, explicit refresh, session-local clear, error and empty states, keyboard focus, responsive layout, and English/Chinese labels.
• Calls made for assistant work, compaction, session-title generation, or another normalized purpose when the call carries a sessionId.

The captured normalized request allowlist is:

provider, model, reasoningEffort, messages, system, tools, temperature, maxTokens, stop, sessionId, and purpose.

The captured response is the ordered array of DSH StreamChunk values observed at llm/stream. The observer delegates exactly once, yields the original chunk objects in the original order, and preserves downstream throws. Whole-chunk capture also preserves JSON-compatible adapter replay metadata, including finish.replayState when an adapter emits it. Independently of body retention, the Host exposes narrow, body-free apiEvidence only when a terminal replay response identifies kind: pi-ai, version: 2, a bounded lowercase-hyphen API id, and the same provider/model as this call. Missing evidence stays absent; malformed, mismatched, getter-failing, and conflicting attributions become rejected or conflicted and are never accepted as protocol facts.

The current built-in DSH image block carries attachment-reference metadata (opaque attachment id, media type, byte size, dimensions, and optional display name), and that reference is captured as part of messages. The plugin does not independently load attachment bytes or observe provider-side base64 wire payloads. Because normalized messages are copied whole, any extension that embeds bytes, base64, credentials, or other private fields inside a custom message block would place that data inside the capture boundary.

Returning to the view

Switching from LLM Calls to Chat, Trajectory, or another conversation view does not discard the current inspection context. A DSH session-scoped view store retains only interaction state: selected call id, search and filters, active detail tab, per-call manual API-reference choice, list scroll, and at most 300 recent call/tab body-scroll positions. Scroll positions and manual choices for calls no longer present in the authoritative snapshot are pruned. An apply-lifecycle-owned, least-recently-used browser-memory cache keeps the latest body-free state snapshot and one selected detail for at most four recent sessions, so a fresh cache can paint immediately without forcing another RPC read. Normal polling resumes when its interval is due; an already stale cache may therefore refresh after the restored view is shown.

Neither layer uses localStorage, sessionStorage, IndexedDB, or another browser-persistent store. The client cache is cleared when its plugin apply lifecycle is disposed, and may evict older sessions before that. The Host memory store remains the authoritative retained record.

API Comparison

The API Comparison tab is a semantic shape projection, not a packet capture. Its left side is the DSH-normalized request and response chunks actually observed. Its right side is an HTTP JSON, SDK-parameter, or command-input reference derived from those normalized fields and a selected API protocol; endpoint templates are used where the adapter's resolved destination is not observable.

For a successful pi-ai call, the preferred attribution is the exact call's validated replay-v2 apiEvidence. The protocol registry projects these eight adapter-reported protocols:

• openai-completions;
• openai-responses;
• azure-openai-responses;
• anthropic-messages;
• google-generative-ai;
• google-vertex;
• bedrock-converse-stream; and
• mistral-conversations.

These are presented as mainstream shape families rather than provider-route names: OpenAI-compatible Chat Completions; OpenAI/Azure Responses; Anthropic Messages; Gemini GenerateContent for the Developer API or Vertex AI; Amazon Bedrock ConverseStream; and Mistral Chat Completions.

The inspector recognizes adapter-reported openai-codex-responses and pi-messages but does not manufacture a projection for them. Unknown reported protocols are also shown as unsupported. If no accepted call-level evidence exists, the exact, case-sensitive deepseek-official route may use a versioned DeepSeek Harness 0.1.1-rc.2 native-adapter reference as a fallback. Valid adapter-reported evidence always takes precedence over that route fallback.

When evidence is absent or a reported protocol has no implemented projection, the user can choose a labeled manual shape reference. That choice is stored only as per-call session view state and restored across view remounts; it neither changes the captured facts nor claims which adapter protocol actually ran. Route names other than the exact DeepSeek fallback, model names, prefixes, and gateway branding are never guessed as protocol evidence.

The projection does not read HTTP headers or API keys, preserve raw SSE frames, prove the adapter's runtime identity, reproduce adapter compatibility defaults, or reveal hidden transport attempts. It never replays or sends a provider request, so opening the tab, switching views, choosing a manual reference, or copying it causes no additional LLM call or provider charge. Direct request JSON is deliberately limited to history that can be materialized without adapter-private ids, signatures, compatibility metadata, or attachment bytes. Complex assistant/system/tool/reasoning history, images/files, and unknown extensions are marked unavailable. A provider field whose final value is adapter-owned—such as a model-clamped output-token limit or an Azure deployment mapping—uses an explicit {$unobserved, dshInput} marker; that marker is not a sendable API value.

Scope boundary

This plugin inspects the DSH-normalized LLM boundary. It is not a provider wire proxy.

It does not capture:

• provider-native HTTP request or response bodies;
• HTTP headers, top-level API keys, abort signals, or undeclared adapter-private fields on the request object;
• raw SSE frames, transport retries hidden inside an adapter, or provider-side processing;
• the adapter's resolved endpoint or the number of physical HTTP attempts behind one normalized call;
• sessionless llm/stream calls; or
• hidden reasoning that the provider does not return as a normalized chunk.

Top-level structural exclusion is not content redaction. A key pasted into a prompt, returned by a tool, or nested inside a plugin-defined message block can still be captured.
Response chunks are preserved whole, so adapter-private JSON inside finish.replayState can also be captured and must be treated as sensitive content. The separately exposed apiEvidence is narrow protocol attribution extracted from replay metadata, not proof of the HTTP request or response bytes.

Why a separate view instead of merging with Trajectory

DeepSeek Harness 0.1.0-rc.8, 0.1.1-rc.1, and 0.1.1-rc.2 expose conversation.view as the public additive UI seam. The built-in Trajectory uses that seam but does not expose a supported inner row or panel extension point.

Trajectory and this inspector also answer different questions:

• Trajectory explains the durable session story: user/assistant/tool events, steps, timing, usage, and outcomes.
• LLM Calls exposes each normalized invocation boundary: the exact captured request snapshot and ordered response chunks observed for that invocation.

The plugin therefore registers an adjacent view at order 20 instead of copying, patching, or depending on Trajectory internals. If Trajectory later publishes a stable cross-link or inner-extension seam, the two views can be connected without changing capture ownership.

Architecture

session-associated GenerateOptions
              |
              v
      llm/stream observer
              |
              v
 bounded per-session memory store
              |
              v
 Connection RPC /dsh-llm-call-inspector (loopback only)
              |
              v
 conversation.view / LLM Calls

One package contains both runtime faces:

• Host injects llm and connection, prepends a transparent llm/stream observer, owns bounded memory, extracts validated call-level pi-ai replay-v2 protocol attribution into body-free apiEvidence, and registers one loopback-only Connection RPC channel.
• Client injects connection, slots, and locale, then registers one conversation.view entry. It polls body-free summaries and fetches the full body only for the selected call. Its DSH session store preserves interaction state—including per-call manual API references—across view remounts, while a bounded four-session apply-lifecycle cache restores the latest summary/detail without browser-persistent storage.
• Bundle declares dsh.bundle.patch and a Web client export, so dsh plugin adds both faces through the supported profile mechanism.

The Host store never writes captured bodies to disk. The bounded client cache may temporarily retain the latest selected detail in browser memory when the view is unmounted, but writes nothing to browser-persistent storage. Host records disappear when you clear the current session in the UI, the configured per-session/session/global-body bounds evict them, the plugin reloads, or DSH restarts.

Install

Prerequisites:

• DeepSeek Harness 0.1.0-rc.8, 0.1.1-rc.1, or 0.1.1-rc.2;
• Node.js 22.19 or newer supported by the package engine; and
• pnpm on PATH, as required by dsh plugin.

Install the GitHub repository into the Web profile:

dsh plugin --profile web add github:striveh/dsh-llm-call-inspector
dsh --profile web --dump-config
dsh web

Restart a running Web profile after adding, updating, or removing a bundle. The config dump should contain a # == dsh-llm-call-inspector layer.

For reproducible use, pin a reviewed commit:

dsh plugin --profile web add github:striveh/dsh-llm-call-inspector#<commit-sha>

The repository ships checked-in lib/ artifacts and deliberately has no prepare or install lifecycle script. A GitHub install therefore does not need pnpm allowBuilds permission.

Configuration

The bundle defaults are:

To override them, add a later row to $DSH_HOME/profiles/web/cordis.patch.yml. A DSH patch replaces the row's complete config, so this example restates every field:

- id: dsh-llm-call-inspector
  config:
    captureBodies: true
    maxCallsPerSession: 50
    maxSessions: 16
    maxRequestBytes: 262144
    maxResponseBytes: 524288
    maxTotalBodyBytes: 33554432
    pollIntervalMs: 1000

If a body exceeds its limit, the plugin drops the whole body and exposes an explicit size-limit omission with measured bytes. Non-JSON-compatible values and disabled capture also produce explicit omission states; metadata and chunk counts remain available.

Metadata-only mode

Set captureBodies: false when provider/model, status, timing, and chunk counts are sufficient:

- id: dsh-llm-call-inspector
  config:
    captureBodies: false
    maxCallsPerSession: 100
    maxSessions: 32
    maxRequestBytes: 524288
    maxResponseBytes: 1048576
    maxTotalBodyBytes: 67108864
    pollIntervalMs: 750

Changing this configuration reloads the plugin and discards its current in-memory records.

Disable or uninstall

To keep the dependency installed but disable the plugin, add this later profile patch and restart Web:

- id: dsh-llm-call-inspector
  disabled: true

To remove the dependency and its bundle layer:

dsh plugin --profile web remove dsh-llm-call-inspector

Restart the profile after removal. Uninstalling or disabling the plugin cannot recover already-evicted in-memory records; none are persisted by this plugin.

Existing options and when to use them

This landscape changes quickly; follow each linked project's current documentation before choosing one.

GitHub topics are discovery metadata, not a security review or official endorsement.

Development

pnpm install --frozen-lockfile
pnpm verify
pnpm pack --dry-run

pnpm verify runs host and client typechecks, automated tests, a clean build, and read-only package checks. The package verifier checks the public exports, committed build artifacts, Web loader identity, bundle patch, DSH client declaration, documentation install command, and absence of install-time lifecycle scripts.

To test a local checkout after building it:

dsh plugin --profile web add .
dsh --profile web --dump-config
dsh web

See CONTRIBUTING.md for change constraints and SECURITY.md for private vulnerability reporting.

Compatibility

DeepSeek Harness is in developer preview and does not promise plugin compatibility across prereleases. Version 0.2.0 declares @deepseek-ai/dsh-* 0.1.0-rc.8, 0.1.1-rc.1, and 0.1.1-rc.2.

On 2026-08-24, the 0.2.0 release candidate passed isolated local rc.8, rc.1, and rc.2 lanes: each asserted 69 uniformly versioned DSH packages, 8 test files / 100 tests, Host + Client typecheck, build, 12-file / 6-client-injection package verification, and dry-run pack. A fresh rc.2 Web profile with a no-network fixture reported anthropic-messages for its title call and openai-completions for its assistant call through the same provider route; switching through a real Trajectory unmount restored the selected call, search, API tab, and protocol view with no browser errors. This is local offline acceptance, not a provider-wire test. Pin the exact reviewed release tag or commit.

License

MIT