@candor-ui/react 0.0.0-stage → 1.0.1

package/dist/chat/tool-call.js

@@ -0,0 +1,33 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { ChevronRight, Wrench } from "lucide-react";
+import { cn } from "../lib/utils.js";
+import { StepMark } from "../blocks/step-list.js";
+import { ShimmerLabel } from "../blocks/streaming-text.js";
+import { statusLabel } from "../lib/status.js";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../ui/collapsible.js";
+import { Payload } from "./payload.js";
+/**
+ * One tool call as a compact row: what it did in plain words, its status, and
+ * how long it took. Expands to the input and output. A failed call opens by
+ * default and leads with its error.
+ */
+function ToolCall({ call, className, }) {
+    const failed = call.status === "failed";
+    const [open, setOpen] = React.useState(failed);
+    const hasDetail = Boolean(call.input || call.output || call.error);
+    return (_jsxs(Collapsible, { open: open, onOpenChange: setOpen, "data-slot": "tool-call", "data-status": call.status, className: cn("group/tool", className), children: [_jsxs(CollapsibleTrigger, { disabled: !hasDetail, className: "flex w-full items-center gap-2.5 rounded-md px-1.5 py-1 text-left outline-none transition-colors duration-150 enabled:hover:bg-accent focus-visible:ring-[3px] focus-visible:ring-ring/40", children: [_jsx(StepMark, { status: call.status }), _jsxs("span", { className: "min-w-0 flex-1 truncate text-sm", children: [call.status === "running" ? _jsx(ShimmerLabel, { className: "font-normal", children: call.title }) : call.title, _jsxs("span", { className: "sr-only", children: [" \u2014 ", statusLabel[call.status]] })] }), _jsx("code", { className: "hidden shrink-0 font-mono text-2xs text-faint-foreground sm:inline", children: call.tool }), call.duration && _jsx("span", { className: "shrink-0 text-xs tabular-nums text-faint-foreground", children: call.duration }), hasDetail && (_jsx(ChevronRight, { "aria-hidden": true, className: "size-3.5 shrink-0 text-faint-foreground transition-transform duration-200 ease-standard group-data-[state=open]/tool:rotate-90" }))] }), _jsx(CollapsibleContent, { className: "data-[state=open]:animate-in data-[state=open]:fade-in-0", children: _jsxs("div", { className: "mt-1 mb-2 ml-[1.375rem] flex flex-col gap-2 border-l pl-3.5", children: [call.error && (_jsx("p", { className: "rounded-md bg-destructive-weak px-2.5 py-1.5 text-xs text-destructive-text", children: call.error })), call.input && _jsx(Payload, { language: "json", title: "Input", text: call.input }), call.output && _jsx(Payload, { language: call.outputLanguage ?? "text", title: "Output", text: call.output })] }) })] }));
+}
+/** A run of tool calls, with a count when it's long enough to fold. */
+function ToolCallGroup({ calls, className, }) {
+    const done = calls.filter((c) => c.status === "succeeded").length;
+    const failed = calls.filter((c) => c.status === "failed").length;
+    const running = calls.some((c) => c.status === "running");
+    const [open, setOpen] = React.useState(true);
+    if (calls.length <= 2) {
+        return (_jsx("div", { "data-slot": "tool-call-group", className: cn("flex flex-col", className), children: calls.map((c) => (_jsx(ToolCall, { call: c }, c.id))) }));
+    }
+    return (_jsxs(Collapsible, { open: open, onOpenChange: setOpen, "data-slot": "tool-call-group", className: cn("group/tools rounded-lg border bg-card", className), children: [_jsxs(CollapsibleTrigger, { className: "flex w-full items-center gap-2 px-3 py-2 text-left text-xs text-muted-foreground outline-none hover:text-foreground focus-visible:ring-[3px] focus-visible:ring-ring/40 rounded-lg", children: [_jsx(Wrench, { "aria-hidden": true, className: "size-3.5" }), _jsxs("span", { className: "flex-1", children: [calls.length, " tool calls", done > 0 && ` · ${done} done`, failed > 0 && _jsxs("span", { className: "text-destructive-text", children: [" \u00B7 ", failed, " failed"] }), running && " · working"] }), _jsx(ChevronRight, { "aria-hidden": true, className: "size-3.5 transition-transform duration-200 ease-standard group-data-[state=open]/tools:rotate-90" })] }), _jsx(CollapsibleContent, { children: _jsx("div", { className: "flex flex-col border-t px-1.5 py-1.5", children: calls.map((c) => (_jsx(ToolCall, { call: c }, c.id))) }) })] }));
+}
+export { ToolCall, ToolCallGroup };

package/dist/claude-server.d.ts

@@ -0,0 +1 @@
+export * from "./adapters/claude-agent-server.js";

package/dist/claude-server.js

@@ -0,0 +1,2 @@
+// Server only: runs the agent with Node and your credentials. Never import this in the browser.
+export * from "./adapters/claude-agent-server.js";

package/dist/claude.d.ts

@@ -0,0 +1,2 @@
+export * from "./adapters/claude-agent-sdk.js";
+export * from "./adapters/use-claude-agent.js";

package/dist/claude.js

@@ -0,0 +1,2 @@
+export * from "./adapters/claude-agent-sdk.js";
+export * from "./adapters/use-claude-agent.js";

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+export * from "./lib/chat.js";
+export * from "./lib/status.js";
+export * from "./lib/use-copy.js";
+export * from "./lib/use-shortcut.js";
+export * from "./blocks/terms.js";
+export * from "./blocks/locked.js";
+export * from "./blocks/status-dot.js";
+export * from "./blocks/step-list.js";
+export * from "./blocks/streaming-text.js";
+export * from "./blocks/relative-time.js";
+export * from "./blocks/copy-field.js";
+export * from "./blocks/degraded-panel.js";
+export * from "./blocks/surface.js";
+export * from "./chat/agent-avatar.js";
+export * from "./chat/entity-chip.js";
+export * from "./chat/citation.js";
+export * from "./chat/payload.js";
+export * from "./chat/message-content.js";
+export * from "./chat/message.js";
+export * from "./chat/message-actions.js";
+export * from "./chat/reasoning.js";
+export * from "./chat/tool-call.js";
+export * from "./chat/thread.js";
+export * from "./chat/composer.js";
+export * from "./chat/prompt-suggestions.js";
+export * from "./chat/context-meter.js";
+export * from "./chat/card-registry.js";
+export * from "./lib/safe-markdown.js";
+export * from "./ui/button.js";
+export * from "./ui/tooltip.js";
+export * from "./ui/collapsible.js";
+export * from "./ui/popover.js";
+export * from "./ui/skeleton.js";
+export * from "./lib/know.js";
+export * from "./lib/render-prop.js";
+export * from "./lib/utils.js";
+export { ToolCall } from "./chat/tool-call.js";
+export type { ToolCall as ToolCallData } from "./lib/chat.js";
+export { Message } from "./chat/message.js";
+export type { Message as MessageData } from "./lib/chat.js";

package/dist/index.js

@@ -0,0 +1,38 @@
+export * from "./lib/chat.js";
+export * from "./lib/status.js";
+export * from "./lib/use-copy.js";
+export * from "./lib/use-shortcut.js";
+export * from "./blocks/terms.js";
+export * from "./blocks/locked.js";
+export * from "./blocks/status-dot.js";
+export * from "./blocks/step-list.js";
+export * from "./blocks/streaming-text.js";
+export * from "./blocks/relative-time.js";
+export * from "./blocks/copy-field.js";
+export * from "./blocks/degraded-panel.js";
+export * from "./blocks/surface.js";
+export * from "./chat/agent-avatar.js";
+export * from "./chat/entity-chip.js";
+export * from "./chat/citation.js";
+export * from "./chat/payload.js";
+export * from "./chat/message-content.js";
+export * from "./chat/message.js";
+export * from "./chat/message-actions.js";
+export * from "./chat/reasoning.js";
+export * from "./chat/tool-call.js";
+export * from "./chat/thread.js";
+export * from "./chat/composer.js";
+export * from "./chat/prompt-suggestions.js";
+export * from "./chat/context-meter.js";
+export * from "./chat/card-registry.js";
+export * from "./lib/safe-markdown.js";
+export * from "./ui/button.js";
+export * from "./ui/tooltip.js";
+export * from "./ui/collapsible.js";
+export * from "./ui/popover.js";
+export * from "./ui/skeleton.js";
+export * from "./lib/know.js";
+export * from "./lib/render-prop.js";
+export * from "./lib/utils.js";
+export { ToolCall } from "./chat/tool-call.js";
+export { Message } from "./chat/message.js";

package/dist/lib/chat.d.ts

@@ -0,0 +1,241 @@
+/**
+ * The data a Candor thread renders. Plain, serialisable shapes: your
+ * service produces them from its own model drivers, and an adapter can produce
+ * them from any SDK. They follow the Candor design system's ChatMessage contract:
+ *
+ * - A message is a list of typed blocks, never markdown or HTML. Text from a
+ *   model or from the user's system is always rendered as text.
+ * - An agent message always carries the agent's full identity.
+ * - A claim the agent has not verified is marked `provisional`, and reasoning
+ *   says whether each step is verified, believed or assumed.
+ */
+import type { RunStatus } from "./status.js";
+/** What an agent does: "assistant", "coder", "reviewer"… The app registers each role's glyph and hue (AgentRolesProvider). */
+export type AgentRole = string;
+export type AgentIdentity = {
+    id: string;
+    /** The displayed name, e.g. "Architect agent". Never derived from model output. */
+    name: string;
+    role: AgentRole;
+    specialty?: string;
+};
+export type MessageAuthor = {
+    role: "user";
+    name?: string;
+} | {
+    role: "agent";
+    agent: AgentIdentity;
+}
+/** A person on the app's own team (support staff, a reviewer), not the user: shown by name, with their team. */
+ | {
+    role: "person";
+    name: string;
+    team?: string;
+}
+/** System lines are the app's own strings, never model text. */
+ | {
+    role: "system";
+};
+/**
+ * What kind of thing an entity is: "record", "table", "workflow"… Any string;
+ * the app registers each kind's icon and noun (see EntityKindsProvider), and
+ * presets cover common systems (e.g. Salesforce).
+ */
+export type EntityKind = string;
+export type EntityRef = {
+    kind: EntityKind;
+    /** The identifier, e.g. "Account.Region__c" or "orders.status". */
+    name: string;
+    /** A friendlier label when there is one, e.g. "Region". */
+    label?: string;
+    /** Where it lives, when more than one place is in scope, e.g. "Shop staging". */
+    location?: string;
+};
+export type InlineNode = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "strong";
+    text: string;
+} | {
+    kind: "em";
+    text: string;
+} | {
+    kind: "code";
+    text: string;
+}
+/** A value read from the environment (a count, a setting). Shown with its source on hover. */
+ | {
+    kind: "measured";
+    text: string;
+    source?: string;
+}
+/** @deprecated Renamed `measured`; still rendered the same way until 2.0. */
+ | {
+    kind: "orgData";
+    text: string;
+    source?: string;
+}
+/** The agent asserts this but has not verified it. */
+ | {
+    kind: "provisional";
+    nodes: InlineNode[];
+    reason?: string;
+} | {
+    kind: "citation";
+    sourceId: string;
+} | {
+    kind: "entity";
+    entity: EntityRef;
+}
+/** An in-app route only; external links are never rendered from model output. */
+ | {
+    kind: "link";
+    text: string;
+    to: string;
+};
+/** "document", "web", "query", "code", "data", "workflow", "knowledge", or the app's own; unknown kinds read as "Source". */
+export type SourceKind = string;
+export type MessageSource = {
+    id: string;
+    /** The [n] shown inline. Assigned by the service, so it is stable across renders. */
+    marker: number;
+    kind: SourceKind;
+    label: string;
+    /** An inert excerpt shown in the popover. Text only. */
+    snippet?: string;
+    /** Where it came from in a human sense: "Docs · Sales process v3", "Query on orders". */
+    origin?: string;
+    provisional?: boolean;
+};
+type ReasoningBase = {
+    id: string;
+    title: string;
+    body?: string;
+    streaming?: boolean;
+};
+export type ReasoningEntry = (ReasoningBase & {
+    basis: "verified";
+    evidence: string;
+}) | (ReasoningBase & {
+    basis: "believed" | "assumed";
+    assumption: string;
+});
+export type ToolCall = {
+    id: string;
+    /** The tool's name, for people who want it: "metadata.describe". */
+    tool: string;
+    /** What it did, in plain words: "Read Account's fields". */
+    title: string;
+    status: RunStatus;
+    /** Shown when expanded. Text only; long values scroll. */
+    input?: string;
+    output?: string;
+    outputLanguage?: PayloadLanguage;
+    /** e.g. "1.2s". Absent while running; never estimated. */
+    duration?: string;
+    /** Required when status is "failed": what went wrong, in a sentence. */
+    error?: string;
+};
+/** The block's language, e.g. "json", "sql", "python", "text". Shown as a label; never executed or highlighted as HTML. */
+export type PayloadLanguage = string;
+export type MessageBlock = {
+    kind: "paragraph";
+    nodes: InlineNode[];
+}
+/**
+ * Text exactly as someone typed it: line breaks and spacing kept, nothing parsed. For a person's own words, so
+ * `*this*` stays `*this*` and a pasted list keeps its lines.
+ */
+ | {
+    kind: "plain";
+    text: string;
+}
+/** A heading inside a reply. Levels are relative to the message, 1 the largest; the page's own headings sit above. */
+ | {
+    kind: "heading";
+    level: 1 | 2 | 3;
+    nodes: InlineNode[];
+} | {
+    kind: "list";
+    ordered?: boolean;
+    items: InlineNode[][];
+} | {
+    kind: "payload";
+    language: PayloadLanguage;
+    text: string;
+    title?: string;
+} | {
+    kind: "tools";
+    calls: ToolCall[];
+}
+/** Something the agent could not do, and what is missing because of it. */
+ | {
+    kind: "degraded";
+    reason: string;
+    missing?: string;
+}
+/**
+ * A typed card (a result table, a plan, an approval) rendered by the app's
+ * card registry. `summary` is the service's plain-text version, used for copy
+ * and whenever the card can't be shown.
+ */
+ | {
+    kind: "card";
+    card: string;
+    props: unknown;
+    summary: string;
+};
+export type MessageStatus = "streaming" | "complete" | "interrupted" | "failed";
+export type Message = {
+    id: string;
+    author: MessageAuthor;
+    /** When it was sent. Absent when the source doesn't say; then no time is shown. */
+    createdAt?: string;
+    status: MessageStatus;
+    blocks: MessageBlock[];
+    reasoning?: ReasoningEntry[];
+    /** How long the agent spent before answering, e.g. "6s". Only once known. */
+    thoughtFor?: string;
+    sources?: MessageSource[];
+    /** Shown under an agent's reply: model, cost. Only values the service measured. */
+    attribution?: {
+        model?: string;
+        cost?: string;
+    };
+};
+/** Where the next message's work lands. */
+export type ComposerScope = {
+    account?: string;
+    environment: string;
+    detail?: string;
+    production: boolean;
+};
+export type MentionOption = {
+    id: string;
+    /** The heading it sits under in the menu, e.g. "Files", "People". Groups appear in the order first used. */
+    group: string;
+    entity?: EntityRef;
+    label: string;
+    description?: string;
+};
+export type SlashCommand = {
+    id: string;
+    name: string;
+    description: string;
+    /** e.g. "<object>" — shown after the name. */
+    args?: string;
+};
+export type Attachment = {
+    id: string;
+    name: string;
+    size?: number;
+    /** 0–1 while uploading; absent when done. */
+    progress?: number;
+    error?: string;
+};
+export type PromptSuggestion = {
+    id: string;
+    text: string;
+};
+export {};

package/dist/lib/chat.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/know.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The data behind the agents' knowledge base and agent settings. Its rules: unknown never renders as definitive; no
+ * figure without a basis; each source door has its own freshness. The model
+ * layer's rule: only zero-data-retention endpoints, and only once an operator
+ * has attested the vendor's contract.
+ */
+import type { AgentIdentity } from "./chat.js";
+import type { RunStatus } from "./status.js";
+/** The ways knowledge gets in. */
+/** How knowledge came in: read from the environment's configuration or data, shared as a file or link, answered by a person, or a vendor's release notes. */
+export type KnowDoor = "config" | "data" | "file" | "link" | "answer" | "release-notes";
+export type KnowSource = {
+    id: string;
+    door: KnowDoor;
+    label: string;
+    /** Who added it, for files, links and answers. */
+    addedBy?: string;
+    addedAt?: string;
+    /** When it was last read; null if never. */
+    readAt: string | null;
+    /** How often it should be re-read, in hours, when it has a schedule. */
+    everyHours?: number;
+    status: RunStatus;
+    /** "214 objects", "38 pages" — only when counted. */
+    extent?: string;
+    /** Required when status is "failed". */
+    error?: string;
+};
+export type Confidence = "high" | "medium" | "low" | "unknown";
+export type RaciRole = "R" | "A" | "C" | "I";
+export type RaciAssignment = {
+    role: RaciRole;
+    who: string;
+};
+export type RetrievedPassage = {
+    id: string;
+    sourceId: string;
+    title: string;
+    excerpt: string;
+    /** Retrieval score 0–1; null when the retriever didn't score it (e.g. a pinned source). */
+    score: number | null;
+    /** Whether the answer actually cites it. */
+    cited: boolean;
+    /** Why it ranked where it did, when the retriever says. */
+    why?: string;
+    readAt: string | null;
+};
+/** A sentence in an answer and the passages it rests on. */
+export type Claim = {
+    id: string;
+    text: string;
+    evidence: string[];
+};
+export type ModelVendor = "Anthropic" | "Google" | "OpenAI" | "xAI";
+export type ModelOption = {
+    id: string;
+    vendor: ModelVendor;
+    name: string;
+    /** One line on what it's good for. */
+    note?: string;
+    /** Relative cost, 1 (cheapest) to 4. */
+    cost: 1 | 2 | 3 | 4;
+    /** The vendor's zero-retention contract has been attested by an operator. */
+    zdr: "attested" | "not-attested";
+};
+export type ReasoningEffort = "low" | "medium" | "high" | "max";
+export type ModelSettingsValue = {
+    model: string;
+    reasoning: ReasoningEffort;
+    /** Most tool-calling steps per run before it stops and asks. */
+    stepLimit: number;
+    /** Used when the primary is unavailable; must also be attested. */
+    fallback?: string;
+};
+export type ToolPermission = "always" | "ask" | "never";
+export type ToolSetting = {
+    id: string;
+    name: string;
+    description: string;
+    /** What the tool can do to the environment. */
+    effect: "read" | "write" | "deploy" | "outside";
+    permission: ToolPermission;
+    /** Permissions this tool can't take, with why. */
+    locked?: Partial<Record<ToolPermission, string>>;
+};
+export type AgentConfig = {
+    agent: AgentIdentity;
+    enabled: boolean;
+    status: RunStatus;
+    model: string;
+    /** Runs per day for the last 14 days, oldest first. */
+    runs: {
+        ok: number;
+        failed: number;
+    }[];
+    lastFailure?: string;
+};
+export type Memory = {
+    id: string;
+    text: string;
+    /** Who taught it: a person said so, or an agent inferred it. */
+    from: {
+        person: string;
+    } | {
+        agent: AgentIdentity;
+    };
+    createdAt: string;
+    scope: "account" | "environment";
+    environmentId?: string;
+};
+export type Version = {
+    id: string;
+    label: string;
+    state: "live" | "draft" | "past";
+    at: string;
+    by: string;
+    note?: string;
+};
+export type ContextSegment = {
+    label: string;
+    tokens: number;
+    kind: "system" | "instructions" | "knowledge" | "thread" | "tools" | "files";
+};

package/dist/lib/know.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/render-prop.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+/**
+ * Lets Candor's Radix-based primitives also take Base UI's `render` prop. In projects on a Base UI style
+ * (shadcn's `base-*` styles), the shadcn CLI rewrites `<Trigger asChild><button/></Trigger>` into
+ * `<Trigger render={<button/>}>`; this turns that back into Radix's asChild, so Candor works in either kind of project.
+ */
+export type RenderProp = {
+    /** Base UI's way to render as another element; the same as `asChild` with that element as the child. */
+    render?: React.ReactElement;
+    /** Base UI's flag for a button rendered as another element; shadcn adds it with `render`. Radix doesn't need it. */
+    nativeButton?: boolean;
+};
+export declare function withRender<P extends {
+    asChild?: boolean;
+    children?: React.ReactNode;
+}>({ render, nativeButton: _nativeButton, ...props }: P & RenderProp): P;

package/dist/lib/render-prop.js

@@ -0,0 +1,7 @@
+import * as React from "react";
+export function withRender({ render, nativeButton: _nativeButton, ...props }) {
+    if (!render)
+        return props;
+    const children = props.children === undefined ? render : React.cloneElement(render, undefined, props.children);
+    return { ...props, asChild: true, children };
+}

package/dist/lib/safe-markdown.d.ts

@@ -0,0 +1,12 @@
+import type { InlineNode, MessageBlock } from "./chat.js";
+/**
+ * Reads model text as safe markdown: paragraphs, lists and fenced code. Never HTML. `#` lines are bold paragraphs
+ * unless `headings` is set, when `#`, `##` and `###` (and deeper, as level 3) become heading blocks.
+ */
+export declare function markdownBlocks(text: string, { headings }?: {
+    headings?: boolean;
+}): MessageBlock[];
+/** `code`, **strong**, *em* and links (as text). Everything else stays literal. */
+export declare function inline(text: string): InlineNode[];
+/** A person's own words as one block, exactly as typed. Adapters use this for user messages: what someone typed is never read as markdown. */
+export declare function plainBlocks(text: string): MessageBlock[];

package/dist/lib/safe-markdown.js

@@ -0,0 +1,98 @@
+/*
+ * Model text → Candor blocks. Candor never renders model output as HTML or
+ * markdown, so text is read as a small, safe subset of markdown (paragraphs,
+ * lists, fenced code, `code`, **strong**, *em*) into typed blocks. Links
+ * become plain text with the address in brackets: nothing from a model is
+ * ever a clickable link. Every adapter uses this.
+ */
+const fenceLanguage = (lang) => (lang === "json" ? "json" : lang === "xml" || lang === "html" ? "xml" : "text");
+/**
+ * Reads model text as safe markdown: paragraphs, lists and fenced code. Never HTML. `#` lines are bold paragraphs
+ * unless `headings` is set, when `#`, `##` and `###` (and deeper, as level 3) become heading blocks.
+ */
+export function markdownBlocks(text, { headings = false } = {}) {
+    const blocks = [];
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    let para = [];
+    let list = null;
+    const flushPara = () => {
+        if (para.length)
+            blocks.push({ kind: "paragraph", nodes: inline(para.join(" ")) });
+        para = [];
+    };
+    const flushList = () => {
+        if (list)
+            blocks.push({ kind: "list", ordered: list.ordered, items: list.items.map(inline) });
+        list = null;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const fence = /^\s*```(\w*)\s*$/.exec(line);
+        if (fence) {
+            flushPara();
+            flushList();
+            const body = [];
+            while (++i < lines.length && !/^\s*```\s*$/.test(lines[i]))
+                body.push(lines[i]);
+            blocks.push({ kind: "payload", language: fenceLanguage(fence[1].toLowerCase()), text: body.join("\n"), title: fence[1] || undefined });
+            continue;
+        }
+        const item = /^\s*(?:([-*+])|(\d+)[.)])\s+(.*)$/.exec(line);
+        if (item) {
+            flushPara();
+            const ordered = !!item[2];
+            if (!list || list.ordered !== ordered) {
+                flushList();
+                list = { ordered, items: [] };
+            }
+            list.items.push(item[3]);
+            continue;
+        }
+        if (!line.trim()) {
+            flushPara();
+            flushList();
+            continue;
+        }
+        flushList();
+        const heading = /^\s*(#{1,6})\s+(.*)$/.exec(line);
+        if (heading) {
+            flushPara();
+            blocks.push(headings
+                ? { kind: "heading", level: Math.min(heading[1].length, 3), nodes: inline(heading[2]) }
+                : { kind: "paragraph", nodes: [{ kind: "strong", text: heading[2] }] });
+            continue;
+        }
+        para.push(line.replace(/^\s*>\s?/, "").trim());
+    }
+    flushPara();
+    flushList();
+    return blocks;
+}
+/** `code`, **strong**, *em* and links (as text). Everything else stays literal. */
+export function inline(text) {
+    const nodes = [];
+    const re = /`([^`]+)`|\*\*([^*]+)\*\*|__([^_]+)__|\*([^*\s][^*]*)\*|_([^_\s][^_]*)_|\[([^\]]+)\]\(([^)\s]+)\)/g;
+    let at = 0;
+    for (let m = re.exec(text); m; m = re.exec(text)) {
+        if (m.index > at)
+            nodes.push({ kind: "text", text: text.slice(at, m.index) });
+        if (m[1] !== undefined)
+            nodes.push({ kind: "code", text: m[1] });
+        else if (m[2] !== undefined || m[3] !== undefined)
+            nodes.push({ kind: "strong", text: (m[2] ?? m[3]) });
+        else if (m[4] !== undefined || m[5] !== undefined)
+            nodes.push({ kind: "em", text: (m[4] ?? m[5]) });
+        else
+            nodes.push({ kind: "text", text: `${m[6]} (${m[7]})` });
+        at = m.index + m[0].length;
+    }
+    if (at < text.length)
+        nodes.push({ kind: "text", text: text.slice(at) });
+    return nodes;
+}
+/** A person's own words as one block, exactly as typed. Adapters use this for user messages: what someone typed is never read as markdown. */
+export function plainBlocks(text) {
+    // Blank lines at the ends would show as empty space in the bubble; inside, they're the person's.
+    const t = text.replace(/\r\n/g, "\n").replace(/^\n+|\n+$/g, "");
+    return t.trim() ? [{ kind: "plain", text: t }] : [];
+}

package/dist/lib/status.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The status vocabulary every Candor agent component shares. Components take
+ * plain data in these shapes rather than an SDK's message objects, so they work
+ * with your own LLM drivers, the Vercel AI SDK or anything else; adapters
+ * map an SDK's parts onto them.
+ */
+export type RunStatus = "idle" | "queued" | "running" | "waiting" | "blocked" | "succeeded" | "failed" | "cancelled" | "skipped";
+export declare const statusLabel: Record<RunStatus, string>;
+/** The Badge variant that carries each status. */
+export declare const statusTone: {
+    readonly idle: "outline";
+    readonly queued: "secondary";
+    readonly running: "running";
+    readonly waiting: "warning";
+    readonly blocked: "outline";
+    readonly succeeded: "success";
+    readonly failed: "destructive";
+    readonly cancelled: "outline";
+    readonly skipped: "outline";
+};
+export declare function isTerminal(status: RunStatus): status is "succeeded" | "failed" | "cancelled" | "skipped";