@sentry/junior-dashboard 0.58.0

package/dist/app.js

@@ -0,0 +1,492 @@
+// src/app.ts
+import { Hono } from "hono";
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { createJuniorReporting } from "@sentry/junior/reporting";
+import { initSentry } from "@sentry/junior/instrumentation";
+
+// src/auth.ts
+import { betterAuth } from "better-auth";
+var DEFAULT_SESSION_MAX_AGE_SECONDS = 60 * 60 * 8;
+function sanitizeDashboardSession(session) {
+  const { email, emailVerified, hostedDomain, name } = session.user;
+  return {
+    user: {
+      email,
+      emailVerified,
+      hostedDomain,
+      name
+    }
+  };
+}
+function required(value, name) {
+  if (!value?.trim()) {
+    throw new Error(`${name} is required for Junior dashboard auth`);
+  }
+  return value.trim();
+}
+function firstHostedDomain(domains) {
+  return domains.length === 1 ? domains[0] : void 0;
+}
+function withHttps(host) {
+  return /^https?:\/\//.test(host) ? host : `https://${host}`;
+}
+function stripTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 1 && value.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
+function resolveBaseURL(config) {
+  const explicit = config.baseURL ?? process.env.BETTER_AUTH_URL ?? process.env.JUNIOR_BASE_URL;
+  if (explicit?.trim()) {
+    return stripTrailingSlashes(withHttps(explicit.trim()));
+  }
+  const vercelProd = process.env.VERCEL_PROJECT_PRODUCTION_URL?.trim();
+  if (vercelProd) {
+    return stripTrailingSlashes(withHttps(vercelProd));
+  }
+  const vercelUrl = process.env.VERCEL_URL?.trim();
+  if (vercelUrl) {
+    return stripTrailingSlashes(withHttps(vercelUrl));
+  }
+  return "http://localhost:3000";
+}
+function createDashboardAuth(config) {
+  const secret = required(
+    config.secret ?? process.env.BETTER_AUTH_SECRET ?? process.env.JUNIOR_SECRET,
+    "JUNIOR_SECRET or BETTER_AUTH_SECRET"
+  );
+  const baseURL = resolveBaseURL(config);
+  const googleClientId = required(
+    config.googleClientId ?? process.env.GOOGLE_CLIENT_ID,
+    "GOOGLE_CLIENT_ID"
+  );
+  const googleClientSecret = required(
+    config.googleClientSecret ?? process.env.GOOGLE_CLIENT_SECRET,
+    "GOOGLE_CLIENT_SECRET"
+  );
+  const auth = betterAuth({
+    appName: "Junior Dashboard",
+    baseURL,
+    basePath: config.authPath,
+    secret,
+    trustedOrigins: config.trustedOrigins,
+    socialProviders: {
+      google: {
+        clientId: googleClientId,
+        clientSecret: googleClientSecret,
+        hd: config.googleHostedDomain,
+        prompt: "select_account",
+        mapProfileToUser(profile) {
+          return {
+            email: profile.email,
+            emailVerified: profile.email_verified,
+            hostedDomain: profile.hd,
+            image: profile.picture,
+            name: profile.name
+          };
+        }
+      }
+    },
+    user: {
+      additionalFields: {
+        hostedDomain: {
+          type: "string",
+          required: false,
+          input: false,
+          returned: true
+        }
+      }
+    },
+    account: {
+      storeStateStrategy: "cookie",
+      storeAccountCookie: false,
+      updateAccountOnSignIn: false
+    },
+    session: {
+      expiresIn: config.sessionMaxAgeSeconds ?? DEFAULT_SESSION_MAX_AGE_SECONDS,
+      disableSessionRefresh: true,
+      cookieCache: {
+        enabled: true,
+        strategy: "jwe",
+        maxAge: config.sessionMaxAgeSeconds ?? DEFAULT_SESSION_MAX_AGE_SECONDS,
+        refreshCache: false
+      }
+    }
+  });
+  return {
+    handler(request) {
+      return auth.handler(request);
+    },
+    async getSession(request) {
+      const session = await auth.api.getSession({ headers: request.headers });
+      if (!session) {
+        return null;
+      }
+      return sanitizeDashboardSession(session);
+    },
+    async signInWithGoogle(request, callbackURL) {
+      const result = await auth.api.signInSocial({
+        body: {
+          provider: "google",
+          callbackURL
+        },
+        headers: request.headers,
+        returnHeaders: true
+      });
+      if (!("url" in result.response) || !result.response.url) {
+        throw new Error("Google sign-in did not return a redirect URL");
+      }
+      result.headers.set("location", result.response.url);
+      return new Response(null, {
+        status: 302,
+        headers: result.headers
+      });
+    }
+  };
+}
+function resolveGoogleHostedDomainHint(domains) {
+  return firstHostedDomain(domains.map((domain) => domain.toLowerCase()));
+}
+
+// src/app.ts
+var DEFAULT_BASE_PATH = "/";
+var DEFAULT_AUTH_PATH = "/api/auth";
+var DASHBOARD_CLIENT_VERSION = Date.now().toString(36);
+function hasSentryConversationLinks() {
+  return Boolean(
+    process.env.SENTRY_DSN?.trim() && process.env.SENTRY_ORG_SLUG?.trim()
+  );
+}
+function normalizePath(path2, fallback) {
+  const value = path2.trim() || fallback;
+  const withSlash = value.startsWith("/") ? value : `/${value}`;
+  return stripTrailingSlashes2(withSlash);
+}
+function stripTrailingSlashes2(value) {
+  let end = value.length;
+  while (end > 1 && value.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
+function normalizeValues(values) {
+  return [
+    ...new Set(
+      (values ?? []).map((value) => value.trim().toLowerCase()).filter(Boolean)
+    )
+  ];
+}
+function isJsonRoute(pathname) {
+  return pathname.startsWith("/api/");
+}
+function dashboardLoginUrl(request) {
+  const url = new URL(request.url);
+  url.pathname = "/api/dashboard/login";
+  url.search = "";
+  return url.toString();
+}
+function callbackUrl(request, basePath) {
+  const url = new URL(request.url);
+  url.pathname = basePath;
+  url.search = "";
+  return url.toString();
+}
+function isAuthorized(session, allowedDomains, allowedEmails) {
+  const email = session.user.email?.toLowerCase();
+  const domain = session.user.hostedDomain?.toLowerCase();
+  if (session.user.emailVerified && email && allowedEmails.includes(email)) {
+    return true;
+  }
+  return Boolean(
+    session.user.emailVerified && domain && allowedDomains.includes(domain)
+  );
+}
+function unauthorized(request) {
+  if (isJsonRoute(new URL(request.url).pathname)) {
+    return Response.json({ error: "unauthenticated" }, { status: 401 });
+  }
+  return Response.redirect(dashboardLoginUrl(request), 302);
+}
+function forbidden(request) {
+  if (!isJsonRoute(new URL(request.url).pathname)) {
+    return new Response(
+      `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Junior access denied</title>
+  <style>
+    ${readDashboardTailwind()}
+  </style>
+</head>
+<body class="m-0 bg-black font-sans text-white [color-scheme:dark]">
+  <main class="grid min-h-screen place-items-center p-8">
+    <section class="max-w-lg border-l-4 border-rose-400 pl-4">
+      <h1 class="m-0 mb-3 text-[1.75rem] font-bold leading-tight">Access denied</h1>
+      <p class="m-0 leading-relaxed text-[#b8b8b8]">Your Google account is authenticated, but it is not allowed to use this Junior dashboard.</p>
+    </section>
+  </main>
+</body>
+</html>`,
+      {
+        headers: {
+          "cache-control": "no-store",
+          "content-type": "text/html; charset=utf-8"
+        },
+        status: 403
+      }
+    );
+  }
+  return Response.json({ error: "forbidden" }, { status: 403 });
+}
+function dashboardSessionBypass() {
+  return {
+    user: {
+      email: "local-dashboard@localhost",
+      emailVerified: true,
+      hostedDomain: "localhost"
+    }
+  };
+}
+function readDashboardAsset(fileName) {
+  const localDistUrl = new URL(`./${fileName}`, import.meta.url);
+  if (existsSync(localDistUrl)) {
+    return readFileSync(localDistUrl, "utf8");
+  }
+  const sourceDistUrl = new URL(`../dist/${fileName}`, import.meta.url);
+  if (existsSync(sourceDistUrl)) {
+    return readFileSync(sourceDistUrl, "utf8");
+  }
+  const workspacePackagePath = path.join(
+    process.cwd(),
+    "node_modules",
+    "@sentry",
+    "junior-dashboard",
+    "dist",
+    fileName
+  );
+  if (existsSync(workspacePackagePath)) {
+    return readFileSync(workspacePackagePath, "utf8");
+  }
+  return "";
+}
+function readDashboardClient() {
+  const client = readDashboardAsset("client.js");
+  if (!client) {
+    throw new Error("Junior dashboard client bundle was not found");
+  }
+  return client;
+}
+function dashboardTimeZone() {
+  return process.env.JUNIOR_TIMEZONE || "America/Los_Angeles";
+}
+function readDashboardTailwind() {
+  return readDashboardAsset("tailwind.css");
+}
+function dashboardPagePaths(basePath) {
+  return [
+    basePath,
+    basePath === "/" ? "/conversations" : `${basePath}/conversations`,
+    basePath === "/" ? "/sessions" : `${basePath}/sessions`
+  ];
+}
+function renderDashboard(basePath) {
+  return new Response(
+    `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Junior</title>
+  <style>
+    ${readDashboardTailwind()}
+  </style>
+</head>
+<body class="m-0 bg-black text-white [color-scheme:dark]">
+  <div id="dashboard-root"></div>
+  <script>
+    window.__JUNIOR_DASHBOARD_BASE_PATH__ = ${JSON.stringify(basePath)};
+    (function () {
+      function escapeHtml(value) {
+        return String(value)
+          .replace(/&/g, "&amp;")
+          .replace(/</g, "&lt;")
+          .replace(/>/g, "&gt;")
+          .replace(/"/g, "&quot;")
+          .replace(/'/g, "&#039;");
+      }
+      function errorText(error) {
+        if (!error) return "Unknown dashboard error";
+        if (typeof error === "string") return error;
+        if (error.stack) return error.stack;
+        if (error.message) return error.message;
+        try {
+          return JSON.stringify(error, null, 2);
+        } catch (_error) {
+          return String(error);
+        }
+      }
+      window.__JUNIOR_DASHBOARD_SHOW_ERROR__ = function (error) {
+        var root = document.getElementById("dashboard-root");
+        if (!root) return;
+        root.innerHTML =
+          '<main class="grid min-h-screen place-items-center bg-black p-8 text-white">' +
+          '<section class="w-full max-w-5xl border border-rose-400/50 bg-[#0b0b0b] p-5 font-sans">' +
+          '<div class="font-mono text-xs uppercase leading-none text-[#888]">Dashboard Error</div>' +
+          '<h1 class="mt-2 text-3xl font-bold leading-tight tracking-normal">Junior failed to render</h1>' +
+          '<p class="my-4 max-w-3xl text-[#b8b8b8]">The dashboard hit a client-side exception. The stack trace is shown here so the page does not fail blank.</p>' +
+          '<pre class="max-h-[60vh] overflow-auto whitespace-pre-wrap break-words border border-white/10 bg-black p-4 font-mono text-sm leading-relaxed text-white">' +
+          escapeHtml(errorText(error)) +
+          "</pre></section></main>";
+      };
+      window.addEventListener("error", function (event) {
+        window.__JUNIOR_DASHBOARD_SHOW_ERROR__(event.error || event.message);
+      });
+      window.addEventListener("unhandledrejection", function (event) {
+        window.__JUNIOR_DASHBOARD_SHOW_ERROR__(event.reason);
+      });
+    })();
+  </script>
+  <script type="module" src="/api/dashboard/client.js?v=${DASHBOARD_CLIENT_VERSION}"></script>
+</body>
+</html>`,
+    {
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "text/html; charset=utf-8"
+      }
+    }
+  );
+}
+function renderFavicon() {
+  return new Response(
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" fill="#000000"/><text x="16" y="20.5" fill="#ffffff" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="11" font-weight="900" text-anchor="middle">Jr</text></svg>`,
+    { headers: { "content-type": "image/svg+xml" } }
+  );
+}
+function createDashboardApp(options) {
+  if (process.env.SENTRY_DSN?.trim()) {
+    initSentry();
+  }
+  const basePath = normalizePath(
+    options.basePath ?? DEFAULT_BASE_PATH,
+    DEFAULT_BASE_PATH
+  );
+  const authPath = normalizePath(
+    options.authPath ?? DEFAULT_AUTH_PATH,
+    DEFAULT_AUTH_PATH
+  );
+  const allowedDomains = normalizeValues(options.allowedGoogleDomains);
+  const allowedEmails = normalizeValues(options.allowedEmails);
+  const authRequired = options.authRequired !== false;
+  if (authRequired && allowedDomains.length === 0 && allowedEmails.length === 0) {
+    throw new Error(
+      "Junior dashboard auth requires allowedGoogleDomains or allowedEmails"
+    );
+  }
+  const auth = authRequired ? options.auth ?? createDashboardAuth({
+    authPath,
+    trustedOrigins: options.trustedOrigins ?? [],
+    googleHostedDomain: resolveGoogleHostedDomainHint(allowedDomains),
+    sessionMaxAgeSeconds: options.sessionMaxAgeSeconds
+  }) : void 0;
+  const reporting = options.reporting ?? createJuniorReporting();
+  const app = new Hono();
+  if (auth) {
+    app.on(["GET", "POST"], `${authPath}/*`, (c) => auth.handler(c.req.raw));
+  }
+  app.get("/favicon.ico", () => renderFavicon());
+  app.get("/api/dashboard/login", async (c) => {
+    if (!auth) {
+      return Response.redirect(callbackUrl(c.req.raw, basePath), 302);
+    }
+    return auth.signInWithGoogle(c.req.raw, callbackUrl(c.req.raw, basePath));
+  });
+  const requireDashboardSession = async (c, next) => {
+    if (!authRequired) {
+      c.set("dashboardSession", dashboardSessionBypass());
+      await next();
+      return;
+    }
+    if (!auth) {
+      return unauthorized(c.req.raw);
+    }
+    const session = await auth.getSession(c.req.raw);
+    if (!session) {
+      return unauthorized(c.req.raw);
+    }
+    if (!isAuthorized(session, allowedDomains, allowedEmails)) {
+      return forbidden(c.req.raw);
+    }
+    c.set("dashboardSession", sanitizeDashboardSession(session));
+    await next();
+  };
+  if (basePath === "/") {
+    app.use("/*", requireDashboardSession);
+  } else {
+    app.use(basePath, requireDashboardSession);
+    app.use(`${basePath}/*`, requireDashboardSession);
+  }
+  app.use("/api/dashboard/*", requireDashboardSession);
+  for (const path2 of dashboardPagePaths(basePath)) {
+    app.get(path2, () => renderDashboard(basePath));
+    if (path2 !== "/") {
+      app.get(`${path2}/*`, () => renderDashboard(basePath));
+    }
+  }
+  app.get("/api/dashboard/health", async () => {
+    return Response.json(await reporting.getHealth());
+  });
+  app.get("/api/dashboard/runtime", async () => {
+    return Response.json(await reporting.getRuntimeInfo());
+  });
+  app.get("/api/dashboard/plugins", async () => {
+    return Response.json(await reporting.getPlugins());
+  });
+  app.get("/api/dashboard/skills", async () => {
+    return Response.json(await reporting.getSkills());
+  });
+  app.get("/api/dashboard/sessions", async () => {
+    return Response.json(await reporting.getSessions());
+  });
+  app.get("/api/dashboard/conversations/:conversationId", async (c) => {
+    return Response.json(
+      await reporting.getConversation(
+        decodeURIComponent(c.req.param("conversationId"))
+      )
+    );
+  });
+  app.get("/api/dashboard/config", () => {
+    return Response.json({
+      allowedEmailCount: allowedEmails.length,
+      allowedGoogleDomainCount: allowedDomains.length,
+      authRequired,
+      authPath,
+      basePath,
+      sentryConversationLinks: hasSentryConversationLinks(),
+      timeZone: dashboardTimeZone()
+    });
+  });
+  app.get("/api/dashboard/me", (c) => {
+    return Response.json(c.get("dashboardSession"));
+  });
+  app.get("/api/dashboard/info", async () => {
+    return Response.json(await reporting.getRuntimeInfo());
+  });
+  app.get("/api/dashboard/client.js", () => {
+    return new Response(readDashboardClient(), {
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "application/javascript; charset=utf-8"
+      }
+    });
+  });
+  return app;
+}
+export {
+  createDashboardApp
+};

package/dist/auth.d.ts

@@ -0,0 +1,30 @@
+export interface DashboardUser {
+    email?: string | null;
+    emailVerified?: boolean;
+    hostedDomain?: string | null;
+    name?: string | null;
+}
+export interface DashboardSession {
+    user: DashboardUser;
+}
+export interface DashboardAuthConfig {
+    baseURL?: string;
+    authPath: string;
+    trustedOrigins: string[];
+    secret?: string;
+    googleClientId?: string;
+    googleClientSecret?: string;
+    googleHostedDomain?: string;
+    sessionMaxAgeSeconds?: number;
+}
+export interface DashboardAuth {
+    handler(request: Request): Promise<Response>;
+    getSession(request: Request): Promise<DashboardSession | null>;
+    signInWithGoogle(request: Request, callbackURL: string): Promise<Response>;
+}
+/** Keep dashboard identity responses limited to user display fields. */
+export declare function sanitizeDashboardSession(session: DashboardSession): DashboardSession;
+/** Create the Better Auth bridge used by dashboard browser routes. */
+export declare function createDashboardAuth(config: DashboardAuthConfig): DashboardAuth;
+/** Resolve a Google hosted-domain login hint when it is unambiguous. */
+export declare function resolveGoogleHostedDomainHint(domains: string[]): string | undefined;

package/dist/client/App.d.ts

@@ -0,0 +1,2 @@
+/** Render the dashboard SPA shell and route-level loading states. */
+export declare function DashboardShell(): import("react/jsx-runtime").JSX.Element;

package/dist/client/api.d.ts

@@ -0,0 +1,10 @@
+import { QueryClient } from "@tanstack/react-query";
+import type { ConversationDetailFeed, DashboardData } from "./types";
+/** Share dashboard query cache between route data and tooltip detail lookups. */
+export declare const client: QueryClient;
+/** Poll the dashboard summary feed used by command center and conversation lists. */
+export declare function useDashboardData(): import("@tanstack/react-query").UseQueryResult<NoInfer<DashboardData>, Error>;
+/** Poll one conversation transcript while preserving route-level disabled state. */
+export declare function useConversationData(conversationId: string | undefined): import("@tanstack/react-query").UseQueryResult<NoInfer<ConversationDetailFeed>, Error>;
+/** Read one conversation transcript payload for dashboard-local detail views. */
+export declare function readConversationData(conversationId: string): Promise<ConversationDetailFeed>;

package/dist/client/code.d.ts

@@ -0,0 +1,15 @@
+import { type BundledLanguage } from "shiki/bundle/web";
+import type { CodeBlock } from "./types";
+/** Count rendered children so transcripts can decide which markup node expands. */
+export declare function countStructuredBlockChildren(block: CodeBlock): number;
+/** Render structured markup blocks as collapsible nodes instead of flat code. */
+export declare function StructuredMarkup(props: {
+    block: CodeBlock;
+    firstChildIndex: number;
+    lastChildIndex: number;
+}): import("react/jsx-runtime").JSX.Element;
+/** Render highlighted code while keeping Shiki output responsive in transcripts. */
+export declare function HighlightedCode(props: {
+    code: string;
+    language: BundledLanguage;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/CommandRail.d.ts

@@ -0,0 +1,6 @@
+import type { DashboardData } from "../types";
+/** Render the command-center summary rail from the dashboard health payload. */
+export declare function CommandRail(props: {
+    data?: DashboardData;
+    error: Error | null;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/ConversationList.d.ts

@@ -0,0 +1,7 @@
+import type { Conversation } from "../types";
+/** Render the full conversation table used by the conversations page. */
+export declare function ConversationList(props: {
+    conversations: Conversation[];
+    selectedId?: string;
+    search?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/ConversationRowStats.d.ts

@@ -0,0 +1,6 @@
+import type { Conversation } from "../types";
+/** Render compact conversation metadata aligned to row context. */
+export declare function ConversationRowStats(props: {
+    conversation: Conversation;
+    timeLabel: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/ConversationStack.d.ts

@@ -0,0 +1,5 @@
+import type { Conversation } from "../types";
+/** Render the compact latest-conversation stack on the command center. */
+export declare function ConversationStack(props: {
+    conversations: Conversation[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/ConversationSummary.d.ts

@@ -0,0 +1,5 @@
+import type { Conversation } from "../types";
+/** Render the shared conversation title, identity, status, and Sentry link. */
+export declare function ConversationSummary(props: {
+    conversation: Conversation;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/EmptyTelemetry.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from "react";
+/** Render the dashboard empty-state block with a warning accent. */
+export declare function EmptyTelemetry(props: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/FilterTabs.d.ts

@@ -0,0 +1,6 @@
+import type { SessionFilter } from "../types";
+/** Render conversation filters while keeping URL state owned by the page. */
+export declare function FilterTabs(props: {
+    current: SessionFilter;
+    onChange(filter: SessionFilter): void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/JuniorLogo.d.ts

@@ -0,0 +1,2 @@
+/** Render the compact Junior wordmark used by the dashboard shell. */
+export declare function JuniorLogo(): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/LoadingView.d.ts

@@ -0,0 +1,4 @@
+/** Render the full-page loading treatment before the first dashboard payload lands. */
+export declare function LoadingView(props: {
+    label: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/Section.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+/** Frame a dashboard content region without leaking CSS class contracts. */
+export declare function Section(props: {
+    children: ReactNode;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/SectionHeader.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+/** Render a dashboard section heading row with optional controls. */
+export declare function SectionHeader(props: {
+    actions?: ReactNode;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/SectionTitle.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from "react";
+/** Render compact section titles that fit inside operational panels. */
+export declare function SectionTitle(props: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/StatusBadge.d.ts

@@ -0,0 +1,6 @@
+import type { VisualStatus } from "../types";
+/** Render readable status text while keeping severity color restrained. */
+export declare function StatusBadge(props: {
+    label?: string;
+    status: VisualStatus | undefined;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/ToolFrame.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+/** Render the shared expandable/non-expandable frame for transcript tools. */
+export declare function ToolFrame(props: {
+    children?: ReactNode;
+    meta: string[];
+    raw?: boolean;
+    signature: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** Provide the shared transcript tool-frame shell for nonstandard part views. */
+export declare function toolFrameClass(): string;

package/dist/client/components/Transcript.d.ts

@@ -0,0 +1,5 @@
+import type { ConversationTurn } from "../types";
+/** Render ordered conversation turns as message, thinking, and tool-call events. */
+export declare function Transcript(props: {
+    turns: ConversationTurn[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/TranscriptHeader.d.ts

@@ -0,0 +1,7 @@
+import type { TranscriptViewMode } from "./transcriptRenderModel";
+/** Render transcript controls without coupling them to turn rendering. */
+export declare function TranscriptHeader(props: {
+    onChange(value: TranscriptViewMode): void;
+    redacted: boolean;
+    value: TranscriptViewMode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/TranscriptLoading.d.ts

@@ -0,0 +1,2 @@
+/** Render a transcript-shaped loading state for route transitions. */
+export declare function TranscriptLoading(): import("react/jsx-runtime").JSX.Element;