pi-sessions 0.8.0 → 0.10.0

package/extensions/session-auto-title/generate.ts

@@ -1,9 +1,9 @@
 import { appendFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { Api, Model, TextContent, UserMessage } from "@earendil-works/pi-ai";
-import { completeSimple } from "@earendil-works/pi-ai/compat";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import type { AutoTitleContext } from "./context.ts";
 import type { AutoTitleTrigger } from "./state.ts";
 
@@ -17,6 +17,12 @@ export interface AutoTitleFailure {
   message: string;
 }
 
+export interface AutoTitleGeneration {
+  systemPrompt: string;
+  timeoutMs: number;
+  thinkingLevel: ThinkingLevel | undefined;
+}
+
 export type AutoTitleGenerationResult =
   | {
       ok: true;
@@ -28,12 +34,11 @@ export type AutoTitleGenerationResult =
     };
 
 export async function generateAutoTitle(
-  ctx: ExtensionContext,
+  modelRuntime: ModelRuntime,
   model: Model<Api>,
   context: AutoTitleContext,
   trigger: AutoTitleTrigger,
-  systemPrompt: string,
-  timeoutMs: number,
+  generation: AutoTitleGeneration,
 ): Promise<AutoTitleGenerationResult> {
   if (!context.conversationText) {
     return {
@@ -46,16 +51,11 @@ export async function generateAutoTitle(
     };
   }
 
-  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-  if (!auth.ok) {
-    return {
-      ok: false,
-      failure: createAutoTitleFailure(trigger, model, "Failed to authenticate auto-title model."),
-    };
-  }
-
   const shouldPreserveTitle = trigger === "periodic" && Boolean(context.currentTitle?.trim());
-  const resolvedSystemPrompt = buildAutoTitleSystemPrompt(systemPrompt, shouldPreserveTitle);
+  const resolvedSystemPrompt = buildAutoTitleSystemPrompt(
+    generation.systemPrompt,
+    shouldPreserveTitle,
+  );
   const userPrompt = buildAutoTitlePrompt(context, resolvedSystemPrompt, shouldPreserveTitle);
   const message: UserMessage = {
     role: "user",
@@ -64,7 +64,8 @@ export async function generateAutoTitle(
   };
 
   const abortController = new AbortController();
-  const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+  const timeoutId = setTimeout(() => abortController.abort(), generation.timeoutMs);
+  const thinkingLevel = generation.thinkingLevel;
 
   try {
     const requestContext = {
@@ -72,10 +73,9 @@ export async function generateAutoTitle(
       messages: [message],
     };
     writeAutoTitleDebugRequest(model, trigger, requestContext);
-    const response = await completeSimple(model, requestContext, {
-      ...(auth.apiKey && { apiKey: auth.apiKey }),
-      ...(auth.headers && { headers: auth.headers }),
+    const response = await modelRuntime.completeSimple(model, requestContext, {
       maxTokens: AUTO_TITLE_MAX_TOKENS,
+      ...(thinkingLevel && thinkingLevel !== "off" ? { reasoning: thinkingLevel } : {}),
       signal: abortController.signal,
     });
     writeAutoTitleDebugResponse(model, trigger, response);

package/extensions/{session-auto-title.ts → session-auto-title/install.ts}

@@ -3,37 +3,30 @@ import type {
   ExtensionAPI,
   ExtensionCommandContext,
   ExtensionContext,
-  SessionStartEvent,
+  ModelRuntime,
   TurnEndEvent,
 } from "@earendil-works/pi-coding-agent";
+import type { SessionLifecycle } from "../shared/composition.ts";
+import type { ModelRuntimeProvider } from "../shared/model-runtime.ts";
+import { isTuiMode } from "../shared/pi-mode.ts";
+import type { SessionSettings } from "../shared/settings.ts";
 import {
   createSessionAutoTitleCommandHandler,
   getRetitleArgumentCompletions,
   type RetitleCommandInvocation,
   type RetitleCommandOutcome,
-} from "./session-auto-title/command.ts";
-import {
-  createSessionAutoTitleController,
-  type SessionAutoTitleController,
-} from "./session-auto-title/controller.ts";
-import { resolveAutoTitleModel } from "./session-auto-title/model.ts";
+} from "./command.ts";
+import { createSessionAutoTitleController, type SessionAutoTitleController } from "./controller.ts";
+import type { AutoTitleGeneration } from "./generate.ts";
+import { type AutoTitleModelResolution, resolveAutoTitleModel } from "./model.ts";
 import {
   buildRetitleScopeScan,
   notifyBulkRetitleResult,
   persistAutoTitleState,
   runBulkRetitle,
   runRetitlePlan,
-} from "./session-auto-title/retitle.ts";
-import { showRetitleWizard } from "./session-auto-title/wizard.ts";
-import { isTuiMode } from "./shared/pi-mode.ts";
-import { loadSettings } from "./shared/settings.ts";
-
-export {
-  createSessionAutoTitleCommandHandler,
-  getRetitleArgumentCompletions,
-  parseRetitleCommand,
-  TITLE_USAGE,
-} from "./session-auto-title/command.ts";
+} from "./retitle.ts";
+import { showRetitleWizard } from "./wizard.ts";
 
 interface TitleRunState {
   controller: SessionAutoTitleController;
@@ -42,12 +35,26 @@ interface TitleRunState {
   clearInFlight: () => void;
 }
 
-export default function sessionAutoTitleExtension(pi: ExtensionAPI): void {
-  const settings = loadSettings();
+export function installAutoTitle(
+  pi: ExtensionAPI,
+  deps: {
+    settings: SessionSettings;
+    getModelRuntime: ModelRuntimeProvider;
+    getSessionEpoch: () => number;
+  },
+): SessionLifecycle {
+  const { settings, getModelRuntime, getSessionEpoch } = deps;
   const controller = createSessionAutoTitleController(settings.autoTitle);
-  let sessionEpoch = 0;
   let titleWorkInFlight: Promise<void> | undefined;
-  let resolvedModel: Model<Api> | undefined;
+
+  // An explicit thinkingLevel setting overrides a thinking suffix on the configured model.
+  const buildGeneration = (
+    resolution: AutoTitleModelResolution | undefined,
+  ): AutoTitleGeneration => ({
+    systemPrompt: settings.autoTitle.prompt,
+    timeoutMs: settings.autoTitle.timeoutMs,
+    thinkingLevel: settings.autoTitle.thinkingLevel ?? resolution?.thinkingLevel,
+  });
 
   pi.registerCommand("title", {
     description: "Generate titles for this session, this folder, or all of Pi",
@@ -58,12 +65,13 @@ export default function sessionAutoTitleExtension(pi: ExtensionAPI): void {
           await titleWorkInFlight;
         }
 
-        const model = resolvedModel ?? resolveAutoTitleModel(ctx, settings.autoTitle.model)?.model;
+        const modelRuntime = await getModelRuntime(ctx.modelRegistry);
+        const resolution = resolveAutoTitleModel(modelRuntime, ctx.model, settings.autoTitle.model);
         return handleTitleInvocation(
           pi,
           {
             controller,
-            getSessionEpoch: () => sessionEpoch,
+            getSessionEpoch,
             setInFlight: (work) => {
               titleWorkInFlight = work;
             },
@@ -72,21 +80,15 @@ export default function sessionAutoTitleExtension(pi: ExtensionAPI): void {
             },
           },
           ctx,
-          model,
+          modelRuntime,
+          resolution?.model,
           invocation,
-          settings.autoTitle.prompt,
-          settings.autoTitle.timeoutMs,
+          buildGeneration(resolution),
         );
       },
     ),
   });
 
-  pi.on("session_start", async (_event: SessionStartEvent, ctx: ExtensionContext) => {
-    sessionEpoch += 1;
-    resolvedModel = resolveAutoTitleModel(ctx, settings.autoTitle.model)?.model;
-    persistAutoTitleState(pi, controller.handleSessionStart(ctx));
-  });
-
   pi.on("turn_end", async (_event: TurnEndEvent, ctx: ExtensionContext) => {
     const result = controller.handleTurnEnd(ctx);
     persistAutoTitleState(pi, result.persistedState);
@@ -95,17 +97,19 @@ export default function sessionAutoTitleExtension(pi: ExtensionAPI): void {
       return;
     }
 
+    const modelRuntime = await getModelRuntime(ctx.modelRegistry);
+    const resolution = resolveAutoTitleModel(modelRuntime, ctx.model, settings.autoTitle.model);
     titleWorkInFlight = runRetitlePlan({
       pi,
       controller,
       ctx,
-      model: resolvedModel,
+      modelRuntime,
+      model: resolution?.model,
       isManual: false,
       existingPlan: result.plan,
-      getSessionEpoch: () => sessionEpoch,
+      getSessionEpoch,
       notifyOnSuccess: false,
-      systemPrompt: settings.autoTitle.prompt,
-      timeoutMs: settings.autoTitle.timeoutMs,
+      generation: buildGeneration(resolution),
     })
       .then((outcome) => {
         if (outcome.ok) {
@@ -126,31 +130,34 @@ export default function sessionAutoTitleExtension(pi: ExtensionAPI): void {
       });
   });
 
-  pi.on("session_shutdown", async () => {
-    sessionEpoch += 1;
-    controller.handleSessionShutdown();
-    titleWorkInFlight = undefined;
-    resolvedModel = undefined;
-  });
+  return {
+    onSessionStart(_event, ctx) {
+      persistAutoTitleState(pi, controller.handleSessionStart(ctx));
+    },
+    onSessionShutdown() {
+      controller.handleSessionShutdown();
+      titleWorkInFlight = undefined;
+    },
+  };
 }
 
 async function handleTitleInvocation(
   pi: ExtensionAPI,
   state: TitleRunState,
   ctx: ExtensionCommandContext,
+  modelRuntime: ModelRuntime,
   model: Model<Api> | undefined,
   invocation: RetitleCommandInvocation,
-  systemPrompt: string,
-  timeoutMs: number,
+  generation: AutoTitleGeneration,
 ): Promise<RetitleCommandOutcome> {
   const retitleOpts = {
     pi,
     controller: state.controller,
     ctx,
+    modelRuntime,
     model,
     isManual: true,
-    systemPrompt,
-    timeoutMs,
+    generation,
     getSessionEpoch: state.getSessionEpoch,
   };
 
@@ -173,10 +180,10 @@ async function handleTitleInvocation(
       pi,
       state.controller,
       ctx,
+      modelRuntime,
       model,
       state.getSessionEpoch,
-      systemPrompt,
-      timeoutMs,
+      generation,
     );
   }
 
@@ -189,10 +196,10 @@ async function handleTitleInvocation(
       pi,
       state.controller,
       ctx,
+      modelRuntime,
       model,
       state.getSessionEpoch,
-      systemPrompt,
-      timeoutMs,
+      generation,
       {
         initialInvocation: {
           scope: invocation.scope,
@@ -209,12 +216,12 @@ async function handleTitleInvocation(
       pi,
       state.controller,
       ctx,
+      modelRuntime,
       model,
       scan,
       mode,
       state.getSessionEpoch,
-      systemPrompt,
-      timeoutMs,
+      generation,
     );
     notifyBulkRetitleResult(ctx, scan, mode, result);
     return "success";

package/extensions/session-auto-title/model.ts

@@ -1,12 +1,15 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { Api, Model } from "@earendil-works/pi-ai";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { findModelByReference } from "../shared/model.ts";
-import { ModelReference } from "../shared/settings.ts";
-
-const DEFAULT_AUTO_TITLE_FALLBACK_MODELS: readonly ModelReference[] = [
-  new ModelReference("google", "gemini-flash-lite-latest"),
-  new ModelReference("anthropic", "claude-haiku-4-5"),
-  new ModelReference("openai", "gpt-5.4-mini"),
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { type ExactModelReference, findModelByReference } from "../shared/model.ts";
+import { resolveAuthenticatedModel } from "../shared/model-resolution.ts";
+import { freshenModel } from "../shared/model-runtime.ts";
+
+const DEFAULT_AUTO_TITLE_FALLBACK_MODELS: readonly ExactModelReference[] = [
+  { provider: "openai-codex", modelId: "gpt-5.6-luna" },
+  { provider: "openai", modelId: "gpt-5.6-luna" },
+  { provider: "anthropic", modelId: "claude-haiku-4-5" },
+  { provider: "google", modelId: "gemini-flash-lite-latest" },
 ] as const;
 
 export type AutoTitleModelSource = "configured" | "fallback" | "current";
@@ -14,24 +17,29 @@ export type AutoTitleModelSource = "configured" | "fallback" | "current";
 export interface AutoTitleModelResolution {
   model: Model<Api>;
   source: AutoTitleModelSource;
+  thinkingLevel?: ThinkingLevel | undefined;
 }
 
 export function resolveAutoTitleModel(
-  ctx: ExtensionContext,
-  configuredModel: ModelReference | undefined,
+  modelRuntime: ModelRuntime,
+  currentModel: Model<Api> | undefined,
+  configuredModel: string | undefined,
 ): AutoTitleModelResolution | undefined {
-  const availableModels = ctx.modelRegistry.getAvailable();
-
   if (configuredModel) {
-    const configuredMatch = findModelByReference(availableModels, configuredModel);
-    if (configuredMatch) {
+    const configured = resolveAuthenticatedModel({
+      modelRuntime,
+      modelPattern: configuredModel,
+    });
+    if (configured.ok) {
       return {
-        model: configuredMatch,
+        model: configured.model,
         source: "configured",
+        thinkingLevel: configured.thinkingLevel,
       };
     }
   }
 
+  const availableModels = modelRuntime.getAvailableSnapshot();
   for (const fallbackReference of DEFAULT_AUTO_TITLE_FALLBACK_MODELS) {
     const fallbackMatch = findModelByReference(availableModels, fallbackReference);
     if (fallbackMatch) {
@@ -42,12 +50,12 @@ export function resolveAutoTitleModel(
     }
   }
 
-  if (!ctx.model) {
+  if (!currentModel) {
     return undefined;
   }
 
   return {
-    model: ctx.model,
+    model: freshenModel(modelRuntime, currentModel),
     source: "current",
   };
 }

package/extensions/session-auto-title/retitle.ts

@@ -3,6 +3,7 @@ import type {
   ExtensionAPI,
   ExtensionCommandContext,
   ExtensionContext,
+  ModelRuntime,
   SessionInfo,
 } from "@earendil-works/pi-coding-agent";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
@@ -10,6 +11,7 @@ import type { RetitleMode, RetitleScope } from "./command.ts";
 import { buildAutoTitleContext } from "./context.ts";
 import type { AutoTitleTriggerPlan, SessionAutoTitleController } from "./controller.ts";
 import {
+  type AutoTitleGeneration,
   type AutoTitleGenerationResult,
   createAutoTitleFailure,
   generateAutoTitle,
@@ -53,12 +55,12 @@ export async function runBulkRetitle(
   pi: ExtensionAPI,
   controller: SessionAutoTitleController,
   ctx: ExtensionCommandContext,
+  modelRuntime: ModelRuntime,
   model: Model<Api> | undefined,
   scan: RetitleScopeScan,
   mode: RetitleMode,
   getSessionEpoch: () => number,
-  systemPrompt: string,
-  timeoutMs: number,
+  generation: AutoTitleGeneration,
 ): Promise<BulkRetitleResult> {
   const result: BulkRetitleResult = {
     attempted: 0,
@@ -83,10 +85,10 @@ export async function runBulkRetitle(
         pi,
         controller,
         ctx,
+        modelRuntime,
         model,
         isManual: true,
-        systemPrompt,
-        timeoutMs,
+        generation,
         getSessionEpoch,
         notifyOnSuccess: false,
       });
@@ -94,7 +96,7 @@ export async function runBulkRetitle(
       continue;
     }
 
-    const outcome = await retitleStoredSession(ctx, model, session.path, systemPrompt, timeoutMs);
+    const outcome = await retitleStoredSession(modelRuntime, model, session.path, generation);
     result[outcome] += 1;
   }
 
@@ -164,10 +166,10 @@ export interface RetitlePlanOptions {
   pi: ExtensionAPI;
   controller: SessionAutoTitleController;
   ctx: ExtensionContext;
+  modelRuntime: ModelRuntime;
   model: Model<Api> | undefined;
   isManual: boolean;
-  systemPrompt: string;
-  timeoutMs: number;
+  generation: AutoTitleGeneration;
   existingPlan?: AutoTitleTriggerPlan;
   getSessionEpoch?: () => number;
   notifyOnSuccess?: boolean;
@@ -180,10 +182,10 @@ export async function runRetitlePlan(
     pi,
     controller,
     ctx,
+    modelRuntime,
     model,
     isManual,
-    systemPrompt,
-    timeoutMs,
+    generation,
     existingPlan,
     getSessionEpoch,
   } = options;
@@ -218,12 +220,11 @@ export async function runRetitlePlan(
     },
   );
   const generatedTitle = await generateAutoTitle(
-    ctx,
+    modelRuntime,
     model,
     titleContext,
     plan.reason,
-    systemPrompt,
-    timeoutMs,
+    generation,
   );
   if (!generatedTitle.ok) {
     return generatedTitle;
@@ -266,11 +267,10 @@ export function persistAutoTitleState(
 }
 
 async function retitleStoredSession(
-  ctx: ExtensionContext,
+  modelRuntime: ModelRuntime,
   model: Model<Api>,
   sessionPath: string,
-  systemPrompt: string,
-  timeoutMs: number,
+  generation: AutoTitleGeneration,
 ): Promise<"retitled" | "unchanged" | "failed"> {
   const sessionManager = SessionManager.open(sessionPath);
   const currentTitle = sessionManager.getSessionName();
@@ -288,12 +288,11 @@ async function retitleStoredSession(
     currentTitle,
   };
   const generatedTitle = await generateAutoTitle(
-    ctx,
+    modelRuntime,
     model,
     titleContext,
     plan.reason,
-    systemPrompt,
-    timeoutMs,
+    generation,
   );
   if (!generatedTitle.ok) {
     return "failed";

package/extensions/session-auto-title/wizard.ts

@@ -3,13 +3,14 @@ import {
   copyToClipboard,
   type ExtensionAPI,
   type ExtensionCommandContext,
+  type ModelRuntime,
   type Theme,
 } from "@earendil-works/pi-coding-agent";
 import type { Focusable, TUI } from "@earendil-works/pi-tui";
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { RetitleCommandOutcome, RetitleMode, RetitleScope } from "./command.ts";
 import type { AutoRetitleStatus, SessionAutoTitleController } from "./controller.ts";
-import type { AutoTitleFailure } from "./generate.ts";
+import type { AutoTitleFailure, AutoTitleGeneration } from "./generate.ts";
 import {
   buildBulkRetitleMessage,
   buildRetitleScopeScan,
@@ -54,10 +55,10 @@ export async function showRetitleWizard(
   pi: ExtensionAPI,
   controller: SessionAutoTitleController,
   ctx: ExtensionCommandContext,
+  modelRuntime: ModelRuntime,
   model: Model<Api> | undefined,
   getSessionEpoch: () => number,
-  systemPrompt: string,
-  timeoutMs: number,
+  generation: AutoTitleGeneration,
   options?: RetitleWizardOptions,
 ): Promise<RetitleCommandOutcome> {
   return ctx.ui.custom<RetitleCommandOutcome>(
@@ -68,10 +69,10 @@ export async function showRetitleWizard(
         pi,
         controller,
         ctx,
+        modelRuntime,
         model,
         getSessionEpoch,
-        systemPrompt,
-        timeoutMs,
+        generation,
         done,
         options,
       ),
@@ -98,10 +99,10 @@ class RetitleWizardPanel implements Focusable {
     private readonly pi: ExtensionAPI,
     private readonly controller: SessionAutoTitleController,
     private readonly ctx: ExtensionCommandContext,
+    private readonly modelRuntime: ModelRuntime,
     private readonly model: Model<Api> | undefined,
     private readonly getSessionEpoch: () => number,
-    private readonly systemPrompt: string,
-    private readonly timeoutMs: number,
+    private readonly generation: AutoTitleGeneration,
     private readonly done: (result: RetitleCommandOutcome) => void,
     options?: RetitleWizardOptions,
   ) {
@@ -250,10 +251,10 @@ class RetitleWizardPanel implements Focusable {
       pi: this.pi,
       controller: this.controller,
       ctx: this.ctx,
+      modelRuntime: this.modelRuntime,
       model: this.model,
       isManual: true,
-      systemPrompt: this.systemPrompt,
-      timeoutMs: this.timeoutMs,
+      generation: this.generation,
       getSessionEpoch: this.getSessionEpoch,
     });
     if (result.ok) {
@@ -309,12 +310,12 @@ class RetitleWizardPanel implements Focusable {
       this.pi,
       this.controller,
       this.ctx,
+      this.modelRuntime,
       this.model,
       scan,
       mode,
       this.getSessionEpoch,
-      this.systemPrompt,
-      this.timeoutMs,
+      this.generation,
     );
     notifyBulkRetitleResult(this.ctx, scan, mode, result);
     this.done(