feat: add reasoning_rewrite adapter and debounced inputs (#446)

## Summary of Changes

This Pull Request introduces the **`reasoning_rewrite` Provider
Adapter** and a highly reusable **`DebouncedInput`** UI component to
solve two distinct operational and performance issues in Plexus.

### 1. The `reasoning_rewrite` Adapter (Backend)
Different LLM backends expect reasoning configurations via various
custom keys (e.g., `enable_thinking`, `budget_tokens`, or
`thinking.type`).
* **Final State:** The backend now includes a declarative
`reasoning_rewrite` adapter that maps unified reasoning properties
(`reasoning.enabled`, `reasoning.effort`) to provider-specific layouts
in outbound request payloads, and then strips the unified values
afterward if configured.
* **Safety & Correctness:** 
* Uses `structuredClone(payload)` upon first mutation to deeply clone
request bodies. This prevents any in-place mutation of nested objects in
the original payload, keeping request-retries and downstream logging
100% stable.
* Extensively tested with 718 custom test scenarios (including
DeepSeek-R1 sequential stripping and mapping scenarios).

### 2. High-Performance `DebouncedInput` Shared UI (Frontend)
To solve rendering overhead when typing in heavy model-level or
provider-level editor forms:
* **Final State:** Added a reusable `DebouncedInput` component under
`packages/frontend/src/components/ui/DebouncedInput.tsx`. It wraps the
standard Input, holding local text state and propagating updates via a
300ms debounce.
* **Performance Upgrades Applied:**
* **`reasoning_rewrite` Adapter:** Source, when conditions, and target
rewrites now use debounced inputs.
* **`model_override` Adapter:** Rewrite target and trigger condition
key-value fields now use debounced inputs.
* **Per-Model "Extra Body Fields":** Key-value inputs are now debounced.
* **Provider-Level Stall Detection Overrides:** Replaced five duplicate
manual state draft hooks and custom blur logic with `DebouncedInput`.
* **Provider-Level Headers & "Extra Body Fields":** Key-value inputs are
now debounced.

All type checking, OpenAPI schemas, biome formatting, and test suites
are 100% green and verified.

Author: mcowger

.gitignore

@@ -80,3 +80,4 @@ plexus
 
 # Profiling output
 .prof/
+.grepai/

bun.lock

@@ -228,6 +228,17 @@ properties:
         Used for providers that expose reasoning variants as separate model
         names rather than respecting reasoning-related request fields.
 
+      - `reasoning_rewrite` — Declaratively rewrites reasoning/thinking fields
+        in outbound request payloads. Different providers accept reasoning
+        effort via different field names (e.g. `enable_thinking`, `thinking.type`,
+        `chat_template_kwargs.enable_thinking`, `budget_tokens`, `thinking_budget`).
+        This adapter maps from unified fields (e.g. `reasoning.enabled`,
+        `reasoning.effort`) to provider-specific formats. Accepts a `rules`
+        array in options where each rule specifies a `source` dotted path,
+        an optional `when` condition (with `op` and `value`), an array of
+        `rewrites` (each with `target` and `value`), and optional `strip`
+        paths to remove after rewriting.
+
       Pass-through optimisation is automatically disabled when any adapter
       is active.
   timeoutMs:

docs/openapi/components/schemas/ProviderConfig.yaml

@@ -7,6 +7,7 @@
     "agent-browser": "^0.27.0",
     "bun-types": "1.3.14",
     "octokit": "^5.0.5",
+    "typescript-language-server": "^5.2.0",
     "vitest": "^4.1.6",
     "yaml": "^2.9.0"
   },

package.json

@@ -117,6 +117,59 @@ export type ModelOverrideRule = z.infer<typeof ModelOverrideRuleSchema>;
 export type ModelOverrideOptions = z.infer<typeof ModelOverrideOptionsSchema>;
 export type AdapterEntry = z.infer<typeof AdapterEntrySchema>;
 
+// ─── Reasoning Rewrite Adapter Config ────────────────────────────────
+
+const ValueTransformSchema = z.union([
+  z.object({ from: z.literal('source') }),
+  z.object({ from: z.literal('map'), values: z.record(z.string(), z.any()) }),
+  z.object({ from: z.literal('boolean'), truthy: z.any(), falsy: z.any() }),
+]);
+
+const FieldRewriteSchema = z.object({
+  /** Dotted path to write (e.g. "enable_thinking", "thinking.type"). */
+  target: z.string().min(1),
+  /**
+   * Value to write at the target path.
+   * Literal primitives are written as-is.
+   * Objects with { from: "source" | "map" | "boolean" } trigger transforms.
+   */
+  value: z.any(),
+});
+
+const MatchConditionSchema = z.object({
+  /** Comparison operator. */
+  op: z.enum(['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'in', 'present', 'absent']),
+  /** Value to compare against (for eq/neq/gt/gte/lt/lte). */
+  value: z.any().optional(),
+  /** Values array for "in" operator. */
+  values: z.array(z.any()).optional(),
+});
+
+const ReasoningRewriteRuleSchema = z.object({
+  /** Dotted path to read from the payload (e.g. "reasoning.enabled", "reasoning.effort"). */
+  source: z.string().min(1),
+  /** Optional condition on the source value. Omit = match any (presence check). */
+  when: MatchConditionSchema.optional(),
+  /** Rewrites to apply when the source matches. All matching rewrites apply. */
+  rewrites: z.array(FieldRewriteSchema).min(1),
+  /**
+   * Dotted paths to REMOVE from the payload after rewrites are applied.
+   * Use to strip unified fields the provider doesn't understand
+   * (e.g. "reasoning" when mapping to "enable_thinking" instead).
+   */
+  strip: z.array(z.string().min(1)).optional(),
+});
+
+const ReasoningRewriteOptionsSchema = z.object({
+  rules: z.array(ReasoningRewriteRuleSchema).min(1),
+});
+
+export type ValueTransform = z.infer<typeof ValueTransformSchema>;
+export type FieldRewrite = z.infer<typeof FieldRewriteSchema>;
+export type MatchCondition = z.infer<typeof MatchConditionSchema>;
+export type ReasoningRewriteRule = z.infer<typeof ReasoningRewriteRuleSchema>;
+export type ReasoningRewriteOptions = z.infer<typeof ReasoningRewriteOptionsSchema>;
+
 const ModelProviderConfigSchema = z.object({
   pricing: PricingSchema.default({
     source: 'simple',