pi-spark 0.15.0 → 0.17.0

package/README.md

@@ -36,7 +36,7 @@ pi-spark ships with custom editor, footer, and fullscreen rendering, replacing t
 
 pi-spark shows the active provider's credit balance or rate-limit usage in the status line, so you can keep an eye on what's left without leaving the terminal.
 
-- Supported providers: DeepSeek, Fireworks, Moonshot, OpenAI Codex, OpenRouter, and Vercel AI Gateway.
+- Supported providers: DeepSeek, Fireworks, Kimi Code, Moonshot, OpenAI Codex, OpenRouter, and Vercel AI Gateway.
 - Most provider fetching follows [CodexBar](https://github.com/steipete/codexbar). Fireworks is the exception: its balance sits behind an internal gRPC API, reverse-engineered from the `firectl` binary (see [docs/fireworks.md](./docs/fireworks.md)).
 
 ![Credits](./assets/screenshot-credits.png)
@@ -57,10 +57,19 @@ pi-spark generates a short recap of the current session after it goes idle, or o
 
 - A recap is generated automatically once the session stays idle past `recap.idle` in `spark.json`.
 - Run `/recap` to generate one manually at any time.
-- The recap can use its own model, configured separately from your working model.
+- The recap generation can use its own model, configured separately from your working model.
 
 ![Recap](./assets/screenshot-recap.png)
 
+### Title
+
+pi-spark names the session automatically after the first exchange, so it's easy to find later in the session selector.
+
+- After the first message is sent and the agent replies, pi-spark generates a short title from the conversation and sets it as the session name.
+- Generation is silent: nothing is shown in the UI, and the usage is recorded in a session entry like the recap.
+- Sessions that already have a name are left untouched.
+- The title generation can use its own model, configured separately from your working model.
+
 ## Configuration
 
 pi-spark reads config from `~/.pi/agent/spark.json` and from the current project's `.pi/spark.json`. Project config overrides matching global fields.
@@ -90,6 +99,11 @@ For example:
     "provider": "openai-codex",
     "model": "gpt-5.4-mini",
     "thinkingLevel": "off"
+  },
+  "title": {
+    "provider": "openai-codex",
+    "model": "gpt-5.4-mini",
+    "thinkingLevel": "off"
   }
 }
 ```
@@ -106,6 +120,7 @@ All fields are optional. Each top-level feature runs with the defaults below unl
 | `fullscreen` | `{}` | Clears the screen and scrollback on start and exit, and pins the editor and footer to the bottom. |
 | `presets` | `{ [name]: Preset }` | Defines named model presets, keyed by name. |
 | `recap` | `RecapConfig` | Generates a session recap when idle or on demand. |
+| `title` | `TitleConfig` | Names the session automatically after the first exchange. |
 
 #### `EditorConfig`
 
@@ -130,14 +145,24 @@ Each preset must set all three fields.
 
 #### `RecapConfig`
 
-All fields are optional, including `thinkingLevel`. If the recap model configuration is incomplete, pi-spark falls back to the session's main model.
+All fields are optional. If the recap model configuration is incomplete, pi-spark falls back to the session's main model. `thinkingLevel` defaults to `off` (clamped to the model), so recap stays cheap regardless of your working thinking level.
 
 | Field | Value | Description |
 | --- | --- | --- |
 | `idle` | number (ms) or duration string | How long the session must stay idle before a recap is generated. Accepts a millisecond number or a [vercel/ms](https://github.com/vercel/ms) string (e.g., `"5m"`); minimum 5000 ms, defaults to 5 minutes. |
 | `provider` | string | Provider ID for the recap model. |
 | `model` | string | Model ID for the recap model. |
-| `thinkingLevel` | `ModelThinkingLevel` | Thinking level for the recap model. |
+| `thinkingLevel` | `ModelThinkingLevel` | Thinking level for the recap model. Defaults to `off`. |
+
+#### `TitleConfig`
+
+All fields are optional. If the title model configuration is incomplete, pi-spark falls back to the session's main model. `thinkingLevel` defaults to `off` (clamped to the model), so title generation stays cheap regardless of your working thinking level.
+
+| Field | Value | Description |
+| --- | --- | --- |
+| `provider` | string | Provider ID for the title model. |
+| `model` | string | Model ID for the title model. |
+| `thinkingLevel` | `ModelThinkingLevel` | Thinking level for the title model. Defaults to `off`. |
 
 #### `ModelThinkingLevel`
 

package/index.ts

@@ -5,6 +5,7 @@ import { registerFooter } from "./src/features/footer";
 import { registerFullscreen } from "./src/features/fullscreen";
 import { registerPresets } from "./src/features/presets";
 import { registerRecap } from "./src/features/recap";
+import { registerTitle } from "./src/features/title";
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
@@ -24,4 +25,5 @@ export default function (pi: ExtensionAPI) {
   registerFullscreen(pi);
   registerPresets(pi);
   registerRecap(pi);
+  registerTitle(pi);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-spark",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "Pi package that polishes your daily experience.",
   "keywords": [
     "pi-coding-agent",

package/src/config/schema.ts

@@ -6,6 +6,7 @@ import { footerConfigSchema } from "../features/footer/config";
 import { fullscreenConfigSchema } from "../features/fullscreen/config";
 import { presetsConfigSchema } from "../features/presets/config";
 import { recapConfigSchema } from "../features/recap/config";
+import { titleConfigSchema } from "../features/title/config";
 
 /**
  * Raw option shape for each feature. The enable/disable/default policy lives in `loadConfig`:
@@ -19,6 +20,7 @@ export const featureSchemas = {
   fullscreen: fullscreenConfigSchema,
   presets: presetsConfigSchema,
   recap: recapConfigSchema,
+  title: titleConfigSchema,
 } as const;
 
 /** Resolved config for every feature; `false` means the feature is disabled. */

package/src/features/credits/providers/index.ts

@@ -1,5 +1,6 @@
 import { deepseekProvider } from "./deepseek";
 import { fireworksProvider } from "./fireworks";
+import { kimiCodeProvider } from "./kimi-code";
 import { moonshotProvider, moonshotCnProvider } from "./moonshot";
 import { openaiCodexProvider } from "./openai-codex";
 import { openrouterProvider } from "./openrouter";
@@ -10,6 +11,7 @@ import type { CreditsProvider } from "../types";
 const PROVIDERS: CreditsProvider[] = [
   deepseekProvider,
   fireworksProvider,
+  kimiCodeProvider,
   moonshotProvider,
   moonshotCnProvider,
   openaiCodexProvider,

package/src/features/credits/providers/kimi-code.ts

@@ -0,0 +1,69 @@
+import { toNumber } from "../../../utils/format";
+
+import type { Credits, CreditsLane, CreditsProvider } from "../types";
+
+const PROVIDER = "kimi-coding";
+const URL = "https://api.kimi.com/coding/v1/usages";
+
+interface KimiCodeUsageResponse {
+  usage?: { used?: string | number } | null;
+  limits?: {
+    window?: { duration?: number; timeUnit?: string } | null;
+    detail?: { used?: string | number } | null;
+  }[] | null;
+}
+
+function toPercent(used: number | undefined): number | undefined {
+  if (used === undefined) return undefined;
+  return Math.min(100, Math.max(0, used));
+}
+
+function formatWindowLabel(window?: { duration?: number; timeUnit?: string } | null): string {
+  if (!window?.duration) return "Limit";
+
+  const duration = window.duration;
+  const unit = window.timeUnit?.toUpperCase() ?? "";
+
+  if (unit === "TIME_UNIT_MINUTE") {
+    if (duration >= 60 && duration % 60 === 0) return `${duration / 60}h`;
+    return `${duration}m`;
+  }
+  if (unit === "TIME_UNIT_HOUR") return `${duration}h`;
+  if (unit === "TIME_UNIT_DAY") return `${duration}d`;
+  if (unit === "TIME_UNIT_MONTH") return `${duration}mo`;
+  return `${duration}${unit.replace("TIME_UNIT_", "").toLowerCase()}`;
+}
+
+function buildLane(label: string, detail?: KimiCodeUsageResponse["usage"]): CreditsLane {
+  return { label, percent: toPercent(toNumber(detail?.used)) };
+}
+
+export const kimiCodeProvider: CreditsProvider = {
+  id: PROVIDER,
+  label: "Kimi Code",
+
+  async fetch(_ctx, apiKey, signal): Promise<Credits> {
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    };
+
+    const response = await fetch(URL, { headers, signal });
+    if (!response.ok) throw new Error("request failed");
+
+    const payload = (await response.json()) as KimiCodeUsageResponse;
+    const lanes: CreditsLane[] = [];
+
+    payload.limits?.forEach((item) => {
+      if (!item) return;
+
+      const label = formatWindowLabel(item.window);
+      lanes.push(buildLane(label, item.detail));
+    });
+
+    const weeklyLane = buildLane("7d", payload.usage);
+    lanes.push(weeklyLane);
+
+    return { type: "windows", lanes };
+  },
+};

package/src/features/credits/providers/openai-codex.ts

@@ -11,16 +11,14 @@ interface CodexUsageResponse {
     primary_window?: CodexRateWindow | null;
     secondary_window?: CodexRateWindow | null;
   } | null;
-  credits?: {
-    unlimited?: boolean;
-  } | null;
+  credits?: { unlimited?: boolean } | null;
 }
 
 interface CodexRateWindow {
   used_percent?: number | string;
 }
 
-export function getAccountId(ctx: ExtensionContext): string | undefined {
+function getAccountId(ctx: ExtensionContext): string | undefined {
   const credential = ctx.modelRegistry.authStorage.get(PROVIDER) as { accountId?: string } | undefined;
   const accountId = credential?.accountId;
 

package/src/features/credits/types.ts

@@ -1,4 +1,4 @@
-import type { Provider } from "@earendil-works/pi-ai";
+import type { ProviderId } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 /**
@@ -18,7 +18,7 @@ export interface CreditsLane {
 
 /** A credits source for a Pi provider, shown in the status line while that provider is active. */
 export interface CreditsProvider {
-  readonly id: Provider;
+  readonly id: ProviderId;
   readonly label: string;
   fetch(ctx: ExtensionContext, apiKey: string, signal: AbortSignal): Promise<Credits>;
 }

package/src/features/footer/index.ts

@@ -4,10 +4,12 @@ import { pathToFileURL } from "node:url";
 
 import { SplitLine } from "../../components/split-line";
 import { loadConfig } from "../../config";
-import { formatContextUsage, formatCost, formatCwd, linkText, sanitizeText } from "../../utils/format";
+import { formatContextUsage, formatCost, formatCwd, sanitizeText } from "../../utils/format";
 import { isFreeModel } from "../../utils/model";
 import { getEntryUsage } from "../../utils/usage";
 
+import { hyperlink } from "@earendil-works/pi-tui";
+
 import type { ExtensionContext, ExtensionAPI, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
 
@@ -36,7 +38,7 @@ class FooterComponent implements Component {
   private getLeft(): string {
     const cwd = this.ctx.sessionManager.getCwd();
     const url = pathToFileURL(resolve(cwd));
-    const cwdText = linkText(formatCwd(cwd, homedir()), url.href);
+    const cwdText = hyperlink(formatCwd(cwd, homedir()), url.href);
     const branch = this.footerData.getGitBranch();
     const sessionName = this.ctx.sessionManager.getSessionName();
 

package/src/features/presets/selector.ts

@@ -20,7 +20,7 @@ export async function showPresetSelector(ctx: ExtensionContext, presetManager: P
       }));
 
     const container = new Container();
-    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    container.addChild(new DynamicBorder((s: string) => theme.fg("border", s)));
 
     const box = new Box(1, 1);
     box.addChild(new Text(theme.bold(theme.fg("accent", "Select preset")), 0, 0));
@@ -46,7 +46,7 @@ export async function showPresetSelector(ctx: ExtensionContext, presetManager: P
     box.addChild(new Text(keyHints.join("  "), 0, 0));
 
     container.addChild(box);
-    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    container.addChild(new DynamicBorder((s: string) => theme.fg("border", s)));
 
     return {
       render: (width: number) => container.render(width),

package/src/features/recap/manager.ts

@@ -1,9 +1,9 @@
-import { completeSimple } from "@earendil-works/pi-ai";
+import { completeSimple } from "@earendil-works/pi-ai/compat";
 import { convertToLlm, serializeConversation } from "@earendil-works/pi-coding-agent";
 
-import { resolveRecapModelSettings } from "./model";
 import { clearRecapWidget, setRecapLoadingWidget, setRecapTextWidget } from "./widget";
 import { sanitizeText } from "../../utils/format";
+import { resolveModelSettings } from "../../utils/model";
 
 import type { Api, Model, ModelThinkingLevel, SimpleStreamOptions, Usage } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -16,7 +16,7 @@ const SYSTEM_PROMPT = [
   "Summarize the user's goal, what was done, current state, and any clearly supported next step.",
   "Respond in the conversation's primary language. Address the user in the second person.",
   "Output 1-2 plain-text sentences under 40 words. No heading, markdown, bullets, or quotes.",
-].join("\n");
+].join(" ");
 
 const MAX_TOKENS = 80;
 const MAX_CONVERSATION_CHARS = 8_000;
@@ -40,10 +40,10 @@ export class RecapManager {
     this.inflight = controller;
 
     try {
-      const recapModelSettings = await resolveRecapModelSettings(this.pi, ctx, this.config);
-      if (controller.signal.aborted || this.inflight !== controller || !recapModelSettings) return;
+      const modelSettings = await resolveModelSettings(ctx, this.config, "recap");
+      if (controller.signal.aborted || this.inflight !== controller || !modelSettings) return;
 
-      const { model, thinkingLevel, warning } = recapModelSettings;
+      const { model, thinkingLevel, warning } = modelSettings;
 
       setRecapLoadingWidget(ctx, warning);
       this.active = false;

package/src/features/title/config.ts

@@ -0,0 +1,7 @@
+import * as z from "zod";
+
+import { optionalModelSchema } from "../../config/model";
+
+export const titleConfigSchema = optionalModelSchema;
+
+export type TitleConfig = z.infer<typeof titleConfigSchema>;

package/src/features/title/index.ts

@@ -0,0 +1,26 @@
+import { TitleManager } from "./manager";
+import { loadConfig } from "../../config";
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export function registerTitle(pi: ExtensionAPI): void {
+  let titleManager: TitleManager | undefined = undefined;
+
+  pi.on("session_start", (_event, ctx) => {
+    const config = loadConfig(ctx).title;
+    if (!ctx.hasUI || !config) return;
+
+    titleManager = new TitleManager(pi, config);
+  });
+
+  // Generate the title after the first exchange, once the session has context to summarize.
+  // The manager runs at most once and skips sessions that already have a name.
+  pi.on("agent_end", (_event, ctx) => {
+    titleManager?.run(ctx);
+  });
+
+  pi.on("session_shutdown", () => {
+    titleManager?.dispose();
+    titleManager = undefined;
+  });
+}

package/src/features/title/manager.ts

@@ -0,0 +1,117 @@
+import { completeSimple } from "@earendil-works/pi-ai/compat";
+import { convertToLlm, serializeConversation } from "@earendil-works/pi-coding-agent";
+
+import { sanitizeText } from "../../utils/format";
+import { resolveModelSettings } from "../../utils/model";
+
+import type { Api, Model, ModelThinkingLevel, SimpleStreamOptions, Usage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { TitleConfig } from "./config";
+
+const SYSTEM_PROMPT = [
+  "You write a concise title for a terminal coding agent session.",
+  "Base the title only on the transcript; do not invent topics, files, or intent.",
+  "Capture the user's main goal or the session's central task.",
+  "Respond in the conversation's primary language.",
+  "Output a single title of 3-8 words. No trailing punctuation, quotes, markdown, or prefix like 'Title:'.",
+].join(" ");
+
+const MAX_TOKENS = 32;
+const MAX_TITLE_CHARS = 80;
+const MAX_CONVERSATION_CHARS = 8_000;
+
+export class TitleManager {
+  private pi: ExtensionAPI;
+  private config: TitleConfig;
+  private inflight: AbortController | undefined;
+
+  constructor(pi: ExtensionAPI, config: TitleConfig) {
+    this.pi = pi;
+    this.config = config;
+  }
+
+  /** Generate and set the session title once, silently, from the current context. */
+  async run(ctx: ExtensionContext): Promise<void> {
+    if (this.pi.getSessionName()) return;
+
+    this.cancelInflight();
+    const controller = new AbortController();
+    this.inflight = controller;
+
+    try {
+      const modelSettings = await resolveModelSettings(ctx, this.config, "title", { notifyOnMissingModel: false });
+      if (controller.signal.aborted || this.inflight !== controller || !modelSettings) return;
+
+      const { model, thinkingLevel } = modelSettings;
+      const result = await this.generate(ctx, model, thinkingLevel, controller.signal);
+      if (controller.signal.aborted || this.inflight !== controller || !result.content) return;
+
+      this.pi.setSessionName(result.content);
+      this.pi.appendEntry("title", {
+        provider: model.provider,
+        model: model.id,
+        usage: result.usage,
+        content: result.content,
+      });
+    } catch {
+      // Title generation is best-effort and silent; ignore failures.
+    } finally {
+      if (this.inflight === controller) this.inflight = undefined;
+    }
+  }
+
+  dispose(): void {
+    this.cancelInflight();
+  }
+
+  private async generate(ctx: ExtensionContext, model: Model<Api>, thinkingLevel: ModelThinkingLevel, signal: AbortSignal): Promise<{ content: string; usage: Usage }> {
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok) throw new Error(auth.error);
+
+    const options: SimpleStreamOptions = { maxTokens: MAX_TOKENS, signal };
+    if (auth.apiKey) options.apiKey = auth.apiKey;
+    if (auth.headers) options.headers = auth.headers;
+    if (thinkingLevel !== "off") options.reasoning = thinkingLevel;
+
+    const response = await completeSimple(model, {
+      systemPrompt: SYSTEM_PROMPT,
+      messages: [{
+        role: "user",
+        content: [{ type: "text", text: this.buildPrompt(ctx) }],
+        timestamp: Date.now(),
+      }],
+    }, options);
+
+    const content = response.content
+      .filter((block) => block.type === "text")
+      .map((block) => block.text)
+      .join("\n")
+      .trim();
+
+    return { content: this.normalizeTitle(content), usage: response.usage };
+  }
+
+  private buildPrompt(ctx: ExtensionContext): string {
+    const messages = ctx.sessionManager.getBranch().filter((entry) => entry.type === "message").map((entry) => entry.message);
+    const text = serializeConversation(convertToLlm(messages));
+    const conversation = text.length > MAX_CONVERSATION_CHARS ? text.slice(0, MAX_CONVERSATION_CHARS) : text;
+
+    return [
+      "Write a short title for this session, based on the transcript below.",
+      "",
+      "<conversation>",
+      conversation,
+      "</conversation>",
+    ].join("\n");
+  }
+
+  private normalizeTitle(content: string): string {
+    const title = sanitizeText(content).replace(/^["'`]+|["'`]+$/g, "").replace(/[.。!！?？]+$/g, "").trim();
+    return title.length > MAX_TITLE_CHARS ? title.slice(0, MAX_TITLE_CHARS).trim() : title;
+  }
+
+  private cancelInflight(): void {
+    this.inflight?.abort();
+    this.inflight = undefined;
+  }
+}

package/src/utils/format.ts

@@ -1,9 +1,9 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 
-import type { Provider } from "@earendil-works/pi-ai";
+import type { ProviderId } from "@earendil-works/pi-ai";
 import type { ContextUsage } from "@earendil-works/pi-coding-agent";
 
-export function formatModel(provider?: Provider, model?: string, thinkingLevel?: string): string {
+export function formatModel(provider?: ProviderId, model?: string, thinkingLevel?: string): string {
   return provider && model ? `${provider}/${model}${thinkingLevel ? `:${thinkingLevel}` : ""}` : "no-model";
 }
 
@@ -49,11 +49,6 @@ function shortenPath(path: string): string {
   }).join(sep);
 }
 
-/** Wrap text in an OSC 8 hyperlink while preserving the visible text. */
-export function linkText(text: string, url: string): string {
-  return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
-}
-
 /** Replace newlines, tabs, carriage returns with space, then collapse multiple spaces */
 export function sanitizeText(text: string): string {
   return text

package/src/utils/model.ts

@@ -1,6 +1,110 @@
-import type { Api, Model } from "@earendil-works/pi-ai";
+import { clampThinkingLevel } from "@earendil-works/pi-ai";
+
+import { formatModel } from "./format";
+
+import type { Api, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { OptionalModelConfig } from "../config/model";
+
+const DEFAULT_THINKING_LEVEL: ModelThinkingLevel = "off";
+
+export type ModelSettings = {
+  model: Model<Api>;
+  thinkingLevel: ModelThinkingLevel;
+  warning: string | undefined;
+};
+
+type ModelSelection = {
+  model: Model<Api>;
+  warning: string | undefined;
+};
+
+type ThinkingLevelSelection = {
+  thinkingLevel: ModelThinkingLevel;
+  warning: string | undefined;
+};
 
 /** Check if a model has zero costs for all categories. */
 export function isFreeModel(model: Model<Api>): boolean {
   return model.cost.input === 0 && model.cost.output === 0 && model.cost.cacheRead === 0 && model.cost.cacheWrite === 0;
 }
+
+/**
+ * Resolve the model and thinking level for a background feature (recap, title, ...).
+ *
+ * `feature` names the config section so warnings can point at the offending fields. When the
+ * feature's model config is incomplete or unavailable, this falls back to the session's main
+ * model and reports why via `warning`. Pass `notifyOnMissingModel: false` for silent features.
+ *
+ * The thinking level defaults to "off" (clamped to the model) when not set in config, so these
+ * background features stay cheap regardless of the working model's thinking level.
+ */
+export async function resolveModelSettings(ctx: ExtensionContext, config: OptionalModelConfig, feature: string, options: { notifyOnMissingModel?: boolean } = {}): Promise<ModelSettings | undefined> {
+  const fallbackModel = ctx.model;
+  if (!fallbackModel) {
+    if (options.notifyOnMissingModel ?? true) ctx.ui.notify(`No model selected for ${feature}`, "warning");
+    return;
+  }
+
+  const { model, warning: modelWarning } = await resolveModelSelection(ctx, config, feature, fallbackModel);
+  const { thinkingLevel, warning: thinkingLevelWarning } = resolveThinkingLevel(model, config.thinkingLevel ?? DEFAULT_THINKING_LEVEL);
+
+  return {
+    model,
+    thinkingLevel,
+    warning: [modelWarning, thinkingLevelWarning].filter(Boolean).join(" ") || undefined,
+  };
+}
+
+async function resolveModelSelection(ctx: ExtensionContext, config: OptionalModelConfig, feature: string, fallbackModel: Model<Api>): Promise<ModelSelection> {
+  if (!config.provider && !config.model) {
+    return {
+      model: fallbackModel,
+      warning: undefined,
+    };
+  }
+
+  if (!config.provider || !config.model) {
+    return {
+      model: fallbackModel,
+      warning: `Both ${feature}.provider and ${feature}.model are required; using the current model.`,
+    };
+  }
+
+  const model = ctx.modelRegistry.find(config.provider, config.model);
+  if (!model) {
+    return {
+      model: fallbackModel,
+      warning: `Model ${formatModel(config.provider, config.model)} not found; using the current model.`,
+    };
+  }
+
+  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+  if (!auth.ok) {
+    return {
+      model: fallbackModel,
+      warning: `Model ${formatModel(config.provider, config.model)} unavailable: ${auth.error}; using the current model.`,
+    };
+  }
+
+  return {
+    model,
+    warning: undefined,
+  };
+}
+
+function resolveThinkingLevel(model: Model<Api>, requested: ModelThinkingLevel): ThinkingLevelSelection {
+  const thinkingLevel = clampThinkingLevel(model, requested);
+  if (thinkingLevel === requested) {
+    return {
+      thinkingLevel,
+      warning: undefined,
+    };
+  }
+
+  const fallback = clampThinkingLevel(model, DEFAULT_THINKING_LEVEL);
+  return {
+    thinkingLevel: fallback,
+    warning: `Thinking level ${requested} is not supported by ${formatModel(model.provider, model.id)}; using ${fallback}.`,
+  };
+}

package/src/features/recap/model.ts

@@ -1,95 +0,0 @@
-import { clampThinkingLevel } from "@earendil-works/pi-ai";
-
-import { formatModel } from "../../utils/format";
-
-import type { Api, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { OptionalModelConfig } from "../../config/model";
-
-const DEFAULT_THINKING_LEVEL: ModelThinkingLevel = "off";
-
-type RecapModelSettings = {
-  model: Model<Api>;
-  thinkingLevel: ModelThinkingLevel;
-  warning: string | undefined;
-};
-
-type ModelSelection = {
-  model: Model<Api>;
-  warning: string | undefined;
-};
-
-type ThinkingLevelSelection = {
-  thinkingLevel: ModelThinkingLevel;
-  warning: string | undefined;
-};
-
-export async function resolveRecapModelSettings(pi: ExtensionAPI, ctx: ExtensionContext, config: OptionalModelConfig): Promise<RecapModelSettings | undefined> {
-  const fallbackModel = ctx.model;
-  if (!fallbackModel) {
-    ctx.ui.notify("No model selected for recap", "warning");
-    return;
-  }
-
-  const { model, warning: modelWarning } = await resolveModelSelection(ctx, config, fallbackModel);
-  const { thinkingLevel, warning: thinkingLevelWarning } = resolveThinkingLevel(model, config.thinkingLevel ?? pi.getThinkingLevel());
-
-  return {
-    model,
-    thinkingLevel,
-    warning: [modelWarning, thinkingLevelWarning].filter(Boolean).join(" ") || undefined,
-  };
-}
-
-async function resolveModelSelection(ctx: ExtensionContext, config: OptionalModelConfig, fallbackModel: Model<Api>): Promise<ModelSelection> {
-  if (!config.provider && !config.model) {
-    return {
-      model: fallbackModel,
-      warning: undefined,
-    };
-  }
-
-  if (!config.provider || !config.model) {
-    return {
-      model: fallbackModel,
-      warning: "Both recap.provider and recap.model are required; using the current model.",
-    };
-  }
-
-  const model = ctx.modelRegistry.find(config.provider, config.model);
-  if (!model) {
-    return {
-      model: fallbackModel,
-      warning: `Model ${formatModel(config.provider, config.model)} not found; using the current model.`,
-    };
-  }
-
-  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-  if (!auth.ok) {
-    return {
-      model: fallbackModel,
-      warning: `Model ${formatModel(config.provider, config.model)} unavailable: ${auth.error}; using the current model.`,
-    };
-  }
-
-  return {
-    model,
-    warning: undefined,
-  };
-}
-
-function resolveThinkingLevel(model: Model<Api>, requested: ModelThinkingLevel): ThinkingLevelSelection {
-  const thinkingLevel = clampThinkingLevel(model, requested);
-  if (thinkingLevel === requested) {
-    return {
-      thinkingLevel,
-      warning: undefined,
-    };
-  }
-
-  const fallback = clampThinkingLevel(model, DEFAULT_THINKING_LEVEL);
-  return {
-    thinkingLevel: fallback,
-    warning: `Thinking level ${requested} is not supported by ${formatModel(model.provider, model.id)}; using ${fallback}.`,
-  };
-}