A fake Poster that records calls and simulates outcomes. - ``post_note``/``post_discussion`` pop configured outcomes; when outcomes run out

A fake urllib response object.

A single invocation owns this handle, including cancellation before process registration. */

A post() that records discussions; optionally fails the first inline.

ReasoningPayload is the openai-chat-completions NativeTurn payload. Named type so a type assertion can't accidentally match an unrelated string.

[status] stays a String: the CLI owns its value set (success / completed_with_errors / * completed_with_warnings / skipped), and a new value appeari

* Every subprocess goes through [ShellEnv]: the environment comes from the login shell, and command names are * resolved to absolute paths by `resolv

* A gutter icon that toggles the inline panel when clicked. * Do not navigate to the line: the icon is already beside it, so the line is visible.

* `startLine` / `endLine` take 0 as the sentinel for "the CLI supplied no usable line number". * Comment anchoring (CommentAnchor) relies on this con

* The location of a comment in a diff, passed to CommentService.decorateDiff. * startLine/endLine form a 1-based inclusive range. */

Effort selects a review effort preset that controls how much work the review agent performs (e.g., number of review rounds).

* A JCEF page with a two-way message bridge. The sidebar and the config panel share this one * implementation. * * The bridge runs both ways: page

Stands in for make_poster(); replays canned outcomes per call.

The context a comment is mounted in once the review finishes; the fields are taken from * [CliRunOptions] (the subset the frontend uses). */

TaskType mirrors session.TaskType.

A single webview channel. The JCEF side implements this interface; the routing layer only hands * it a JSON string to send. */

AttemptOutcome is the per-attempt result.

BatchStrategy enumerates the grouping policies for scan dispatch.

Thrown when the CLI exits non-zero. The message has already been refined by [extractCliError] and is safe to show to users. */

Raised when the CodeUp OpenAPI call fails.

* Comment mounting and actions. The three-stage fallback uses valid line numbers, then an existingCode sliding-window match, * then sidebar-only disp

[sha] is the 7-character short hash, matching the frontend's truncation rule. */

* Message routing for the config panel; dispatches by message type. * * Two key behaviours to confirm before changing: * 1. Every handler wraps its

* Reads and writes `~/.opencodereview/config.json`. Division of labor: * single-key writes go through the CLI (`ocr config set`), which validates and

A Poster that prints instead of touching the network.

ErrorClass is the attempt-level error classification. It is derived only from the HTTP status and the Go error type — never from error message text —

FailureClass is the typed classification attached to every failed coverage item. The set is fixed so downstream consumers can switch on it reliably. F

FailurePhase records where in the request lifecycle the failure surfaced.

A single file's section of a unified diff.

Transport object encapsulating all GitLab REST operations. Discussions are posted through :meth:`post_discussion`, which owns an idempotency-

* Calls the command-line git directly. Every git invocation is forced to include `-c core.quotepath=false`. */

GroupingStrategy is how a change set gets partitioned into review groups.

One @@ ... @@ block of a unified diff.

* Window implementation for the config panel, using a non-modal dialog: it can sit next to the * editor, be dragged and resized, and is released as s

* The sidebar's JCEF host: creates the webview, wires the message bridge and posts host messages. * Dispatching is left to the routing layer. * atta

Raised when the ocr CLI fails to run or produce usable output.

Outcome is the request-level result of a logical request. It is decided once, at Finalize, from the whole attempt sequence plus the logical request's

* One review corresponds to one session; state lives only inside the session (the `cancelled` flag), * with no cross-session persistence. After the w

RunFailureClass classifies why the whole run stopped. It is a distinct enumeration from the per-item FailureClass: a run never fails with "provider" o

* Sidebar message routing: receives and dispatches every message the frontend webview sends during * the workspace review flow. * * The message typ

TerminalState is the single, coverage-derived outcome of a run. It is the authoritative replacement for the warning-derived "completed_with_errors" st

Agent orchestrates full-file code review. It delegates the per-file LLM tool-use loop to llmloop.Runner and owns only scan-specific concerns (file enu

Agent orchestrates the AI-powered code review. LLM tool-use loop / memory compression / token aggregation now live in internal/llmloop.Runner; this st

AgentWarning describes a non-fatal warning recorded during one subtask's review/scan. The name is kept for backwards compatibility with the previous i

--- AnthropicClient --- AnthropicClient implements the Anthropic Messages API using the official SDK.

Args bundles all dependencies needed for one scan session. Note: Template is the scan-specific template.ScanTemplate (loaded from scan_template.json)

Args holds all dependencies and configuration needed to run a review session.

AttemptRecord is one observed real HTTP attempt. Number, Outcome, DurationToHeadersMS and ObservedBackoffMS are assigned by the collector; values pas

BuiltinToolProvider implements tools that don't require external system access.

CategoryCount holds counts for each review comment category.

ChatMessage represents a single message in a conversation.

ChatMessage represents a single message in a conversation.

ChatRequest represents the payload for a chat completion call.

ChatResponse is the parsed result of a completion request.

Choice holds a single choice from the response.