Fixed Pi provider model picker corruption, labels, and added thread title auto-generation

Model picker & display fixes:
- Added "pi" to toLegacyProvider() allowlist (mappers.store.ts) — prevents
  session provider from being silently coerced to "codex" after first turn
- Added formatSlugAsDisplayName() helper in ProviderModelPicker.tsx to convert
  raw slugs like "gemini-3-flash-preview" into friendly display names
- Fixed getDefaultModelSelection() and composer hook to preserve subProviderID
  so model picker stays on the selected Pi model after sending
- Added PI_PROVIDER_DISPLAY_NAMES and getPiProviderDisplayName() helpers in
  PiProvider.utils.ts for consistent provider group headers

Thread title auto-generation:
- Added generatePiThreadTitleNative() that spawns a temporary Pi RPC process,
  writes the title prompt via write() (avoids early RPC ack resolution),
  collects streamed text deltas until turn_end/agent_end, and stops the
  process via Effect.ensuring. Single Effect.timeoutOption timeout with no
  inner setTimeout race; rejects on empty response
- Routed Pi provider in RoutingTextGeneration.ts to native title generation
  instead of Claude CLI fallback; removed unsafe type casts
- Fixed maybeGenerateThreadTitleForFirstTurn gate: now falls back to
  thread.modelSelection when event.payload.modelSelection is absent (Pi
  turn-start events don't carry it), ensuring Pi threads always trigger title
  generation
- Handled setTitle extension UI request in PiAdapter.stream.handlers.ts:
  emits thread.metadata.updated wrapped in catchCause so schema failures
  don't disrupt session event flow

Author: youpele52

apps/server/package.json

@@ -29,6 +29,7 @@
     "@effect/platform-node": "catalog:",
     "@effect/sql-sqlite-bun": "catalog:",
     "@github/copilot-sdk": "0.2.1",
+    "@mariozechner/pi-coding-agent": "^0.67.6",
     "@opencode-ai/sdk": "^1.3.13",
     "@pierre/diffs": "^1.1.0-beta.16",
     "effect": "catalog:",

apps/server/src/git/Layers/ProviderNativeThreadTitleGeneration.ts

@@ -8,20 +8,25 @@ import {
   TextGenerationError,
   type CopilotModelSelection,
   type OpencodeModelSelection,
+  type PiModelSelection,
 } from "@bigcode/contracts";
 import { Effect, Option } from "effect";
 
+import { createPiRpcProcess } from "../../provider/Layers/PiRpcProcess.ts";
+import type { PiRpcStdoutEvent } from "../../provider/Layers/PiRpcProcess.ts";
+import type { ServerSettingsShape } from "../../ws/serverSettings.ts";
+
 import type { ThreadTitleGenerationInput } from "../Services/TextGeneration.ts";
 import { buildThreadTitlePrompt } from "../Prompts.ts";
 import { limitSection, sanitizeThreadTitle } from "../Utils.ts";
 import { makeNodeWrapperCliPath } from "../../provider/Layers/CopilotAdapter.types.ts";
 import { resolveProviderIDForModel } from "../../provider/Layers/OpencodeAdapter.session.helpers.ts";
 import { withOpencodeDirectory } from "../../provider/Layers/OpencodeAdapter.stream.ts";
-import type { ServerSettingsShape } from "../../ws/serverSettings.ts";
 import type { OpencodeServerManagerShape } from "../../provider/Services/OpencodeServerManager.ts";
 
 const COPILOT_TIMEOUT_MS = 60_000;
 const OPENCODE_TIMEOUT_MS = 60_000;
+const PI_TIMEOUT_MS = 60_000;
 
 type CopilotThreadTitleGenerationInput = Omit<ThreadTitleGenerationInput, "modelSelection"> & {
   readonly modelSelection: CopilotModelSelection;
@@ -31,6 +36,10 @@ type OpencodeThreadTitleGenerationInput = Omit<ThreadTitleGenerationInput, "mode
   readonly modelSelection: OpencodeModelSelection;
 };
 
+type PiThreadTitleGenerationInput = Omit<ThreadTitleGenerationInput, "modelSelection"> & {
+  readonly modelSelection: PiModelSelection;
+};
+
 export interface NativeThreadTitleGenerationDeps {
   readonly serverSettingsService: ServerSettingsShape;
   readonly opencodeServerManager: OpencodeServerManagerShape;
@@ -321,3 +330,163 @@ export const generateOpencodeThreadTitleNative = (
       serverHandle.release();
     }
   });
+
+const PI_TITLE_PROMPT_PREFIX = [
+  "Write a concise thread title for a coding conversation.",
+  "Return plain text only — no JSON, no quotes, no prefixes, no trailing punctuation.",
+  "Keep it short and specific (3-8 words).",
+  "",
+  "User message:",
+].join("\n");
+
+/**
+ * Generates a thread title using the Pi RPC process directly.
+ * Spawns a temporary Pi process, sends the title-generation prompt,
+ * collects streamed text, then stops the process.
+ */
+export const generatePiThreadTitleNative = (
+  deps: NativeThreadTitleGenerationDeps,
+  input: PiThreadTitleGenerationInput,
+) =>
+  Effect.gen(function* () {
+    const piSettings = yield* deps.serverSettingsService.getSettings.pipe(
+      Effect.map((settings) => settings.providers.pi),
+      Effect.mapError(
+        () =>
+          new TextGenerationError({
+            operation: "generateThreadTitle",
+            detail: "Failed to read Pi settings.",
+          }),
+      ),
+    );
+
+    const prompt = [
+      PI_TITLE_PROMPT_PREFIX,
+      limitSection(input.message, 8_000),
+      ...(input.attachments && input.attachments.length > 0
+        ? [
+            "",
+            "Attachment metadata:",
+            limitSection(
+              input.attachments
+                .map((a) => `- ${a.name} (${a.mimeType}, ${a.sizeBytes} bytes)`)
+                .join("\n"),
+              4_000,
+            ),
+          ]
+        : []),
+    ].join("\n");
+
+    const rpcProcess = yield* Effect.tryPromise({
+      try: () =>
+        createPiRpcProcess({
+          binaryPath: piSettings.binaryPath,
+          ...(input.cwd ? { cwd: input.cwd } : {}),
+          env: process.env,
+        }),
+      catch: (cause) =>
+        new TextGenerationError({
+          operation: "generateThreadTitle",
+          detail:
+            cause instanceof Error
+              ? `Failed to start Pi process for thread title generation: ${cause.message}`
+              : "Failed to start Pi process for thread title generation.",
+          cause,
+        }),
+    });
+
+    const stopProcess = Effect.promise(() => rpcProcess.stop().catch(() => undefined));
+
+    const generateTitle = Effect.tryPromise({
+      try: () =>
+        new Promise<string>((resolve, reject) => {
+          let collectedText = "";
+          let settled = false;
+
+          const unsubscribe = rpcProcess.subscribe((message) => {
+            if (!("type" in message)) return;
+            const event = message as PiRpcStdoutEvent;
+
+            if (
+              event.type === "message_update" &&
+              "assistantMessageEvent" in event &&
+              event.assistantMessageEvent?.type === "text_delta"
+            ) {
+              collectedText += event.assistantMessageEvent.delta;
+            } else if (event.type === "message_end") {
+              // Fallback: extract text from final message if streaming deltas weren't received
+              const msg = (event as { type: "message_end"; message: Record<string, unknown> })
+                .message;
+              if (collectedText.length === 0) {
+                const content = msg.content;
+                if (typeof content === "string" && content.trim().length > 0) {
+                  collectedText = content;
+                } else if (Array.isArray(content)) {
+                  for (const part of content) {
+                    if (
+                      part &&
+                      typeof part === "object" &&
+                      "type" in part &&
+                      part.type === "text" &&
+                      "text" in part &&
+                      typeof part.text === "string"
+                    ) {
+                      collectedText += part.text;
+                    }
+                  }
+                }
+              }
+            } else if (event.type === "turn_end" || event.type === "agent_end") {
+              if (!settled) {
+                settled = true;
+                unsubscribe();
+                if (collectedText.trim().length === 0) {
+                  reject(new Error("Pi thread title generation produced an empty response."));
+                } else {
+                  resolve(collectedText);
+                }
+              }
+            }
+          });
+
+          // Use write() instead of request() so the promise doesn't resolve early
+          // on the RPC acknowledgment — we wait for turn_end above instead.
+          rpcProcess.write({ type: "prompt", message: prompt }).catch((err: unknown) => {
+            if (!settled) {
+              settled = true;
+              unsubscribe();
+              reject(err instanceof Error ? err : new Error(String(err)));
+            }
+          });
+        }),
+      catch: (cause) =>
+        new TextGenerationError({
+          operation: "generateThreadTitle",
+          detail:
+            cause instanceof Error
+              ? `Pi thread title generation failed: ${cause.message}`
+              : "Pi thread title generation failed.",
+          cause,
+        }),
+    }).pipe(
+      Effect.timeoutOption(PI_TIMEOUT_MS),
+      Effect.flatMap(
+        Option.match({
+          onNone: () =>
+            Effect.fail(
+              new TextGenerationError({
+                operation: "generateThreadTitle",
+                detail: "Pi thread title generation timed out.",
+              }),
+            ),
+          onSome: (value) => Effect.succeed(value),
+        }),
+      ),
+    );
+
+    const title = yield* generateTitle.pipe(Effect.ensuring(stopProcess));
+
+    return {
+      title: sanitizeThreadTitle(title.trim()),
+    };
+  });

apps/server/src/git/Layers/RoutingTextGeneration.ts

@@ -18,14 +18,14 @@ import {
 import {
   TextGeneration,
   type TextGenerationProvider,
-  type ThreadTitleGenerationInput,
   type TextGenerationShape,
 } from "../Services/TextGeneration.ts";
 import { CodexTextGenerationLive } from "./CodexTextGeneration.ts";
 import { ClaudeTextGenerationLive } from "./ClaudeTextGeneration.ts";
 import {
   generateCopilotThreadTitleNative,
   generateOpencodeThreadTitleNative,
+  generatePiThreadTitleNative,
 } from "./ProviderNativeThreadTitleGeneration.ts";
 import { ServerSettingsService } from "../../ws/serverSettings.ts";
 import { OpencodeServerManager } from "../../provider/Services/OpencodeServerManager.ts";
@@ -49,6 +49,7 @@ export function normalizeTextGenerationModelSelection(
     case "claudeAgent":
     case "codex":
       return modelSelection;
+    case "pi":
     case "opencode":
       return {
         provider: "claudeAgent",
@@ -109,16 +110,31 @@ const makeRoutingTextGeneration = Effect.gen(function* () {
         case "codex":
         case "claudeAgent":
           return route(input.modelSelection.provider).generateThreadTitle(input);
+        case "pi":
+          return generatePiThreadTitleNative(
+            {
+              serverSettingsService,
+              opencodeServerManager,
+            },
+            {
+              cwd: input.cwd,
+              message: input.message,
+              ...(input.attachments !== undefined ? { attachments: input.attachments } : {}),
+              modelSelection: input.modelSelection,
+            },
+          );
         case "copilot":
           return generateCopilotThreadTitleNative(
             {
               serverSettingsService,
               opencodeServerManager,
             },
             {
-              ...(input as ThreadTitleGenerationInput),
+              cwd: input.cwd,
+              message: input.message,
+              ...(input.attachments !== undefined ? { attachments: input.attachments } : {}),
               modelSelection: input.modelSelection,
-            } as ThreadTitleGenerationInput & { modelSelection: { provider: "copilot" } },
+            },
           );
         case "opencode":
           return generateOpencodeThreadTitleNative(
@@ -127,9 +143,11 @@ const makeRoutingTextGeneration = Effect.gen(function* () {
               opencodeServerManager,
             },
             {
-              ...(input as ThreadTitleGenerationInput),
+              cwd: input.cwd,
+              message: input.message,
+              ...(input.attachments !== undefined ? { attachments: input.attachments } : {}),
               modelSelection: input.modelSelection,
-            } as ThreadTitleGenerationInput & { modelSelection: { provider: "opencode" } },
+            },
           );
       }
     },

apps/server/src/orchestration/Layers/ProviderCommandReactorHandlers.ts

@@ -217,14 +217,14 @@ export const makeProviderCommandHandlers = Effect.gen(function* () {
         ...generationInput,
       }).pipe(Effect.forkScoped);
 
-      if (
-        event.payload.modelSelection &&
-        canReplaceThreadTitle(thread.title, event.payload.titleSeed)
-      ) {
+      if (canReplaceThreadTitle(thread.title, event.payload.titleSeed)) {
+        // Fall back to the thread's own modelSelection when the turn-start event doesn't
+        // carry one (e.g. Pi, where the thread is already bound to a provider).
+        const titleModelSelection = event.payload.modelSelection ?? thread.modelSelection;
         yield* maybeGenerateThreadTitleForFirstTurn(sessionOpServices)({
           threadId: event.payload.threadId,
           cwd: generationCwd,
-          modelSelection: event.payload.modelSelection,
+          modelSelection: titleModelSelection,
           ...generationInput,
         }).pipe(Effect.forkScoped);
       }