feat(assistant): surface confirmed tool results via a host renderer (fix lost API key) (#179)

* feat(assistant): surface confirmed tool results via a host renderer, fix lost API key

A confirmed create_api_key returns its one-time secret in output.key, but the
client dropped it: describeOutcome read only the prefix and told the user to
"copy it from the API Keys page" — impossible, since a key's secret is shown
only once at creation. Retain a confirmed tool's output on the resolving status
message and render it prominently via a new host `renderConfirmedResult` slot
(threaded through AssistantDock/Panel/transcript, mirroring toolRenderers), so a
host can show a one-time reveal card. Correct the create_api_key status text.

The secret lives only in the in-memory transcript (never cached, never sent back
to the model), so it is shown once and gone on reload — matching the dedicated
create-key page. Unlike toolRenderers' collapsed detail, the result card is
expanded so a one-time secret is visible without a click.

* fix(assistant): don't wrap a null confirmed-result in a margin box

renderConfirmedResult returns null for a tool the host doesn't render a card
for; the transcript still wrapped that null in `<div class="mt-3">`, leaving an
empty spacer under every other confirmed tool's status line. Compute the node
first and only wrap when it is non-null.

Author: Tjemmmic

src/assistant/AssistantDock.tsx

@@ -23,6 +23,7 @@ import { useAssistantLauncher } from "./launcher";
 import { ResizeHandle } from "./ResizeHandle";
 import type {
   AssistantTranscriptView,
+  ConfirmedResult,
   ConnectionRequirement,
   ConnectRequirementResult,
 } from "./types";
@@ -52,6 +53,11 @@ export interface AssistantDockProps {
   renderMarkdown?: (content: string) => ReactNode;
   /** Per-tool custom detail renderers for expanded tool cards in the transcript. */
   toolRenderers?: ToolDetailRenderers;
+  /** Render a prominent card for a CONFIRMED tool's result (e.g. a one-time
+   *  API-key reveal for `create_api_key`), shown inline after the action's status
+   *  line. The result's `output` may carry a one-time secret — see
+   *  {@link ConfirmedResult} for the never-persist/never-to-model contract. */
+  renderConfirmedResult?: (result: ConfirmedResult) => ReactNode;
   /** Swap the conversation rendering for a host-supplied renderer (see
    *  {@link AssistantPanelProps.renderTranscript}); the dock chrome, composer,
    *  transport, and proposal flow stay owned by the panel. */
@@ -79,6 +85,7 @@ export function AssistantDock({
   onConnectRequirement,
   renderMarkdown,
   toolRenderers,
+  renderConfirmedResult,
   renderTranscript,
 }: AssistantDockProps) {
   const { open, openAssistant, closeAssistant } = useAssistantLauncher();
@@ -199,6 +206,7 @@ export function AssistantDock({
           renderGraph={renderGraph}
           renderMarkdown={renderMarkdown}
           toolRenderers={toolRenderers}
+          renderConfirmedResult={renderConfirmedResult}
           renderTranscript={renderTranscript}
         />
         {isDesktop && (

src/assistant/AssistantPanel.tsx

@@ -19,7 +19,7 @@ import type { AssistantModels } from "./client";
 import { isLowBalance, presentError } from "./presentation";
 import { ProposalCard } from "./ProposalCard";
 import { AssistantTranscript, assistantIsThinking } from "./transcript";
-import type { AssistantTranscriptView } from "./types";
+import type { AssistantTranscriptView, ConfirmedResult } from "./types";
 import type { AssistantChat } from "./useAssistantChat";
 import { useAssistantModels } from "./useAssistantModels";
 import { useAssistantThreads } from "./useAssistantThreads";
@@ -44,6 +44,10 @@ export interface AssistantPanelProps {
   renderMarkdown?: (content: string) => ReactNode;
   /** Per-tool custom detail renderers for expanded tool cards in the transcript. */
   toolRenderers?: ToolDetailRenderers;
+  /** Render a prominent card for a CONFIRMED tool's result (e.g. a one-time
+   *  API-key reveal for `create_api_key`), shown inline after the action's status
+   *  line. Ignored when a host swaps the whole transcript via `renderTranscript`. */
+  renderConfirmedResult?: (result: ConfirmedResult) => ReactNode;
   /** Swap ONLY the conversation rendering for a host-supplied renderer (e.g. a
    *  different chat-message component), while the panel keeps owning the header,
    *  composer, model picker, history, transport, and proposal orchestration.
@@ -149,6 +153,7 @@ export function AssistantPanel({
   renderGraph,
   renderMarkdown,
   toolRenderers,
+  renderConfirmedResult,
   renderTranscript,
 }: AssistantPanelProps) {
   const models = useAssistantModels();
@@ -480,6 +485,7 @@ export function AssistantPanel({
                 view={transcriptView}
                 renderMarkdown={renderMarkdown}
                 toolRenderers={toolRenderers}
+                renderConfirmedResult={renderConfirmedResult}
                 emptyState={
                   <p className="px-4 py-8 text-center text-muted-foreground text-sm">
                     {EMPTY_STATE}

src/assistant/presentation.test.ts

@@ -175,6 +175,20 @@ describe("describeOutcome", () => {
   it("has a sensible default for unknown tools", () => {
     expect(describeOutcome("mystery", {})).toBe("Action completed.");
   });
+
+  it("records a created API key by prefix without pointing at the (impossible) keys page", () => {
+    // The secret is shown ONCE at creation and is unreadable from the API Keys
+    // page afterwards, so the status line must not tell the user to copy it from
+    // there — the reveal card carries the secret instead.
+    const text = describeOutcome("create_api_key", {
+      prefix: "sk-tan-abc",
+      key: "sk-tan-abc-THE-SECRET",
+    });
+    expect(text).toBe("Created API key (sk-tan-abc…).");
+    expect(text).not.toContain("API Keys page");
+    // The one-time secret must never leak into the transcript status line.
+    expect(text).not.toContain("THE-SECRET");
+  });
 });
 
 describe("describeFailure", () => {

src/assistant/presentation.ts

@@ -301,9 +301,11 @@ export function describeOutcome(name: string, output: unknown): string {
       return wf.enabled ? "Workflow enabled." : "Workflow disabled.";
     }
     case "create_api_key":
-      return o.prefix
-        ? `Created API key (${str(o.prefix)}…). Copy it from the API Keys page.`
-        : "API key created.";
+      // No "copy it from the API Keys page" instruction: a key's secret is shown
+      // ONLY once, at creation, and can't be retrieved from that page later. The
+      // secret rides `output.key` on the confirmed result and is surfaced by the
+      // host's reveal card (see ConfirmedResult); this line is just the record.
+      return o.prefix ? `Created API key (${str(o.prefix)}…).` : "API key created.";
     case "revoke_api_key":
       return "API key revoked.";
     case "invoke_integration":

src/assistant/transcript.test.tsx

@@ -0,0 +1,122 @@
+// @vitest-environment jsdom
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import { adaptTranscript, AssistantTranscript } from "./transcript";
+import type {
+  AssistantTranscriptView,
+  ChatMessage,
+  ConfirmedResult,
+} from "./types";
+
+/** A transcript view over a fixed message list — the fields a non-streaming,
+ *  proposal-free transcript needs; `renderProposal` is never reached here. */
+function viewOf(messages: ChatMessage[]): AssistantTranscriptView {
+  return {
+    messages,
+    reasoning: null,
+    streamingId: null,
+    model: null,
+    isStreaming: false,
+    isThinking: false,
+    pendingProposals: [],
+    usage: null,
+    renderProposal: () => null,
+  };
+}
+
+describe("adaptTranscript — confirmed results", () => {
+  it("surfaces a status message's retained result, keyed by that message's id", () => {
+    const result: ConfirmedResult = {
+      name: "create_api_key",
+      output: { key: "sk-tan-SECRET", prefix: "sk-tan" },
+      args: { name: "ci" },
+    };
+    const { confirmedResults } = adaptTranscript(
+      viewOf([
+        { id: "u1", role: "user", text: "make a key" },
+        { id: "s1", role: "status", text: "Created API key (sk-tan…).", result },
+      ]),
+    );
+    expect(confirmedResults.get("s1")).toBe(result);
+  });
+
+  it("carries nothing for a plain status message (no result)", () => {
+    const { confirmedResults } = adaptTranscript(
+      viewOf([{ id: "s1", role: "status", text: "Action cancelled." }]),
+    );
+    expect(confirmedResults.size).toBe(0);
+  });
+});
+
+describe("AssistantTranscript — confirmed-result card", () => {
+  it("renders the host card for a confirmed result while the secret stays out of the status text", () => {
+    const result: ConfirmedResult = {
+      name: "create_api_key",
+      output: { key: "sk-tan-SECRET", prefix: "sk-tan" },
+      args: { name: "ci" },
+    };
+    render(
+      <AssistantTranscript
+        view={viewOf([
+          { id: "u1", role: "user", text: "make a key" },
+          {
+            id: "s1",
+            role: "status",
+            text: "Created API key (sk-tan…).",
+            result,
+          },
+        ])}
+        renderConfirmedResult={(r) => (
+          <div data-testid="reveal">{String((r.output as { key: string }).key)}</div>
+        )}
+      />,
+    );
+    // The card renders the secret (a host reveal card would mask it; here we just
+    // prove the output reaches the renderer)…
+    expect(screen.getByTestId("reveal").textContent).toBe("sk-tan-SECRET");
+    // …and the status line is present and free of the secret.
+    expect(screen.getByText("Created API key (sk-tan…).")).toBeTruthy();
+  });
+
+  it("shows only the status line when no host renderer is supplied", () => {
+    render(
+      <AssistantTranscript
+        view={viewOf([
+          {
+            id: "s1",
+            role: "status",
+            text: "Created API key (sk-tan…).",
+            result: {
+              name: "create_api_key",
+              output: { key: "sk-tan-SECRET" },
+            },
+          },
+        ])}
+      />,
+    );
+    // With no `renderConfirmedResult`, the result is retained but never shown, so
+    // the transcript degrades to just the status line — no secret anywhere.
+    expect(screen.getByText("Created API key (sk-tan…).")).toBeTruthy();
+    expect(screen.queryByText(/sk-tan-SECRET/)).toBeNull();
+  });
+
+  it("adds no wrapper (no empty spacer) when the renderer returns null for a result", () => {
+    // A confirmed tool the host renderer doesn't handle (returns null) must not
+    // leave an empty margin box under its status line.
+    const { container } = render(
+      <AssistantTranscript
+        view={viewOf([
+          {
+            id: "s1",
+            role: "status",
+            text: "Workflow created.",
+            result: { name: "create_workflow", output: { ok: true } },
+          },
+        ])}
+        renderConfirmedResult={() => null}
+      />,
+    );
+    expect(screen.getByText("Workflow created.")).toBeTruthy();
+    expect(container.querySelector(".mt-3")).toBeNull();
+  });
+});

src/assistant/transcript.tsx

@@ -22,6 +22,7 @@ import {
 import type { AssistantState } from "./reducer";
 import type {
   AssistantTranscriptView,
+  ConfirmedResult,
   PendingProposal,
   ToolOutcome,
 } from "./types";
@@ -57,6 +58,10 @@ export interface AdaptedTranscript {
   /** The current/most-recent turn's assistant message — where the turn cost line
    *  renders (it carries the turn's metrics), or null when there is none. */
   metricsHostId: string | null;
+  /** Confirmed-tool results to render under their (system) message, keyed by that
+   *  message's id — carried from a `status` message's retained `result` so a host
+   *  card (e.g. a one-time API-key reveal) renders inline right after the action. */
+  confirmedResults: Map<string, ConfirmedResult>;
 }
 
 /**
@@ -87,6 +92,7 @@ type TurnMessage = ChatUiMessage & { segments: ChatMessageSegment[] };
  */
 export function adaptTranscript(view: AssistantTranscriptView): AdaptedTranscript {
   const messages: ChatUiMessage[] = [];
+  const confirmedResults = new Map<string, ConfirmedResult>();
   let turn: TurnMessage | null = null;
   // The assistant message of the CURRENT turn — the one opened since the most
   // recent user message — or null when the live turn has produced no assistant
@@ -144,6 +150,10 @@ export function adaptTranscript(view: AssistantTranscriptView): AdaptedTranscrip
     } else {
       // `status` — an informational system note that ends the assistant turn.
       messages.push({ id: msg.id, role: "system", content: msg.text });
+      // A confirmed mutating tool that returned a renderable result attaches it
+      // to its status message; carry it out keyed by this system message's id so
+      // the host card renders inline right under the status line.
+      if (msg.result) confirmedResults.set(msg.id, msg.result);
       turn = null;
     }
   }
@@ -198,6 +208,7 @@ export function adaptTranscript(view: AssistantTranscriptView): AdaptedTranscrip
       currentTurnAssistant && !isEmptyShell(currentTurnAssistant)
         ? currentTurnAssistant.id
         : null,
+    confirmedResults,
   };
 }
 
@@ -224,6 +235,12 @@ export interface AssistantTranscriptProps {
   renderMarkdown?: (content: string) => ReactNode;
   /** Per-tool custom detail renderers for expanded tool cards. */
   toolRenderers?: ToolDetailRenderers;
+  /** Render a prominent card for a CONFIRMED tool's result, inline after its
+   *  status line (e.g. a one-time API-key reveal for `create_api_key`). Return
+   *  null to fall back to just the status line. Unlike `toolRenderers` (collapsed
+   *  detail for a read-only tool chip), this is shown expanded, so a one-time
+   *  secret is visible without a click. See {@link ConfirmedResult}. */
+  renderConfirmedResult?: (result: ConfirmedResult) => ReactNode;
   /** Zero-state shown for a fresh, non-streaming thread. */
   emptyState?: ReactNode;
 }
@@ -238,9 +255,10 @@ export function AssistantTranscript({
   view,
   renderMarkdown,
   toolRenderers,
+  renderConfirmedResult,
   emptyState,
 }: AssistantTranscriptProps) {
-  const { messages, proposalHostId, metricsHostId } = useMemo(
+  const { messages, proposalHostId, metricsHostId, confirmedResults } = useMemo(
     () => adaptTranscript(view),
     [view],
   );
@@ -280,6 +298,19 @@ export function AssistantTranscript({
               ))}
             </div>
           ) : null;
+        // A confirmed tool's host card, rendered inline under its status line
+        // (e.g. the one-time API-key reveal). Only when the host supplied a
+        // renderer AND it returns a node for this result — a renderer that
+        // returns null (a tool it doesn't handle) must add no wrapper, or every
+        // other confirmed tool would get an empty `mt-3` spacer under its status.
+        const confirmed = confirmedResults.get(message.id);
+        const confirmedNode =
+          confirmed && renderConfirmedResult
+            ? renderConfirmedResult(confirmed)
+            : null;
+        const confirmedCard = confirmedNode ? (
+          <div className="mt-3">{confirmedNode}</div>
+        ) : null;
         // The settled turn's at-cost figure, shown once under its assistant
         // bubble. Hidden while streaming and for a replayed (uncharged) turn.
         const cost =
@@ -291,9 +322,10 @@ export function AssistantTranscript({
               {formatTurnCost(view.usage.costUsd)} this turn
             </p>
           ) : null;
-        if (!proposals && !cost) return null;
+        if (!proposals && !cost && !confirmedCard) return null;
         return (
           <>
+            {confirmedCard}
             {proposals}
             {cost}
           </>

src/assistant/types.ts

@@ -162,6 +162,28 @@ export type ToolOutcome =
   | { ok: true; result?: unknown }
   | { ok: false; error?: { code: string; message: string } };
 
+/**
+ * The result of a CONFIRMED mutating tool, retained on the resolving `status`
+ * message so a host can render it prominently (e.g. a one-time API-key reveal).
+ *
+ * SECURITY: `output` may carry a one-time secret (e.g. a freshly minted API
+ * key). It lives ONLY in the in-memory transcript for the session — the message
+ * transcript is deliberately never cached (see `persistence.ts`) and is never
+ * sent back to the model (a turn request carries only the new user text, see
+ * {@link ChatRequest}). So the secret is shown once and is gone on reload,
+ * matching how a dedicated create-key page reveals a key exactly once. A host
+ * renderer must uphold the same contract: reveal-on-demand, never persist it.
+ */
+export interface ConfirmedResult {
+  /** The confirmed tool's name (e.g. "create_api_key"). */
+  name: string;
+  /** The tool's raw output. May contain a one-time secret — see the type doc. */
+  output: unknown;
+  /** The arguments the action was confirmed with, for a renderer that needs them
+   *  (e.g. the key's name). */
+  args?: unknown;
+}
+
 export interface ChatMessage {
   id: string;
   role: ChatRole;
@@ -174,6 +196,11 @@ export interface ChatMessage {
     args?: Record<string, unknown>;
     outcome?: ToolOutcome;
   };
+  /** Present only on a `status` message that resolved a confirmed mutating tool
+   *  which returned a renderable result — carries that result so the transcript
+   *  can render a host-supplied card (e.g. a one-time key reveal) next to the
+   *  status line. See {@link ConfirmedResult} for the one-time-secret contract. */
+  result?: ConfirmedResult;
 }
 
 /** A mutating action the assistant proposed, awaiting the user's confirmation. */