@beeuni/sdk 0.1.0 → 0.3.0

package/dist/genui/fence-entry.d.ts

@@ -0,0 +1,2 @@
+export { genuiVersionFromClassName, genuiVersionOf, separateGenuiClosers, splitGenui } from './fence.js';
+export type { GenuiSegment } from './types.js';

package/dist/genui/fence-entry.js

@@ -0,0 +1 @@
+export { genuiVersionFromClassName, genuiVersionOf, separateGenuiClosers, splitGenui } from './fence.js';

package/dist/genui/fence.d.ts

@@ -0,0 +1,21 @@
+import type { GenuiSegment } from './types.js';
+export declare function genuiVersionOf(tag: string): number | null;
+export declare function genuiVersionFromClassName(className: string | undefined): number | null;
+export declare function fenceOpener(line: string): {
+    prefix: string;
+    marker: string;
+    version: number | null;
+} | null;
+export declare function isTopLevel(prefix: string): boolean;
+export declare function closesFence(line: string, marker: string): boolean;
+export interface ContainerFence {
+    prefix: string;
+    first: string;
+    marker: string;
+    nested: boolean;
+    version: number | null;
+}
+export declare function containerFenceOpener(line: string): ContainerFence | null;
+export declare function fenceBodyLine(line: string, fence: ContainerFence): string | null;
+export declare function separateGenuiClosers(text: string): string;
+export declare function splitGenui(text: string): GenuiSegment[];

package/dist/genui/fence.js

@@ -0,0 +1,138 @@
+const V1_TAGS = new Set(['openui', 'openui-lang']);
+const FENCE_START = /^([ \t>]*)(`{3,}|~{3,})/;
+const INFO_TAG = /^[ \t]*([^\s`]*)/;
+const CLOSE_FENCE = /^ {0,3}(`{3,}|~{3,})\s*$/;
+const TOP_LEVEL = /^ {0,3}$/;
+export function genuiVersionOf(tag) {
+    const lang = tag.trim().toLowerCase();
+    if (V1_TAGS.has(lang))
+        return 1;
+    const match = /^openui-v(\d{1,3})$/.exec(lang);
+    return match ? Number(match[1]) : null;
+}
+export function genuiVersionFromClassName(className) {
+    const match = /(?:^|\s)language-([\w-]+)/.exec(className ?? '');
+    return match?.[1] ? genuiVersionOf(match[1]) : null;
+}
+export function fenceOpener(line) {
+    const match = FENCE_START.exec(line);
+    if (!match)
+        return null;
+    const info = line.slice(match[0].length);
+    if (info.includes('`'))
+        return null;
+    return { prefix: match[1], marker: match[2], version: genuiVersionOf(INFO_TAG.exec(info)[1]) };
+}
+export function isTopLevel(prefix) {
+    return TOP_LEVEL.test(prefix);
+}
+export function closesFence(line, marker) {
+    const close = CLOSE_FENCE.exec(line);
+    return close !== null && close[1][0] === marker[0] && close[1].length >= marker.length;
+}
+const LIST_FENCE = /^([ \t>]*)([-*+]|\d{1,9}[.)])([ \t]+)(?=`{3}|~{3})/;
+const LEAD = /^[ \t>]*/;
+const quoteDepth = (prefix) => prefix.split('>').length - 1;
+export function containerFenceOpener(line) {
+    const item = LIST_FENCE.exec(line);
+    const open = fenceOpener(item ? line.slice(item[0].length) : line);
+    if (!open)
+        return null;
+    const prefix = item ? item[1] + ' '.repeat(item[2].length + item[3].length) : open.prefix;
+    return { marker: open.marker, version: open.version, prefix, first: item ? item[0] : prefix, nested: item !== null || !isTopLevel(open.prefix) };
+}
+export function fenceBodyLine(line, fence) {
+    if (!fence.nested)
+        return line;
+    if (line.startsWith(fence.prefix))
+        return line.slice(fence.prefix.length);
+    const lead = LEAD.exec(line)[0];
+    if (fence.prefix.includes('>') && quoteDepth(lead) === quoteDepth(fence.prefix))
+        return line.slice(lead.length);
+    return line.trim() === '' || line.trimEnd() === fence.prefix.trimEnd() ? '' : null;
+}
+function gluedCloserAt(body, marker) {
+    let end = body.length;
+    while (end > 0 && (body[end - 1] === ' ' || body[end - 1] === '\t'))
+        end--;
+    let start = end;
+    while (start > 0 && body[start - 1] === marker[0])
+        start--;
+    const before = body[start - 1];
+    return end - start >= marker.length && (before === ')' || before === ']' || before === '"') ? start : -1;
+}
+export function separateGenuiClosers(text) {
+    if (!/openui/i.test(text))
+        return text;
+    const lines = text.split('\n');
+    let fence = null;
+    let changed = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!fence) {
+            fence = containerFenceOpener(line);
+            continue;
+        }
+        const body = fenceBodyLine(line, fence);
+        if (body === null) {
+            fence = null;
+            i--;
+            continue;
+        }
+        if (closesFence(body, fence.marker)) {
+            fence = null;
+            continue;
+        }
+        const at = fence.version === null ? -1 : gluedCloserAt(body, fence.marker);
+        if (at < 0)
+            continue;
+        const cut = line.length - body.length + at;
+        lines[i] = `${line.slice(0, cut)}\n${fence.prefix}${line.slice(cut).trimEnd()}`;
+        changed = true;
+        fence = null;
+    }
+    return changed ? lines.join('\n') : text;
+}
+export function splitGenui(text) {
+    const segments = [];
+    const lines = text.split('\n');
+    let markdown = [];
+    let fence = null;
+    const flushMarkdown = () => {
+        if (markdown.length > 0)
+            segments.push({ kind: 'markdown', text: markdown.join('\n') });
+        markdown = [];
+    };
+    for (const line of lines) {
+        if (!fence) {
+            const open = fenceOpener(line);
+            if (!open || !isTopLevel(open.prefix)) {
+                markdown.push(line);
+                continue;
+            }
+            fence = { marker: open.marker, version: open.version, body: [] };
+            if (open.version === null)
+                markdown.push(line);
+            else
+                flushMarkdown();
+            continue;
+        }
+        if (!closesFence(line, fence.marker)) {
+            if (fence.version === null)
+                markdown.push(line);
+            else
+                fence.body.push(line);
+            continue;
+        }
+        if (fence.version === null)
+            markdown.push(line);
+        else
+            segments.push({ kind: 'genui', code: fence.body.join('\n'), version: fence.version, closed: true });
+        fence = null;
+    }
+    if (fence && fence.version !== null) {
+        segments.push({ kind: 'genui', code: fence.body.join('\n'), version: fence.version, closed: false });
+    }
+    flushMarkdown();
+    return segments;
+}

package/dist/genui/index.d.ts

@@ -0,0 +1,6 @@
+export { genuiVersionFromClassName, genuiVersionOf, separateGenuiClosers, splitGenui } from './fence.js';
+export { GENUI_CUT_OFF_NOTE, GENUI_UNSUPPORTED_NOTE, genuiA11yText, genuiBlockToMarkdown, genuiNodeToMarkdown, genuiToMarkdown, } from './markdown.js';
+export { createGenuiParser, parseGenui, type GenuiParser } from './parse.js';
+export { buildGenuiPrompt, GENUI_PROMPT_VERSION } from './prompt.js';
+export { GENUI_SCHEMA_VERSION, type GenuiIssue, type GenuiIssueCode, type GenuiNode, type GenuiParseResult, type GenuiSegment, } from './types.js';
+export { safeUrl } from './urls.js';

package/dist/genui/index.js

@@ -0,0 +1,6 @@
+export { genuiVersionFromClassName, genuiVersionOf, separateGenuiClosers, splitGenui } from './fence.js';
+export { GENUI_CUT_OFF_NOTE, GENUI_UNSUPPORTED_NOTE, genuiA11yText, genuiBlockToMarkdown, genuiNodeToMarkdown, genuiToMarkdown, } from './markdown.js';
+export { createGenuiParser, parseGenui } from './parse.js';
+export { buildGenuiPrompt, GENUI_PROMPT_VERSION } from './prompt.js';
+export { GENUI_SCHEMA_VERSION, } from './types.js';
+export { safeUrl } from './urls.js';

package/dist/genui/markdown.d.ts

@@ -0,0 +1,12 @@
+import { type GenuiNode, type GenuiParseResult } from './types.js';
+export declare const GENUI_UNSUPPORTED_NOTE = "This content needs a newer version of Beeuni.";
+export declare const GENUI_CUT_OFF_NOTE = "Response was cut off.";
+export declare function genuiNodeToMarkdown(node: GenuiNode): string;
+export declare function genuiA11yText(node: GenuiNode): string | null;
+export declare function genuiResultToMarkdown(result: GenuiParseResult): string;
+export declare function genuiBlockToMarkdown(code: string, version?: number, options?: {
+    streaming?: boolean;
+}): string;
+export declare function genuiToMarkdown(text: string, options?: {
+    streaming?: boolean;
+}): string;

package/dist/genui/markdown.js

@@ -0,0 +1,104 @@
+import { GENUI_SPECS } from './catalog.js';
+import { closesFence, containerFenceOpener, fenceBodyLine, separateGenuiClosers, splitGenui } from './fence.js';
+import { createGenuiParser } from './parse.js';
+import { GENUI_SCHEMA_VERSION } from './types.js';
+export const GENUI_UNSUPPORTED_NOTE = 'This content needs a newer version of Beeuni.';
+export const GENUI_CUT_OFF_NOTE = 'Response was cut off.';
+const UNAVAILABLE_NOTE = 'This content could not be displayed.';
+export function genuiNodeToMarkdown(node) {
+    const spec = GENUI_SPECS[node.type];
+    return spec && !node.partial ? spec.toMarkdown(node.props, genuiNodeToMarkdown) : '';
+}
+export function genuiA11yText(node) {
+    return GENUI_SPECS[node.type]?.a11y?.(node.props) ?? null;
+}
+export function genuiResultToMarkdown(result) {
+    try {
+        const body = result.root ? genuiNodeToMarkdown(result.root) : '';
+        if (result.streaming)
+            return body;
+        if (result.issues.some((issue) => issue.code === 'cut-off'))
+            return [body, `*${GENUI_CUT_OFF_NOTE}*`].filter(Boolean).join('\n\n');
+        return result.root ? body : `*${UNAVAILABLE_NOTE}*`;
+    }
+    catch {
+        return '';
+    }
+}
+export function genuiBlockToMarkdown(code, version = GENUI_SCHEMA_VERSION, options = {}) {
+    if (version !== GENUI_SCHEMA_VERSION)
+        return `*${GENUI_UNSUPPORTED_NOTE}*`;
+    return genuiResultToMarkdown(createGenuiParser(version).update(code, options.streaming ?? false));
+}
+function convertNestedBlocks(text, streaming) {
+    const lines = text.split('\n');
+    const out = [];
+    let fence = null;
+    let changed = false;
+    const finish = (unclosed) => {
+        if (fence?.body) {
+            changed = true;
+            const markdown = genuiBlockToMarkdown(fence.body.join('\n'), fence.version, { streaming: streaming && unclosed });
+            const { prefix, first } = fence;
+            if (markdown) {
+                markdown.split('\n').forEach((line, index) => out.push(index === 0 ? first + line : line ? prefix + line : prefix.trimEnd()));
+            }
+        }
+        fence = null;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!fence) {
+            const open = containerFenceOpener(line);
+            if (open) {
+                fence = { ...open, body: open.nested && open.version !== null ? [] : null };
+                if (fence.body)
+                    continue;
+            }
+            out.push(line);
+            continue;
+        }
+        const inside = fenceBodyLine(line, fence);
+        if (inside === null) {
+            finish(false);
+            i--;
+            continue;
+        }
+        if (closesFence(inside, fence.marker)) {
+            if (!fence.body)
+                out.push(line);
+            finish(false);
+            continue;
+        }
+        if (fence.body)
+            fence.body.push(inside);
+        else
+            out.push(line);
+    }
+    finish(true);
+    return changed ? out.join('\n') : text;
+}
+function trimNewlines(text) {
+    let start = 0;
+    let end = text.length;
+    while (start < end && text[start] === '\n')
+        start++;
+    while (end > start && text[end - 1] === '\n')
+        end--;
+    return text.slice(start, end);
+}
+export function genuiToMarkdown(text, options = {}) {
+    if (!/openui/i.test(text))
+        return text;
+    const streaming = options.streaming ?? false;
+    const flat = convertNestedBlocks(separateGenuiClosers(text), streaming);
+    const segments = splitGenui(flat);
+    if (!segments.some((segment) => segment.kind === 'genui'))
+        return flat;
+    return segments
+        .map((segment) => segment.kind === 'markdown'
+        ? trimNewlines(segment.text)
+        : genuiBlockToMarkdown(segment.code, segment.version, { streaming: streaming && !segment.closed }))
+        .filter((part) => part.trim().length > 0)
+        .join('\n\n');
+}

package/dist/genui/parse.d.ts

@@ -0,0 +1,6 @@
+import { type GenuiParseResult } from './types.js';
+export interface GenuiParser {
+    update(code: string, streaming: boolean): GenuiParseResult;
+}
+export declare function createGenuiParser(version?: number): GenuiParser;
+export declare function parseGenui(code: string, version?: number): GenuiParseResult;

package/dist/genui/parse.js

@@ -0,0 +1,75 @@
+import { createStreamingParser } from '@openuidev/lang-core';
+import { GENUI_LIBRARY } from './catalog.js';
+import { expansionIssue, pendingStatementId } from './expansion.js';
+import { shareNodes } from './share.js';
+import { GENUI_SCHEMA_VERSION } from './types.js';
+import { sanitizeTree } from './validate.js';
+let librarySchema = null;
+const schema = () => (librarySchema ??= GENUI_LIBRARY.toJSONSchema());
+const fromLangCore = (error) => ({
+    code: error.code === 'unknown-component' ? 'unknown-component' : 'schema',
+    component: error.component,
+    statementId: error.statementId,
+    message: error.message,
+});
+const MAX_ISSUES = 50;
+export function createGenuiParser(version = GENUI_SCHEMA_VERSION) {
+    if (version !== GENUI_SCHEMA_VERSION) {
+        const unsupported = {
+            root: null,
+            pending: [],
+            issues: [{ code: 'version', message: `Block version ${version}; this client renders ${GENUI_SCHEMA_VERSION}` }],
+            streaming: false,
+        };
+        return { update: () => unsupported };
+    }
+    let parser = createStreamingParser(schema(), 'Stack');
+    let last = null;
+    let previousNodes = new Map();
+    let lastGood = { root: null, pending: [] };
+    const rejected = (issue, streaming) => streaming ? { ...lastGood, issues: [issue], streaming } : { root: null, pending: [], issues: [issue], streaming };
+    const parse = (code, streaming) => {
+        let raw;
+        let sanitized;
+        try {
+            const issue = expansionIssue(code);
+            if (issue)
+                return rejected(issue, streaming);
+            raw = parser.set(code);
+            sanitized = sanitizeTree(raw.root, { streaming, unfinished: raw.meta.incomplete ? pendingStatementId(code) : null });
+        }
+        catch (error) {
+            parser = createStreamingParser(schema(), 'Stack');
+            previousNodes = new Map();
+            const message = error instanceof Error ? error.message : String(error);
+            return rejected({ code: 'parse-failed', message: message.slice(0, 200) }, streaming);
+        }
+        const shared = shareNodes(sanitized.root, previousNodes);
+        previousNodes = shared.byId;
+        lastGood = { root: shared.root, pending: raw.meta.unresolved };
+        const issues = [...raw.meta.errors.map(fromLangCore), ...sanitized.issues];
+        const unsupported = raw.queryStatements.length + raw.mutationStatements.length + Object.keys(raw.stateDeclarations).length;
+        if (unsupported > 0) {
+            issues.push({ code: 'unsupported-statement', message: `${unsupported} Query/Mutation/state statement(s) ignored` });
+        }
+        if (!streaming && !shared.root)
+            issues.push({ code: 'no-root', message: 'The block has no valid root block' });
+        const capped = issues.slice(0, MAX_ISSUES);
+        const cutOff = issues.find((issue) => issue.code === 'cut-off');
+        if (cutOff && !capped.includes(cutOff))
+            capped.push(cutOff);
+        return { root: shared.root, pending: raw.meta.unresolved, issues: capped, streaming };
+    };
+    return {
+        update(code, streaming) {
+            if (last && last.code === code && last.streaming === streaming)
+                return last.result;
+            const result = parse(code, streaming);
+            last = { code, streaming, result };
+            return result;
+        },
+    };
+}
+export function parseGenui(code, version = GENUI_SCHEMA_VERSION) {
+    return createGenuiParser(version).update(code, false);
+}

package/dist/genui/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare function buildGenuiPrompt(): string;
+export declare const GENUI_PROMPT_VERSION: string;

package/dist/genui/prompt.js

@@ -0,0 +1,206 @@
+import { GENUI_LIBRARY } from './catalog.js';
+const PREAMBLE = `# Generative UI
+
+The Beeuni chat renders \`openui\` code blocks inside your markdown reply as rich UI: step rows with photos,
+option cards, checklists, image galleries, maps, tables, comparisons, stat rows, and charts.
+
+## The shape of a visual answer
+
+1. Open with 1 or 2 sentences that answer the question or give your recommendation.
+2. Then one section per part of the answer: a \`##\` heading (numbered when there are 3 or more), 1 to 3 short
+   sentences, then the one block that shows the section. A short numbered list of exact actions may follow it.
+   Requirements, specs, and rules (size, format, deadline) are bullets with a bold label (**Photo size:** 35 × 45 mm),
+   never a Checklist. Words the user should say or send go in a \`>\` quote.
+3. End with one closing sentence or a short "## My recommendation", then **Official source:** [page](url) when one exists.
+   After it, ask one short question only when one missing detail would change your recommendation, about that one detail.
+   Ask nothing when the answer is complete or the user asked for plain text.
+
+One block per section, one job per block. A guide, a trip, or a how-to has 4 to 10 blocks. A short data answer
+is one sentence and one block. Never put the whole answer in one block, and never put explanations inside a block.
+
+Answer in this reply; never ask first. When a missing detail (dates, budget) changes the answer, assume the common case,
+say so in one sentence, and give the whole answer. Never assume what the request already says (a weekend is both days).
+Never reply with only questions, and never put questions in a Checklist.
+
+Before you write: list the sections and pick each block. First run ONE web_search batch for the routes, times,
+prices, and rules you will show; then ONE image_search for the photos, and the coordinates with bash (see Rules).
+
+## Pick the block from the content
+
+Products, places, food, and parts the user will buy, visit, eat, or handle always show their photos.
+
+- a journey or route, leg by leg (home → station → airport) → Steps, one Step per leg, each with a photo
+- a process the user does in the real world (check in, apply for a visa, fix a tire, cook a dish) → Steps, one Step per action
+- things to pack or gather (a packing list, documents to collect) → Checklist
+- what a correct result looks like (a valid passport photo, the part to buy) → one Image with text beside it
+- 2 to 8 options to choose between (routes, flights, products, cafés, hotels) → a Stack of Cards, each with its photo.
+  Choosing how to do something (taxi or train, which flight) is always Cards, never Compare
+- the user asks for a spec-by-spec table or pros and cons of 2 to 4 named options → Compare, with the winner set when you recommend one
+- a ranked list of things with no photo (ideas, strategies) → RankedList. A product or place shortlist is Cards, never a RankedList
+- 2 or more named places the user goes to or picks from (stations, hotels, sights) → Map; add Cards or Steps for them only when they carry photos or facts the pins do not
+- what a place or a stage looks like → a gallery: a Stack of 3 Images
+- a schedule or timeline, or other rows and columns → Table
+- 2 to 4 headline numbers → StatRow. One number across items → BarChart. A value over time → LineChart. Shares of a whole or survey answers → PieChart
+- one warning the user must not miss → Callout
+- optional detail a reader may skip → Accordion. Views the user asked to switch between → Tabs
+
+Never put the main steps or options in an Accordion or Tabs. Never write them as "### Step 1" headings or a long
+numbered list: use Steps. 4 or more real-world actions in order are Steps, not prose or a numbered list. Never write a markdown table for data.
+
+## Stay in prose
+
+Write no block for chat, a fact under about 3 sentences, an explanation of how something works, a one-line opinion with no options to compare,
+translating or rewriting text, and code. Code and terminal commands stay in ordinary code fences, so a software
+install or setup guide is prose with code fences, at any length. When the user asks for plain text, markdown, JSON, or no UI, write exactly that format and no block.`;
+const SYNTAX = `## Syntax
+
+1. One statement per line: \`name = Component(arg1, arg2, ...)\`. Strings use double quotes.
+2. Write \`root\` first. root is the one component the block shows. Use a Stack only for 2 or more components in one block.
+3. Arguments are positional only: Stat("Users", "900"), never Stat(label: "Users", value: "900") and never Stat("Users", "900", unit="k"). To set a later argument, write null for each one you skip.
+4. Every name except root is used by another statement. An unused name does not render.
+5. Put the closing \`\`\` on its own line, never right after the last statement.
+
+\`\`\`openui
+root = Steps([a, b, c])
+a = Step("Title", "What to do.")
+b = Step("Title", "What to do.")
+c = Step("Title", "What to do.")
+\`\`\``;
+const RULES = [
+    'Children of Stack, Tab, and AccordionItem are component references, never plain strings. Prose goes between blocks, never inside a Callout or a Card.',
+    'Respect argument order and limits: Map(markers, source, zoom?, route?). Step(title, text?, image?, meta?). Image(src, alt, caption?, text?). Checklist(title, items). Stat delta and Badge label are at most 24 characters. Checklist items and Table caption are at most 120 characters. Table takes exactly columns, rows, caption?.',
+    'Write at least one sentence of prose before the first block and between two blocks, except when the second block continues the first. The prose never repeats the block.',
+    'Show the same data once: never a chart and a table, or two charts, of the same numbers.',
+    'Images, links, numbers, prices, times, and coordinates come only from tool results, files, or the user. Never invent them. Charts and maps always fill source with the origin in 2 to 5 words (web_search, the billing export), never "provided" or "supplied". Mention a fact the tool results lack only when the user must act on it, once, as an instruction.',
+    'Get every photo for the reply in ONE image_search call before you write: one query per Step, Card, and Image, joined with |||, and num_results 3. For each item, use the first fitting result of its own query. A Step photo may show the kind of place or action (a check-in hall). Without image_search, use a web_search result image whose description matches. Never fetch pages for images. Never use one photo for two items: leave the image empty rather than use a wrong one.',
+    "Every Step and every Card in a list carries its photo, in the item's own image argument, never in a separate gallery under the items.",
+    'In an option Card, subtitle is the route, kind, or travel time line (City A → Hub City → City B, 60 to 90 min), price the cost, body 1 or 2 sentences, href its official or booking page, and Badge("My first choice", "good") marks your pick among 2 or more options: a single item, a day plan, or a schedule has no pick badge. A hotel, product, or place Card also carries its rating and reviews from a tool result. Leave price empty when no tool result gives it. A score out of 10 goes in subtitle with its review count (Old Town · Booking 9.3/10, 2,345 reviews), never halved and never a Badge; then leave rating and reviews empty.',
+    'Set a Stack of Cards to list when the text matters more than the picture (routes, flights, a shortlist, logos), and to grid when the picture is the choice (hotels, places, food): Stack([a, b], "col", "list").',
+    'A Step title is under 60 characters: the leg (Home → Central Station) or the action (Check in your bag). Its text is 1 to 3 short sentences, each on its own line with \\n. meta is a short time or cost (about 35 min, 5 USD), never an instruction. A fare or timetable time needs a tool result; a cooking or task time may come from know-how.',
+    'Steps holds 3 to 8 Steps, one leg or action each. Never pack several legs or actions into one Step. A single action is a sentence of prose, not Steps. A trip guide opens with a Steps of every leg, door to arrival, one short line per leg; the actions inside a leg go only in that leg\'s own section. A trip guide also maps the airports and stations it names.',
+    'Checklist items are short things the reader ticks off (Valid passport), each under 80 characters, 3 to 15 of them. Next steps, recommendations, swaps, tips, and questions stay prose or a short numbered list of at most 5 items, one sentence each, never a Checklist, RankedList, Callout, or Cards.',
+    'A gallery is a Stack of Images and nothing else; 3 read best, as one row. Put the name and a one-line note in each caption, and no text. Never put images in a RankedList or in Cards only to show them.',
+    "A Marker's value is the number the user asked about (a rating, a price, a population), never a word (no 'Luxury'): otherwise leave it empty.",
+    'To map places you know only by name or address, look them all up in ONE bash call, one request per second: printf "%s\\n" "Place One, City" "Place Two, City" | while IFS= read -r q; do curl -sG -A "Beeuni agent (https://beeuni.com)" https://nominatim.openstreetmap.org/search -d format=jsonv2 -d limit=1 --data-urlencode "q=$q"; echo; sleep 1; done. Keep a place only when its display_name names it; otherwise look it up once more, in a second bash call, with its street address from your web_search results, and keep that result when its display_name has the same street and house number. Write the Map with source "OpenStreetMap Nominatim". If fewer than 2 places are found, give links instead of a Map.',
+    'When the user asks to see an answer as cards, a list, a chart, a table, or a map, write the block in this reply. Do not call the show tool, build a page, or write a file unless they ask you to build or save one.',
+    'Write openui blocks only in your chat reply. Never put them in messages you send to Slack, Teams, email, or files.',
+];
+const EXAMPLES = [
+    `Example: a first-time travel guide. Every name, number, and URL is a placeholder: real ones come from your tool results.
+
+After one web_search batch for the facts and one bash call for the coordinates, one call for every photo:
+image_search(query: "Airport One Terminal 2 ||| plane takeoff runway ||| Hub Airport transfer area ||| Airport Two arrivals ||| City A taxi rank ||| City A train platform ||| Carrier One aircraft ||| Carrier Two aircraft ||| airport check-in ||| airport security ||| airport gate ||| Airport Two passport control", num_results: 3)
+
+Then the reply:
+
+Since this is your first flight, here is the whole trip from your door in City A to City B, with one connection at Hub City.
+
+## 1. Your journey at a glance
+
+Here is every leg, door to arrival.
+
+\`\`\`openui
+root = Steps([s1, s2, s3, s4])
+s1 = Step("Home → Airport One", "Take a taxi to Terminal 2.", "https://example.com/photos/terminal-two.jpg", "60 to 90 min")
+s2 = Step("Airport One → Hub Airport", "Your first flight, on Carrier One.", "https://example.com/photos/takeoff.jpg")
+s3 = Step("Hub Airport", "Change planes inside the international transfer area.", "https://example.com/photos/hub-transfer.jpg")
+s4 = Step("Airport Two", "Land in City B.", "https://example.com/photos/arrivals.jpg")
+\`\`\`
+
+## 2. How to reach Airport One
+
+Airport One is 25 km east of Central Station.
+
+\`\`\`openui
+root = Map([m1, m2], "OpenStreetMap Nominatim", 11)
+m1 = Marker(10.01, 20.01, "Central Station", "Main entrance")
+m2 = Marker(10.05, 20.24, "Airport One", "Terminal 2")
+\`\`\`
+
+You have two good choices. With two suitcases, take the taxi.
+
+\`\`\`openui
+root = Stack([taxi, train], "col", "list")
+taxi = Card("Option A: taxi", "No changes and easiest with big bags. Book it the evening before.", "Home → Terminal 2, 60 to 90 min", "https://example.com/photos/taxi.jpg", null, [pick], null, null, "about 40 USD")
+pick = Badge("Best for a first flight", "good")
+train = Card("Option B: train", "Cheaper, but you carry your bags through Central Station.", "Central Station → Terminal 2, 70 to 100 min", "https://example.com/photos/train-platform.jpg", null, null, null, null, "about 5 USD")
+\`\`\`
+
+## 3. Which flight to book
+
+Book both flights on one ticket, with a 2 to 4 hour connection, so your bag goes straight through.
+
+\`\`\`openui
+root = Stack([one, two], "col", "list")
+one = Card("Carrier One", "One ticket and one short connection.", "City A → Hub City → City B", "https://example.com/photos/carrier-one.jpg", "https://example.com/carrier-one", [first])
+first = Badge("My first choice", "good")
+two = Card("Carrier Two", "A good alternative through Other Hub.", "City A → Other Hub → City B", "https://example.com/photos/carrier-two.jpg", "https://example.com/carrier-two")
+\`\`\`
+
+## 4. Inside Airport One
+
+Arrive 3 hours before departure. This is the order you go through.
+
+\`\`\`openui
+root = Steps([c1, c2, c3])
+c1 = Step("Check in your bag", "Find your airline's counter on the screens.\\nShow your passport and booking.", "https://example.com/photos/check-in.jpg")
+c2 = Step("Immigration and security", "Show your passport and visa.\\nPut your laptop and liquids in the trays.", "https://example.com/photos/security.jpg", "about 30 min")
+c3 = Step("Find your gate", "Your boarding pass shows the gate.\\nCheck the screens: gates can change.", "https://example.com/photos/gate.jpg")
+\`\`\`
+
+## 5. After you land in City B
+
+Passport control comes first.
+
+\`\`\`openui
+root = Image("https://example.com/photos/passport-control.jpg", "Passport control hall", null, "Join the line for foreign passports. Have your visa and hotel address ready.")
+\`\`\`
+
+1. Follow the signs to passport control.
+2. Collect your bag and walk through customs.
+3. Take an official taxi or the airport bus to the centre.
+
+## 6. What to pack
+
+Keep these in your cabin bag.
+
+\`\`\`openui
+root = Checklist("Your travel checklist", ["Valid passport", "Visa or entry permit", "Flight booking and boarding passes", "Bank card and some cash", "Phone, charger, and power bank in your cabin bag"])
+\`\`\`
+
+## 7. Departure day
+
+For a 07:00 flight, plan the morning like this:
+
+\`\`\`openui
+root = Table(["Time", "What to do"], [["03:00", "Leave home by taxi"], ["04:00 to 06:00", "Check in, immigration, and security"], ["07:00", "Departure"]], "Example times, not your booking")
+\`\`\`
+
+My pick for a first trip: the taxi to Airport One, and Carrier One on one ticket through Hub City.`,
+    `Example: a short data answer (placeholders).
+
+Revenue grew every quarter, by 50 USD in total.
+
+\`\`\`openui
+root = BarChart(["Q1", "Q2", "Q3"], [revenue], "billing export from the tool result", "USD")
+revenue = Series("Revenue", [120, 150, 170])
+\`\`\``,
+];
+export function buildGenuiPrompt() {
+    const signatures = Object.values(GENUI_LIBRARY.toSpec().components).map((c) => `${c.signature} — ${c.description}`);
+    return [
+        PREAMBLE,
+        SYNTAX,
+        `## Components\n\nArguments marked with ? are optional.\n\n${signatures.join('\n')}`,
+        `## Rules\n\n${RULES.map((rule) => `- ${rule}`).join('\n')}`,
+        `## Examples\n\n${EXAMPLES.join('\n\n')}`,
+    ].join('\n\n');
+}
+export const GENUI_PROMPT_VERSION = (() => {
+    let hash = 0x811c9dc5;
+    for (const char of buildGenuiPrompt()) {
+        hash ^= char.codePointAt(0);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(16).padStart(8, '0');
+})();

package/dist/genui/react/default-components.d.ts

@@ -0,0 +1,2 @@
+import type { GenuiComponentMap } from './genui-block.js';
+export declare const defaultGenuiComponents: GenuiComponentMap;