gloomberb 0.16.3 → 0.16.4

package/src/plugins/builtin/chat/message/render-state.ts

@@ -20,6 +20,8 @@ export interface ChatMessageRenderState {
   replyAuthorColor: string;
   headerStatus: string;
   headerStatusColor: string;
+  /** The dim "Discord" tag beside the author of a message that came from Discord. */
+  originTagColor: string;
   authorColor: string;
   authorAttributes: number;
   bodyColor: string;
@@ -82,6 +84,7 @@ export function getChatMessageRenderState({
         : hasFailed
           ? colors.negative
           : colors.textMuted,
+    originTagColor: isSelected ? selectedTextColor : colors.textDim,
     authorColor: isSelected ? selectedTextColor : hasFailed ? colors.negative : colors.positive,
     authorAttributes: (isSending ? TextAttributes.DIM : 0) | TextAttributes.BOLD,
     bodyColor: isSelected ? selectedTextColor : hasFailed ? colors.negative : isSending ? colors.textDim : colors.text,

package/src/plugins/builtin/chat/pane-requests.ts

@@ -0,0 +1,60 @@
+import { useSyncExternalStore } from "react";
+
+/**
+ * Something a Chat pane should do once it has the keyboard, asked for from
+ * outside it: the command bar opens a conversation to write in, or the New DM
+ * dialog. The pane that is focused on that conversation takes it.
+ */
+export type ChatPaneRequest =
+  | { action: "compose"; channelId: string }
+  | { action: "new-dm" };
+
+interface PendingChatPaneRequest {
+  request: ChatPaneRequest;
+  at: number;
+}
+
+/** A request no pane took by then (the pane never opened) must not fire later. */
+const REQUEST_TTL_MS = 10_000;
+
+let pending: PendingChatPaneRequest | null = null;
+const listeners = new Set<() => void>();
+
+function emit(): void {
+  for (const listener of listeners) listener();
+}
+
+export function requestChatPaneAction(request: ChatPaneRequest, now = Date.now()): void {
+  pending = { request, at: now };
+  emit();
+}
+
+/**
+ * Hands the request to the pane on `channelId` and clears it. Null when there
+ * is none for that pane or it went stale.
+ */
+export function takeChatPaneRequest(channelId: string, now = Date.now()): ChatPaneRequest | null {
+  if (!pending) return null;
+  const { request, at } = pending;
+  if (now - at > REQUEST_TTL_MS) {
+    pending = null;
+    emit();
+    return null;
+  }
+  if (request.action === "compose" && request.channelId !== channelId) return null;
+  pending = null;
+  emit();
+  return request;
+}
+
+function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/** The request waiting for a pane, so a pane can take it once it has the keyboard. */
+export function usePendingChatPaneRequest(): ChatPaneRequest | null {
+  return useSyncExternalStore(subscribe, () => pending?.request ?? null);
+}

package/src/plugins/builtin/chat/pane-state.ts

@@ -1,6 +1,6 @@
 import { updatePaneInstance } from "../../../pane-settings";
-import { removePane } from "../../../layout/pane-manager";
-import type { AppConfig } from "../../../types/config";
+import { isPaneInLayout, removePane } from "../../../layout/pane-manager";
+import type { AppConfig, LayoutConfig, PaneInstanceConfig } from "../../../types/config";
 import { LAST_VISITED_CHAT_CHANNEL_KEY, normalizeChannelId } from "./channels";
 
 type ChatPaneSettings = Record<string, unknown>;
@@ -32,6 +32,36 @@ export function clearChatPaneTargetMessage(
   return nextSettings;
 }
 
+function paneChannelId(instance: PaneInstanceConfig): string | null {
+  return typeof instance.settings?.channelId === "string" ? normalizeChannelId(instance.settings.channelId) : null;
+}
+
+/**
+ * The Chat pane the command bar shows a conversation in: the one already on
+ * it, else the focused one, else the one in front. Null when none is open, so
+ * the caller opens one.
+ */
+export function pickChatPaneToReuse(
+  layout: LayoutConfig,
+  focusedPaneId: string | null,
+  channelId: string | null,
+): PaneInstanceConfig | null {
+  const chatPanes = layout.instances.filter((instance) => (
+    instance.paneId === "chat" && isPaneInLayout(layout, instance.instanceId)
+  ));
+  if (chatPanes.length === 0) return null;
+  const onChannel = channelId ? chatPanes.find((instance) => paneChannelId(instance) === channelId) : undefined;
+  if (onChannel) return onChannel;
+  const focused = chatPanes.find((instance) => instance.instanceId === focusedPaneId);
+  if (focused) return focused;
+  // A floating pane without a stacking order sits at the default of 50; docked panes sit below every one.
+  const zIndexOf = (instance: PaneInstanceConfig) => {
+    const entry = layout.floating.find((floating) => floating.instanceId === instance.instanceId);
+    return entry ? entry.zIndex ?? 50 : -1;
+  };
+  return [...chatPanes].sort((left, right) => zIndexOf(right) - zIndexOf(left))[0] ?? null;
+}
+
 function setChatPaneJump(
   settings: ChatPaneSettings | undefined,
   channelId: string,

package/src/plugins/builtin/chat/pane.tsx

@@ -77,6 +77,14 @@ export function ChatPane({ focused, width, height }: PaneProps) {
   }, [dispatch, paneId, stateRef]);
   const [channelId, setLocalChannelId] = useState(initialChannelIdRef.current);
   const pendingChannelIdRef = useRef<string | null>(null);
+  // A channel set from outside the pane (the command bar, the unread list)
+  // usually arrives with focus. Taking it in the same render keeps the pane
+  // from showing the old channel focused for a frame, which marks it read.
+  const [followedChannelId, setFollowedChannelId] = useState(persistedChannelId);
+  if (followedChannelId !== persistedChannelId) {
+    setFollowedChannelId(persistedChannelId);
+    if (!pendingChannelIdRef.current && channelId !== persistedChannelId) setLocalChannelId(persistedChannelId);
+  }
 
   useEffect(() => {
     if (rawPaneChannelId) return;

package/src/plugins/builtin/cloud/askg/controller.ts

@@ -8,18 +8,23 @@ import type { ASKGToolExecutor } from "./executor";
 import {
   activeTurn,
   askgReducer,
+  canRateTurn,
   EMPTY_ASKG_CONVERSATION,
   isTurnRunning,
   requiresLocalConfirmation,
   type ASKGAction,
   type ASKGConversationState,
   type ASKGErrorState,
+  type ASKGTurnFeedback,
 } from "./model";
 import {
   ASKG_CLIENT_CAPABILITIES,
   ASKG_PROTOCOL_VERSION,
   type ASKGCapabilities,
   type ASKGClientDescriptor,
+  type ASKGFeedbackRating,
+  type ASKGFeedbackReason,
+  type ASKGFeedbackRequest,
   type ASKGSessionContext,
   type ASKGSessionStartResponse,
   type ASKGSseEvent,
@@ -104,6 +109,16 @@ function turnCapabilities(session: ASKGSessionStartResponse): ASKGCapabilities |
   return session.capabilities?.scripts === 1 ? { scripts: 1 } : null;
 }
 
+/**
+ * Refusals that say ratings cannot work from here at all: signed out, no plan
+ * that reaches Ask Gloom, or a protocol this build does not speak. The control
+ * goes away rather than failing on every click.
+ */
+function feedbackUnavailable(error: unknown): boolean {
+  return error instanceof ASKGTransportError
+    && (error.code === "unauthorized" || error.code === "tier_required" || error.code === "protocol");
+}
+
 function errorState(error: unknown): ASKGErrorState {
   if (error instanceof ASKGTransportError) {
     return {
@@ -136,6 +151,10 @@ export class ASKGSessionController {
   private readonly abandonedCalls = new Set<string>();
   private readonly toolTasks = new Set<Promise<void>>();
   private turnAbort: AbortController | null = null;
+  /** Ratings of one answer go out in the order they were made. */
+  private readonly feedbackQueues = new Map<string, Promise<void>>();
+  /** The latest rating request per answer; an older answer never wins. */
+  private readonly feedbackVersions = new Map<string, number>();
   private disposed = false;
   private readonly now: () => number;
   private readonly createId: () => string;
@@ -188,6 +207,7 @@ export class ASKGSessionController {
         model: session.model,
         limits: session.limits,
         acceptedTools: session.acceptedTools,
+        feedback: session.capabilities?.feedback === 1,
       });
       return session;
     })();
@@ -311,14 +331,14 @@ export class ASKGSessionController {
   }
 
   /**
-   * Asks a failed question again. The failed turn is dropped rather than kept
-   * above the retry, so a transcript reads as the conversation the user had
-   * rather than as a list of attempts.
+   * Asks a failed or stopped question again. The attempt is dropped rather
+   * than kept above the retry, so a transcript reads as the conversation the
+   * user had rather than as a list of attempts.
    */
   async retryTurn(turnId: string): Promise<void> {
     if (this.disposed || isTurnRunning(this.state)) return;
     const turn = this.state.turns.find((entry) => entry.id === turnId);
-    if (!turn || turn.status !== "error") return;
+    if (!turn || (turn.status !== "error" && turn.status !== "cancelled")) return;
     this.dispatch({ type: "drop-turn", turnId });
     await this.ask(turn.prompt);
   }
@@ -445,6 +465,94 @@ export class ASKGSessionController {
     this.rejectPendingConfirmations();
   }
 
+  /**
+   * Rates one answer. The control shows the choice at once; a refusal puts the
+   * previous one back without a word, because a rating is not worth an error.
+   * A thumbs down keeps the reason it already had, a thumbs up drops it.
+   */
+  rateAnswer(turnId: string, rating: ASKGFeedbackRating): Promise<void> {
+    const current = this.state.turns.find((turn) => turn.id === turnId)?.feedback;
+    const reason = rating === "down" && current?.rating === "down" ? current.reason : null;
+    return this.sendFeedback(turnId, { rating, reason }, {
+      rating,
+      reason,
+      shared: current?.shared ?? false,
+      pending: "rating",
+    });
+  }
+
+  /** Says why an answer got a thumbs down. */
+  chooseFeedbackReason(turnId: string, reason: ASKGFeedbackReason): Promise<void> {
+    const current = this.state.turns.find((turn) => turn.id === turnId)?.feedback;
+    return this.sendFeedback(turnId, { rating: "down", reason }, {
+      rating: "down",
+      reason,
+      shared: current?.shared ?? false,
+      pending: "rating",
+    });
+  }
+
+  /**
+   * Sends one answer to Gloom with its rating. Only the consent travels: the
+   * platform copies the question, the answer and which tools ran from its own
+   * transcript, so nothing else on this machine can go with it.
+   */
+  shareAnswer(turnId: string): Promise<void> {
+    const current = this.state.turns.find((turn) => turn.id === turnId)?.feedback;
+    if (!current?.rating || current.shared) return Promise.resolve();
+    return this.sendFeedback(
+      turnId,
+      { rating: current.rating, reason: current.reason, share: true },
+      { rating: current.rating, reason: current.reason, shared: false, pending: "share" },
+    );
+  }
+
+  private sendFeedback(
+    turnId: string,
+    request: ASKGFeedbackRequest,
+    optimistic: ASKGTurnFeedback,
+  ): Promise<void> {
+    const turn = this.state.turns.find((entry) => entry.id === turnId);
+    if (this.disposed || !turn || !canRateTurn(this.state, turn) || !turn.remoteTurnId) {
+      return Promise.resolve();
+    }
+    const remoteTurnId = turn.remoteTurnId;
+    const previous = turn.feedback ? { ...turn.feedback, pending: null } : null;
+    const version = (this.feedbackVersions.get(turnId) ?? 0) + 1;
+    this.feedbackVersions.set(turnId, version);
+    this.dispatch({ type: "feedback", turnId, feedback: optimistic });
+
+    const send = async () => {
+      const latest = () => this.feedbackVersions.get(turnId) === version;
+      try {
+        const stored = await this.options.transport.sendFeedback(remoteTurnId, request);
+        if (!latest()) return;
+        if (!stored) {
+          // No answer of this person's under that id: nothing here can rate it.
+          this.dispatch({ type: "feedback", turnId, feedback: previous });
+          this.dispatch({ type: "feedback-unavailable" });
+          return;
+        }
+        this.dispatch({
+          type: "feedback",
+          turnId,
+          feedback: {
+            ...stored,
+            pending: null,
+            ...(request.share && !stored.shared ? { shareFailed: true } : {}),
+          },
+        });
+      } catch (error) {
+        if (!latest()) return;
+        this.dispatch({ type: "feedback", turnId, feedback: previous });
+        if (feedbackUnavailable(error)) this.dispatch({ type: "feedback-unavailable" });
+      }
+    };
+    const queued = (this.feedbackQueues.get(turnId) ?? Promise.resolve()).then(send);
+    this.feedbackQueues.set(turnId, queued);
+    return queued;
+  }
+
   setExpanded(toolCallId: string, expanded: boolean): void {
     this.dispatch({ type: "tool-expanded", toolCallId, expanded });
   }

package/src/plugins/builtin/cloud/askg/conversation-store.ts

@@ -46,6 +46,7 @@ export class ASKGConversationListStore {
   private persistence: PluginPersistence | null = null;
   private transport: ASKGTransport | null = null;
   private inFlight: Promise<void> | null = null;
+  private openConversationId: string | null = null;
 
   getSnapshot(): ASKGConversationListSnapshot {
     return this.snapshot;
@@ -126,6 +127,7 @@ export class ASKGConversationListStore {
   async delete(id: string): Promise<void> {
     const transport = this.transport;
     if (!transport) return;
+    if (this.openConversationId === id) this.openConversationId = null;
     const previous = this.snapshot.conversations;
     this.remove(id);
     try {
@@ -178,11 +180,30 @@ export class ASKGConversationListStore {
     this.persistence?.setState(WIDTH_STATE_KEY, width);
   }
 
+  /**
+   * The conversation an Ask Gloom pane last showed. Closing the pane (Esc Esc
+   * is two keys) must not lose the answer on screen, so the next pane this
+   * app session opens picks it up again. Kept in memory only: a fresh launch
+   * starts a fresh conversation, and every older one is in the list.
+   */
+  rememberOpen(id: string | null): void {
+    this.openConversationId = id;
+  }
+
+  rememberedOpen(): string | null {
+    const id = this.openConversationId;
+    if (!id) return null;
+    // A conversation deleted since is not brought back.
+    if (this.snapshot.loaded && !this.snapshot.conversations.some((conversation) => conversation.id === id)) return null;
+    return id;
+  }
+
   /** Test hook: drops the persisted handle, the transport and the rows. */
   reset(): void {
     this.persistence = null;
     this.transport = null;
     this.inFlight = null;
+    this.openConversationId = null;
     this.snapshot = EMPTY;
   }
 

package/src/plugins/builtin/cloud/askg/manifest.ts

@@ -74,6 +74,7 @@ function projectOptions(options: HeadlessPaneDefinition["options"]): ToolManifes
   return options.map(({
     settingKey: _settingKey,
     pluginState: _pluginState,
+    normalize: _normalize,
     values,
     aliases,
     defaultValue,