@madgagarin/pi-agentrouter 2.0.0 → 2.1.2

package/README.md

@@ -5,9 +5,9 @@
 [![Pi Plugin](https://img.shields.io/badge/Pi-Extension-purple.svg)](https://pi.dev)
 [![AgentRouter Gateway](https://img.shields.io/badge/Gateway-agentrouter.org-orange.svg)](https://agentrouter.org)
 
-Use **GPT-5.6 Sol**, **Claude Opus 5**, **Claude Opus 4.8**, **DeepSeek V4 Flash**, and **GLM 5.3** in your [Pi Coding Agent](https://pi.dev) using a single API key from [AgentRouter](https://agentrouter.org).
+Use **GPT-6 Astra**, **GPT-5.6 Sol**, **Claude Opus 5**, **Claude Opus 4.8**, and **DeepSeek V4 Flash** in your [Pi Coding Agent](https://pi.dev) using a single API key from [AgentRouter](https://agentrouter.org).
 
-> 🎁 **Free Trial Credits:** New to AgentRouter? Get up to **$175 in free credits** (including a **+$50 bonus**) to test GPT-5.6, Claude Opus 5, and DeepSeek V4 — no credit card needed. That's enough for **over 80,000,000 tokens** on DeepSeek V4!  
+> 🎁 **Free Trial Credits:** New to AgentRouter? Get up to **$175 in free credits** (including a **+$50 bonus**) to test GPT-6 Astra, Claude Opus 5, and DeepSeek V4 — no credit card needed. That's enough for **millions of tokens** on DeepSeek V4!  
 > 👉 **[Claim your free trial credits on AgentRouter.org →](https://agentrouter.org/register?aff=34dc)**
 
 ---
@@ -34,48 +34,48 @@ pi install npm:@madgagarin/pi-agentrouter
 
 ---
 
-## Why use this plugin?
+## Features
 
-[AgentRouter](https://agentrouter.org) ([agentrouter.org](https://agentrouter.org)) provides affordable unified access to frontier LLMs, but using raw OpenAI/Anthropic proxy configurations in Pi often runs into edge cases: Cloudflare WAF checks, rate-limit bursts from parallel subagents, prompt caching cache misses, and role naming conflicts.
-
-This plugin fixes all of that automatically:
-
-- **Live USD Pricing in Pi:** Pulls current rates from [agentrouter.org/api/pricing](https://agentrouter.org/api/pricing) on startup so Pi's built-in cost tracking shows your exact spend in dollars.
-- **Live Quota Monitor (`/agentrouter check`):** Quick health check that pings all models to see if daily batch quotas are open, and displays your monthly usage in USD.
-- **1M Context Windows:** All models are configured with their full 1,048,576 token context limits and native reasoning/adaptive thinking.
-- **Cross-Process Rate Pacing:** Uses a shared lock file (`~/.pi/agent/.agentrouter-pacing`) so background subagents (`pi-subagents`) and the main chat won't trip 429 rate limits.
-- **Zero 400 & 401 Errors:** Handles canonical `pi-code` prompt header placement for WAF authorization and automatically normalizes OpenAI `developer` roles to `system`.
-- **High Cache Hit Rates (>80%):** Preserves session affinity headers and disables destructive prompt rewriting on AgentRouter routes.
+- **DeepSeek Multi-Turn Tool Calling:** Seamlessly flattens multi-turn tool history and preserves `reasoning_content` across tool execution turns, completely preventing upstream gateway 400 thinking mode errors.
+- **Model Synchronization:** Automatically registers and adds active models to `enabledModels` in `settings.json` for quick selection via `Ctrl+P`.
+- **Schema Sanitization:** Automatically normalizes tool definitions (e.g. converting `required: null` to empty arrays) for strict OpenAI schema validation compatibility.
+- **WAF Diagnostics & Safe Redaction:** Intercepts upstream blocks and safely redacts older messages while preserving thinking placeholders for reasoning models.
+- **Isolated Credential Storage:** Manages API keys exclusively within `agentrouter-*` provider namespaces in `auth.json` without modifying default third-party provider keys.
+- **Live Pricing & Quota Probing:** Fetches current rates from the gateway API on startup and provides `/agentrouter check` to probe model availability and track usage.
+- **Subagent Rate Pacing:** Uses a file-based lock (`~/.pi/agent/.agentrouter-pacing`) across concurrent subagents to prevent 429 rate limit errors.
+- **Prompt Caching Compatibility:** Preserves affinity headers and pricing for prompt caching reuse.
 
 ---
 
 ## Models & Pricing
 
-Rates are pulled directly from the [agentrouter.org](https://agentrouter.org) gateway API ($2.00 / 1M tokens base unit):
+Rates are fetched from the [agentrouter.org](https://agentrouter.org) gateway API ($2.00 / 1M tokens base unit):
 
-| Model | Provider | Context | Output | Reasoning | Input / 1M | Output / 1M | Quota Policy |
-| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
-| `deepseek-v4-flash` | `agentrouter-openai` | 1M | 64K | Yes | $2.00 | $6.00 | Unlimited |
-| `glm-5.3` | `agentrouter-openai` | 1M | 128K | Yes | $3.00 | $12.00 | Unlimited |
-| `gpt-5.6-sol` | `agentrouter-openai` | 1M | 128K | Yes | $3.00 | $15.00 | Daily batch drops |
-| `claude-opus-5` | `agentrouter-clode` | 1M | 64K | Yes (Adaptive) | $8.00 | $40.00 | Daily batch drops |
+| Model | Provider | Context | Output | Reasoning | Input / 1M | Output / 1M | Cache Read / 1M | Quota Policy |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+| `deepseek-v4-flash` | `agentrouter-openai` | 1M | 64K | Yes | $4.00 | $12.00 | $2.00 | Unlimited |
+| `glm-5.3` | `agentrouter-openai` | 1M | 128K | Yes | $3.00 | $12.00 | - | Unlimited |
+| `gpt-6-astra` | `agentrouter-openai` | 1M | 128K | Yes | $3.00 | $15.00 | - | Daily batch drops |
+| `gpt-5.6-sol` | `agentrouter-openai` | 1M | 128K | Yes | $3.00 | $15.00 | - | Daily batch drops |
+| `claude-opus-5` | `agentrouter-clode` | 1M | 64K | Yes (Adaptive) | $6.00 | $30.00 | Daily batch drops |
 | `claude-opus-4-8` | `agentrouter-clode` | 1M | 64K | Yes (Adaptive) | $8.00 | $40.00 | Daily batch drops |
 
-*Note: Claude and GPT models are released in daily batches on AgentRouter. If you hit a 402, run `/agentrouter check` to verify, and switch to `deepseek-v4-flash` or `glm-5.3` for unlimited coding.*
+*Note: Claude and GPT models are released in daily batches on AgentRouter. When a batch is exhausted (HTTP 402), use `/agentrouter check` to monitor status or switch to `deepseek-v4-flash` / `glm-5.3` for unrestricted usage.*
 
 ---
 
 ## In-Chat Commands
 
-| Command | What it does |
+| Command | Description |
 | :--- | :--- |
-| `/agentrouter` | Overview of active model, current monthly USD spend, package order, and pacing delay. |
-| `/agentrouter check` | Live preflight probe of all model quotas (200 OK vs 402) and monthly usage. |
-| `/agentrouter pricing` | Fetches and prints the latest official pricing table from [agentrouter.org](https://agentrouter.org). |
-| `/agentrouter key <key>` | Sets API key and syncs it across `agentrouter.json` and Pi's `auth.json`. |
-| `/agentrouter pacing <ms>` | Sets delay between consecutive requests (default: `3500` ms). |
-| `/agentrouter fix-order` | Places this plugin above `pi-cache-optimizer` in `settings.json` if needed. |
-| `/compact` | Compresses chat history safely without 401 authorization drops. |
+| `/agentrouter` | Show active model, current monthly spend, extension ordering, and pacing delay. |
+| `/agentrouter check` | Probe model availability (200 OK vs 402) and display monthly usage. |
+| `/agentrouter pricing` | Display current pricing table from [agentrouter.org](https://agentrouter.org). |
+| `/agentrouter sync` | Sync active flagship models into `enabledModels` in `settings.json`. |
+| `/agentrouter key <key>` | Set API key and store it in `agentrouter.json` and `auth.json`. |
+| `/agentrouter pacing <ms>` | Configure delay between requests (default: `3500` ms). |
+| `/agentrouter fix-order` | Reorder extension before `pi-cache-optimizer` in `settings.json` if necessary. |
+| `/compact` | Compact conversation history while preserving required gateway headers. |
 
 ---
 
@@ -83,7 +83,7 @@ Rates are pulled directly from the [agentrouter.org](https://agentrouter.org) ga
 
 | Shortcut | Action |
 | :--- | :--- |
-| `Ctrl + P` | Cycle to next model (`deepseek-v4-flash` ➔ `glm-5.3` ➔ `gpt-5.6-sol` ➔ `claude-opus-5` ➔ `claude-opus-4-8`) |
+| `Ctrl + P` | Cycle to next model (`deepseek-v4-flash` ➔ `gpt-6-astra` ➔ `gpt-5.6-sol` ➔ `claude-opus-5` ➔ `claude-opus-4-8`) |
 | `Shift + Ctrl + P` | Cycle to previous model |
 | `Shift + Tab` | Toggle reasoning depth (`off` ➔ `minimal` ➔ `low` ➔ `medium` ➔ `high`) |
 | `Ctrl + T` | Toggle reasoning block visibility |
@@ -93,7 +93,7 @@ Rates are pulled directly from the [agentrouter.org](https://agentrouter.org) ga
 
 ## Recommended `settings.json`
 
-Add this to `~/.pi/agent/settings.json` for convenient model switching:
+Add this to `~/.pi/agent/settings.json` for model switching:
 
 ```json
 {
@@ -102,7 +102,7 @@ Add this to `~/.pi/agent/settings.json` for convenient model switching:
   "defaultThinkingLevel": "low",
   "enabledModels": [
     "agentrouter-openai/deepseek-v4-flash",
-    "agentrouter-openai/glm-5.3",
+    "agentrouter-openai/gpt-6-astra",
     "agentrouter-openai/gpt-5.6-sol",
     "agentrouter-clode/claude-opus-5",
     "agentrouter-clode/claude-opus-4-8"
@@ -128,3 +128,4 @@ AgentRouter requires the base `pi-code` prompt signature for authentication. If
 ## License
 
 MIT © [madgagarin](https://github.com/madgagarin)
+

package/index.ts

@@ -41,6 +41,16 @@ export interface ApiPricingModel {
 }
 
 export const KNOWN_MODEL_SPECS: Record<string, ModelSpec> = {
+  "gpt-6-astra": {
+    id: "gpt-6-astra",
+    name: "gpt-6-astra",
+    providerType: "openai",
+    contextWindow: 1048576,
+    maxTokens: 131072,
+    reasoning: true,
+    compat: { sendSessionAffinityHeaders: true },
+    cost: { input: 3.0 / 1_000_000, output: 15.0 / 1_000_000, cacheRead: 0, cacheWrite: 0 },
+  },
   "deepseek-v4-flash": {
     id: "deepseek-v4-flash",
     name: "deepseek-v4-flash",
@@ -49,7 +59,7 @@ export const KNOWN_MODEL_SPECS: Record<string, ModelSpec> = {
     maxTokens: 65536,
     reasoning: true,
     compat: { sendSessionAffinityHeaders: true },
-    cost: { input: 2.0 / 1_000_000, output: 6.0 / 1_000_000, cacheRead: 0, cacheWrite: 0 },
+    cost: { input: 4.0 / 1_000_000, output: 12.0 / 1_000_000, cacheRead: 2.0 / 1_000_000, cacheWrite: 0 },
   },
   "deepseek-v4f": {
     id: "deepseek-v4f",
@@ -59,7 +69,7 @@ export const KNOWN_MODEL_SPECS: Record<string, ModelSpec> = {
     maxTokens: 65536,
     reasoning: true,
     compat: { sendSessionAffinityHeaders: true },
-    cost: { input: 2.0 / 1_000_000, output: 6.0 / 1_000_000, cacheRead: 0, cacheWrite: 0 },
+    cost: { input: 4.0 / 1_000_000, output: 12.0 / 1_000_000, cacheRead: 2.0 / 1_000_000, cacheWrite: 0 },
   },
   "glm-5.3": {
     id: "glm-5.3",
@@ -129,7 +139,7 @@ export const KNOWN_MODEL_SPECS: Record<string, ModelSpec> = {
       sendSessionAffinityHeaders: true,
       supportsEagerToolInputStreaming: false,
     },
-    cost: { input: 8.0 / 1_000_000, output: 40.0 / 1_000_000, cacheRead: 0, cacheWrite: 0 },
+    cost: { input: 6.0 / 1_000_000, output: 30.0 / 1_000_000, cacheRead: 0, cacheWrite: 0 },
   },
   "claude-opus-4-7": {
     id: "claude-opus-4-7",
@@ -197,7 +207,6 @@ export function saveConfig(cfg: AgentRouterConfig): void {
       }
       auth["agentrouter-openai"] = { type: "api_key", key: cfg.apiKey };
       auth["agentrouter-clode"] = { type: "api_key", key: cfg.apiKey };
-      auth["anthropic"] = { type: "api_key", key: cfg.apiKey };
       fs.writeFileSync(authPath, JSON.stringify(auth, null, 2), "utf-8");
     }
   } catch {}
@@ -272,6 +281,36 @@ export function fixPackagePriorityInSettings(): boolean {
   return false;
 }
 
+export const FLAGSHIP_MODELS: string[] = [
+  "agentrouter-openai/deepseek-v4-flash",
+  "agentrouter-openai/gpt-6-astra",
+  "agentrouter-openai/gpt-5.6-sol",
+  "agentrouter-clode/claude-opus-5",
+  "agentrouter-clode/claude-opus-4-8",
+];
+
+export function syncEnabledModelsInSettings(): { added: string[]; count: number } {
+  try {
+    if (!fs.existsSync(SETTINGS_FILE)) return { added: [], count: 0 };
+    const settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
+    if (!Array.isArray(settings.enabledModels)) return { added: [], count: 0 };
+
+    const added: string[] = [];
+    for (const m of FLAGSHIP_MODELS) {
+      if (!settings.enabledModels.includes(m)) {
+        settings.enabledModels.push(m);
+        added.push(m);
+      }
+    }
+    if (added.length > 0) {
+      fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), "utf-8");
+    }
+    return { added, count: settings.enabledModels.length };
+  } catch {
+    return { added: [], count: 0 };
+  }
+}
+
 export function getLastRequestEndTime(): number {
   try {
     if (fs.existsSync(PACING_FILE)) {
@@ -338,10 +377,611 @@ export function enforceCanonicalRootPrompt(systemPrompt: string | any[] | undefi
   return systemPrompt;
 }
 
+export function isDeepSeekRequest(event: any, ctx: any): boolean {
+  const modelId = (
+    (event as any)?.model?.id ||
+    (ctx as any)?.model?.id ||
+    (event as any)?.payload?.model ||
+    ""
+  ).toLowerCase();
+  return modelId.includes("deepseek");
+}
+export const WAF_BLOCK_RE = /sensitive[_ ]words?[_ ]detected|content-blocked/i;
+export const SENSITIVE_WORDS_RE = /sensitive[_ ]words?[_ ]detected/i;
+export const REDACTED_NOTE = "[Message withheld by local policy]";
+
+export function cleanJsonSchemaObject(schema: any): void {
+  if (!schema || typeof schema !== "object") return;
+
+  if (schema.type === "object" || schema.properties) {
+    if (schema.required === null || schema.required === undefined || !Array.isArray(schema.required)) {
+      schema.required = [];
+    }
+  }
+
+  if (schema.properties && typeof schema.properties === "object") {
+    for (const [propName, propDef] of Object.entries(schema.properties)) {
+      if (propDef && typeof propDef === "object") {
+        cleanJsonSchemaObject(propDef);
+      }
+    }
+  }
+
+  if (schema.items) {
+    if (typeof schema.items === "object") {
+      cleanJsonSchemaObject(schema.items);
+    } else if (schema.items === null) {
+      delete schema.items;
+    }
+  }
+}
+
+export function sanitizeOpenAiTools(tools: any[]): void {
+  if (!Array.isArray(tools)) return;
+  for (const tool of tools) {
+    if (!tool || typeof tool !== "object") continue;
+    const fn = tool.function || tool;
+    if (fn.parameters && typeof fn.parameters === "object") {
+      cleanJsonSchemaObject(fn.parameters);
+    }
+  }
+}
+
+export function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+export const redactSet = new Set<string>();
+export let escalatePending = false;
+export let isSensitiveBlock = false;
+export let exhausted = false;
+export let sessionAnchor: string | null = null;
+export let wafNotified = false;
+
+export function resetPoisonRedactionState(): void {
+  redactSet.clear();
+  escalatePending = false;
+  isSensitiveBlock = false;
+  exhausted = false;
+  sessionAnchor = null;
+  wafNotified = false;
+}
+
+export function triggerEscalation(sensitive: boolean = false): void {
+  escalatePending = true;
+  isSensitiveBlock = sensitive;
+}
+
+
+export function fingerprintOf(msg: Record<string, unknown>): string {
+  const tc = Array.isArray(msg.tool_calls) ? JSON.stringify(msg.tool_calls).slice(0, 80) : "";
+  if (msg.type === "function_call" || msg.type === "function_call_output") {
+    return `${msg.type}:${(msg as any).call_id}:${JSON.stringify((msg as any).arguments ?? (msg as any).output ?? "").slice(0, 160)}`;
+  }
+  return `${msg.role ?? msg.type}:${JSON.stringify(msg.content ?? "").slice(0, 160)}:${tc}`;
+}
+
+export function firstUserAnchor(messages: unknown[]): string {
+  for (const m of messages) {
+    if (isRecord(m) && isHumanUserMessage(m as Record<string, unknown>)) return fingerprintOf(m);
+  }
+  return String(messages.length);
+}
+
+export function isTextBlock(block: Record<string, unknown>): boolean {
+  return block.type === "text" || block.type === "input_text" || block.type === "output_text";
+}
+
+export function isHumanUserMessage(msg: Record<string, unknown>): boolean {
+  if (msg.role !== "user") return false;
+  if (typeof msg.content === "string") return true;
+  if (Array.isArray(msg.content)) {
+    const hasToolResult = msg.content.some((b) => isRecord(b) && b.type === "tool_result");
+    const hasHumanText = msg.content.some(
+      (b) =>
+        isRecord(b) &&
+        (b.type === "text" || b.type === "input_text") &&
+        typeof b.text === "string" &&
+        b.text.trim().length > 0 &&
+        b.text !== REDACTED_NOTE
+    );
+    if (hasToolResult && !hasHumanText) return false;
+    return true;
+  }
+  return false;
+}
+
+export function lastHumanUserIndex(messages: unknown[]): number {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (isRecord(messages[i]) && isHumanUserMessage(messages[i] as Record<string, unknown>)) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+export function hasRedactableText(content: unknown, msg?: Record<string, unknown>): boolean {
+  if (msg) {
+    if (msg.details && (typeof msg.details === "string" || Object.keys(msg.details).length > 0)) return true;
+    if (typeof (msg as any).reasoning_content === "string" && (msg as any).reasoning_content.length > 0) return true;
+    if (typeof (msg as any).thinking === "string" && (msg as any).thinking.length > 0) return true;
+  }
+  if (msg?.type === "function_call") return typeof (msg as any).arguments === "string" && (msg as any).arguments !== "{}";
+  if (msg?.type === "function_call_output") return hasRedactableText((msg as any).output);
+  if (typeof content === "string") return content.length > 0 && content !== REDACTED_NOTE;
+  if (Array.isArray(content)) {
+    for (const b of content) {
+      if (!isRecord(b)) continue;
+      if (b.type === "thinking" || b.type === "reasoning") return true;
+      if (isTextBlock(b) && typeof b.text === "string" && b.text.length > 0 && b.text !== REDACTED_NOTE) return true;
+      if (b.type === "tool_result") {
+        if (typeof b.content === "string" && b.content.length > 0 && b.content !== REDACTED_NOTE) return true;
+        if (Array.isArray(b.content)) {
+          for (const c of b.content) {
+            if (isRecord(c) && isTextBlock(c) && typeof c.text === "string" && c.text.length > 0 && c.text !== REDACTED_NOTE) {
+              return true;
+            }
+          }
+        }
+      }
+      if (b.type === "tool_use" && isRecord(b.input) && Object.keys(b.input).length > 0) {
+        return true;
+      }
+      if (b.type === "toolCall" && isRecord(b.arguments) && Object.keys(b.arguments).length > 0) {
+        return true;
+      }
+    }
+  }
+  if (msg && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+    for (const tc of msg.tool_calls) {
+      if (isRecord(tc) && isRecord(tc.function) && typeof tc.function.arguments === "string" && tc.function.arguments !== "{}") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+export function redactBlocks(content: unknown): void {
+  if (!Array.isArray(content)) return;
+  for (let idx = content.length - 1; idx >= 0; idx--) {
+    const block = content[idx];
+    if (!isRecord(block)) continue;
+
+    // For thinking / reasoning blocks, keep a harmless placeholder rather than deleting,
+    // because thinking models (like DeepSeek) strictly require thinking blocks to be present in multi-turn history
+    if (block.type === "thinking" || block.type === "reasoning") {
+      if (typeof (block as any).thinking === "string") {
+        (block as any).thinking = "Thinking...";
+      }
+      if (typeof (block as any).text === "string") {
+        (block as any).text = "Thinking...";
+      }
+      continue;
+    }
+
+    if (isTextBlock(block) && typeof block.text === "string") {
+      block.text = REDACTED_NOTE;
+    } else if (block.type === "tool_result") {
+      if (typeof block.content === "string") {
+        block.content = REDACTED_NOTE;
+      } else if (Array.isArray(block.content)) {
+        for (const b of block.content) {
+          if (isRecord(b) && isTextBlock(b) && typeof b.text === "string") {
+            b.text = REDACTED_NOTE;
+          }
+        }
+      }
+    } else if (block.type === "tool_use") {
+      block.input = {};
+    } else if (block.type === "toolCall") {
+      block.arguments = {};
+    }
+  }
+}
+
+export function isHideable(msg: Record<string, unknown>): boolean {
+  return (
+    msg.role === "user" ||
+    msg.role === "assistant" ||
+    msg.role === "tool" ||
+    msg.role === "toolResult" ||
+    msg.type === "function_call" ||
+    msg.type === "function_call_output"
+  );
+}
+
+export function redactMessageAt(messages: unknown[], i: number): void {
+  const msg = messages[i];
+  if (!isRecord(msg)) return;
+
+  // Clear tool result details / raw diffs / attachments
+  if ("details" in msg) delete msg.details;
+  // DeepSeek and reasoning models require reasoning_content/thinking to exist in thinking mode.
+  // Never delete them completely; keep a sanitized minimal placeholder.
+  if ("reasoning_content" in msg) {
+    (msg as any).reasoning_content = "Thinking...";
+  }
+  if ("thinking" in msg) {
+    (msg as any).thinking = "Thinking...";
+  }
+
+  if (msg.type === "function_call") {
+    (msg as any).arguments = "{}";
+    return;
+  }
+  if (msg.type === "function_call_output") {
+    if (typeof (msg as any).output === "string") (msg as any).output = REDACTED_NOTE;
+    else redactBlocks((msg as any).output);
+    return;
+  }
+  if (typeof msg.content === "string") {
+    msg.content = REDACTED_NOTE;
+  } else if (Array.isArray(msg.content)) {
+    redactBlocks(msg.content);
+    if (msg.content.length === 0 && !Array.isArray(msg.tool_calls)) {
+      msg.content = [{ type: "text", text: REDACTED_NOTE }];
+    }
+  } else if (msg.role === "tool" || msg.role === "toolResult" || msg.role === "assistant") {
+    msg.content = REDACTED_NOTE;
+  }
+  if (Array.isArray(msg.tool_calls)) {
+    for (const tc of msg.tool_calls) {
+      if (isRecord(tc) && isRecord(tc.function) && typeof tc.function.arguments === "string") {
+        tc.function.arguments = "{}";
+      }
+    }
+  }
+}
+
+export function applyPoisonRedaction(payload: Record<string, unknown>): void {
+  const messages = Array.isArray(payload.messages) ? payload.messages : (payload as any).input;
+  if (!Array.isArray(messages) || messages.length === 0) return;
+
+  // Prune failed assistant messages carrying error status/text in-place so dead error turns do not linger
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (!isRecord(m)) continue;
+    if (m.role === "assistant") {
+      if (m.stopReason === "error") {
+        messages.splice(i, 1);
+      } else if (typeof m.content === "string" && WAF_BLOCK_RE.test(m.content)) {
+        messages.splice(i, 1);
+      }
+    }
+  }
+
+  const fps = messages.map((m) => (isRecord(m) ? fingerprintOf(m) : ""));
+
+  const anchor = firstUserAnchor(messages);
+  if (anchor !== sessionAnchor) {
+    const firstContact = sessionAnchor === null;
+    sessionAnchor = anchor;
+    if (!firstContact) {
+      redactSet.clear();
+      escalatePending = false;
+      isSensitiveBlock = false;
+      exhausted = false;
+      wafNotified = false;
+    }
+  }
+
+  if (redactSet.size > 0 && !fps.some((fp) => fp && redactSet.has(fp))) {
+    redactSet.clear();
+  }
+
+  const lastHumanUser = lastHumanUserIndex(messages);
+
+  for (let i = 0; i < messages.length; i++) {
+    if (i === lastHumanUser) continue;
+    if (!isRecord(messages[i]) || !isHideable(messages[i] as Record<string, unknown>)) continue;
+    if (redactSet.has(fps[i])) redactMessageAt(messages, i);
+  }
+
+  if (escalatePending) {
+    escalatePending = false;
+    const sensitive = isSensitiveBlock;
+    isSensitiveBlock = false;
+
+    if (sensitive) {
+      // Sensitive words detected: neutralize ALL turns (older user, tool, assistant, active tool results) except active human user
+      for (let i = 0; i < messages.length; i++) {
+        if (i === lastHumanUser) continue;
+        if (!isRecord(messages[i])) continue;
+        const m = messages[i] as Record<string, unknown>;
+        if (!isHideable(m)) continue;
+        redactSet.add(fps[i]);
+        if (hasRedactableText(m.content, m)) {
+          redactMessageAt(messages, i);
+        }
+      }
+    } else {
+      // Language ratio block: Stage 1 older user turns, Stage 2 assistant & tool
+      let anyRedacted = false;
+      for (let i = 0; i < messages.length; i++) {
+        if (i === lastHumanUser) continue;
+        if (!isRecord(messages[i])) continue;
+        const m = messages[i] as Record<string, unknown>;
+        if (m.role !== "user") continue;
+        if (redactSet.has(fps[i])) continue;
+        redactSet.add(fps[i]);
+        if (hasRedactableText(m.content, m)) {
+          redactMessageAt(messages, i);
+          anyRedacted = true;
+        }
+      }
+      if (!anyRedacted) {
+        for (let i = 0; i < messages.length; i++) {
+          if (i === lastHumanUser) continue;
+          if (!isRecord(messages[i])) continue;
+          const m = messages[i] as Record<string, unknown>;
+          if (!isHideable(m) || m.role === "user") continue;
+          if (redactSet.has(fps[i])) continue;
+          redactSet.add(fps[i]);
+          if (hasRedactableText(m.content, m)) {
+            redactMessageAt(messages, i);
+            anyRedacted = true;
+          }
+        }
+      }
+    }
+  }
+
+  // Exhausted if there are no more hideable messages left to redact other than lastHumanUser
+  exhausted = true;
+  for (let i = 0; i < messages.length; i++) {
+    if (i === lastHumanUser) continue;
+    if (!isRecord(messages[i]) || !isHideable(messages[i] as Record<string, unknown>)) continue;
+    if (!redactSet.has(fps[i])) {
+      exhausted = false;
+      break;
+    }
+  }
+}
+
+export function normalizeMessagesForAgentRouter(messages: any[], isDeepSeek: boolean = false): void {
+  if (!Array.isArray(messages)) return;
+
+  // Prune poisoned/failed assistant turns globally across all models (e.g. prior 402 quota failure, network errors, empty turns)
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg || typeof msg !== "object") continue;
+    if (msg.role === "assistant") {
+      const hasToolCalls = Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+      const hasToolUseBlocks =
+        Array.isArray(msg.content) &&
+        msg.content.some((b: any) => b && typeof b === "object" && (b.type === "tool_use" || b.type === "tool_call"));
+      const hasTools = hasToolCalls || hasToolUseBlocks;
+      const isEmptyContent =
+        !msg.content ||
+        msg.content === "" ||
+        (Array.isArray(msg.content) && (
+          msg.content.length === 0 ||
+          msg.content.every((b: any) => b && typeof b === "object" && (b.type === "text" || b.type === "input_text") && (!b.text || b.text.trim() === ""))
+        ));
+
+      if (
+        msg.stopReason === "error" ||
+        (msg.stopReason === "aborted" && isEmptyContent) ||
+        (typeof msg.content === "string" && WAF_BLOCK_RE.test(msg.content)) ||
+        (isEmptyContent && !hasTools && !msg.reasoning_content)
+      ) {
+        messages.splice(i, 1);
+      }
+    }
+  }
+
+
+  for (const msg of messages) {
+    if (!msg || typeof msg !== "object") continue;
+    if (msg.role === "developer") {
+      msg.role = "system";
+    }
+    if (msg.role === "assistant") {
+      let extractedThinking: string | undefined;
+
+      if (Array.isArray(msg.content)) {
+        const thinkingParts: string[] = [];
+        const nonThinkingParts: any[] = [];
+
+        for (const part of msg.content) {
+          if (part && typeof part === "object" && (part.type === "thinking" || part.type === "reasoning")) {
+            const text = part.thinking || part.text;
+            if (text) thinkingParts.push(text);
+          } else {
+            nonThinkingParts.push(part);
+          }
+        }
+
+        if (thinkingParts.length > 0) {
+          extractedThinking = thinkingParts.join("\n");
+        }
+
+        if (nonThinkingParts.length === 0) {
+          msg.content = "";
+        } else if (nonThinkingParts.length === 1 && nonThinkingParts[0].type === "text") {
+          msg.content = nonThinkingParts[0].text;
+        } else {
+          msg.content = nonThinkingParts;
+        }
+      }
+
+      if (extractedThinking && !msg.reasoning_content) {
+        msg.reasoning_content = extractedThinking;
+      }
+
+      // If assistant executed tool calls, AgentRouter DeepSeek proxy strictly requires reasoning_content
+      if (
+        Array.isArray(msg.tool_calls) &&
+        msg.tool_calls.length > 0 &&
+        (!msg.reasoning_content || (typeof msg.reasoning_content === "string" && !msg.reasoning_content.trim()))
+      ) {
+        msg.reasoning_content = "Executing tools...";
+      }
+
+      // If DeepSeek model and content is still empty without tool calls, provide fallback text
+      if (isDeepSeek && (!msg.content || msg.content === "") && (!Array.isArray(msg.tool_calls) || msg.tool_calls.length === 0)) {
+        msg.content = "[Interrupted]";
+        if (!msg.reasoning_content) {
+          msg.reasoning_content = "Interrupted response";
+        }
+      }
+    }
+
+    if (isDeepSeek) {
+      // Flatten past assistant tool_calls into text and convert tool roles into user turns.
+      // This prevents AgentRouter's upstream Anthropic gateway from rejecting the request with:
+      // "400: The `content[].thinking` in the thinking mode must be passed back to the API."
+      if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+        let contentStr = typeof msg.content === "string" ? msg.content : "";
+        for (const tc of msg.tool_calls) {
+          const fnName = tc?.function?.name || tc?.name || "tool";
+          const fnArgs = tc?.function?.arguments || "{}";
+          contentStr += (contentStr ? "\n" : "") + `[Tool Call]: ${fnName}(${fnArgs})`;
+        }
+        msg.content = contentStr;
+        delete msg.tool_calls;
+        if (!msg.reasoning_content || (typeof msg.reasoning_content === "string" && !msg.reasoning_content.trim())) {
+          msg.reasoning_content = "Executing tools...";
+        }
+      }
+
+      if (msg.role === "tool" || msg.role === "toolResult") {
+        const text = typeof msg.content === "string" ? msg.content : "";
+        const toolName = (msg as any).toolName || (msg as any).name || "tool";
+        msg.role = "user";
+        msg.content = `[Tool Result for ${toolName}]:\n${text}`;
+        delete msg.tool_call_id;
+        delete (msg as any).toolCallId;
+      }
+
+    }
+  }
+}
+
+export function cleanupDeepSeekDuplicates(): {
+  cleanedSettings: boolean;
+  cleanedCache: boolean;
+  cleanedModelsJson: boolean;
+} {
+  let cleanedSettings = false;
+  let cleanedCache = false;
+  let cleanedModelsJson = false;
+
+  // 1. Clean settings.json
+  try {
+    if (fs.existsSync(SETTINGS_FILE)) {
+      const settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
+      let modified = false;
+
+      if (Array.isArray(settings.enabledModels)) {
+        const clodeIdx = settings.enabledModels.indexOf("agentrouter-clode/deepseek-v4-flash");
+        if (clodeIdx !== -1) {
+          settings.enabledModels.splice(clodeIdx, 1);
+          modified = true;
+        }
+        // Deduplicate enabledModels
+        const seen = new Set<string>();
+        const deduped: string[] = [];
+        for (const m of settings.enabledModels) {
+          if (!seen.has(m)) {
+            seen.add(m);
+            deduped.push(m);
+          } else {
+            modified = true;
+          }
+        }
+        settings.enabledModels = deduped;
+      }
+
+      if (settings.subagents && typeof settings.subagents === "object" && settings.subagents.agentOverrides) {
+        for (const override of Object.values(settings.subagents.agentOverrides)) {
+          if ((override as any)?.model === "agentrouter-clode/deepseek-v4-flash") {
+            (override as any).model = "agentrouter-openai/deepseek-v4-flash";
+            modified = true;
+          }
+        }
+      }
+
+      if (settings.defaultProvider === "agentrouter-clode" && settings.defaultModel === "deepseek-v4-flash") {
+        settings.defaultProvider = "agentrouter-openai";
+        modified = true;
+      }
+
+      if (modified) {
+        fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), "utf-8");
+        cleanedSettings = true;
+      }
+    }
+  } catch {}
+
+  // 2. Clean MODELS_CACHE_FILE (.agentrouter-models-cache.json)
+  try {
+    if (fs.existsSync(MODELS_CACHE_FILE)) {
+      const cacheData = JSON.parse(fs.readFileSync(MODELS_CACHE_FILE, "utf-8"));
+      if (Array.isArray(cacheData)) {
+        let modified = false;
+        for (const item of cacheData) {
+          if (item && item.model_name === "deepseek-v4-flash") {
+            if (Array.isArray(item.supported_endpoint_types) && item.supported_endpoint_types.includes("anthropic")) {
+              item.supported_endpoint_types = item.supported_endpoint_types.filter((t: string) => t !== "anthropic");
+              modified = true;
+            }
+          }
+        }
+        if (modified) {
+          fs.writeFileSync(MODELS_CACHE_FILE, JSON.stringify(cacheData, null, 2), "utf-8");
+          cleanedCache = true;
+        }
+      }
+    }
+  } catch {}
+
+  // 3. Clean models.json (if present)
+  try {
+    const modelsJsonPath = path.join(process.env.HOME || "", ".pi/agent/models.json");
+    if (fs.existsSync(modelsJsonPath)) {
+      const modelsJson = JSON.parse(fs.readFileSync(modelsJsonPath, "utf-8"));
+      let modified = false;
+      if (modelsJson?.providers?.["agentrouter-clode"]?.models) {
+        const origLen = modelsJson.providers["agentrouter-clode"].models.length;
+        modelsJson.providers["agentrouter-clode"].models = modelsJson.providers["agentrouter-clode"].models.filter(
+          (m: any) => (typeof m === "string" ? m !== "deepseek-v4-flash" : m?.id !== "deepseek-v4-flash")
+        );
+        if (modelsJson.providers["agentrouter-clode"].models.length !== origLen) {
+          modified = true;
+        }
+      }
+      if (modified) {
+        fs.writeFileSync(modelsJsonPath, JSON.stringify(modelsJson, null, 2), "utf-8");
+        cleanedModelsJson = true;
+      }
+    }
+  } catch {}
+
+  return { cleanedSettings, cleanedCache, cleanedModelsJson };
+}
+
+let lastWarnedErrorTimestamp = 0;
+export function checkAndNotifyContentBlocked(errMessage: string | undefined, ctx: any): void {
+  if (!errMessage) return;
+  const now = Date.now();
+  if (now - lastWarnedErrorTimestamp < 2000) return;
+  if (errMessage.includes("content-blocked")) {
+    lastWarnedErrorTimestamp = now;
+    const tip = "[AgentRouter] Request was blocked by upstream gateway content filter (content-blocked).";
+    if (ctx?.hasUI) {
+      ctx.ui.notify(tip, "warning");
+    } else {
+      console.warn(`\n⚠️  ${tip}\n`);
+    }
+  }
+}
+
 export async function fetchLivePricing(): Promise<ApiPricingModel[] | null> {
   try {
     const res = await fetch("https://agentrouter.org/api/pricing", {
-      headers: { "User-Agent": "pi-code" },
+      
     });
     if (!res.ok) return null;
     const data = await res.json();
@@ -365,8 +1005,7 @@ export async function fetchTokenUsage(apiKey: string): Promise<number | null> {
       {
         headers: {
           Authorization: `Bearer ${apiKey}`,
-          "User-Agent": "pi-code",
-        },
+          },
       }
     );
     if (!res.ok) return null;
@@ -392,12 +1031,12 @@ export async function probeModelQuota(modelId: string, apiKey: string, isAnthrop
         "Content-Type": "application/json",
         "x-api-key": apiKey,
         "anthropic-version": "2023-06-01",
-        "User-Agent": "pi-code",
+        "User-Agent": getPiUserAgent(),
       }
     : {
         "Content-Type": "application/json",
         Authorization: `Bearer ${apiKey}`,
-        "User-Agent": "pi-code",
+        "User-Agent": getPiUserAgent(),
       };
 
   const body = isAnthropic
@@ -427,10 +1066,12 @@ export async function probeModelQuota(modelId: string, apiKey: string, isAnthrop
       return { model: modelId, status: "READY", code: res.status };
     }
 
-    const data = await res.json().catch(() => ({}));
-    const msg = data.error?.message || data.message || "";
-
-    if (res.status === 402 || msg.toLowerCase().includes("quota") || msg.toLowerCase().includes("exhausted")) {
+    if (
+      res.status === 402 ||
+      msg.toLowerCase().includes("quota") ||
+      msg.toLowerCase().includes("exhausted") ||
+      msg.toLowerCase().includes("budget pool")
+    ) {
       return { model: modelId, status: "QUOTA_EXHAUSTED", code: 402, message: msg };
     }
     if (res.status === 403) {
@@ -572,6 +1213,7 @@ export default function (pi: ExtensionAPI) {
     return newModels;
   }
 
+  cleanupDeepSeekDuplicates();
   const cachedPricing = loadCachedPricing();
   registerAgentRouterProviders(currentApiKey, cachedPricing);
 
@@ -598,16 +1240,19 @@ export default function (pi: ExtensionAPI) {
 
       const payload = event.payload;
       if (payload) {
+        const isDeepSeek = isDeepSeekRequest(event, ctx);
+
         if (payload.system !== undefined) {
           payload.system = enforceCanonicalRootPrompt(payload.system);
         }
-        if (Array.isArray(payload.messages) && payload.messages.length > 0) {
-          for (const msg of payload.messages) {
-            if (msg && msg.role === "developer") {
-              msg.role = "system";
-            }
-          }
-          const firstMsg = payload.messages[0];
+
+        applyPoisonRedaction(payload);
+
+        const messages = Array.isArray(payload.messages) ? payload.messages : payload.input;
+        if (Array.isArray(messages) && messages.length > 0) {
+          normalizeMessagesForAgentRouter(messages, isDeepSeek);
+
+          const firstMsg = messages[0];
           if (firstMsg && (firstMsg.role === "system" || firstMsg.role === "developer")) {
             firstMsg.role = "system";
             if (typeof firstMsg.content === "string") {
@@ -617,16 +1262,73 @@ export default function (pi: ExtensionAPI) {
             }
           }
         }
+        if (Array.isArray(payload.tools) && payload.tools.length > 0) {
+          sanitizeOpenAiTools(payload.tools);
+        }
       }
     }
     return undefined;
   });
 
-  pi.on("message_end", async (_event, ctx) => {
-    const model = ctx?.model;
-    if (isAgentRouter(model?.provider, (model as any)?.baseUrl)) {
+  pi.on("message_end", async (event, ctx) => {
+    const message = (event as any)?.message;
+    if (!message) return;
+
+    if (message.role === "assistant" && message.stopReason !== "error") {
+      wafNotified = false;
+      isSensitiveBlock = false;
+    }
+
+    const provider = message.provider ?? ctx?.model?.provider;
+    const baseUrl = (message as any)?.baseUrl ?? (ctx?.model as any)?.baseUrl;
+    if (isAgentRouter(provider, baseUrl)) {
       setLastRequestEndTime(Date.now());
     }
+
+    if (message.role !== "assistant" || message.stopReason !== "error") return;
+    if (!isAgentRouter(provider, baseUrl)) return;
+
+    const errorMessage = message.errorMessage ?? "";
+    if (!WAF_BLOCK_RE.test(errorMessage)) return;
+
+    escalatePending = true;
+    if (SENSITIVE_WORDS_RE.test(errorMessage)) {
+      isSensitiveBlock = true;
+    }
+
+    if (exhausted) {
+      if (!wafNotified) {
+        wafNotified = true;
+        const warning =
+          "AgentRouter content filter keeps blocking even with earlier messages hidden. " +
+          "Your latest message is likely the trigger — please rephrase or split it.";
+        if (ctx?.hasUI) {
+          ctx.ui.notify(warning, "warning");
+        } else {
+          console.warn(`\n⚠️  ${warning}\n`);
+        }
+      }
+      return;
+    }
+
+    if (!wafNotified) {
+      wafNotified = true;
+      const note = isSensitiveBlock
+        ? "Sensitive words detected in agent activity. Neutralizing previous leftovers so subsequent chats can proceed safely."
+        : "AgentRouter content filter blocked the request. Retrying automatically with earlier messages hidden.";
+      if (ctx?.hasUI) {
+        ctx.ui.notify(note, "warning");
+      } else {
+        console.warn(`\n⚠️  ${note}\n`);
+      }
+    }
+
+    return {
+      message: {
+        ...message,
+        errorMessage: `${errorMessage} (provider returned error — retrying with earlier messages hidden)`,
+      },
+    };
   });
 
   pi.on("turn_end", async (_event, ctx) => {
@@ -645,13 +1347,18 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("session_start", async (_event, ctx) => {
     currentApiKey = getEffectiveApiKey();
+    resetPoisonRedactionState();
+    cleanupDeepSeekDuplicates();
     updatePromptRewriteEnvForModel(ctx.model);
     setLastRequestEndTime(Date.now());
+    syncEnabledModelsInSettings();
 
     fetchLivePricing().then((livePricing) => {
       if (livePricing) {
         saveCachedPricing(livePricing);
         const newModels = registerAgentRouterProviders(currentApiKey, livePricing);
+        cleanupDeepSeekDuplicates();
+        syncEnabledModelsInSettings();
         if (newModels.length > 0 && ctx.hasUI) {
           ctx.ui.notify(
             `[AgentRouter] Discovered new models on gateway: ${newModels.join(", ")}.\n` +
@@ -798,10 +1505,21 @@ export default function (pi: ExtensionAPI) {
         currentApiKey = cleanKey;
         saveConfig({ apiKey: cleanKey, minIntervalMs });
         registerAgentRouterProviders(cleanKey, loadCachedPricing());
+        syncEnabledModelsInSettings();
         ctx.ui.notify("AgentRouter API key updated successfully for all models.", "info");
         return;
       }
 
+      if (action === "sync" || action === "enable-models") {
+        const res = syncEnabledModelsInSettings();
+        if (res.added.length > 0) {
+          ctx.ui.notify(`[AgentRouter] Added to enabledModels: ${res.added.join(", ")} (total: ${res.count}).`, "info");
+        } else {
+          ctx.ui.notify(`[AgentRouter] All flagship models already enabled in settings.json (total: ${res.count}).`, "info");
+        }
+        return;
+      }
+
       if (action === "fix-order" || action === "order") {
         const order = getPackageOrderState();
         if (!order.needsFix) {
@@ -893,10 +1611,10 @@ export default function (pi: ExtensionAPI) {
             }))
           : [
               { id: "deepseek-v4-flash", isAnthropic: false },
-              { id: "glm-5.3", isAnthropic: false },
+              { id: "gpt-6-astra", isAnthropic: false },
               { id: "gpt-5.6-sol", isAnthropic: false },
-              { id: "claude-opus-4-8", isAnthropic: true },
               { id: "claude-opus-5", isAnthropic: true },
+              { id: "claude-opus-4-8", isAnthropic: true },
             ];
 
         const probeResults = await Promise.all(
@@ -924,7 +1642,7 @@ export default function (pi: ExtensionAPI) {
         }
 
         report +=
-          `\nTip: Claude and GPT models use daily batch quotas. If exhausted, switch to DeepSeek V4 or GLM 5.3 which have unlimited availability.`;
+          `\nTip: Claude and GPT models use daily batch quotas. If exhausted, switch to DeepSeek V4 Flash which has unlimited availability.`;
 
         ctx.ui.notify(report, "info");
         return;
@@ -948,7 +1666,7 @@ export default function (pi: ExtensionAPI) {
       }
 
       ctx.ui.notify(
-        `[AgentRouter Plugin v2.0.0]\n` +
+        `[AgentRouter Plugin v2.1.2]\n` +
           `- Active model: ${activeModel?.id || "none"} (${isAR ? "AgentRouter [yes]" : "Other Provider"})\n` +
           `- Package Priority: ${priorityStatus}\n` +
           `- API Key: ${maskedKey}\n` +
@@ -956,6 +1674,7 @@ export default function (pi: ExtensionAPI) {
           `- Commands:\n` +
           `   /agentrouter check        (probe live batch quotas & spending)\n` +
           `   /agentrouter pricing      (fetch live pricing table $/1M)\n` +
+          `   /agentrouter sync         (sync enabledModels in settings.json)\n` +
           `   /agentrouter key <key>    (update API key)\n` +
           `   /agentrouter pacing <ms>  (adjust rate limit delay)\n` +
           `   /agentrouter fix-order    (move plugin above pi-cache-optimizer)`,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@madgagarin/pi-agentrouter",
-  "version": "2.0.0",
-  "description": "Official Pi Coding Agent extension for AgentRouter (agentrouter.org). Connects GPT-5.6 Sol, Claude Opus 5, DeepSeek V4 Flash, and GLM 5.3 with live USD pricing, batch quota health probe, prompt caching, and WAF protection.",
+  "version": "2.1.2",
+  "description": "Official Pi Coding Agent extension for AgentRouter (agentrouter.org). Connects GPT-6 Astra, GPT-5.6 Sol, Claude Opus 5, DeepSeek V4 Flash, and GLM 5.3 with live USD pricing, auto-sync settings, batch quota probe, prompt caching, and WAF protection.",
   "publishConfig": {
     "access": "public"
   },
@@ -15,6 +15,8 @@
     "agentrouter-org",
     "agent-router",
     "pi-agentrouter",
+    "gpt-6-astra",
+    "gpt-6",
     "gpt-5.6-sol",
     "claude-opus-5",
     "claude-opus-4-8",