@makinbakin/sdk 0.0.0-bootstrap.0

package/_internal/core/routing/define.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Authoring helpers for the routing module.
+ *
+ * `defineRoute`, `defineCoreRoute`, and `definePlugin` exist to preserve
+ * precise per-route type inference that bare `APIRoute<...>[]` annotations
+ * widen and lose. The function signatures explicitly take separate generics
+ * for path-params (P), query (Q), and body (B) so TypeScript can infer them
+ * from the schemas in the route literal.
+ */
+import type { APIRoute, CoreContext, PluginContextLite } from './types';
+/**
+ * Declare a plugin route. Handler `ctx` is bound to `PluginContextLite`. The
+ * three generics (P/Q/B) are inferred from `params`, `query`, and `body`
+ * schemas respectively; they default to `undefined` when those fields are
+ * omitted, which causes `ParsedInput` to omit the corresponding key.
+ */
+export declare function defineRoute<P = undefined, Q = undefined, B = undefined>(route: APIRoute<PluginContextLite, P, Q, B>): APIRoute<PluginContextLite, P, Q, B>;
+/**
+ * Declare a core (host) route. Handler `ctx` is bound to `CoreContext`.
+ */
+export declare function defineCoreRoute<P = undefined, Q = undefined, B = undefined>(route: APIRoute<CoreContext, P, Q, B>): APIRoute<CoreContext, P, Q, B>;
+/** Lower-bound shape every plugin definition must satisfy. */
+export interface DefinePluginInput {
+    id: string;
+    name: string;
+    version: string;
+    routes?: ReadonlyArray<APIRoute<PluginContextLite, any, any, any>>;
+    [key: string]: unknown;
+}
+/**
+ * Declare a plugin. Returns the input unchanged. Use this instead of a bare
+ * `BakinPlugin` annotation so `routes` keeps per-element inference.
+ */
+export declare function definePlugin<const T extends DefinePluginInput>(plugin: T): T;

package/_internal/core/routing/dispatcher.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Route dispatcher — runs a registered route against a Web Request.
+ *
+ * Responsibilities:
+ *   - Parse path params (provided by the registry's match), query string,
+ *     and request body against the route's Zod schemas.
+ *   - On parse failure, return `400 { error, issues }` without invoking the
+ *     handler.
+ *   - On body content-type mismatch, return `415 { error }`.
+ *   - Call the handler with the typed `parsed` object.
+ *   - In dev / test, validate the response body against `responses[status]`
+ *     and surface mismatches (test → throw, dev → console.warn).
+ *
+ * Adapter mapping: legacy `APIRoute.input` is treated as a JSON `body` schema
+ * and legacy `APIRoute.output` is treated as `responses[200]`. This keeps
+ * routes registered via the migration-window `ctx.registerRoute({...})` shim
+ * flowing through the same validation path.
+ */
+import { z } from 'zod';
+import type { BodySpec, ResponseSpec } from './types';
+/**
+ * Loose route shape accepted by the dispatcher. Concrete `APIRoute<...>`
+ * types from `defineRoute(...)` are assignable to this — the variance issue
+ * with strongly-typed handler signatures is sidestepped by typing `handler`
+ * as the most-permissive shape.
+ */
+export interface DispatchableRoute {
+    path: string;
+    method: string;
+    params?: z.ZodType<unknown>;
+    query?: z.ZodType<unknown>;
+    body?: BodySpec<unknown>;
+    responses?: Partial<Record<string | number, ResponseSpec>>;
+    handler: (req: Request, ctx: any, parsed?: any) => Response | Promise<Response>;
+    input?: z.ZodType<unknown>;
+    output?: z.ZodType<unknown>;
+}
+export interface DispatchInput {
+    req: Request;
+    ctx: unknown;
+    route: DispatchableRoute;
+    params: Record<string, string>;
+}
+export declare function dispatchRoute(input: DispatchInput): Promise<Response>;

package/_internal/core/routing/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `@bakin/core/routing` — typed route contracts.
+ *
+ * Re-exports the route types and authoring helpers used by both the host and
+ * plugin authors (via `@bakin/sdk/routing`).
+ */
+export type { HttpMethod, HttpStatus, RouteContext, PluginContextLite, CoreContext, JsonBodySpec, MultipartBodySpec, RawBodySpec, NoBodySpec, BodySpec, JsonResponseSpec, NoContentResponseSpec, NonJsonResponseSpec, ResponseSpec, ParsedInput, APIRoute, PluginWithRoutes, } from './types';
+export { defineRoute, defineCoreRoute, definePlugin } from './define';
+export type { DefinePluginInput } from './define';
+export { RouteRegistry } from './registry';
+export type { RouteScope, RegisteredRoute, RouteMatch } from './registry';
+export { operationIdFor } from './operation-id';
+export { dispatchRoute } from './dispatcher';
+export type { DispatchInput } from './dispatcher';
+export { searchRoute } from './search-route';

package/_internal/core/routing/operation-id.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Derives a stable OpenAPI `operationId` from `<scope, method, path>`.
+ *
+ * Convention: `<scope>.<methodLower>.<slug(path)>` where `slug` is the path
+ * with `/` and `:`/`{}` placeholder syntax normalized to a kebab-case
+ * identifier. Routes that declare their own `operationId` use that value
+ * verbatim; this helper is the default for routes that don't.
+ */
+export declare function operationIdFor(scope: string, method: string, path: string): string;

package/_internal/core/routing/registry.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Route registry — single source of truth for HTTP route dispatch.
+ *
+ * Routes register here at boot (core first, then plugins, then user plugins).
+ * The dispatcher (T4) looks up routes by <method, url> against this table.
+ * Docs generation reads `all()` to emit OpenAPI from the in-memory registry.
+ *
+ * Path matching uses radix-style precedence: literal segments beat `:param`,
+ * and `:param` beats wildcards. Duplicates throw at registration so boot
+ * fails loudly on a misconfiguration rather than silently shadowing.
+ */
+import type { APIRoute, RouteContext } from './types';
+export type RouteScope = {
+    scope: 'core';
+    route: APIRoute<any, any, any, any>;
+} | {
+    scope: 'plugin';
+    pluginId: string;
+    route: APIRoute<any, any, any, any>;
+};
+/** A route as stored in the registry, with derived metadata. */
+export interface RegisteredRoute {
+    route: APIRoute<RouteContext, any, any, any>;
+    scope: 'core' | string;
+    fullPath: string;
+    operationId: string;
+}
+export interface RouteMatch {
+    route: APIRoute<RouteContext, any, any, any>;
+    scope: 'core' | string;
+    fullPath: string;
+    operationId: string;
+    params: Record<string, string>;
+}
+export declare class RouteRegistry {
+    private byMethod;
+    private operationIds;
+    private fullPaths;
+    /**
+     * Register a route. Throws on duplicate <method, fullPath> or operationId.
+     */
+    register(input: RouteScope): RegisteredRoute;
+    /**
+     * Match a request against the registered routes. Returns the most specific
+     * match or null. Path is the full URL pathname (e.g., `/api/plugins/tasks/abc`).
+     */
+    match(method: string, path: string): RouteMatch | null;
+    /** Return every registered route. Used by docs generation. */
+    all(): RegisteredRoute[];
+    /** Reset state. Tests must call this in beforeEach when reusing the registry. */
+    clear(): void;
+}

package/_internal/core/routing/search-route.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `searchRoute({ table })` — factory for the per-plugin `GET /search` route.
+ *
+ * Replaces the auto-wired search route that `ctx.search.registerContentType`
+ * historically created as a side effect during `activate()`. Plugins now
+ * include this in their declarative `routes: [...]` array — the schemas
+ * are bound at module scope, but the handler reads `ctx.search` at request
+ * time (no closure over `activate()`-initialized services).
+ */
+import { z } from 'zod';
+import type { APIRoute, PluginContextLite } from './types';
+declare const searchQuery: z.ZodObject<{
+    q: z.ZodString;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    facets: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Returns the standard `GET /search` route for a plugin's content type.
+ * Plugins consume it by including the result in their `routes` array.
+ */
+export declare function searchRoute(opts: {
+    table: string;
+    description?: string;
+}): APIRoute<PluginContextLite, undefined, z.infer<typeof searchQuery>, undefined>;
+export {};

package/_internal/core/routing/types.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Routing primitives — typed route contracts that drive runtime dispatch and
+ * OpenAPI emission from a single source.
+ *
+ * The legacy `APIRoute` interface in `../plugin-types.ts` remains during the
+ * migration window; this module's `APIRoute<C, P, Q, B>` is the new
+ * declarative shape that plugins move to under T6–T16. The two coexist via the
+ * `ctx.registerRoute` adapter wired in T4.
+ */
+import type { z } from 'zod';
+import type { ContractStability, ContractVisibility, DocsExample, SourceLocation } from '../docs';
+import type { AgentRuntimeAdapter } from '../adapters/runtime';
+import type { StorageAdapter, EventBus, SearchAPI, ActivityAPI, HookAPI, AssetsAPI, PluginTaskService } from '../plugin-types';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type HttpStatus = 200 | 201 | 202 | 204 | 301 | 302 | 304 | 400 | 401 | 403 | 404 | 409 | 410 | 415 | 422 | 429 | 500 | 502 | 503 | 504;
+/**
+ * Common surface every route handler can rely on, regardless of origin.
+ * `PluginContext` and `CoreContext` extend this with their own additions.
+ *
+ * Types here mirror the plugin-context surface so a plugin handler that
+ * declares `ctx: PluginContextLite` can call `ctx.search.index(...)`,
+ * `ctx.activity.log(...)`, etc. without casting.
+ */
+export interface RouteContext {
+    runtime: AgentRuntimeAdapter;
+    search: SearchAPI;
+    storage: StorageAdapter;
+    events: EventBus;
+    activity: ActivityAPI;
+    hooks: HookAPI;
+    assets: AssetsAPI;
+    tasks: PluginTaskService;
+}
+/**
+ * Lite plugin context — the public-facing slice every plugin route handler
+ * receives. The full `PluginContext` (in `../plugin-types.ts`) extends this
+ * with the imperative `registerRoute`/`registerExecTool`/etc. surface that
+ * `activate()` uses; route handlers don't need that surface at request time.
+ */
+export interface PluginContextLite extends RouteContext {
+    pluginId: string;
+    getSettings<T = Record<string, unknown>>(): T;
+}
+/**
+ * Core (host) context — host-only surface for routes registered under
+ * `packages/host/src/core-routes/`.
+ */
+export type CoreContext = RouteContext;
+export interface JsonBodySpec<B = unknown> {
+    contentType: 'application/json';
+    schema: z.ZodType<B>;
+}
+export interface MultipartBodySpec<B = unknown> {
+    contentType: 'multipart/form-data';
+    schema?: z.ZodType<B>;
+}
+export interface RawBodySpec<B = unknown> {
+    contentType: '*/*';
+    schema?: z.ZodType<B>;
+}
+export interface NoBodySpec {
+    contentType: 'none';
+}
+/**
+ * `body` declaration:
+ *   - `z.ZodType` shorthand → JSON body validated against the schema.
+ *   - explicit JSON spec → same, content-type stated.
+ *   - multipart / raw → handler reads `req.formData()` / `req.body` itself.
+ *   - none → dispatcher rejects non-empty bodies with 415.
+ *
+ * Omit the field entirely on routes that don't consume a body.
+ */
+export type BodySpec<B = unknown> = z.ZodType<B> | JsonBodySpec<B> | MultipartBodySpec<B> | RawBodySpec<B> | NoBodySpec;
+export interface JsonResponseSpec {
+    contentType: 'application/json';
+    schema: z.ZodType;
+}
+export interface NoContentResponseSpec {
+    contentType: 'none';
+}
+export interface NonJsonResponseSpec {
+    contentType: 'text/event-stream' | 'text/html' | 'text/plain' | 'application/octet-stream' | 'image/png' | 'image/jpeg' | 'image/svg+xml' | (string & Record<never, never>);
+    schema?: z.ZodType;
+}
+export type ResponseSpec = z.ZodType | JsonResponseSpec | NoContentResponseSpec | NonJsonResponseSpec;
+/** Helper: `{ body: B }` if B is declared (non-undefined), else no fields. */
+type Field<K extends string, T> = [T] extends [undefined] ? unknown : {
+    [P in K]: T;
+};
+type Normalize<T> = {
+    [K in keyof T]: T[K];
+};
+export type ParsedInput<P, Q, B> = Normalize<Field<'params', P> & Field<'query', Q> & Field<'body', B>>;
+export interface APIRoute<C extends RouteContext = RouteContext, P = undefined, Q = undefined, B = undefined> {
+    path: string;
+    method: HttpMethod;
+    summary?: string;
+    description?: string;
+    params?: z.ZodType<P>;
+    query?: z.ZodType<Q>;
+    body?: P extends never ? never : BodySpec<B>;
+    responses?: Partial<Record<HttpStatus, ResponseSpec>>;
+    visibility?: ContractVisibility;
+    stability?: ContractStability;
+    permissions?: string[];
+    examples?: DocsExample[];
+    operationId?: string;
+    tags?: string[];
+    source?: SourceLocation;
+    handler: (req: Request, ctx: C, parsed: ParsedInput<P, Q, B>) => Response | Promise<Response>;
+}
+/**
+ * Subset of plugin metadata `definePlugin` cares about. The full `BakinPlugin`
+ * interface lives in `../plugin-types.ts`; this declares the new fields the
+ * routing module needs to typecheck without circular imports.
+ */
+export interface PluginWithRoutes {
+    id: string;
+    name: string;
+    version: string;
+    routes?: ReadonlyArray<APIRoute<PluginContextLite, any, any, any>>;
+}
+export {};

package/_internal/plugins/team/hooks/use-agent-store.d.ts

@@ -0,0 +1,49 @@
+import type { AgentMeta, AgentDisplaySettings, AgentDisplaySettingsMap, AgentWithStatus, OrgTeam, PackageStateRow } from '../types';
+interface AgentStore {
+    /** Lightweight agent list (for dropdowns, badges, avatars) */
+    agents: AgentMeta[];
+    /** Pre-computed ID list (stable reference for selectors) */
+    agentIds: string[];
+    /** Lookup map by ID */
+    agentMap: Record<string, AgentMeta>;
+    /** Agents with runtime status (for team grid) */
+    agentsWithStatus: AgentWithStatus[];
+    /** Display settings (colors, display names, team assignments — Bakin-owned) */
+    displaySettings: AgentDisplaySettingsMap;
+    /** Organizational teams */
+    teams: OrgTeam[];
+    /**
+     * Agent-package state per agent id, sourced from `/api/agent-packages`.
+     * Fetched in parallel with the roster on `load()`. Empty map when the
+     * endpoint fails — agent-packages is optional context, not load-blocking.
+     */
+    packageStates: Record<string, PackageStateRow>;
+    /** Canonical main/orchestrator agent id (resolved server-side from the runtime adapter) */
+    mainAgentId: string | null;
+    /** Whether initial load has completed */
+    loaded: boolean;
+    /** Fetch agents + display settings + package states from the API */
+    load: () => Promise<void>;
+    /** Re-fetch only `/api/agent-packages` — used after Adopt to invalidate staleness */
+    refreshPackageStates: () => Promise<void>;
+    /** Update display settings for a single agent */
+    updateDisplay: (agentId: string, patch: Partial<AgentDisplaySettings>) => Promise<void>;
+}
+export declare const useAgentStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AgentStore>>;
+/** Get a single agent's meta by ID */
+export declare function useAgent(agentId: string): AgentMeta | undefined;
+/** Get the full agent list */
+export declare function useAgentList(): AgentMeta[];
+/** Get an agent's accent color (hex). Falls back to zinc if unknown. */
+export declare function useAgentColor(agentId: string): string;
+/** Get an agent's package state row. Undefined when the API hasn't reported one. */
+export declare function usePackageState(agentId: string): PackageStateRow | undefined;
+/** Get an agent's display name override, if any. */
+export declare function useAgentDisplayName(agentId: string): string | undefined;
+/** Get all agent IDs (stable reference) */
+export declare function useAgentIds(): string[];
+/** Get the canonical main/orchestrator agent id. Null until the store has loaded. */
+export declare function useMainAgentId(): string | null;
+/** Utility: convert hex to rgba with opacity */
+export declare function hexToMuted(hex: string, opacity?: number): string;
+export {};

package/_internal/plugins/team/types.d.ts

@@ -0,0 +1,131 @@
+/** Lightweight agent info for badges, dropdowns, selectors */
+export interface AgentMeta {
+    id: string;
+    name: string;
+    emoji: string;
+    role: string;
+    headshot: string;
+}
+/** Full agent profile merged from runtime config + workspace files */
+export interface AgentProfile extends AgentMeta {
+    model: string;
+    workspacePath: string;
+    soul: string | null;
+    identity: string | null;
+    rules: string | null;
+    tools: string | null;
+    heartbeatMd: string | null;
+    subagentPerms: string[] | null;
+}
+/** Agent with runtime status */
+export interface AgentWithStatus extends AgentMeta {
+    status: 'online' | 'working' | 'available' | 'offline';
+    model: string;
+    heartbeat: HeartbeatData | null;
+    heartbeatAge: number | null;
+}
+export interface HeartbeatData {
+    timestamp: string;
+    status: string;
+    currentTask?: string;
+}
+/** Display-only settings owned by Bakin */
+export interface AgentDisplaySettings {
+    displayName?: string;
+    accentColor?: string;
+    teamId?: string;
+}
+export type AgentDisplaySettingsMap = Record<string, AgentDisplaySettings>;
+/** Organizational team — Bakin-owned grouping layer */
+export interface OrgTeam {
+    id: string;
+    label: string;
+    /**
+     * Agent ID this team reports to, or `null` to indicate "reports to the
+     * main orchestrator". Stored as `null` whenever the incoming value
+     * matches the current main agent id so team.json stays decoupled from
+     * the specific orchestrator name.
+     */
+    reportsTo: string | null;
+    color?: string;
+    order?: number;
+}
+/** Full team settings stored in team.json */
+export interface TeamPluginSettings {
+    displaySettings: AgentDisplaySettingsMap;
+    teams: OrgTeam[];
+}
+/** Skill summary from workspace skills/ directory */
+export interface SkillSummary {
+    id: string;
+    name: string;
+    hasSkillMd: boolean;
+}
+/**
+ * Per-agent agent-package state, sourced from `/api/agent-packages`. Mirrors
+ * the server-side `AgentStateInfo` shape but stays self-contained so the
+ * client doesn't reach across the package boundary for types.
+ *
+ * The server today returns 4 states (`absent | unmanaged | adopted | managed`).
+ * `drifted` and `update-available` are declared on the badge component for
+ * forward-compat — wiring handles them but the API doesn't yet emit them.
+ */
+export interface PackageStateRow {
+    agentId: string;
+    state: 'absent' | 'unmanaged' | 'adopted' | 'managed' | 'drifted' | 'update-available';
+    packageId?: string;
+    entry?: {
+        source: string;
+        ref: string;
+        commitSha: string;
+        installedAt: string;
+        version?: string;
+        dependencies?: string[];
+    };
+}
+/**
+ * Single message from a runtime session JSONL. Used by the Active Context
+ * tab to render what the agent has actually been sent + has produced.
+ */
+export interface SessionMessage {
+    /** system / user / assistant / tool — drives the role badge color */
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    /** Raw text content. JSON tool calls are pretty-printed by the renderer. */
+    content: string;
+    /** Model id present on assistant messages when usage was recorded. */
+    model?: string;
+    /** ISO timestamp when present; absent on synthetic system messages. */
+    ts?: string;
+    /** Tool name for `role: 'tool'` entries. */
+    toolName?: string;
+}
+/**
+ * Latest-session transcript surfaced through `/api/plugins/team/:id/active-context`.
+ * `truncated` is true when the underlying JSONL had more than the requested
+ * cap (default 200) and we returned the most-recent N.
+ */
+export interface SessionTranscript {
+    sessionId: string;
+    sessionStarted: string | null;
+    messages: SessionMessage[];
+    truncated: boolean;
+    totalMessages: number;
+}
+/**
+ * Per-agent activity counts pulled from the in-memory `recordUsage` recorder.
+ * Resets on server restart — `sinceServerStart` exists so the UI can frame
+ * the numbers honestly rather than claim lifetime totals.
+ */
+export interface RecentActivity {
+    windowMs: Record<'5m' | '1h' | '24h', number>;
+    errors: Record<'5m' | '1h' | '24h', number>;
+    sinceServerStart: string;
+}
+/**
+ * Raw heartbeat surface — the markdown body the agent wrote to its heartbeat
+ * file plus the file mtime. The Heartbeat tab renders this view-only.
+ */
+export interface HeartbeatRaw {
+    content: string;
+    lastUpdated: string | null;
+}

package/_internal/plugins/workflows/hooks/channel-icon.d.ts

@@ -0,0 +1,6 @@
+interface ChannelIconProps {
+    channelId: string;
+    className?: string;
+}
+export declare function ChannelIcon({ channelId, className }: ChannelIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/_internal/plugins/workflows/hooks/use-notification-channels.d.ts

@@ -0,0 +1,13 @@
+import type { NotificationChannelDef } from '../lib/notification-channel-registry';
+export declare function useNotificationChannels(): NotificationChannelDef[];
+export declare function getChannelLabel(id: string, channels: NotificationChannelDef[]): string;
+/**
+ * Returns the 2-character badge for a channel id, with uppercase-prefix
+ * fallback for unknown ids. Part of the public client surface (compact
+ * chips in admin UIs, CLI listings, etc) — no core consumer uses it today
+ * now that the drawer renders icon+label pairs, but it's still the right
+ * shape when a caller wants the compact form.
+ */
+export declare function getChannelInitials(id: string, channels: NotificationChannelDef[]): string;
+/** Test-only: reset the module-level cache so tests run with a clean slate. */
+export declare function __resetNotificationChannelsCache(): void;

package/_internal/plugins/workflows/lib/notification-channel-registry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Notification-channel registry — single source of truth for the set of
+ * channels a workflow can notify (gate alerts, messaging publishes, etc).
+ *
+ * Builtins self-register at the bottom of this module, matching the
+ * node-type-registry precedent. Plugins register their own channels via
+ * `ctx.registerNotificationChannel()`, which calls `registerPluginNotificationChannel()`
+ * here. Plugin ids are auto-namespaced as `{pluginId}.{id}` to avoid
+ * cross-plugin collisions with the shared builtin ids.
+ */
+import type { NotificationChannelDef, PluginNotificationChannelInput } from '../../../core/plugin-types';
+export type { NotificationChannelDef, PluginNotificationChannelInput };
+export declare function registerNotificationChannel(def: NotificationChannelDef): void;
+export declare function getNotificationChannel(id: string): NotificationChannelDef | undefined;
+export declare function listNotificationChannels(): NotificationChannelDef[];
+/** Remove a single registration. Useful for test cleanup. */
+export declare function unregisterNotificationChannel(id: string): void;
+/** Remove every channel owned by a plugin. Called at plugin teardown / hot reload. */
+export declare function unregisterPluginNotificationChannels(pluginId: string): void;
+/**
+ * Register a plugin-owned notification channel. The id is auto-namespaced
+ * to `{pluginId}.{id}` so two plugins can ship the same unprefixed id
+ * without colliding. Returns the namespaced id so callers can reference
+ * it from downstream code and tests.
+ */
+export declare function registerPluginNotificationChannel(pluginId: string, input: PluginNotificationChannelInput): string;

package/components/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `@bakin/sdk/components` — shared layout + compound components.
+ *
+ * Plugin-author-visible components that wrap shadcn primitives with Bakin-
+ * specific behavior (headers, filters, markdown, agent displays, etc.). Does
+ * not include layout chrome (sidebar, header, toaster) — those are Bakin's
+ * shell, not plugin-author territory.
+ */
+export { AgentAvatar } from '../_internal/app/components/agent-avatar';
+export { AgentFilter } from '../_internal/app/components/agent-filter';
+export { AgentSelect } from '../_internal/app/components/agent-select';
+export { AgentDot, AgentStatus } from '../_internal/app/components/agent-status';
+export { BakinDrawer } from '../_internal/app/components/bakin-drawer';
+export { ColorPicker } from '../_internal/app/components/color-picker';
+export { EmptyState } from '../_internal/app/components/empty-state';
+export { ErrorBanner } from '../_internal/app/components/error-banner';
+export { ErrorState } from '../_internal/app/components/error-state';
+export { FacetFilter } from '../_internal/app/components/facet-filter';
+export type { FacetOption } from '../_internal/app/components/facet-filter';
+export { IntegratedBrainstorm } from '../_internal/app/components/integrated-brainstorm';
+export type { BrainstormMessage, IntegratedBrainstormProps, BrainstormOnSend, SendContext, AssistantTransformed, } from '../_internal/app/components/integrated-brainstorm';
+export { MarkdownContent } from '../_internal/app/components/markdown-content';
+export { MarkdownEditor } from '../_internal/app/components/markdown-editor';
+export { ModelSelect } from '../_internal/app/components/model-select';
+export { PageLayout } from '../_internal/app/components/page-layout';
+export { PluginHeader } from '../_internal/app/components/plugin-header';
+export { PluginSettingsRenderer } from '../_internal/app/components/plugin-settings-renderer';
+export type { PluginSettingsSchema } from '../_internal/app/components/plugin-settings-renderer';
+export { SortableHead } from '../_internal/app/components/sortable-head';
+export type { SortDir } from '../_internal/app/components/sortable-head';
+export { UnderlineTabs } from '../_internal/app/components/underline-tabs';
+export type { UnderlineTab } from '../_internal/app/components/underline-tabs';
+export { ChannelIcon } from '../_internal/plugins/workflows/hooks/channel-icon';