pi-btw 0.2.1 → 0.3.8

package/README.md

@@ -15,6 +15,7 @@ A small [pi](https://github.com/badlogic/pi-mono) extension that adds a `/btw` s
 - opens a focused BTW modal shell with its own composer and transcript
 - keeps the BTW overlay open while you switch focus back to the main editor with `Alt+/`
 - keeps BTW thread entries out of the main agent's future context
+- supports BTW-only model and thinking overrides without changing the main thread settings
 - lets you inject the full thread, or a summary of it, back into the main agent
 - optionally saves an individual BTW exchange as a visible session note with `--save`
 
@@ -52,6 +53,8 @@ pi install /absolute/path/to/pi-btw
 /btw --save summarize the last error in one sentence
 /btw:new let's start a fresh thread about auth
 /btw:tangent brainstorm from first principles without using the current chat context
+/btw:model openai gpt-5-mini openai-responses
+/btw:thinking low
 /btw:inject implement the plan we just discussed
 /btw:summarize turn that side thread into a short handoff
 /btw:clear
@@ -105,11 +108,26 @@ pi install /absolute/path/to/pi-btw
 
 ### `/btw:summarize [instructions]`
 
-- summarizes the BTW thread with the current model
+- summarizes the BTW thread with the current effective BTW model
+- always runs summarize with thinking off, even if BTW chat is using a thinking override
 - injects the summary into the main agent
 - if pi is busy, queues it as a follow-up
 - clears the BTW thread after sending
 
+### `/btw:model [<provider> <model> <api> | clear]`
+
+- with no args, shows the current effective BTW model and whether it is inherited or overridden
+- with values, sets a BTW-only model override
+- `clear` removes the override and returns BTW to inheriting the main thread model
+- if the configured BTW model has no credentials, BTW warns and falls back to the main thread model
+
+### `/btw:thinking [<level> | clear]`
+
+- with no args, shows the current effective BTW thinking level and whether it is inherited or overridden
+- with a value, sets a BTW-only thinking override for normal BTW chat
+- `clear` removes the override and returns BTW to inheriting the main thread thinking level
+- changing `/btw:model` or `/btw:thinking` disposes the current BTW sub-session and applies the new settings on the next BTW prompt while preserving the hidden thread
+
 ## Behavior
 
 ### Real sub-session model
@@ -118,6 +136,8 @@ BTW is implemented as an actual pi sub-session with its own in-memory session st
 
 - contextual `/btw` threads seed that sub-session from the current main-session branch while filtering out BTW-visible notes from the parent context
 - `/btw:tangent` starts the same BTW UI in a contextless mode with no inherited main-session conversation
+- BTW can inherit the main thread model/thinking settings or use BTW-only overrides via `/btw:model` and `/btw:thinking`
+- `/btw:summarize` uses the current effective BTW model but keeps thinking off
 - the overlay transcript/status line is driven from sub-session events, so tool activity, streaming deltas, failures, and recovery are all visible without scraping rendered output
 - handoff commands (`/btw:inject` and `/btw:summarize`) read from the BTW sub-session thread rather than maintaining a separate manual transcript model
 
@@ -125,7 +145,7 @@ BTW is implemented as an actual pi sub-session with its own in-memory session st
 
 Inside the BTW modal composer, slash handling is split at the BTW/session boundary:
 
-- `/btw:new`, `/btw:tangent`, `/btw:clear`, `/btw:inject`, and `/btw:summarize` stay owned by BTW because they control BTW lifecycle or handoff behavior
+- `/btw:new`, `/btw:tangent`, `/btw:clear`, `/btw:model`, `/btw:thinking`, `/btw:inject`, and `/btw:summarize` stay owned by BTW because they control BTW lifecycle, configuration, or handoff behavior
 - any other slash-prefixed input is routed through the BTW sub-session's normal `prompt()` path
 - this means ordinary pi slash commands like `/help` are handled by the sub-session instead of being rejected by a modal-only fallback
 - if the sub-session cannot handle a slash command, BTW surfaces the real sub-session failure through the transcript/status state instead of inventing an "unsupported slash input" warning
@@ -141,6 +161,7 @@ BTW exchanges are persisted in the session as hidden custom entries so they:
 - survive reloads and restarts
 - rehydrate the BTW modal shell for the current branch
 - preserve whether the current side thread is a normal `/btw` thread or a contextless `/btw:tangent`
+- preserve the current BTW-only model and thinking overrides for that session history
 - stay out of the main agent's LLM context
 
 ### Visible saved notes

package/extensions/btw.ts

@@ -11,7 +11,7 @@ import {
   type ExtensionContext,
   type ResourceLoader,
 } from "@mariozechner/pi-coding-agent";
-import { type AssistantMessage, type Message, type ThinkingLevel as AiThinkingLevel } from "@mariozechner/pi-ai";
+import { type AssistantMessage, type Message, type ThinkingLevel as AiThinkingLevel, type UserMessage } from "@mariozechner/pi-ai";
 import {
   Box,
   Container,
@@ -31,6 +31,8 @@ import {
 const BTW_MESSAGE_TYPE = "btw-note";
 const BTW_ENTRY_TYPE = "btw-thread-entry";
 const BTW_RESET_TYPE = "btw-thread-reset";
+const BTW_MODEL_OVERRIDE_TYPE = "btw-model-override";
+const BTW_THINKING_OVERRIDE_TYPE = "btw-thinking-override";
 const BTW_FOCUS_SHORTCUTS = [Key.alt("/"), Key.ctrlAlt("w")] as const;
 
 function matchesBtwFocusShortcut(data: string): boolean {
@@ -53,6 +55,7 @@ const BTW_CONTINUE_THREAD_ASSISTANT_TEXT = "Understood, continuing our side conv
 
 type SessionThinkingLevel = "off" | AiThinkingLevel;
 type BtwThreadMode = "contextual" | "tangent";
+type SessionModel = NonNullable<ExtensionCommandContext["model"]>;
 
 type BtwDetails = {
   question: string;
@@ -60,6 +63,7 @@ type BtwDetails = {
   answer: string;
   provider: string;
   model: string;
+  api: string;
   thinkingLevel: SessionThinkingLevel;
   timestamp: number;
   usage?: AssistantMessage["usage"];
@@ -77,6 +81,30 @@ type BtwResetDetails = {
   mode?: BtwThreadMode;
 };
 
+type BtwModelOverrideDetails =
+  | ({ timestamp: number; action: "set" } & Pick<SessionModel, "provider" | "id" | "api">)
+  | { timestamp: number; action: "clear" };
+
+type BtwThinkingOverrideDetails =
+  | { timestamp: number; action: "set"; thinkingLevel: SessionThinkingLevel }
+  | { timestamp: number; action: "clear" };
+
+type ResolvedBtwModel = {
+  model: SessionModel | null;
+  source: "override" | "main" | "none";
+  configuredOverride: SessionModel | null;
+  fallbackReason?: string;
+};
+
+type ResolvedBtwSettings = {
+  model: SessionModel | null;
+  modelSource: "override" | "main" | "none";
+  configuredModelOverride: SessionModel | null;
+  thinkingLevel: SessionThinkingLevel;
+  thinkingSource: "override" | "main";
+  fallbackReason?: string;
+};
+
 type BtwTranscriptEntry =
   | { id: number; turnId: number; type: "turn-boundary"; phase: "start" | "end" }
   | { id: number; turnId: number; type: "user-message"; text: string }
@@ -152,7 +180,6 @@ function createBtwResourceLoader(
     getAgentsFiles: () => ({ agentsFiles: [] }),
     getSystemPrompt: () => systemPrompt,
     getAppendSystemPrompt: () => appendSystemPrompt,
-    getPathMetadata: () => new Map(),
     extendResources: () => {},
     reload: async () => {},
   };
@@ -186,17 +213,61 @@ function parseBtwArgs(args: string): ParsedBtwArgs {
   return { question, save };
 }
 
+function parseBtwModelArgs(args: string):
+  | { action: "show" }
+  | { action: "clear" }
+  | { action: "set"; model: SessionModel }
+  | { action: "invalid"; message: string } {
+  const trimmed = args.trim();
+  if (!trimmed) {
+    return { action: "show" };
+  }
+
+  if (trimmed === "clear") {
+    return { action: "clear" };
+  }
+
+  const parts = trimmed.split(/\s+/);
+  if (parts.length !== 3) {
+    return { action: "invalid", message: "Usage: /btw:model <provider> <model> <api> | clear" };
+  }
+
+  const [provider, id, api] = parts;
+  return { action: "set", model: { provider, id, api } };
+}
+
+function parseBtwThinkingArgs(args: string):
+  | { action: "show" }
+  | { action: "clear" }
+  | { action: "set"; thinkingLevel: SessionThinkingLevel } {
+  const trimmed = args.trim();
+  if (!trimmed) {
+    return { action: "show" };
+  }
+
+  if (trimmed === "clear") {
+    return { action: "clear" };
+  }
+
+  return { action: "set", thinkingLevel: trimmed as SessionThinkingLevel };
+}
+
+function formatModelRef(model: Pick<SessionModel, "provider" | "id" | "api">): string {
+  return `${model.provider}/${model.id} (${model.api})`;
+}
+
 function buildBtwSeedState(
   ctx: ExtensionCommandContext,
   thread: BtwDetails[],
   mode: BtwThreadMode,
+  sessionModel: SessionModel | null,
 ): { messages: Message[]; sideThreadStartIndex: number } {
   const messages: Message[] = [];
 
   if (mode === "contextual") {
     try {
       messages.push(
-        ...buildSessionContext(ctx.sessionManager.getEntries(), ctx.sessionManager.getLeafId()).messages.filter(
+        ...(buildSessionContext(ctx.sessionManager.getEntries(), ctx.sessionManager.getLeafId()).messages as Message[]).filter(
           (message) => !isVisibleBtwMessage(message),
         ),
       );
@@ -207,7 +278,7 @@ function buildBtwSeedState(
             return [];
           }
 
-          const message = entry as Partial<Message> & { role?: string; customType?: string; content?: unknown };
+          const message = entry as unknown as Partial<Message> & { role?: string; customType?: string; content?: unknown };
           if (typeof message.role !== "string" || !Array.isArray(message.content)) {
             return [];
           }
@@ -230,9 +301,9 @@ function buildBtwSeedState(
       {
         role: "assistant",
         content: [{ type: "text", text: BTW_CONTINUE_THREAD_ASSISTANT_TEXT }],
-        provider: ctx.model?.provider ?? "unknown",
-        model: ctx.model?.id ?? "unknown",
-        api: ctx.model?.api ?? "openai-responses",
+        provider: sessionModel?.provider ?? "unknown",
+        model: sessionModel?.id ?? "unknown",
+        api: sessionModel?.api ?? "openai-responses",
         usage: {
           input: 0,
           output: 0,
@@ -258,7 +329,7 @@ function buildBtwSeedState(
           content: [{ type: "text", text: entry.answer }],
           provider: entry.provider,
           model: entry.model,
-          api: ctx.model?.api ?? "openai-responses",
+          api: entry.api || sessionModel?.api || ctx.model?.api || "openai-responses",
           usage:
             entry.usage ?? {
               input: 0,
@@ -336,7 +407,7 @@ function ensureTranscriptTurn(state: BtwTranscriptState): number {
   const turnId = state.nextTurnId++;
   state.currentTurnId = turnId;
   state.lastTurnId = turnId;
-  appendTranscriptEntry(state, { type: "turn-boundary", turnId, phase: "start" });
+  appendTranscriptEntry(state, { type: "turn-boundary", turnId, phase: "start" } as Omit<Extract<BtwTranscriptEntry, { type: "turn-boundary" }>, "id">);
   return turnId;
 }
 
@@ -350,7 +421,7 @@ function finishTranscriptTurn(state: BtwTranscriptState, turnId?: number | null)
     (entry) => entry.turnId === resolvedTurnId && entry.type === "turn-boundary" && entry.phase === "end",
   );
   if (!hasEndBoundary) {
-    appendTranscriptEntry(state, { type: "turn-boundary", turnId: resolvedTurnId, phase: "end" });
+    appendTranscriptEntry(state, { type: "turn-boundary", turnId: resolvedTurnId, phase: "end" } as Omit<Extract<BtwTranscriptEntry, { type: "turn-boundary" }>, "id">);
   }
 
   for (const entry of state.entries) {
@@ -415,8 +486,18 @@ function ensureTranscriptTurnForUserMessage(state: BtwTranscriptState): number {
   return ensureTranscriptTurn(state);
 }
 
-function extractMessageText(message: { content?: AssistantMessage["content"] }): string {
-  return Array.isArray(message.content) ? extractText(message.content, "text") : "";
+function extractMessageText(message: { content?: string | AssistantMessage["content"] | UserMessage["content"] }): string {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (!Array.isArray(message.content)) {
+    return "";
+  }
+  return message.content
+    .filter((part): part is { type: "text"; text: string } => part.type === "text" && typeof part.text === "string")
+    .map((part) => part.text)
+    .join("\n")
+    .trim();
 }
 
 function upsertUserMessageEntry(state: BtwTranscriptState, turnId: number, text: string): void {
@@ -430,7 +511,7 @@ function upsertUserMessageEntry(state: BtwTranscriptState, turnId: number, text:
     return;
   }
 
-  appendTranscriptEntry(state, { type: "user-message", turnId, text });
+  appendTranscriptEntry(state, { type: "user-message", turnId, text } as Omit<Extract<BtwTranscriptEntry, { type: "user-message" }>, "id">);
 }
 
 function upsertTranscriptTextEntry(
@@ -451,7 +532,7 @@ function upsertTranscriptTextEntry(
     return;
   }
 
-  appendTranscriptEntry(state, { type, turnId, text, streaming });
+  appendTranscriptEntry(state, { type, turnId, text, streaming } as Omit<Extract<BtwTranscriptEntry, { type: "thinking" | "assistant-text" }>, "id">);
 }
 
 function summarizeToolResult(value: unknown, maxLength = 400): { content: string; truncated: boolean } {
@@ -522,7 +603,7 @@ function ensureToolCallEntry(
     toolCallId,
     toolName,
     args,
-  });
+  } as Omit<Extract<BtwTranscriptEntry, { type: "tool-call" }>, "id">);
   const record = { turnId, callEntryId: callEntry.id };
   state.toolCalls.set(toolCallId, record);
   return record;
@@ -561,21 +642,17 @@ function upsertToolResultEntry(
     truncated,
     isError,
     streaming,
-  });
+  } as Omit<Extract<BtwTranscriptEntry, { type: "tool-result" }>, "id">);
   toolCall.resultEntryId = resultEntry.id;
 }
 
 function applyAssistantMessageToTranscript(
   state: BtwTranscriptState,
   turnId: number,
-  message: AgentSessionEvent extends { message: infer T } ? T : never,
+  message: AssistantMessage,
   streaming: boolean,
 ): void {
-  if (!message || typeof message !== "object" || (message as { role?: string }).role !== "assistant") {
-    return;
-  }
-
-  const assistantMessage = message as AssistantMessage;
+  const assistantMessage = message;
   const thinking = extractThinking(assistantMessage);
   const answer = extractMessageText(assistantMessage);
 
@@ -847,7 +924,7 @@ function isThreadContinuationMarker(messages: Message[], index: number): boolean
 
 function extractBtwHandoffThread(sessionRuntime: BtwSessionRuntime): BtwHandoffExchange[] {
   const handoffMessages = sessionRuntime.session.state.messages.slice(sessionRuntime.sideThreadStartIndex);
-  const threadMessages = isThreadContinuationMarker(handoffMessages, 0) ? handoffMessages.slice(2) : handoffMessages;
+  const threadMessages = isThreadContinuationMarker(handoffMessages as Message[], 0) ? handoffMessages.slice(2) : handoffMessages;
   const exchanges: BtwHandoffExchange[] = [];
   let currentUser = "";
   let currentAssistant = "";
@@ -927,8 +1004,8 @@ function getOverlayTitle(mode: BtwThreadMode): string {
 function buildTranscriptBadge(
   theme: ExtensionContext["ui"]["theme"],
   label: string,
-  background: string,
-  foreground: string,
+  background: "userMessageBg" | "toolPendingBg" | "customMessageBg",
+  foreground: "accent" | "warning" | "success",
 ): string {
   return theme.bg(background, theme.fg(foreground, theme.bold(` ${label} `)));
 }
@@ -953,6 +1030,10 @@ class BtwOverlayComponent extends Container implements Focusable {
   private transcriptViewportHeight = 8;
   private followTranscript = true;
   private _focused = false;
+  private modeTextValue = "";
+  private summaryTextValue = "";
+  private statusTextValue = "";
+  private hintsTextValue = "";
 
   get focused(): boolean {
     return this._focused;
@@ -1002,7 +1083,18 @@ class BtwOverlayComponent extends Container implements Focusable {
 
     const originalHandleInput = this.input.handleInput.bind(this.input);
     this.input.handleInput = (data: string) => {
-      if (keybindings.matches(data, "selectCancel")) {
+      if (keybindings.matches(data, "app.clear")) {
+        if (this.input.getValue().length > 0) {
+          this.input.setValue("");
+          this.tui.requestRender();
+          return;
+        }
+
+        this.onDismissCallback();
+        return;
+      }
+
+      if (keybindings.matches(data, "tui.select.cancel")) {
         this.onDismissCallback();
         return;
       }
@@ -1111,12 +1203,12 @@ class BtwOverlayComponent extends Container implements Focusable {
     const hiddenBelow = Math.max(0, maxScroll - this.transcriptScrollOffset);
     const summary =
       hiddenAbove || hiddenBelow
-        ? `${this.summaryText.text.trim()} · ↑${hiddenAbove} ↓${hiddenBelow}`
-        : this.summaryText.text.trim();
+        ? `${this.summaryTextValue.trim()} · ↑${hiddenAbove} ↓${hiddenBelow}`
+        : this.summaryTextValue.trim();
 
     const lines = [this.borderLine(innerWidth, "top")];
 
-    lines.push(this.frameLine(this.theme.fg("accent", this.theme.bold(this.modeText.text.trim())), innerWidth));
+    lines.push(this.frameLine(this.theme.fg("accent", this.theme.bold(this.modeTextValue.trim())), innerWidth));
     lines.push(this.frameLine(this.theme.fg("dim", summary), innerWidth));
     lines.push(this.ruleLine(innerWidth));
 
@@ -1128,9 +1220,9 @@ class BtwOverlayComponent extends Container implements Focusable {
     }
 
     lines.push(this.ruleLine(innerWidth));
-    lines.push(this.frameLine(this.theme.fg("warning", this.statusText.text.trim()), innerWidth));
+    lines.push(this.frameLine(this.theme.fg("warning", this.statusTextValue.trim()), innerWidth));
     lines.push(this.inputFrameLine(dialogWidth));
-    lines.push(this.frameLine(this.theme.fg("dim", this.hintsText.text.trim()), innerWidth));
+    lines.push(this.frameLine(this.theme.fg("dim", this.hintsTextValue.trim()), innerWidth));
     lines.push(this.borderLine(innerWidth, "bottom"));
 
     return lines;
@@ -1150,11 +1242,13 @@ class BtwOverlayComponent extends Container implements Focusable {
   }
 
   refresh(): void {
-    this.modeText.setText(`${getOverlayTitle(this.getMode())} · hidden thread preserved`);
+    this.modeTextValue = `${getOverlayTitle(this.getMode())} · hidden thread preserved`;
+    this.modeText.setText(this.modeTextValue);
     const entries = this.readTranscriptEntries();
     const exchanges = getCompletedExchangeCount(entries);
     const active = hasStreamingTranscriptEntry(entries) ? " · streaming" : " · idle";
-    this.summaryText.setText(`${exchanges} exchange${exchanges === 1 ? "" : "s"}${active}`);
+    this.summaryTextValue = `${exchanges} exchange${exchanges === 1 ? "" : "s"}${active}`;
+    this.summaryText.setText(this.summaryTextValue);
 
     this.transcriptLines = buildOverlayTranscript(entries, this.theme);
     this.transcript.clear();
@@ -1163,8 +1257,10 @@ class BtwOverlayComponent extends Container implements Focusable {
     }
 
     const status = this.getStatus() ?? "Ready. Enter submits; Escape dismisses without clearing.";
-    this.statusText.setText(status);
-    this.hintsText.setText("Enter submit · Alt+/ toggle focus · Escape dismiss · PgUp/PgDn scroll");
+    this.statusTextValue = status;
+    this.statusText.setText(this.statusTextValue);
+    this.hintsTextValue = "Enter submit · Alt+/ toggle focus · Escape dismiss · PgUp/PgDn scroll";
+    this.hintsText.setText(this.hintsTextValue);
     this.tui.requestRender();
   }
 }
@@ -1172,6 +1268,8 @@ class BtwOverlayComponent extends Container implements Focusable {
 export default function (pi: ExtensionAPI) {
   let pendingThread: BtwDetails[] = [];
   let pendingMode: BtwThreadMode = "contextual";
+  let btwModelOverride: SessionModel | null = null;
+  let btwThinkingOverride: SessionThinkingLevel | null = null;
   let transcriptState = createEmptyTranscriptState();
   let overlayStatus: string | null = null;
   let overlayDraft = "";
@@ -1317,26 +1415,161 @@ export default function (pi: ExtensionAPI) {
     await disposeBtwSession();
   }
 
+  async function resolveBtwModel(
+    ctx: ExtensionCommandContext,
+    notifyOnFallback = false,
+  ): Promise<ResolvedBtwModel> {
+    if (btwModelOverride) {
+      const auth = await ctx.modelRegistry.getApiKeyAndHeaders(btwModelOverride);
+      if (auth.ok && auth.apiKey) {
+        return {
+          model: btwModelOverride,
+          source: "override",
+          configuredOverride: btwModelOverride,
+        };
+      }
+
+      const fallbackReason = ctx.model
+        ? `Configured BTW model ${formatModelRef(btwModelOverride)} has no credentials. Falling back to main model ${formatModelRef(
+            ctx.model,
+          )}.`
+        : `Configured BTW model ${formatModelRef(btwModelOverride)} has no credentials, and no main model is active.`;
+      if (notifyOnFallback) {
+        notify(ctx, fallbackReason, "warning");
+      }
+
+      if (ctx.model) {
+        return {
+          model: ctx.model,
+          source: "main",
+          configuredOverride: btwModelOverride,
+          fallbackReason,
+        };
+      }
+
+      return {
+        model: null,
+        source: "none",
+        configuredOverride: btwModelOverride,
+        fallbackReason,
+      };
+    }
+
+    if (ctx.model) {
+      return {
+        model: ctx.model,
+        source: "main",
+        configuredOverride: null,
+      };
+    }
+
+    return {
+      model: null,
+      source: "none",
+      configuredOverride: null,
+    };
+  }
+
+  async function resolveBtwSettings(
+    ctx: ExtensionCommandContext,
+    notifyOnFallback = false,
+  ): Promise<ResolvedBtwSettings> {
+    const resolvedModel = await resolveBtwModel(ctx, notifyOnFallback);
+    const thinkingLevel = btwThinkingOverride ?? (pi.getThinkingLevel() as SessionThinkingLevel);
+
+    return {
+      model: resolvedModel.model,
+      modelSource: resolvedModel.source,
+      configuredModelOverride: resolvedModel.configuredOverride,
+      thinkingLevel,
+      thinkingSource: btwThinkingOverride ? "override" : "main",
+      fallbackReason: resolvedModel.fallbackReason,
+    };
+  }
+
+  function describeResolvedModel(settings: ResolvedBtwSettings): string {
+    if (!settings.model) {
+      if (settings.configuredModelOverride && settings.fallbackReason) {
+        return `BTW model unavailable. ${settings.fallbackReason}`;
+      }
+      return "BTW model unavailable. No active model selected.";
+    }
+
+    const source =
+      settings.modelSource === "override"
+        ? "override"
+        : settings.configuredModelOverride
+          ? "inherited fallback"
+          : "inherits main thread";
+    return `BTW model: ${formatModelRef(settings.model)} (${source}).${
+      settings.fallbackReason ? ` ${settings.fallbackReason}` : ""
+    }`;
+  }
+
+  function describeResolvedThinking(settings: ResolvedBtwSettings): string {
+    const source = settings.thinkingSource === "override" ? "override" : "inherits main thread";
+    return `BTW thinking: ${settings.thinkingLevel} (${source}).`;
+  }
+
+  async function setBtwModelOverride(ctx: ExtensionCommandContext, nextModel: SessionModel | null): Promise<void> {
+    btwModelOverride = nextModel;
+    const details: BtwModelOverrideDetails = nextModel
+      ? { action: "set", timestamp: Date.now(), provider: nextModel.provider, id: nextModel.id, api: nextModel.api }
+      : { action: "clear", timestamp: Date.now() };
+    pi.appendEntry(BTW_MODEL_OVERRIDE_TYPE, details);
+    await disposeBtwSession();
+    const settings = await resolveBtwSettings(ctx);
+    const message = nextModel
+      ? `BTW model override set to ${formatModelRef(nextModel)}.`
+      : "BTW model override cleared. BTW now inherits the main thread model.";
+    setOverlayStatus(message, ctx);
+    notify(ctx, `${message} ${describeResolvedModel(settings)}`, "info");
+  }
+
+  async function setBtwThinkingOverride(
+    ctx: ExtensionCommandContext,
+    nextThinkingLevel: SessionThinkingLevel | null,
+  ): Promise<void> {
+    btwThinkingOverride = nextThinkingLevel;
+    const details: BtwThinkingOverrideDetails = nextThinkingLevel
+      ? { action: "set", timestamp: Date.now(), thinkingLevel: nextThinkingLevel }
+      : { action: "clear", timestamp: Date.now() };
+    pi.appendEntry(BTW_THINKING_OVERRIDE_TYPE, details);
+    await disposeBtwSession();
+    const settings = await resolveBtwSettings(ctx);
+    const message = nextThinkingLevel
+      ? `BTW thinking override set to ${nextThinkingLevel}.`
+      : "BTW thinking override cleared. BTW now inherits the main thread thinking level.";
+    setOverlayStatus(message, ctx);
+    notify(ctx, `${message} ${describeResolvedThinking(settings)}`, "info");
+  }
+
   async function createBtwSubSession(ctx: ExtensionCommandContext, mode: BtwThreadMode): Promise<BtwSessionRuntime> {
+    const settings = await resolveBtwSettings(ctx, true);
+    if (!settings.model) {
+      throw new Error(settings.fallbackReason || "No active model selected.");
+    }
+
     const { session } = await createAgentSession({
       sessionManager: SessionManager.inMemory(),
-      model: ctx.model,
+      model: settings.model,
       modelRegistry: ctx.modelRegistry as AgentSession["modelRegistry"],
-      thinkingLevel: pi.getThinkingLevel() as SessionThinkingLevel,
+      thinkingLevel: settings.thinkingLevel,
       tools: codingTools,
       resourceLoader: createBtwResourceLoader(ctx),
     });
 
-    const { messages: seedMessages, sideThreadStartIndex } = buildBtwSeedState(ctx, pendingThread, mode);
+    const { messages: seedMessages, sideThreadStartIndex } = buildBtwSeedState(ctx, pendingThread, mode, settings.model);
     if (seedMessages.length > 0) {
-      session.agent.replaceMessages(seedMessages as typeof session.state.messages);
+      session.agent.state.messages = seedMessages as typeof session.state.messages;
     }
 
     return { session, mode, subscriptions: new Set(), sideThreadStartIndex };
   }
 
   async function ensureBtwSession(ctx: ExtensionCommandContext, mode: BtwThreadMode): Promise<BtwSessionRuntime | null> {
-    if (!ctx.model) {
+    const settings = await resolveBtwSettings(ctx);
+    if (!settings.model) {
       return null;
     }
 
@@ -1511,6 +1744,40 @@ export default function (pi: ExtensionAPI) {
       return true;
     }
 
+    if (name === "btw:model") {
+      const parsed = parseBtwModelArgs(trimmedArgs);
+      if (parsed.action === "invalid") {
+        setOverlayStatus(parsed.message, ctx);
+        notify(ctx, parsed.message, "error");
+        return true;
+      }
+
+      if (parsed.action === "show") {
+        const settings = await resolveBtwSettings(ctx);
+        const message = describeResolvedModel(settings);
+        setOverlayStatus(message, ctx);
+        notify(ctx, message, settings.model ? "info" : "warning");
+        return true;
+      }
+
+      await setBtwModelOverride(ctx, parsed.action === "clear" ? null : parsed.model);
+      return true;
+    }
+
+    if (name === "btw:thinking") {
+      const parsed = parseBtwThinkingArgs(trimmedArgs);
+      if (parsed.action === "show") {
+        const settings = await resolveBtwSettings(ctx);
+        const message = describeResolvedThinking(settings);
+        setOverlayStatus(message, ctx);
+        notify(ctx, message, "info");
+        return true;
+      }
+
+      await setBtwThinkingOverride(ctx, parsed.action === "clear" ? null : parsed.thinkingLevel);
+      return true;
+    }
+
     if (name === "btw:inject") {
       if (pendingThread.length === 0) {
         notify(ctx, "No BTW thread to inject.", "warning");
@@ -1573,7 +1840,7 @@ export default function (pi: ExtensionAPI) {
 
   function parseOverlayBtwCommand(value: string): { name: string; args: string } | null {
     const trimmed = value.trim();
-    const match = trimmed.match(/^\/(btw:(?:new|tangent|clear|inject|summarize))(?:\s+(.*))?$/);
+    const match = trimmed.match(/^\/(btw:(?:new|tangent|clear|inject|summarize|model|thinking))(?:\s+(.*))?$/);
     if (!match) {
       return null;
     }
@@ -1596,17 +1863,18 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
+    const cmdCtx = ctx as ExtensionCommandContext;
     const btwCommand = parseOverlayBtwCommand(question);
     if (btwCommand) {
       setOverlayDraft("");
-      await dispatchBtwCommand(btwCommand.name, btwCommand.args, ctx);
+      await dispatchBtwCommand(btwCommand.name, btwCommand.args, cmdCtx);
       return;
     }
 
     setOverlayDraft("");
     setOverlayStatus("⏳ streaming...", ctx);
     syncUi(ctx);
-    await runBtw(ctx, question, false, pendingMode);
+    await runBtw(cmdCtx, question, false, pendingMode);
   }
 
   async function resetThread(
@@ -1631,6 +1899,8 @@ export default function (pi: ExtensionAPI) {
     await disposeBtwSession();
     pendingThread = [];
     pendingMode = "contextual";
+    btwModelOverride = null;
+    btwThinkingOverride = null;
     transcriptState = createEmptyTranscriptState();
     overlayDraft = "";
     lastUiContext = ctx;
@@ -1640,9 +1910,29 @@ export default function (pi: ExtensionAPI) {
     let lastResetIndex = -1;
 
     for (let i = 0; i < branch.length; i++) {
+      if (isCustomEntry(branch[i], BTW_MODEL_OVERRIDE_TYPE)) {
+        const details = branch[i].data as BtwModelOverrideDetails | undefined;
+        btwModelOverride =
+          details?.action === "set"
+            ? { provider: details.provider, id: details.id, api: details.api }
+            : details?.action === "clear"
+              ? null
+              : btwModelOverride;
+      }
+
+      if (isCustomEntry(branch[i], BTW_THINKING_OVERRIDE_TYPE)) {
+        const details = branch[i].data as BtwThinkingOverrideDetails | undefined;
+        btwThinkingOverride =
+          details?.action === "set"
+            ? details.thinkingLevel
+            : details?.action === "clear"
+              ? null
+              : btwThinkingOverride;
+      }
+
       if (isCustomEntry(branch[i], BTW_RESET_TYPE)) {
         lastResetIndex = i;
-        const details = branch[i].data as BtwResetDetails | undefined;
+        const details = (branch[i] as unknown as { data?: BtwResetDetails }).data;
         pendingMode = details?.mode ?? "contextual";
       }
     }
@@ -1652,13 +1942,18 @@ export default function (pi: ExtensionAPI) {
         continue;
       }
 
-      const details = entry.data as BtwDetails | undefined;
+      const details = (entry as unknown as { data?: BtwDetails }).data;
       if (!details?.question || !details.answer) {
         continue;
       }
 
-      pendingThread.push(details);
-      appendPersistedTranscriptTurn(transcriptState, details);
+      const normalizedDetails: BtwDetails = {
+        ...details,
+        api: details.api || ctx.model?.api || "openai-responses",
+      };
+
+      pendingThread.push(normalizedDetails);
+      appendPersistedTranscriptTurn(transcriptState, normalizedDetails);
     }
 
     syncUi(ctx);
@@ -1671,16 +1966,18 @@ export default function (pi: ExtensionAPI) {
     mode: BtwThreadMode,
   ): Promise<void> {
     lastUiContext = ctx;
-    const model = ctx.model;
+    const settings = await resolveBtwSettings(ctx);
+    const model = settings.model;
     if (!model) {
-      setOverlayStatus("No active model selected.", ctx);
-      notify(ctx, "No active model selected.", "error");
+      const message = settings.fallbackReason || "No active model selected.";
+      setOverlayStatus(message, ctx);
+      notify(ctx, message, "error");
       return;
     }
 
-    const apiKey = await ctx.modelRegistry.getApiKey(model);
-    if (!apiKey) {
-      const message = `No credentials available for ${model.provider}/${model.id}.`;
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok || !auth.apiKey) {
+      const message = auth.ok ? `No credentials available for ${model.provider}/${model.id}.` : auth.error;
       setOverlayStatus(message, ctx);
       notify(ctx, message, "error");
       await ensureOverlay(ctx);
@@ -1697,7 +1994,7 @@ export default function (pi: ExtensionAPI) {
     const session = sessionRuntime.session;
     const wasBusy = !ctx.isIdle();
     pendingMode = mode;
-    const thinkingLevel = pi.getThinkingLevel() as SessionThinkingLevel;
+    const thinkingLevel = settings.thinkingLevel;
 
     setOverlayStatus("⏳ streaming...", ctx);
     await ensureOverlay(ctx);
@@ -1730,6 +2027,7 @@ export default function (pi: ExtensionAPI) {
         answer,
         provider: model.provider,
         model: model.id,
+        api: model.api,
         thinkingLevel,
         timestamp: Date.now(),
         usage: response.usage,
@@ -1778,14 +2076,15 @@ export default function (pi: ExtensionAPI) {
   }
 
   async function summarizeThread(ctx: ExtensionCommandContext, thread: BtwHandoffExchange[]): Promise<string> {
-    const model = ctx.model;
+    const settings = await resolveBtwSettings(ctx, true);
+    const model = settings.model;
     if (!model) {
-      throw new Error("No active model selected.");
+      throw new Error(settings.fallbackReason || "No active model selected.");
     }
 
-    const apiKey = await ctx.modelRegistry.getApiKey(model);
-    if (!apiKey) {
-      throw new Error(`No credentials available for ${model.provider}/${model.id}.`);
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok || !auth.apiKey) {
+      throw new Error(auth.ok ? `No credentials available for ${model.provider}/${model.id}.` : auth.error);
     }
 
     const { session } = await createAgentSession({
@@ -1837,7 +2136,10 @@ export default function (pi: ExtensionAPI) {
 
     if (expanded && details) {
       lines.push(
-        theme.fg("dim", `model: ${details.provider}/${details.model} · thinking: ${details.thinkingLevel}`),
+        theme.fg(
+          "dim",
+          `model: ${details.provider}/${details.model} (${details.api ?? "openai-responses"}) · thinking: ${details.thinkingLevel}`,
+        ),
       );
 
       if (details.usage) {
@@ -1865,10 +2167,6 @@ export default function (pi: ExtensionAPI) {
     await restoreThread(ctx);
   });
 
-  pi.on("session_switch", async (_event, ctx) => {
-    await restoreThread(ctx);
-  });
-
   pi.on("session_tree", async (_event, ctx) => {
     await restoreThread(ctx);
   });
@@ -1881,7 +2179,7 @@ export default function (pi: ExtensionAPI) {
   for (const shortcut of BTW_FOCUS_SHORTCUTS) {
     pi.registerShortcut(shortcut, {
       description: "Toggle BTW overlay focus while leaving it open.",
-      handler: async (_args, _ctx) => {
+      handler: async (_ctx) => {
         toggleOverlayFocus();
       },
     });
@@ -1928,4 +2226,18 @@ export default function (pi: ExtensionAPI) {
       await dispatchBtwCommand("btw:summarize", args, ctx);
     },
   });
+
+  pi.registerCommand("btw:model", {
+    description: "Show, set, or clear the BTW-only model override.",
+    handler: async (args, ctx) => {
+      await dispatchBtwCommand("btw:model", args, ctx);
+    },
+  });
+
+  pi.registerCommand("btw:thinking", {
+    description: "Show, set, or clear the BTW-only thinking override.",
+    handler: async (args, ctx) => {
+      await dispatchBtwCommand("btw:thinking", args, ctx);
+    },
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-btw",
-  "version": "0.2.1",
+  "version": "0.3.8",
   "description": "A pi extension for parallel side conversations with /btw",
   "type": "module",
   "license": "MIT",
@@ -42,11 +42,12 @@
     "image": "https://raw.githubusercontent.com/dbachelder/pi-btw/main/docs/btw-overlay.png"
   },
   "peerDependencies": {
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*"
+    "@mariozechner/pi-ai": "^0.66.1",
+    "@mariozechner/pi-coding-agent": "^0.66.1",
+    "@mariozechner/pi-tui": "^0.66.1"
   },
   "devDependencies": {
+    "typescript": "^6.0.2",
     "vitest": "^4.1.0"
   }
 }