pi-sessions 0.7.2 → 0.9.0

package/extensions/session-ask/presenter.ts

@@ -0,0 +1,23 @@
+import type { ExpandableContentPresentation } from "../shared/rendering/expandable-content-layout.ts";
+import type { RenderTheme } from "../shared/rendering/theme.ts";
+import { formatSessionTitleOrShortId } from "../shared/session-ui.ts";
+import type { SessionAskViewModel } from "./view-model.ts";
+
+export function buildSessionAskPresentation(
+  model: SessionAskViewModel,
+  theme: RenderTheme,
+): ExpandableContentPresentation {
+  const identity = formatSessionTitleOrShortId(model.sessionName, model.sessionId);
+  return {
+    header: `title: ${theme.bold(identity)}`,
+    ...(model.question
+      ? {
+          metadata: [theme.fg("muted", `prompt: ${model.question}`)],
+        }
+      : {}),
+    body: {
+      text: model.answer,
+      collapsedRows: 6,
+    },
+  };
+}

package/extensions/session-ask/renderer.ts

@@ -0,0 +1,63 @@
+import type {
+  AgentToolResult,
+  Theme,
+  ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+import { type Component, Text } from "@earendil-works/pi-tui";
+import { ExpandableContentLayout } from "../shared/rendering/expandable-content-layout.ts";
+import { formatSessionTitleOrShortId } from "../shared/session-ui.ts";
+import { safeParseTypeBoxValue } from "../shared/typebox.ts";
+import { buildSessionAskPresentation } from "./presenter.ts";
+import {
+  SESSION_ASK_PROGRESS_DETAILS_SCHEMA,
+  SESSION_ASK_RESULT_DETAILS_SCHEMA,
+} from "./tool-contract.ts";
+import { buildSessionAskView } from "./view-model.ts";
+
+interface SessionAskToolRendererState {
+  layout?: ExpandableContentLayout | undefined;
+}
+
+interface SessionAskToolRenderContext {
+  state: SessionAskToolRendererState;
+  isError: boolean;
+}
+
+export function renderSessionAskResult(
+  result: AgentToolResult<unknown>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+  context: SessionAskToolRenderContext,
+): Component {
+  const content = result.content[0];
+  if (content?.type !== "text") {
+    return new Text(theme.fg("error", "No session output"), 0, 0);
+  }
+
+  if (context.isError) {
+    return new Text(theme.fg("error", content.text), 0, 0);
+  }
+
+  if (options.isPartial) {
+    const details = safeParseTypeBoxValue(SESSION_ASK_PROGRESS_DETAILS_SCHEMA, result.details);
+    const lines = [theme.bold(theme.fg("warning", "Reading session..."))];
+    if (details) {
+      const identity = formatSessionTitleOrShortId(details.sessionName, details.sessionId);
+      lines.push(`title: ${theme.fg("accent", identity)}`);
+    }
+    if (details?.question) {
+      lines.push(theme.fg("muted", `prompt: ${details.question}`));
+    }
+    return new Text(lines.join("\n"), 0, 0);
+  }
+
+  const details = safeParseTypeBoxValue(SESSION_ASK_RESULT_DETAILS_SCHEMA, result.details);
+  if (!details) {
+    return new Text(content.text, 0, 0);
+  }
+
+  const layout = context.state.layout ?? new ExpandableContentLayout(theme);
+  context.state.layout = layout;
+  layout.update(buildSessionAskPresentation(buildSessionAskView(details), theme), options.expanded);
+  return layout;
+}

package/extensions/session-ask/tool-contract.ts

@@ -0,0 +1,27 @@
+import { type Static, Type } from "typebox";
+
+export const SESSION_ASK_RELEVANT_FILE_SCHEMA = Type.Object({
+  path: Type.String(),
+  reason: Type.String(),
+});
+
+export const SESSION_ASK_PROGRESS_DETAILS_SCHEMA = Type.Object({
+  question: Type.String({ minLength: 1 }),
+  sessionId: Type.String({ minLength: 1 }),
+  sessionName: Type.String(),
+  sessionPath: Type.String({ minLength: 1 }),
+});
+
+export const SESSION_ASK_RESULT_DETAILS_SCHEMA = Type.Object({
+  answer: Type.String({ minLength: 1 }),
+  debugSessionPath: Type.Optional(Type.String({ minLength: 1 })),
+  question: Type.String({ minLength: 1 }),
+  relevantFiles: Type.Array(SESSION_ASK_RELEVANT_FILE_SCHEMA),
+  sessionId: Type.String({ minLength: 1 }),
+  sessionName: Type.String(),
+  sessionPath: Type.String({ minLength: 1 }),
+});
+
+export type SessionAskRelevantFile = Static<typeof SESSION_ASK_RELEVANT_FILE_SCHEMA>;
+export type SessionAskProgressDetails = Static<typeof SESSION_ASK_PROGRESS_DETAILS_SCHEMA>;
+export type SessionAskResultDetails = Static<typeof SESSION_ASK_RESULT_DETAILS_SCHEMA>;

package/extensions/session-ask/view-model.ts

@@ -0,0 +1,18 @@
+import { normalizeOptionalText } from "../shared/text.ts";
+import type { SessionAskResultDetails } from "./tool-contract.ts";
+
+export interface SessionAskViewModel {
+  sessionId: string;
+  sessionName?: string | undefined;
+  question: string;
+  answer: string;
+}
+
+export function buildSessionAskView(details: SessionAskResultDetails): SessionAskViewModel {
+  return {
+    sessionId: details.sessionId.trim(),
+    sessionName: normalizeOptionalText(details.sessionName),
+    question: details.question.trim(),
+    answer: details.answer.trim(),
+  };
+}

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

@@ -1,13 +1,12 @@
 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";
 
-const AUTO_TITLE_REQUEST_TIMEOUT_MS = 15_000;
 const AUTO_TITLE_MAX_TOKENS = 64;
 const AUTO_TITLE_CHAR_MAX = 80;
 
@@ -18,6 +17,12 @@ export interface AutoTitleFailure {
   message: string;
 }
 
+export interface AutoTitleGeneration {
+  systemPrompt: string;
+  timeoutMs: number;
+  thinkingLevel: ThinkingLevel | undefined;
+}
+
 export type AutoTitleGenerationResult =
   | {
       ok: true;
@@ -29,11 +34,11 @@ export type AutoTitleGenerationResult =
     };
 
 export async function generateAutoTitle(
-  ctx: ExtensionContext,
+  modelRuntime: ModelRuntime,
   model: Model<Api>,
   context: AutoTitleContext,
   trigger: AutoTitleTrigger,
-  systemPrompt: string,
+  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(), AUTO_TITLE_REQUEST_TIMEOUT_MS);
+  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,20 +80,15 @@ export default function sessionAutoTitleExtension(pi: ExtensionAPI): void {
             },
           },
           ctx,
-          model,
+          modelRuntime,
+          resolution?.model,
           invocation,
-          settings.autoTitle.prompt,
+          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);
@@ -94,16 +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,
+      generation: buildGeneration(resolution),
     })
       .then((outcome) => {
         if (outcome.ok) {
@@ -124,29 +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,
+  generation: AutoTitleGeneration,
 ): Promise<RetitleCommandOutcome> {
   const retitleOpts = {
     pi,
     controller: state.controller,
     ctx,
+    modelRuntime,
     model,
     isManual: true,
-    systemPrompt,
+    generation,
     getSessionEpoch: state.getSessionEpoch,
   };
 
@@ -165,7 +176,15 @@ async function handleTitleInvocation(
       return retitleCurrentSession();
     }
 
-    return showRetitleWizard(pi, state.controller, ctx, model, state.getSessionEpoch, systemPrompt);
+    return showRetitleWizard(
+      pi,
+      state.controller,
+      ctx,
+      modelRuntime,
+      model,
+      state.getSessionEpoch,
+      generation,
+    );
   }
 
   if (invocation.scope === "this") {
@@ -177,9 +196,10 @@ async function handleTitleInvocation(
       pi,
       state.controller,
       ctx,
+      modelRuntime,
       model,
       state.getSessionEpoch,
-      systemPrompt,
+      generation,
       {
         initialInvocation: {
           scope: invocation.scope,
@@ -196,11 +216,12 @@ async function handleTitleInvocation(
       pi,
       state.controller,
       ctx,
+      modelRuntime,
       model,
       scan,
       mode,
       state.getSessionEpoch,
-      systemPrompt,
+      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,11 +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,
+  generation: AutoTitleGeneration,
 ): Promise<BulkRetitleResult> {
   const result: BulkRetitleResult = {
     attempted: 0,
@@ -82,9 +85,10 @@ export async function runBulkRetitle(
         pi,
         controller,
         ctx,
+        modelRuntime,
         model,
         isManual: true,
-        systemPrompt,
+        generation,
         getSessionEpoch,
         notifyOnSuccess: false,
       });
@@ -92,7 +96,7 @@ export async function runBulkRetitle(
       continue;
     }
 
-    const outcome = await retitleStoredSession(ctx, model, session.path, systemPrompt);
+    const outcome = await retitleStoredSession(modelRuntime, model, session.path, generation);
     result[outcome] += 1;
   }
 
@@ -162,9 +166,10 @@ export interface RetitlePlanOptions {
   pi: ExtensionAPI;
   controller: SessionAutoTitleController;
   ctx: ExtensionContext;
+  modelRuntime: ModelRuntime;
   model: Model<Api> | undefined;
   isManual: boolean;
-  systemPrompt: string;
+  generation: AutoTitleGeneration;
   existingPlan?: AutoTitleTriggerPlan;
   getSessionEpoch?: () => number;
   notifyOnSuccess?: boolean;
@@ -173,8 +178,17 @@ export interface RetitlePlanOptions {
 export async function runRetitlePlan(
   options: RetitlePlanOptions,
 ): Promise<AutoTitleGenerationResult> {
-  const { pi, controller, ctx, model, isManual, systemPrompt, existingPlan, getSessionEpoch } =
-    options;
+  const {
+    pi,
+    controller,
+    ctx,
+    modelRuntime,
+    model,
+    isManual,
+    generation,
+    existingPlan,
+    getSessionEpoch,
+  } = options;
   const notifyOnSuccess = options.notifyOnSuccess ?? isManual;
 
   const plan = existingPlan ?? controller.handleManualRetitle(ctx);
@@ -206,11 +220,11 @@ export async function runRetitlePlan(
     },
   );
   const generatedTitle = await generateAutoTitle(
-    ctx,
+    modelRuntime,
     model,
     titleContext,
     plan.reason,
-    systemPrompt,
+    generation,
   );
   if (!generatedTitle.ok) {
     return generatedTitle;
@@ -253,10 +267,10 @@ export function persistAutoTitleState(
 }
 
 async function retitleStoredSession(
-  ctx: ExtensionContext,
+  modelRuntime: ModelRuntime,
   model: Model<Api>,
   sessionPath: string,
-  systemPrompt: string,
+  generation: AutoTitleGeneration,
 ): Promise<"retitled" | "unchanged" | "failed"> {
   const sessionManager = SessionManager.open(sessionPath);
   const currentTitle = sessionManager.getSessionName();
@@ -274,11 +288,11 @@ async function retitleStoredSession(
     currentTitle,
   };
   const generatedTitle = await generateAutoTitle(
-    ctx,
+    modelRuntime,
     model,
     titleContext,
     plan.reason,
-    systemPrompt,
+    generation,
   );
   if (!generatedTitle.ok) {
     return "failed";