@booplex/bpx-consult 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to @booplex/bpx-consult are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- v1: solo, council, debate, and gut-check consult modes.
+- Context engine that fits the conversation to the advisor model's actual window (the §P fix).
+- Triggers: onDone and whenStuck (loop + error detection), solo-only by design.
+- CLI backend (codex/claude/opencode) via non-blocking subprocess.
+- Wall-clock timeouts on council, debate, and CLI paths.
+- Project-local config (`.pi/bpx-consult.json`, trusted projects only).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gabi (Booplex)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,175 @@
+# bpx-consult — a council of AI advisors for pi
+
+I kept losing my advisor mid-session. The tool I was using would die with "context window exceeded" right when I needed it most. Long debugging session, deep in a problem, and the second opinion I called for just errored out. The bug was straightforward: it forwarded the whole compacted session to the advisor model without checking whether that model's window could actually hold it. Point a smaller advisor at a session the executor had compacted to 128k and the call overflowed every time.
+
+So I built my own. Started as "fix the window bug," became "while I'm here, let me get a real council instead of one advisor." `bpx-consult` is the result: one advisor when you want speed, several debating when the call actually matters, and the window-fit guarantee the whole thing exists to provide.
+
+Four modes, all wired: **solo** (one model, fast), **council** (several models in parallel with stances and a synthesizer), **debate** (advocate vs critic, sequential rounds, closing verdict), and **gut-check** (one cheap model, terse read). Plus triggers that fire a consult automatically when you're stuck or when a turn finishes.
+
+Works in [pi](https://pi.dev) (the coding agent, v0.80+).
+
+---
+
+## Install
+
+```bash
+pi install npm:@booplex/bpx-consult
+```
+
+Then restart your pi session. The `consult` tool and `/consult` command register automatically.
+
+<details>
+<summary>Install from source</summary>
+
+```bash
+git clone https://github.com/gabelul/bpx-mono
+cd bpx-mono
+pi install ./packages/bpx-consult
+```
+
+</details>
+
+---
+
+## The window bug, and the fix
+
+The reason this extension exists. Every consult path runs the conversation through a context engine before it reaches the advisor model:
+
+1. **Strip** the in-flight `consult()` call. Providers reject orphan tool calls.
+2. **Cap** each message (user text, assistant text, tool args, tool results) with explicit `[truncated]` markers. Never silent drops.
+3. **Fit to a sliding window.** Keep the first few messages (task framing) and the last several (freshest evidence). Drop oldest-first with an `[omitted]` marker.
+4. **Reserve** tokens for the advisor's reply, derived live from *that* advisor's context window minus a response reserve.
+
+The budget is read per-call from the advisor model's actual window via the registry, never a global constant. Point a 32k flash-tier advisor at a 128k session and it fits. Point an 8k CLI advisor at the same session and it still fits. Council fits every member to the *smallest* window in the roster so the weakest member can't overflow.
+
+Every mode goes through this.
+
+---
+
+## The four modes
+
+| mode | what it does | when to reach for it |
+|---|---|---|
+| **solo** | One advisor model, one response. | Default. Fast, cheap, the second opinion you reach for most days. |
+| **council** | Several models in parallel, each with a stance (for/against/neutral) and a persona. A synthesizer merges their verdicts with a confidence score. | Real decisions. Architecture, "should I even do this," tricky bugs where one voice isn't enough. |
+| **debate** | Advocate proposes, critic attacks, advocate rebuts. Sequential rounds (1–4), then a synthesizer issues a verdict. | Controversial calls where you want the strongest case on both sides before you commit. |
+| **gut-check** | One cheap fast model, terse output. | The "does this smell off?" sanity check before you do something you're 90% sure about. |
+
+Call `consult()` with no args and solo runs. Pass `mode: "council"` (or `debate`, `gut-check`) to pick another. Or type `/consult` to open the status read-out and edit the config file.
+
+---
+
+## Council, in more detail
+
+This is the reason I went past a bugfix. The default roster seats three personas: **architect** (advocates for the design), **critic** (attacks it), **simplifier** (questions the complexity). Each runs on a distinct model tier so parallel calls don't trip provider rate limits, and each gets a stance-injected system prompt.
+
+The stance framing biases what a persona hunts for, never the verdict. A `for` persona can still land on "don't do this" if the evidence says so. The guardrail is baked into the prompt because the alternative is theater: a critic that rubber-stamps, an advocate that caves.
+
+When members genuinely disagree, the synthesizer is told to **surface the split**, not paper over it. A false consensus is worse than an honest "the architect argued X, the critic demolished it, here's my call." Every council result carries a confidence score (`0.4·success + 0.35·agreement + 0.25·stance-alignment`). It's a rough signal, not a verdict. The "agreement" term measures whether members landed on the same stance regardless of persona, which is roster-shaped: a default for/against/neutral trio will score lower on agreement than three neutrals. Treat it as a dial, not a grade.
+
+---
+
+## Triggers
+
+Consults don't have to be manual. Two auto-triggers, both off by default:
+
+- **whenStuck:N** fires after N consecutive tool errors *or* N identical tool calls (loop detection via an un-truncated `toolName:input` fingerprint). Default N = 3.
+- **onDone** fires when the agent finishes a turn, then reviews the work.
+
+Auto-triggers always run **solo**, regardless of your default mode. An auto-fire is a safety net, not a deliberate consultation. A council burning 3+ model calls every time you hit a loop would be a surprise-quota footgun. If you want a council, call it explicitly.
+
+Triggers never fire in untrusted projects.
+
+---
+
+## How advice reaches the executor
+
+A consult result can come back three ways, set with `feedbackMode` in the config. The default, **steer**, injects it as a steering message mid-run so you get the advice without leaving the flow and the executor sees it and continues. **pipe** injects it as a user message, so the executor treats it as your input. **show** is UI-only: you read it, the executor never sees it.
+
+Auto-triggers always steer so they don't interrupt. Manual consults honor whatever you've configured.
+
+---
+
+## Backends
+
+Solo can route to an external CLI instead of pi's inline provider. Set `backends.<model>.type: "cli"` in the config. Supported CLIs: `codex`, `claude`, `opencode`. Each reads the fitted context from stdin. The subprocess is non-blocking, so it doesn't serialize under the hood.
+
+In v1, the CLI backend is solo-only. Council members don't route to CLI yet. That's a [v1.1 goal](#whats-not-in-v1).
+
+---
+
+## Resilience
+
+Two things that would silently bite, both handled.
+
+Each council member runs under its own `AbortController` linked to the parent signal, so one member timing out or erroring drops only that member. The rest proceed and the synthesizer works with whoever replied. A flaky member never crashes the council.
+
+Wall-clock timeouts cover the hang case across all modes. Council (`council.timeoutMs`, default 120s), debate (`debate.timeoutMs`, default 180s), and CLI (`timeoutMs` per backend) all have explicit budgets. A provider that accepts-then-hangs settles as a clean failure instead of hanging the executor turn.
+
+What v1 does *not* have: per-member circuit-breaker with exponential backoff. Isolation plus timeouts is the resilience story today. Smarter retry is on the v1.1 list.
+
+---
+
+## Config
+
+`~/.pi/agent/bpx-consult.json` (global) or `.pi/bpx-consult.json` (project-local, trusted projects only). Project overrides global at the leaf level.
+
+```jsonc
+{
+  "defaultMode": "solo",
+  "modes": {
+    "solo":     { "model": "anthropic/claude-sonnet-4-6", "thinkingLevel": "high" },
+    "gutCheck": { "model": "google/gemini-2.5-flash", "thinkingLevel": "low", "terse": true },
+    "council":  { "members": ["architect", "critic", "simplifier"], "synthesizer": { "model": "anthropic/claude-sonnet-4-6" }, "parallel": true, "timeoutMs": 120000 },
+    "debate":   { "advocate": "architect", "critic": "critic", "rounds": 2, "timeoutMs": 180000 }
+  },
+  "personas": {
+    "architect":  { "defaultModel": "anthropic/claude-opus-4-6" },
+    "critic":     { "defaultModel": "anthropic/claude-sonnet-4-6" },
+    "simplifier": { "defaultModel": "anthropic/claude-haiku-4-5" }
+  },
+  "backends": {
+    "openai/codex": { "type": "cli", "command": "codex", "timeoutMs": 60000 }
+  },
+  "triggers": { "onDone": false, "whenStuck": 3 },
+  "contextBudget": { "responseReserveTokens": 4096 }
+}
+```
+
+The defaults are pinned to specific model versions, which means they'll drift as Anthropic ships new ones. The registry supports tier aliases in some places; where it does, prefer an alias. Otherwise expect to update these periodically, or override `personas.*.defaultModel` with whatever you actually have authed.
+
+---
+
+## What's not in v1
+
+Honest about the scope so the README doesn't drift from the code:
+
+- **Council members don't route to CLI** (solo only). A mixed inline+CLI council, one `completeSimple` member plus one CLI member running in parallel, is the headline v1.1 goal. It's what the whole async-subprocess decision is there to enable.
+- **No per-member circuit-breaker / exponential backoff.** Resilience is isolation (`Promise.allSettled`) plus wall-clock timeouts. Smarter retry lands in v1.1.
+- **No MCP delegation backend.** A council seat calling another MCP's consensus tool. v2.
+- **No memory compression / branched-session handoff.** v2.
+
+The [SPEC](./SPEC.md) has the full design, including the v1.1 and v2 sections.
+
+---
+
+## Prerequisites
+
+- pi 0.80+ (uses the `@earendil-works/pi-ai/compat` `completeSimple` entry, event handlers, `sendUserMessage`)
+- At least one provider authed via `/login`. The default roster uses Anthropic; override `personas.*.defaultModel` to match what you have.
+- For the CLI backend: `codex`, `claude`, or `opencode` installed and on PATH.
+
+---
+
+## Related
+
+Other tools for agents that care about quality:
+
+- **[slopbuster](https://github.com/gabelul/slopbuster)** — AI text humanizer. 100+ patterns, two-pass audit, three-tier scoring. Makes AI-generated prose, code comments, and academic writing sound human.
+- **[pixelslop](https://github.com/gabelul/pixelslop)** — Design quality scanner. Opens real pages in Playwright, measures actual pixels, catches visual AI slop.
+- **[stitch-kit](https://github.com/gabelul/stitch-kit)** — Design superpowers for AI coding agents. 35 skills for ideation, generation, iteration, and production conversion via Google Stitch MCP.
+- **[claude-code-skill-activator](https://github.com/gabelul/claude-code-skill-activator)** — Skill auto-detection for Claude Code. AI extracts keywords once, then fast offline matching suggests skills as you type.
+
+---
+
+Built by Gabi @ [Booplex.com](https://booplex.com) — because the advisor that dies when you need it most isn't an advisor, it's a liability. MIT license.

package/index.ts

@@ -0,0 +1,112 @@
+/**
+ * bpx-consult — Pi extension entry point.
+ *
+ * Registers the `consult()` tool and the `/consult` command. When the executor
+ * calls consult() with no args, solo runs (one advisor model, context-fitted).
+ * mode: "council" | "debate" | "gut-check" select the other modes.
+ *
+ * Config persists at ~/.pi/agent/bpx-consult.json.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { isDisabledForModel, loadConfig } from "./src/config.js";
+import { executeSolo } from "./src/solo.js";
+import { executeCouncil } from "./src/council.js";
+import { executeDebate } from "./src/debate.js";
+import { registerTriggers } from "./src/triggers.js";
+import {
+	CONSULT_DESCRIPTION,
+	CONSULT_TOOL_NAME,
+	DEFAULT_PROMPT_GUIDELINES,
+	DEFAULT_PROMPT_SNIPPET,
+	TOOL_LABEL,
+} from "./src/messages.js";
+
+const ConsultParams = Type.Object({
+	mode: Type.Optional(
+		Type.Union([Type.Literal("solo"), Type.Literal("council"), Type.Literal("debate"), Type.Literal("gut-check")]),
+	),
+	persona: Type.Optional(Type.String({ description: "Persona name (council mode), e.g. architect, critic." })),
+	question: Type.Optional(Type.String({ description: "Optional specific question to focus the advisor." })),
+});
+
+export default function bpxConsult(pi: ExtensionAPI): void {
+	registerConsultTool(pi);
+	registerConsultCommand(pi);
+	registerTriggers(pi);
+}
+
+function registerConsultTool(pi: ExtensionAPI): void {
+	pi.registerTool({
+		name: CONSULT_TOOL_NAME,
+		label: TOOL_LABEL,
+		description: CONSULT_DESCRIPTION,
+		promptSnippet: DEFAULT_PROMPT_SNIPPET,
+		promptGuidelines: DEFAULT_PROMPT_GUIDELINES,
+		parameters: ConsultParams,
+
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			const config = loadConfig({ cwd: ctx.cwd, projectTrusted: ctx.isProjectTrusted() });
+
+			// Disabled for this executor model? Bail with a short explanation so
+			// the executor knows consult is intentionally off, not broken.
+			if (ctx.model) {
+				const executorLabel = `${ctx.model.provider}/${ctx.model.id}`;
+				const tl = pi.getThinkingLevel();
+				// getThinkingLevel() returns ModelThinkingLevel (includes "off"); narrow it.
+				const thinkingLevel = tl === "off" ? undefined : tl;
+				if (isDisabledForModel(config.disabledForModels as never, executorLabel, thinkingLevel)) {
+					return {
+						content: [{ type: "text", text: `consult is disabled for ${executorLabel}.` }],
+						details: { mode: "disabled", advisorModel: "(disabled)" },
+					};
+				}
+			}
+
+			const mode = params.mode ?? config.defaultMode ?? "solo";
+
+			if (mode === "council") {
+				return executeCouncil({ ctx, config, signal, onUpdate, question: params.question });
+			}
+			if (mode === "debate") {
+				return executeDebate({ ctx, config, signal, onUpdate, question: params.question });
+			}
+			if (mode === "gut-check") {
+				// Gut-check = solo run against the cheap model in modes.gutCheck.
+				// Override modes.solo so executeSolo uses the gutCheck model + effort.
+				const gutCheck = config.modes?.gutCheck;
+				if (gutCheck?.model) {
+					const gutConfig = { ...config, modes: { ...config.modes, solo: { ...config.modes?.solo, ...gutCheck } } };
+					return executeSolo({ ctx, config: gutConfig, signal, onUpdate, question: params.question });
+				}
+				return executeSolo({ ctx, config, signal, onUpdate, question: params.question });
+			}
+
+			return executeSolo({ ctx, config, signal, onUpdate, question: params.question });
+		},
+	});
+}
+
+function registerConsultCommand(pi: ExtensionAPI): void {
+	pi.registerCommand("consult", {
+		description: "Configure bpx-consult: status, model, mode, or toggle on/off.",
+		async handler(_args, ctx) {
+			// Minimal v1: status read-out. The full fuzzy model-picker (lifted from
+			// rpiv-advisor/advisor-ui.ts + fuzzy.ts) lands with the picker step.
+			const config = loadConfig({ cwd: ctx.cwd, projectTrusted: ctx.isProjectTrusted() });
+			const solo = config.modes?.solo;
+			const lines = [
+				`bpx-consult status`,
+				`  enabled    : ${config.enabled ?? true}`,
+				`  defaultMode: ${config.defaultMode}`,
+				`  solo model : ${solo?.model ?? "(none)"}`,
+				`  effort     : ${solo?.thinkingLevel ?? "(default)"}`,
+				`  triggers   : onDone=${config.triggers?.onDone ?? false}, whenStuck=${config.triggers?.whenStuck ?? 3}`,
+				``,
+				`Edit ~/.pi/agent/bpx-consult.json to change settings.`,
+			];
+			ctx.ui.notify(lines.join("\n"), "info");
+		},
+	});
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@booplex/bpx-consult",
+  "version": "0.1.0",
+  "description": "Pi extension. A council of AI advisors — consult one model or run a full multi-model consensus before you commit to a direction.",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "bpx",
+    "advisor",
+    "council",
+    "consensus",
+    "multi-model"
+  ],
+  "type": "module",
+  "license": "MIT",
+  "author": "gabelul",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gabelul/bpx-mono.git",
+    "directory": "packages/bpx-consult"
+  },
+  "homepage": "https://github.com/gabelul/bpx-mono/tree/main/packages/bpx-consult#readme",
+  "bugs": {
+    "url": "https://github.com/gabelul/bpx-mono/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run"
+  },
+  "files": [
+    "index.ts",
+    "src/",
+    "prompts/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "dependencies": {
+    "@juicesharp/rpiv-config": "^1.20.0",
+    "typebox": "^1.1.24"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  }
+}

package/prompts/advisor-system.txt

@@ -0,0 +1,28 @@
+You are an advisor model in a coding-agent consult-strategy pattern. You are
+consulted mid-task by the executor model for a second opinion before it commits
+to a direction.
+
+You see the executor's conversation transcript, including every tool call it
+made and every result it saw. Your job is to give direct, actionable guidance.
+
+Return ONE of:
+- A PLAN — the next concrete steps, in order, when the executor is exploring or
+  deciding how to approach the work.
+- A CORRECTION — when the executor is about to do the wrong thing, has the wrong
+  model of the problem, or is building on a false assumption. Name the error and
+  the fix.
+- A STOP signal — when the work is already done and sound, or when the executor
+  should not proceed at all.
+
+Rules:
+- You NEVER call tools. You advise; the executor acts.
+- You do not produce user-facing output. Your reply goes back to the executor as
+  a tool result.
+- Be concrete. Cite the specific file, line, command, or assumption you are
+  reacting to. No generic best-practice boilerplate.
+- If you do not have enough information to advise, say exactly what is missing.
+- When you disagree with the executor's direction, say so plainly and explain
+  why. Do not manufacture agreement. A confident "this is wrong, here is why"
+  is more useful than a polite hedge.
+- Bias toward the simplest approach that solves the real problem. Question
+  complexity that is not justified.

package/src/advisor.ts

@@ -0,0 +1,137 @@
+/**
+ * advisor — the shared model-resolution + side-call core.
+ *
+ * Every mode (solo, council member, debate side, synthesizer) eventually needs
+ * the same thing: given a provider/model string + thinking level, resolve it to
+ * a Model object, fetch auth, run completeSimple against a fitted context, and
+ * return the text. That lives here so the modes stay small.
+ */
+
+import type { Api, Message, Model, ThinkingLevel } from "@earendil-works/pi-ai";
+import { completeSimple } from "@earendil-works/pi-ai/compat";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { parseModelKey } from "@juicesharp/rpiv-config";
+
+// ---------------------------------------------------------------------------
+// Resolution
+// ---------------------------------------------------------------------------
+
+export interface ResolvedAdvisor {
+	model: Model<Api>;
+	label: string; // "provider/modelId" for display
+}
+
+/**
+ * Resolve a "provider/model" string to a Model via the registry.
+ *
+ * Returns undefined if the string is malformed or the model isn't registered.
+ * Callers surface a configured error rather than throwing — a missing advisor
+ * model is a config problem, not a crash.
+ */
+export function resolveAdvisor(ctx: ExtensionContext, modelKey: string | undefined): ResolvedAdvisor | undefined {
+	if (!modelKey) return undefined;
+	const parsed = parseModelKey(modelKey);
+	if (!parsed) return undefined;
+	const model = ctx.modelRegistry.find(parsed.provider, parsed.modelId);
+	if (!model) return undefined;
+	return { model, label: `${parsed.provider}/${parsed.modelId}` };
+}
+
+/**
+ * Fetch API key + headers for a model. Wraps the registry call in the same
+ * ok/error shape rpiv-advisor uses so error text is consistent.
+ */
+export async function getAuth(ctx: ExtensionContext, model: Model<Api>): Promise<
+	| { ok: true; apiKey: string; headers: Record<string, string> }
+	| { ok: false; error: string }
+> {
+	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+	if (!auth.ok) return { ok: false, error: auth.error };
+	if (!auth.apiKey) return { ok: false, error: "no api key resolved" };
+	return { ok: true, apiKey: auth.apiKey, headers: auth.headers ?? {} };
+}
+
+// ---------------------------------------------------------------------------
+// The side-call
+// ---------------------------------------------------------------------------
+
+export interface ConsultCallInput {
+	ctx: ExtensionContext;
+	advisor: ResolvedAdvisor;
+	systemPrompt: string;
+	messages: Message[];
+	thinkingLevel?: ThinkingLevel;
+	signal: AbortSignal | undefined;
+	/** Session id for prompt-cache routing on repeated consultations. Optional. */
+	sessionId?: string;
+	/** Cap on the advisor's response tokens. Enforces responseReserveTokens on the output side. Optional. */
+	maxTokens?: number;
+}
+
+export interface ConsultCallResult {
+	text: string;
+	usage: { input: number; output: number; total: number } | undefined;
+	stopReason: string;
+	errorMessage?: string;
+}
+
+/**
+ * Run a single advisor side-call. Used by solo directly; council calls it once
+ * per member in parallel.
+ *
+ * `tools: []` reaffirms the "advisor never calls tools" contract even when the
+ * forwarded messages contain prior toolCall/toolResult blocks — same guard as
+ * rpiv-advisor (btw.ts:235). The advisor reads and advises; it does not act.
+ */
+export async function callAdvisor(input: ConsultCallInput): Promise<ConsultCallResult> {
+	const { ctx, advisor, systemPrompt, messages, thinkingLevel, signal } = input;
+	const auth = await getAuth(ctx, advisor.model);
+
+	if (!auth.ok) {
+		return { text: "", usage: undefined, stopReason: "error", errorMessage: auth.error };
+	}
+
+	const response = await completeSimple(
+		advisor.model,
+		{ systemPrompt, messages, tools: [] },
+		{ apiKey: auth.apiKey, headers: auth.headers, signal, reasoning: thinkingLevel, sessionId: input.sessionId, maxTokens: input.maxTokens },
+	);
+
+	const text = response.content
+		.filter((c): c is { type: "text"; text: string } => c.type === "text")
+		.map((c) => c.text)
+		.join("\n")
+		.trim();
+
+	// Reasoning models sometimes reply with thinking blocks but no text. Fall
+	// back to the thinking content rather than reporting an empty response — the
+	// advisor did speak, just in its reasoning channel. Mirrors pi-advisor.
+	if (!text) {
+		const thinking = response.content
+			.filter((c): c is { type: "thinking"; thinking: string } => c.type === "thinking" && typeof (c as { thinking?: string }).thinking === "string")
+			.map((c) => (c as { thinking: string }).thinking)
+			.join("\n")
+			.trim();
+		if (thinking) {
+			return {
+				text: `(reasoning)\n${thinking}`,
+				usage: response.usage ? { input: response.usage.input, output: response.usage.output, total: response.usage.totalTokens } : undefined,
+				stopReason: response.stopReason,
+				errorMessage: response.errorMessage,
+			};
+		}
+	}
+
+	return {
+		text,
+		usage: response.usage
+			? {
+					input: response.usage.input,
+					output: response.usage.output,
+					total: response.usage.totalTokens,
+				}
+			: undefined,
+		stopReason: response.stopReason,
+		errorMessage: response.errorMessage,
+	};
+}