@schlessera/brain-ui-react 0.21.0 → 0.23.0

package/src/lib/api-client.ts

@@ -80,6 +80,30 @@ export interface BackendInfo {
   };
 }
 
+/** Auth status of one configured pi provider (mirror of the server view). */
+export interface PiAuthProviderStatus {
+  providerId: string;
+  /** Human label for the credential, e.g. "OpenAI (ChatGPT Plus/Pro)". */
+  name: string;
+  configured: boolean;
+  source?: string;
+  /** Whether this provider can be signed in through the UI. */
+  oauth: boolean;
+}
+
+/** One OAuth device-code login flow (mirror of the server view). */
+export interface PiLoginFlow {
+  id: string;
+  providerId: string;
+  status: "pending" | "success" | "error" | "cancelled";
+  userCode?: string;
+  verificationUri?: string;
+  intervalSeconds?: number;
+  expiresInSeconds?: number;
+  error?: string;
+  startedAt: number;
+}
+
 async function fetchJson<T>(path: string, init?: RequestInit): Promise<T> {
   const res = await fetch(`${apiBase()}${path}`, {
     ...init,
@@ -209,6 +233,34 @@ export const api = {
   /** Pricing-table freshness for the Activity staleness indicator (see `PricingState`). */
   pricingState: () => fetchJson<PricingState>("/models/pricing"),
 
+  /** Auth status of configured pi providers; empty when pi is not in play. */
+  piAuthProviders: () =>
+    fetchJson<{ providers: PiAuthProviderStatus[] }>("/pi-auth/providers"),
+
+  /** Start an OAuth device-code login; resolves once the user code exists. */
+  piAuthStart: (providerId: string) =>
+    fetchJson<{ flow: PiLoginFlow }>("/pi-auth/login", {
+      method: "POST",
+      body: JSON.stringify({ providerId }),
+    }),
+
+  /** Poll one login flow. */
+  piAuthFlow: (id: string) =>
+    fetchJson<{ flow: PiLoginFlow }>(`/pi-auth/login/${encodeURIComponent(id)}`),
+
+  /** Abort a pending login flow. */
+  piAuthCancel: (id: string) =>
+    fetchJson<{ ok: boolean }>(`/pi-auth/login/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+    }),
+
+  /** Remove the stored credential for a pi provider. */
+  piAuthLogout: (providerId: string) =>
+    fetchJson<{ ok: boolean }>("/pi-auth/logout", {
+      method: "POST",
+      body: JSON.stringify({ providerId }),
+    }),
+
   /** Force a discovery refresh, bypassing the TTL. */
   refreshModels: () =>
     fetchJson<ModelCatalogResponse>("/models/refresh", { method: "POST" }),

package/src/lib/tool-names.ts

@@ -21,7 +21,12 @@ export function normalizeToolName(name: string): string {
     : name;
 }
 
+// The pi backend registers its ask-user tool under the bare name.
+const PI_ASK_USER_TOOL_NAME = "ask_user";
+
 export const isAskUserTool = (name: string | undefined): boolean =>
-  !!name && normalizeToolName(name) === ASK_USER_TOOL_NAME;
+  !!name &&
+  (normalizeToolName(name) === ASK_USER_TOOL_NAME ||
+    name === PI_ASK_USER_TOOL_NAME);
 export const isLocationTool = (name: string | undefined): boolean =>
   !!name && normalizeToolName(name) === GET_LOCATION_TOOL_NAME;

package/src/stores/chat-store.ts

@@ -123,6 +123,12 @@ interface ChatState {
    * absence of a running/queued turn.
    */
   runStates: Record<string, "streaming" | "queued" | "idle">;
+  /**
+   * Backend that owns each session, from `session_info` (or the session list
+   * for history sessions). Scopes tool-call renderer resolution per backend;
+   * absence falls back to the deployment default.
+   */
+  backendIds: Record<string, string>;
   /**
    * Per-session note attached to a `queued` status — the host sends one once a
    * session's follow-up queue grows heavy. Cleared when the session leaves the
@@ -190,6 +196,8 @@ interface ChatState {
     state: "streaming" | "queued" | "idle",
     note?: string
   ) => void;
+  /** Record which backend owns a session (idempotent). */
+  setSessionBackend: (sessionId: string, backendId: string) => void;
 }
 
 let messageCounter = 0;
@@ -350,6 +358,7 @@ export const useChatStore = create<ChatState>((set, get) => {
     activeSessionId: readPersistedSessionId(),
     runStates: {},
     queueNotes: {},
+    backendIds: {},
 
     // createIfMissing: a user-initiated send must never be dropped, even when
     // the active session's buffer hasn't been materialized yet (cold start
@@ -659,6 +668,13 @@ export const useChatStore = create<ChatState>((set, get) => {
         return { runStates, queueNotes };
       }),
 
+    setSessionBackend: (sessionId, backendId) =>
+      set((state) =>
+        state.backendIds[sessionId] === backendId
+          ? state
+          : { backendIds: { ...state.backendIds, [sessionId]: backendId } }
+      ),
+
     clearMessages: () => {
       const state = get();
       if (state.draft) revokeAttachmentUrls(state.draft.messages);