@kweaver-ai/kweaver-sdk 0.4.0

package/dist/resources/knowledge-networks.js

@@ -0,0 +1,167 @@
+import { listKnowledgeNetworks, getKnowledgeNetwork, createKnowledgeNetwork, updateKnowledgeNetwork, deleteKnowledgeNetwork, listObjectTypes, listRelationTypes, listActionTypes, } from "../api/knowledge-networks.js";
+import { fetchTextOrThrow } from "../utils/http.js";
+function is404(err) {
+    return !!(err && typeof err === "object" && "status" in err && err.status === 404);
+}
+export class KnowledgeNetworksResource {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async list(opts = {}) {
+        const raw = await listKnowledgeNetworks({ ...this.ctx.base(), ...opts });
+        const parsed = JSON.parse(raw);
+        const data = parsed && typeof parsed === "object" && "data" in parsed
+            ? parsed.data
+            : parsed;
+        return Array.isArray(data) ? data : [];
+    }
+    async get(knId, opts = {}) {
+        const raw = await getKnowledgeNetwork({ ...this.ctx.base(), knId, ...opts });
+        return JSON.parse(raw);
+    }
+    async create(opts) {
+        const raw = await createKnowledgeNetwork({ ...this.ctx.base(), body: JSON.stringify(opts) });
+        return JSON.parse(raw);
+    }
+    async update(knId, opts) {
+        const raw = await updateKnowledgeNetwork({ ...this.ctx.base(), knId, body: JSON.stringify(opts) });
+        return JSON.parse(raw);
+    }
+    async delete(knId) {
+        await deleteKnowledgeNetwork({ ...this.ctx.base(), knId });
+    }
+    async listObjectTypes(knId, opts = {}) {
+        const raw = await listObjectTypes({ ...this.ctx.base(), knId, ...opts });
+        const parsed = JSON.parse(raw);
+        const items = Array.isArray(parsed)
+            ? parsed
+            : parsed && typeof parsed === "object" && "entries" in parsed
+                ? parsed.entries
+                : [];
+        return items;
+    }
+    async listRelationTypes(knId, opts = {}) {
+        const raw = await listRelationTypes({ ...this.ctx.base(), knId, ...opts });
+        const parsed = JSON.parse(raw);
+        const items = Array.isArray(parsed)
+            ? parsed
+            : parsed && typeof parsed === "object" && "entries" in parsed
+                ? parsed.entries
+                : [];
+        return items;
+    }
+    async listActionTypes(knId, opts = {}) {
+        const raw = await listActionTypes({ ...this.ctx.base(), knId, ...opts });
+        const parsed = JSON.parse(raw);
+        const items = Array.isArray(parsed)
+            ? parsed
+            : parsed && typeof parsed === "object" && "entries" in parsed
+                ? parsed.entries
+                : [];
+        return items;
+    }
+    /**
+     * Trigger a full build (index rebuild) of a BKN.
+     * Call this after adding datasources or modifying object/relation types.
+     *
+     * @param bknId   BKN ID to build.
+     * @returns A promise that resolves immediately after the build is triggered.
+     *          Use `buildAndWait` to block until completion.
+     */
+    async build(bknId) {
+        const { baseUrl, accessToken, businessDomain } = this.ctx.base();
+        const headers = {
+            "content-type": "application/json",
+            authorization: `Bearer ${accessToken}`,
+            token: accessToken,
+            "x-business-domain": businessDomain,
+        };
+        try {
+            await fetchTextOrThrow(`${baseUrl}/api/agent-retrieval/in/v1/kn/full_build_ontology`, { method: "POST", headers, body: JSON.stringify({ kn_id: bknId }) });
+        }
+        catch (err) {
+            if (!is404(err))
+                throw err;
+            // Fallback: call ontology-manager jobs endpoint directly
+            try {
+                await fetchTextOrThrow(`${baseUrl}/api/ontology-manager/in/v1/knowledge-networks/${encodeURIComponent(bknId)}/jobs`, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify({ name: `sdk_build_${bknId.slice(0, 8)}`, job_type: "full" }),
+                });
+            }
+            catch (err2) {
+                if (is404(err2)) {
+                    throw new Error(`No build endpoint available for BKN ${bknId}. ` +
+                        `Both agent-retrieval and ontology-manager returned 404. ` +
+                        `This deployment may not support index rebuilds.`);
+                }
+                throw err2;
+            }
+        }
+    }
+    /** Poll build status for a BKN. */
+    async buildStatus(bknId) {
+        const { baseUrl, accessToken, businessDomain } = this.ctx.base();
+        const headers = {
+            authorization: `Bearer ${accessToken}`,
+            token: accessToken,
+            "x-business-domain": businessDomain,
+        };
+        try {
+            const { body } = await fetchTextOrThrow(`${baseUrl}/api/agent-retrieval/in/v1/kn/full_ontology_building_status?kn_id=${encodeURIComponent(bknId)}`, { headers });
+            const data = JSON.parse(body);
+            return { state: data.state ?? "running", state_detail: data.state_detail };
+        }
+        catch (err) {
+            if (!is404(err))
+                throw err;
+            // Fallback: check ontology-manager jobs for latest status
+            try {
+                const { body } = await fetchTextOrThrow(`${baseUrl}/api/ontology-manager/in/v1/knowledge-networks/${encodeURIComponent(bknId)}/jobs?limit=1&direction=desc`, { headers });
+                const data = JSON.parse(body);
+                const jobs = Array.isArray(data)
+                    ? data
+                    : data && typeof data === "object" && "entries" in data
+                        ? (data.entries ?? [])
+                        : data && typeof data === "object" && "data" in data
+                            ? (data.data ?? [])
+                            : [];
+                if (jobs.length > 0) {
+                    return { state: jobs[0].state ?? "running" };
+                }
+                return { state: "completed" };
+            }
+            catch (err2) {
+                if (is404(err2))
+                    return { state: "completed" };
+                throw err2;
+            }
+        }
+    }
+    /**
+     * Trigger a full BKN build and wait for it to complete.
+     *
+     * @param bknId     BKN ID to build.
+     * @param timeout   Max wait time in milliseconds (default 300_000 = 5 min).
+     * @param interval  Poll interval in milliseconds (default 2_000).
+     * @throws Error if the build fails or times out.
+     */
+    async buildAndWait(bknId, { timeout = 300_000, interval = 2_000 } = {}) {
+        await this.build(bknId);
+        const deadline = Date.now() + timeout;
+        while (true) {
+            await new Promise((r) => setTimeout(r, interval));
+            const status = await this.buildStatus(bknId);
+            if (status.state === "completed")
+                return status;
+            if (status.state === "failed") {
+                throw new Error(`BKN build failed for ${bknId}: ${status.state_detail ?? "no detail"}`);
+            }
+            if (Date.now() > deadline) {
+                throw new Error(`BKN build timed out after ${timeout}ms for ${bknId}`);
+            }
+        }
+    }
+}

package/dist/ui/ChatApp.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+export interface TokenPayload {
+    baseUrl: string;
+    accessToken: string;
+}
+export interface ChatAppProps {
+    getToken: () => Promise<TokenPayload>;
+    agentId: string;
+    agentKey: string;
+    agentVersion: string;
+    businessDomain: string;
+    verbose: boolean;
+    initialConversationId?: string;
+    stream?: boolean;
+}
+export declare function ChatApp(props: ChatAppProps): React.JSX.Element;

package/dist/ui/ChatApp.js

@@ -0,0 +1,248 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useRef, useState } from "react";
+import { Box, Static, Text, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import Spinner from "ink-spinner";
+import { sendChatRequest, sendChatRequestStream } from "../api/agent-chat.js";
+import { formatHttpError } from "../auth/oauth.js";
+import { normalizeDisplayText } from "./display-text.js";
+import { MarkdownBlock } from "./MarkdownBlock.js";
+const MIDDLE_ANSWER_MAX_LINES = 5;
+function formatProgressValue(value) {
+    if (typeof value === "string")
+        return normalizeDisplayText(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (value === null || value === undefined)
+        return "";
+    try {
+        return normalizeDisplayText(JSON.stringify(value));
+    }
+    catch {
+        return String(value);
+    }
+}
+function getLinesForItem(item, idx) {
+    const name = item.agent_name ?? item.skill_info?.name ?? `Step ${idx + 1}`;
+    const status = item.status ?? "";
+    const lines = [`${name}${status ? ` — ${status}` : ""}`];
+    const isTool = item.skill_info?.type === "TOOL";
+    if (isTool) {
+        const toolName = item.skill_info?.name ?? item.agent_name;
+        if (toolName) {
+            lines.push(`tool: ${normalizeDisplayText(toolName)}`);
+        }
+        for (const arg of item.skill_info?.args ?? []) {
+            const argName = arg.name ?? "arg";
+            const argValue = formatProgressValue(arg.value);
+            lines.push(`${argName}: ${argValue}`);
+        }
+    }
+    let answerStr;
+    if (typeof item.answer === "string") {
+        answerStr = item.answer;
+    }
+    else if (item.answer && typeof item.answer === "object") {
+        const o = item.answer;
+        const d = typeof o.description === "string" ? o.description : "";
+        const c = typeof o.code === "string" ? o.code : "";
+        const s = typeof o.solution === "string" ? o.solution : "";
+        const link = typeof o.link === "string" ? o.link : "";
+        answerStr = [d, c ? `code: ${c}` : "", s ? `solution: ${s}` : "", link ? `link: ${link}` : ""]
+            .filter(Boolean)
+            .join("\n");
+    }
+    else {
+        answerStr = item.result ?? "";
+    }
+    if (answerStr)
+        lines.push(...normalizeDisplayText(answerStr).split("\n"));
+    return lines;
+}
+function getVisibleProgress(items) {
+    const itemLines = items.map((item, idx) => ({ item, lines: getLinesForItem(item, idx) }));
+    let remaining = MIDDLE_ANSWER_MAX_LINES;
+    const visible = [];
+    for (const { item, lines } of itemLines) {
+        if (remaining <= 0)
+            break;
+        const take = Math.min(remaining, lines.length);
+        visible.push({ item, lines: lines.slice(0, take) });
+        remaining -= take;
+    }
+    const totalLines = itemLines.reduce((s, { lines }) => s + lines.length, 0);
+    return { visible, hiddenLineCount: Math.max(0, totalLines - MIDDLE_ANSWER_MAX_LINES) };
+}
+function renderStaticItem(item, index) {
+    if (item.kind === "header") {
+        return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Chat \u2014 type exit, quit or q to leave" }) }, index));
+    }
+    if (item.kind === "msg") {
+        const { msg } = item;
+        if (msg.role === "user") {
+            return (_jsx(Box, { flexDirection: "column", marginY: 1, width: "100%", paddingRight: 1, children: _jsx(Box, { width: "100%", paddingX: 1, paddingY: 1, backgroundColor: "#2C2C2C", children: _jsx(Text, { color: "#9B9B9B", children: normalizeDisplayText(msg.content) }) }) }, index));
+        }
+        return (_jsx(Box, { flexDirection: "column", marginY: 1, children: _jsxs(_Fragment, { children: [msg.hadProgress ? (_jsx(Text, { dimColor: true, children: "/plan \u751F\u6210\u4FEE\u6539\u8BA1\u5212" })) : null, _jsx(MarkdownBlock, { content: normalizeDisplayText(msg.content) })] }) }, index));
+    }
+    return _jsx(Box, {}, index);
+}
+const DynamicContent = React.memo(function DynamicContent(props) {
+    const { toolProgress, streamingContent, status, errorMessage } = props;
+    return (_jsxs(Box, { flexDirection: "column", children: [toolProgress.length > 0 ? (_jsxs(Box, { marginY: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, paddingY: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, dimColor: true, children: "Tool output" }), (() => {
+                        const { visible, hiddenLineCount } = getVisibleProgress(toolProgress);
+                        return (_jsxs(_Fragment, { children: [visible.map(({ item, lines }, i) => {
+                                    const isTool = item.skill_info?.type === "TOOL";
+                                    const content = (_jsx(_Fragment, { children: lines.map((line, j) => (_jsx(Text, { dimColor: true, children: line }, j))) }));
+                                    if (isTool) {
+                                        return (_jsx(Box, { marginY: 0, borderStyle: "single", borderColor: "green", paddingX: 1, paddingY: 0, flexDirection: "column", children: content }, i));
+                                    }
+                                    return (_jsx(Box, { flexDirection: "column", children: content }, i));
+                                }), hiddenLineCount > 0 ? (_jsxs(Text, { dimColor: true, italic: true, children: ["(\u5DF2\u9690\u85CF ", hiddenLineCount, " \u884C)"] })) : null] }));
+                    })()] })) : null, toolProgress.length > 0 && (streamingContent || status === "loading") ? (_jsx(Text, { dimColor: true, children: "/plan \u751F\u6210\u4FEE\u6539\u8BA1\u5212" })) : null, streamingContent ? (_jsx(Box, { flexDirection: "column", marginY: 1, children: _jsx(MarkdownBlock, { content: normalizeDisplayText(streamingContent) }) })) : null, errorMessage ? (_jsx(Box, { marginY: 1, children: _jsx(Text, { color: "red", children: errorMessage }) })) : null] }));
+});
+export function ChatApp(props) {
+    const { getToken, agentId, agentKey, agentVersion, businessDomain, verbose, initialConversationId, stream: useStream = true, } = props;
+    const [messages, setMessages] = useState([]);
+    const [streamingContent, setStreamingContent] = useState("");
+    const [toolProgress, setToolProgress] = useState([]);
+    const [conversationId, setConversationId] = useState(initialConversationId);
+    const [inputValue, setInputValue] = useState("");
+    const [status, setStatus] = useState("idle");
+    const [errorMessage, setErrorMessage] = useState("");
+    const pendingQueriesRef = useRef([]);
+    const streamingBufferRef = useRef("");
+    const toolProgressBufferRef = useRef([]);
+    const streamFlushIntervalRef = useRef(null);
+    const STREAM_FLUSH_MS = 550;
+    const { exit } = useApp();
+    const EXIT_WORDS = ["exit", "quit", "q"];
+    const doSendQuery = (query, convId) => {
+        setMessages((prev) => [...prev, { role: "user", content: query }]);
+        setInputValue("");
+        setStreamingContent("");
+        setToolProgress([]);
+        setErrorMessage("");
+        setStatus("loading");
+        streamingBufferRef.current = "";
+        toolProgressBufferRef.current = [];
+        const onDone = (result) => {
+            const hadProgress = (result.progress?.length ?? 0) > 0 || toolProgressBufferRef.current.length > 0;
+            setStreamingContent("");
+            setToolProgress(result.progress !== undefined ? result.progress : toolProgressBufferRef.current);
+            setMessages((prev) => [
+                ...prev,
+                { role: "agent", content: normalizeDisplayText(result.text), hadProgress },
+            ]);
+            if (result.conversationId) {
+                setConversationId(result.conversationId);
+            }
+            setStatus("idle");
+            const next = pendingQueriesRef.current.shift();
+            if (next !== undefined) {
+                doSendQuery(next, result.conversationId);
+            }
+        };
+        const onFail = (error) => {
+            setErrorMessage(formatHttpError(error));
+            setStatus("error");
+            setStreamingContent("");
+            setToolProgress([]);
+            const next = pendingQueriesRef.current.shift();
+            if (next !== undefined) {
+                pendingQueriesRef.current.unshift(next);
+            }
+        };
+        if (!useStream) {
+            void getToken()
+                .then((token) => sendChatRequest({
+                baseUrl: token.baseUrl,
+                accessToken: token.accessToken,
+                agentId,
+                agentKey,
+                agentVersion,
+                query,
+                conversationId: convId,
+                stream: false,
+                verbose,
+                businessDomain,
+            }))
+                .then(onDone)
+                .catch(onFail);
+            return;
+        }
+        if (streamFlushIntervalRef.current) {
+            clearInterval(streamFlushIntervalRef.current);
+            streamFlushIntervalRef.current = null;
+        }
+        streamFlushIntervalRef.current = setInterval(() => {
+            const nextText = streamingBufferRef.current;
+            const nextProgress = toolProgressBufferRef.current;
+            const normalizedNextText = normalizeDisplayText(nextText);
+            setStreamingContent((prev) => (normalizedNextText === prev ? prev : normalizedNextText));
+            setToolProgress((prev) => prev.length !== nextProgress.length || prev.some((p, i) => p !== nextProgress[i])
+                ? nextProgress
+                : prev);
+        }, STREAM_FLUSH_MS);
+        void getToken()
+            .then((token) => sendChatRequestStream({
+            baseUrl: token.baseUrl,
+            accessToken: token.accessToken,
+            agentId,
+            agentKey,
+            agentVersion,
+            query,
+            conversationId: convId,
+            stream: true,
+            verbose,
+            businessDomain,
+        }, {
+            onTextDelta: (fullText) => {
+                streamingBufferRef.current = normalizeDisplayText(fullText);
+            },
+            onProgress: (progress) => {
+                toolProgressBufferRef.current = progress;
+            },
+        }))
+            .then((result) => {
+            if (streamFlushIntervalRef.current) {
+                clearInterval(streamFlushIntervalRef.current);
+                streamFlushIntervalRef.current = null;
+            }
+            streamingBufferRef.current = "";
+            onDone(result);
+        })
+            .catch((error) => {
+            if (streamFlushIntervalRef.current) {
+                clearInterval(streamFlushIntervalRef.current);
+                streamFlushIntervalRef.current = null;
+            }
+            streamingBufferRef.current = "";
+            onFail(error);
+        });
+    };
+    useInput((input, key) => {
+        if (key.ctrl && input === "\x03") {
+            exit();
+        }
+    });
+    const handleSubmit = (value) => {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return;
+        if (EXIT_WORDS.includes(trimmed.toLowerCase())) {
+            exit();
+            return;
+        }
+        if (status === "loading") {
+            pendingQueriesRef.current.push(trimmed);
+            setInputValue("");
+            return;
+        }
+        doSendQuery(trimmed, conversationId);
+    };
+    const staticItems = [
+        { kind: "header" },
+        ...messages.map((msg) => ({ kind: "msg", msg })),
+    ];
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Static, { items: staticItems, style: { width: "100%" }, children: (item, index) => renderStaticItem(item, index) }), _jsx(DynamicContent, { toolProgress: toolProgress, streamingContent: streamingContent, status: status, errorMessage: errorMessage }), _jsxs(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", backgroundColor: "black", paddingX: 1, paddingY: 0, children: [_jsx(Text, { color: "gray", children: "> " }), _jsx(TextInput, { value: inputValue, onChange: setInputValue, onSubmit: handleSubmit, placeholder: "Type a message..." })] }), status === "loading" ? (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "green", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Thinking..." })] })) : null] }));
+}

package/dist/ui/MarkdownBlock.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export interface MarkdownBlockProps {
+    content: string;
+}
+export declare function MarkdownBlock({ content }: MarkdownBlockProps): React.JSX.Element;

package/dist/ui/MarkdownBlock.js

@@ -0,0 +1,137 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment, useMemo } from "react";
+import { Box, Text } from "ink";
+import { marked } from "marked";
+import { normalizeDisplayText } from "./display-text.js";
+function hasTokens(token) {
+    return "tokens" in token && Array.isArray(token.tokens);
+}
+function isListToken(token) {
+    return token.type === "list" && "items" in token;
+}
+function isTableToken(token) {
+    return token.type === "table" && "header" in token && "rows" in token;
+}
+function tokensToPlainText(tokens) {
+    if (!tokens || tokens.length === 0)
+        return "";
+    return tokens
+        .map((token) => {
+        switch (token.type) {
+            case "text":
+                return hasTokens(token) ? tokensToPlainText(token.tokens) : token.text;
+            case "strong":
+            case "em":
+            case "del":
+                return tokensToPlainText(token.tokens ?? []);
+            case "codespan":
+                return `\`${token.text}\``;
+            case "link":
+                return `${tokensToPlainText(token.tokens ?? [])} (${token.href})`;
+            case "image":
+                return `[image: ${token.text || token.href}]`;
+            case "br":
+                return "\n";
+            case "escape":
+            case "html":
+                return token.text;
+            default:
+                if (hasTokens(token)) {
+                    return tokensToPlainText(token.tokens);
+                }
+                if ("text" in token && typeof token.text === "string") {
+                    return token.text;
+                }
+                return token.raw;
+        }
+    })
+        .join("");
+}
+function renderInlineToken(token, key) {
+    switch (token.type) {
+        case "text":
+            if (hasTokens(token)) {
+                return _jsx(Fragment, { children: renderInlineTokens(token.tokens, `${key}-text`) }, key);
+            }
+            return _jsx(Fragment, { children: token.text }, key);
+        case "strong":
+            return (_jsx(Text, { bold: true, children: renderInlineTokens(token.tokens ?? [], `${key}-strong`) }, key));
+        case "em":
+            return (_jsx(Text, { italic: true, children: renderInlineTokens(token.tokens ?? [], `${key}-em`) }, key));
+        case "del":
+            return (_jsx(Text, { dimColor: true, children: renderInlineTokens(token.tokens ?? [], `${key}-del`) }, key));
+        case "codespan":
+            return (_jsx(Text, { color: "cyan", children: ` \`${token.text}\` ` }, key));
+        case "link":
+            return (_jsxs(Text, { color: "blue", underline: true, children: [renderInlineTokens(token.tokens ?? [], `${key}-link`), ` (${token.href})`] }, key));
+        case "image":
+            return (_jsxs(Text, { color: "yellow", children: ["[", token.text || "image", "] ", token.href] }, key));
+        case "br":
+            return _jsx(Fragment, { children: "\n" }, key);
+        case "escape":
+        case "html":
+            return _jsx(Fragment, { children: token.text }, key);
+        default:
+            if (hasTokens(token)) {
+                return _jsx(Fragment, { children: renderInlineTokens(token.tokens, `${key}-generic`) }, key);
+            }
+            if ("text" in token && typeof token.text === "string") {
+                return _jsx(Fragment, { children: token.text }, key);
+            }
+            return _jsx(Fragment, { children: token.raw }, key);
+    }
+}
+function renderInlineTokens(tokens, keyPrefix) {
+    return tokens.map((token, index) => renderInlineToken(token, `${keyPrefix}-${index}`));
+}
+function renderTable(token, key) {
+    const rows = [
+        token.header.map((cell) => tokensToPlainText(cell.tokens)),
+        ...token.rows.map((row) => row.map((cell) => tokensToPlainText(cell.tokens))),
+    ];
+    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: rows.map((row, rowIndex) => (_jsx(Text, { children: row.join(" | ") }, `${key}-row-${rowIndex}`))) }, key));
+}
+function renderList(token, key) {
+    const start = typeof token.start === "number" ? token.start : 1;
+    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: token.items.map((item, index) => {
+            const marker = token.ordered ? `${start + index}.` : "•";
+            const text = tokensToPlainText(item.tokens).trim();
+            return (_jsx(Box, { children: _jsx(Text, { children: `${marker} ${text}` }) }, `${key}-item-${index}`));
+        }) }, key));
+}
+function renderBlock(token, key) {
+    switch (token.type) {
+        case "space":
+            return null;
+        case "heading":
+            return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: token.depth <= 2 ? "cyan" : "green", children: renderInlineTokens(token.tokens ?? [], `${key}-heading`) }) }, key));
+        case "paragraph":
+            return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: renderInlineTokens(token.tokens ?? [], `${key}-paragraph`) }) }, key));
+        case "text":
+            return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: hasTokens(token) ? renderInlineTokens(token.tokens, `${key}-text`) : token.text }) }, key));
+        case "code":
+            return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [token.lang ? _jsx(Text, { dimColor: true, children: token.lang }) : null, token.text.split("\n").map((line, index) => (_jsx(Text, { color: "cyan", children: line }, `${key}-line-${index}`)))] }, key));
+        case "blockquote": {
+            const lines = tokensToPlainText(token.tokens).split("\n");
+            return (_jsx(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 1, children: lines.map((line, index) => (_jsx(Text, { dimColor: true, children: `> ${line}` }, `${key}-quote-${index}`))) }, key));
+        }
+        case "list":
+            return isListToken(token) ? renderList(token, key) : null;
+        case "table":
+            return isTableToken(token) ? renderTable(token, key) : null;
+        case "hr":
+            return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "----------------------------------------" }) }, key));
+        case "html":
+            return token.block ? (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: token.text }) }, key)) : null;
+        default:
+            return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: tokensToPlainText(hasTokens(token) ? token.tokens : undefined) || token.raw }) }, key));
+    }
+}
+export function MarkdownBlock({ content }) {
+    const trimmed = normalizeDisplayText(content).trim();
+    const tokens = useMemo(() => (trimmed ? marked.lexer(trimmed) : []), [trimmed]);
+    if (!trimmed) {
+        return _jsx(Text, {});
+    }
+    return _jsx(Box, { flexDirection: "column", children: tokens.map((token, index) => renderBlock(token, `md-${index}`)) });
+}

package/dist/ui/display-text.d.ts

@@ -0,0 +1 @@
+export { decodeHtmlEntities, normalizeDisplayText, stripHtmlComments, } from "../utils/display-text.js";

package/dist/ui/display-text.js

@@ -0,0 +1 @@
+export { decodeHtmlEntities, normalizeDisplayText, stripHtmlComments, } from "../utils/display-text.js";

package/dist/utils/browser.d.ts

@@ -0,0 +1 @@
+export declare function openBrowser(url: string): Promise<boolean>;

package/dist/utils/browser.js

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+export function openBrowser(url) {
+    const command = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "cmd"
+            : "xdg-open";
+    const args = process.platform === "win32"
+        ? ["/c", "start", "", url]
+        : [url];
+    return new Promise((resolve) => {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.on("error", () => resolve(false));
+        child.unref();
+        resolve(true);
+    });
+}

package/dist/utils/display-text.d.ts

@@ -0,0 +1,3 @@
+export declare function decodeHtmlEntities(s: string): string;
+export declare function stripHtmlComments(s: string): string;
+export declare function normalizeDisplayText(s: string): string;

package/dist/utils/display-text.js

@@ -0,0 +1,46 @@
+function decodeHtmlEntitiesPass(s) {
+    return s
+        .replace(/&/g, "&")
+        .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, code) => String.fromCodePoint(parseInt(code, 16)))
+        .replace(/"/g, "\"")
+        .replace(/'|'/g, "'")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&nbsp;/g, " ");
+}
+export function decodeHtmlEntities(s) {
+    let current = s;
+    for (let i = 0; i < 5; i += 1) {
+        const decoded = decodeHtmlEntitiesPass(current);
+        if (decoded === current) {
+            break;
+        }
+        current = decoded;
+    }
+    return current;
+}
+export function stripHtmlComments(s) {
+    let current = s.trimStart();
+    // Suppress leading comment-only frames during streaming, but keep text that follows
+    // once the leading comment block is complete.
+    while (current.startsWith("<!--")) {
+        const endIdx = current.indexOf("-->");
+        if (endIdx === -1) {
+            return "";
+        }
+        current = current.slice(endIdx + 3).trimStart();
+    }
+    return current.replace(/<!--[\s\S]*?-->/g, "").trim();
+}
+export function normalizeDisplayText(s) {
+    let current = s;
+    for (let i = 0; i < 5; i += 1) {
+        const normalized = stripHtmlComments(decodeHtmlEntities(current));
+        if (normalized === current) {
+            break;
+        }
+        current = normalized;
+    }
+    return current;
+}