@jini-ai/chat 0.1.0

package/dist/react/index.js

@@ -0,0 +1,118 @@
+export { RendererRegistry, } from './artifact-types.js';
+export { clearToolRenderers, getToolRenderer, registerToolRenderer, } from './tool-renderer-registry.js';
+export { clearExtEventRenderers, getExtEventRenderer, registerExtEventRenderer, } from './ext-event-renderer-registry.js';
+// `features/model-picker/` (REF-001 Step B, 2026-08-05): NOT re-exported here. It was, on the
+// theory in the comment this replaced — "an independent slice... for a consumer that wants
+// everything from one barrel" — but that consumer never existed. Checked twice, once before and
+// once after the 2026-08-05 BYOK restructure of this directory: zero imports of any of its 27
+// symbols anywhere in this monorepo's other packages, Jini's own examples/, or the one real
+// external host consuming this package via a `file:` dependency, and zero internal use from
+// `ChatPane`'s own composition. Every apparent
+// name-collision hit (`AgentDefinition`, `AgentDiagnostic`, `CredentialStatus`, `ModelOption`,
+// `ModelProvider`, `matchesModelQuery`) traced back to an unrelated same-named symbol native to
+// `@jini-ai/protocol`/`@jini-ai/agent-runtime` or a same-named local helper in `@jini-ai/ui` — not
+// this package's re-export. See ADS-memory/reports/refactor/2026-08-05-ref-001-steps-bcd-proposal.md
+// §2.4 for the full trace and §9 for the re-confirmation against the post-BYOK tree.
+//
+// The feature itself is not deleted — `./features/model-picker/index.js` still exists and still
+// works for anything inside this package that wants it (nothing currently does). This removes only
+// the root barrel's re-export of it. A future consumer that genuinely needs it gets a real ADR-worthy
+// decision (its own subpath, most likely, following Step C's pattern) instead of a standing
+// "just in case" export nobody asked for.
+/**
+ * @deprecated REF-001 Step C (2026-08-05): `ChatPane` and its companions moved to their own
+ * subpath, `@jini-ai/chat/react/chat-pane` — import from there in new code. Re-exported here,
+ * unchanged, so every existing `import { ChatPane } from '@jini-ai/chat/react'` keeps working.
+ * This alias has no removal date scheduled yet; see `chat-pane.ts` for the canonical surface and
+ * the module doc there for why the split exists.
+ */
+export { AgentRuntimePicker, CHAT_PANE_AGENT_TOOLS, ChatPane, createDaemonAttachmentUploader, createMcpUiToolCaller, defaultChatPaneSelection, orderChatPaneAgents, resolveChatPaneSelection, useChatPane, useChatPaneAgentControl, useChatPaneRuntimeInventory, useChatPaneWorkingDirectory, } from './chat-pane.js';
+export { useRunStream, } from './hooks/useRunStream.js';
+export { useConversation, } from './hooks/useConversation.js';
+export { useComposer, } from './hooks/useComposer.js';
+export { useToolTimeline, } from './hooks/useToolTimeline.js';
+export { useExtEventGroups, } from './hooks/useExtEventGroups.js';
+export { usePinnedTodos, } from './hooks/usePinnedTodos.js';
+export { parseSubmittedAnswers, useQuestionForms, } from './hooks/useQuestionForms.js';
+export { useArtifactStream, } from './hooks/useArtifactStream.js';
+export { CHAT_FAB_DRAG_THRESHOLD_PX, CHAT_FAB_EDGE_MARGIN_PX, clampChatFabToViewport, useChatFabDrag, } from './hooks/useChatFabDrag.js';
+export { useT, useI18n, useAnalytics, useProjectContext, useChatTransport, useArtifactRegistry, } from './hooks/context.js';
+/**
+ * REF-001 Step D (2026-08-05): both newly public. `ChatPane`'s own composition already depended
+ * on both — `useLatestOperation` for the "only the newest attempt may write state" guard every
+ * async hook in this package needs, `definedProps` for collapsing `exactOptionalPropertyTypes`
+ * prop-forwarding ternaries — which was itself the finding: a consumer building an equivalent
+ * custom async hook or an equivalent prop-forwarding composition could not reach either one, so
+ * `ChatPane` was doing something the published API didn't let anyone else do. Both are general
+ * building blocks with no `ChatPane`-specific coupling (see each module's own doc), not composition
+ * internals, so exporting them is a surface completion, not a leak. See
+ * `scripts/check-chatpane-public-surface.ts` (R10) and
+ * ADS-memory/reports/refactor/2026-08-05-ref-001-steps-bcd-proposal.md §9.
+ */
+export { normalizeOperationError, useLatestOperation, } from './hooks/useLatestOperation.js';
+export { definedProps } from './util/defined-props.js';
+/**
+ * Newly public for the same R10 reason as `definedProps`/`useLatestOperation` above:
+ * `ChatPane`'s `composerHandle.insertText` (see `types.ts`'s `ChatPaneComposerHandle`) joins
+ * inserted text onto the existing draft with `appendComposerDiscovery` — the same joining rule the
+ * "+" discovery menu's own `insertText` items use, so a host writing into the draft from outside
+ * `ChatPane`'s props gets the identical, already-established behavior rather than inventing a
+ * second concatenation rule. Zero `ChatPane`-specific coupling (it operates on a plain draft string
+ * and an insertion string), so a consumer assembling an equivalent external-insertion feature faced
+ * the same problem and could not previously reach this solution either.
+ */
+export { appendComposerDiscovery } from './components/composer-discovery.js';
+/**
+ * REF-001 §10 (2026-08-05): newly public, same reasoning as `definedProps`/`useLatestOperation`
+ * above. `MessageRow.tsx` (itself public) depends on `interleaveMessageBlocks` to reconstruct an
+ * assistant message's original event order — text and tool cards interleaved where they actually
+ * happened — from `ChatMessage.content` + `ChatMessage.events` (see `message-blocks.ts`'s own
+ * module doc for why this needs computing at all, and when it refuses rather than guesses). Zero
+ * `ChatPane`-specific coupling: it operates on core `AgentEvent`/message vocabulary, not anything
+ * `ChatPane`-shaped. A consumer building an equivalent custom message-row component, with its own
+ * tool-timeline data, faced the identical interleaving problem and could not reach this solution —
+ * the same API-gap finding as §9.2, just found one hop further out by §10's transitive-reach trace
+ * rather than by `ChatPane`'s own direct imports. See
+ * ADS-memory/reports/refactor/2026-08-05-ref-001-steps-bcd-proposal.md §10.2: this export closes
+ * the one live instance §10 found of R10's documented transitive-reach scope limit.
+ */
+export { interleaveMessageBlocks } from './message-blocks.js';
+export { TodoCard } from './components/TodoCard.js';
+/**
+ * The conversation switcher — new / select / delete / search / rename-on-double-click. Storage
+ * agnostic: it takes data plus callbacks, so a host backs it with `@jini-ai/sqlite`'s
+ * `ChatHistoryStore`, an HTTP endpoint, or a plain array. Drop it into `ChatPane`'s
+ * `leadingAccessory` slot; it needs no changes to `ChatPane` itself.
+ */
+export { ConversationList } from './components/ConversationList.js';
+export { ToolCard } from './components/ToolCard.js';
+export { A2uiSurfaceCard } from './components/A2uiSurfaceCard.js';
+/**
+ * Moved from `@jini-ai/ui`'s `react/mcp-ui/` 2026-08-03 (see `McpUiSurfaceCard.tsx`'s own file
+ * doc) — the same `kind: 'ext'` extensibility seam as `A2uiSurfaceCard` above, just for MCP-UI
+ * resources instead of A2UI surfaces.
+ */
+export { McpUiSurfaceCard, registerMcpUiSurfaceRenderer, MCP_UI_EXT_EVENT_NAME } from './components/McpUiSurfaceCard.js';
+export { ExtEventErrorBoundary } from './components/ExtEventErrorBoundary.js';
+export { QuestionForm } from './components/QuestionForm.js';
+export { QuestionsPanel } from './components/QuestionsPanel.js';
+export { NextStepActions } from './components/NextStepActions.js';
+export { Markdown } from './components/Markdown.js';
+export { MessageRow } from './components/MessageRow.js';
+export { MessageList } from './components/MessageList.js';
+export { Composer } from './components/Composer.js';
+export { AttachmentTray } from './components/AttachmentTray.js';
+export { ChatFab } from './components/ChatFab.js';
+export { JiniChatProvider, useJiniChatSlots, useOnFeedback } from './components/JiniChatProvider.js';
+/**
+ * Agent bridge — the browser half of daemon-relayed frontend control.
+ *
+ * Lives here rather than in an example because a consumer cannot copy-paste its way to a
+ * transport: this is the piece that makes `ChatPaneAgentBridgeAccess` satisfiable at all.
+ *
+ * `createDomPageDriver`/`currentAgentPage` moved to `@jini-ai/agentic/dom` in the 2026-07-26
+ * extraction — re-exported here so existing `@jini-ai/chat-react` importers keep working.
+ */
+export { createFrontendSessionBridge } from './agent-bridge/frontend-session-bridge.js';
+export { createDomPageDriver, currentAgentPage } from '@jini-ai/agentic/dom';
+//# sourceMappingURL=index.js.map

package/dist/react/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/react/index.ts"],"names":[],"mappings":"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"}

package/dist/react/message-blocks.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @module message-blocks
+ *
+ * Restores the original event-stream ordering of an assistant message: text and tool cards
+ * interleaved where they actually happened, instead of all the text followed by all the tools.
+ *
+ * ## Why this needs computing at all
+ *
+ * A rendered assistant message draws from three different shapes of the same turn.
+ * `ChatMessage.content` is a single string — `useConversation.ts` builds it by concatenating every
+ * `kind: 'text'` event (`out += ev.text`) — tool cards come from `ChatMessage.events`'s `tool_use`
+ * entries, and interactive surfaces (MCP-UI, A2UI) come from that same array's `kind: 'ext'`
+ * entries. Rendering `content`, then the tool timeline, then every `ext` group is the
+ * straightforward composition, and it is what `MessageRow.tsx` shipped in v1 (its own header
+ * records this as a known deferral pending the `AssistantMessage.tsx` extraction).
+ *
+ * The cost is not merely cosmetic ordering. Because the text runs on either side of a tool call (or
+ * an interactive surface) get concatenated with nothing between them, a message reads as
+ * `"I'll look for a tool that changes the site language.Done — the language is now English."` —
+ * two separate thoughts, from before and after the tool ran, fused mid-sentence. Worse for an `ext`
+ * surface specifically: a reply narrating what the human just submitted through an MCP-UI form (a
+ * `text` event that only exists BECAUSE the form's `ext` event was answered) renders ABOVE that
+ * form instead of below it — the answer appears to precede the question. The reader cannot tell
+ * which claims preceded the evidence and which followed it.
+ *
+ * Since `content` is exactly the concatenation of the text events, the split points are recoverable:
+ * walk the events in order, and every tool call or ext surface marks a boundary in that
+ * concatenation.
+ *
+ * ## Refuses rather than guesses
+ *
+ * {@link interleaveMessageBlocks} returns `null` whenever it cannot prove the reconstruction is
+ * lossless, and the caller falls back to the old flat layout. Losing the ordering is a presentation
+ * regression; dropping or duplicating a chunk of the assistant's actual words is a correctness one,
+ * so every check below prefers the former.
+ *
+ * It refuses when:
+ * - there are no events, or no tool rows AND no ext events to interleave (nothing to do — the flat
+ *   path is identical);
+ * - the concatenated text events do not reproduce `content` byte for byte. This is the load-bearing
+ *   check. A message persisted before the events schema settled, one rebuilt by a host that
+ *   assembles `content` some other way, or any future divergence between the two, all land here;
+ * - the walk does not emit exactly the rows it was given (a `tool_use` with no matching row, or a
+ *   row never reached), which would mean silently dropping a tool card.
+ *
+ * Artifacts are handled by the caller, not here — see `MessageRow.tsx`.
+ */
+import type { AgentEvent } from '../core/index.js';
+/**
+ * One rendered block. Consecutive tool cards are coalesced into a single `tools` block so they keep
+ * rendering inside one `.jini-message-tools` container, exactly as the flat layout did — a run of
+ * back-to-back calls should stay one visual group, not become N separately-boxed ones. An `ext`
+ * block marks where a `kind: 'ext'` group of a given `name` (an MCP-UI/A2UI surface, or any other
+ * host-registered ext renderer) belongs in reading order — one block per name, at its FIRST
+ * occurrence, since `MessageRow.tsx`'s `useExtEventGroups` already folds every event sharing that
+ * name (however many arrive, however late) into one evolving render slot; this block only fixes
+ * WHERE that slot sits relative to the surrounding text, not what it renders.
+ */
+export type MessageBlock<Row> = {
+    readonly kind: 'text';
+    readonly text: string;
+    readonly key: string;
+} | {
+    readonly kind: 'tools';
+    readonly rows: readonly Row[];
+    readonly key: string;
+} | {
+    readonly kind: 'ext';
+    readonly name: string;
+    readonly key: string;
+};
+/**
+ * Rebuilds an assistant message as ordered blocks, or returns `null` if that cannot be done
+ * losslessly.
+ *
+ * @param events - The message's event array, in arrival order.
+ * @param content - The message's `content`, expected to equal the concatenated text events.
+ * @param rows - The tool timeline rows, already deduped and paired by `useToolTimeline`. Only rows
+ *   present here are emitted, so a row the timeline chose to drop stays dropped.
+ * @returns Ordered blocks, or `null` to signal "render the flat layout instead".
+ * @complexity O(n + m) in the event and row counts.
+ */
+export declare function interleaveMessageBlocks<Row extends {
+    id: string;
+}>(events: readonly AgentEvent[] | undefined, content: string, rows: readonly Row[]): MessageBlock<Row>[] | null;
+//# sourceMappingURL=message-blocks.d.ts.map

package/dist/react/message-blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-blocks.d.ts","sourceRoot":"","sources":["../../src/react/message-blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,CAAC,GAAG,IACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACtE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1E;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAChE,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,SAAS,EACzC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,GAAG,EAAE,GACnB,YAAY,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CA+D5B"}

package/dist/react/message-blocks.js

@@ -0,0 +1,78 @@
+/**
+ * Rebuilds an assistant message as ordered blocks, or returns `null` if that cannot be done
+ * losslessly.
+ *
+ * @param events - The message's event array, in arrival order.
+ * @param content - The message's `content`, expected to equal the concatenated text events.
+ * @param rows - The tool timeline rows, already deduped and paired by `useToolTimeline`. Only rows
+ *   present here are emitted, so a row the timeline chose to drop stays dropped.
+ * @returns Ordered blocks, or `null` to signal "render the flat layout instead".
+ * @complexity O(n + m) in the event and row counts.
+ */
+export function interleaveMessageBlocks(events, content, rows) {
+    if (!events || events.length === 0)
+        return null;
+    const hasExtEvent = events.some((ev) => ev.kind === 'ext');
+    if (rows.length === 0 && !hasExtEvent)
+        return null;
+    // The reconstruction is only trustworthy if the text events are demonstrably the source `content`
+    // was built from. Anything else and the offsets below are fiction.
+    let concatenated = '';
+    for (const ev of events) {
+        if (ev.kind === 'text')
+            concatenated += ev.text;
+    }
+    if (concatenated !== content)
+        return null;
+    const rowById = new Map(rows.map((row) => [row.id, row]));
+    const blocks = [];
+    const emitted = new Set();
+    const emittedExtNames = new Set();
+    let buffer = '';
+    const flushText = () => {
+        if (buffer.length === 0)
+            return;
+        blocks.push({ kind: 'text', text: buffer, key: `text-${blocks.length}` });
+        buffer = '';
+    };
+    for (const ev of events) {
+        if (ev.kind === 'text') {
+            buffer += ev.text;
+            continue;
+        }
+        if (ev.kind === 'ext') {
+            // One block per name, at its FIRST occurrence — later events sharing the name fold into the
+            // SAME render slot (`useExtEventGroups`'s job in `MessageRow.tsx`), not a second block.
+            if (emittedExtNames.has(ev.name))
+                continue;
+            emittedExtNames.add(ev.name);
+            flushText();
+            blocks.push({ kind: 'ext', name: ev.name, key: `ext-${ev.name}` });
+            continue;
+        }
+        if (ev.kind !== 'tool_use')
+            continue;
+        const row = rowById.get(ev.id);
+        // A `tool_use` the timeline did not surface (deduped away as a repeat of one already seen).
+        // Skipping it keeps this function's output consistent with `rows`, which is the authority on
+        // what gets a card.
+        if (!row || emitted.has(ev.id))
+            continue;
+        emitted.add(ev.id);
+        flushText();
+        const last = blocks[blocks.length - 1];
+        if (last && last.kind === 'tools') {
+            blocks[blocks.length - 1] = { kind: 'tools', rows: [...last.rows, row], key: last.key };
+        }
+        else {
+            blocks.push({ kind: 'tools', rows: [row], key: `tools-${blocks.length}` });
+        }
+    }
+    flushText();
+    // Every row must have found its place. If one did not, the message would render with a tool card
+    // missing entirely — strictly worse than the flat layout it would have had.
+    if (emitted.size !== rows.length)
+        return null;
+    return blocks;
+}
+//# sourceMappingURL=message-blocks.js.map

package/dist/react/message-blocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-blocks.js","sourceRoot":"","sources":["../../src/react/message-blocks.ts"],"names":[],"mappings":"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"}

package/dist/react/poc-mcp-ui-official/PocMcpUiCard.d.ts

@@ -0,0 +1,9 @@
+export interface PocMcpUiCardProps {
+    /** Pre-fetched HTML — normally the `resource.text` from `createPocUiResource()`. */
+    html: string;
+    /** Where the (not-stood-up, for this POC) sandbox proxy page would live. */
+    sandboxUrl: URL;
+}
+/** Renders one static MCP-UI card through the real `@mcp-ui/client` `AppRenderer`. */
+export declare function PocMcpUiCard({ html, sandboxUrl }: PocMcpUiCardProps): import("react").JSX.Element;
+//# sourceMappingURL=PocMcpUiCard.d.ts.map

package/dist/react/poc-mcp-ui-official/PocMcpUiCard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PocMcpUiCard.d.ts","sourceRoot":"","sources":["../../../src/react/poc-mcp-ui-official/PocMcpUiCard.tsx"],"names":[],"mappings":"AAwBA,MAAM,WAAW,iBAAiB;IAChC,oFAAoF;IACpF,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,UAAU,EAAE,GAAG,CAAC;CACjB;AAED,sFAAsF;AACtF,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,iBAAiB,+BAQnE"}

package/dist/react/poc-mcp-ui-official/PocMcpUiCard.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @module poc-mcp-ui-official/PocMcpUiCard
+ *
+ * PROOF OF CONCEPT — see `create-poc-resource.ts`'s module doc for full context. Not wired into
+ * this package's public API, not a replacement for `McpUiSurfaceCard.tsx`.
+ *
+ * Wraps `@mcp-ui/client`'s real `AppRenderer` component (the current name for what older versions
+ * of `@mcp-ui/client` called `UIResourceRenderer` — renamed around its v6.0.0 rebrand onto the
+ * `@modelcontextprotocol/ext-apps` "MCP Apps" spec). `AppRenderer` is given pre-fetched `html`
+ * directly (skipping MCP resource-fetching, since this POC has no live MCP server behind it) and no
+ * `client`, which is an explicitly supported mode per its own prop doc ("Omit to disable automatic
+ * MCP forwarding and use custom handlers instead" — this POC supplies neither, since the one static
+ * card it renders never calls a tool back).
+ *
+ * `AppRenderer` builds its own `AppBridge` internally and, on mount, creates a real sandboxed
+ * `<iframe>` pointed at `sandbox.url`, then waits for that iframe to `postMessage` back a
+ * `ui/notifications/sandbox-proxy-ready` notification before it will hand the HTML over. That
+ * handshake needs a REAL sandbox-proxy page served at `sandbox.url` — this POC does not stand one
+ * up (out of scope for validating the package's own API surface), so the test that renders this
+ * component asserts on the real, unmocked iframe `AppRenderer` creates (src, sandbox attribute,
+ * default sizing) rather than waiting for a live handshake that would just time out under jsdom.
+ */
+import { AppRenderer } from '@mcp-ui/client';
+/** Renders one static MCP-UI card through the real `@mcp-ui/client` `AppRenderer`. */
+export function PocMcpUiCard({ html, sandboxUrl }) {
+    return (_jsx(AppRenderer, { toolName: "poc-mcp-ui-official-card", sandbox: { url: sandboxUrl }, html: html }));
+}
+//# sourceMappingURL=PocMcpUiCard.js.map

package/dist/react/poc-mcp-ui-official/PocMcpUiCard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PocMcpUiCard.js","sourceRoot":"","sources":["../../../src/react/poc-mcp-ui-official/PocMcpUiCard.tsx"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAS7C,sFAAsF;AACtF,MAAM,UAAU,YAAY,CAAC,EAAE,IAAI,EAAE,UAAU,EAAqB;IAClE,OAAO,CACL,KAAC,WAAW,IACV,QAAQ,EAAC,0BAA0B,EACnC,OAAO,EAAE,EAAE,GAAG,EAAE,UAAU,EAAE,EAC5B,IAAI,EAAE,IAAI,GACV,CACH,CAAC;AACJ,CAAC"}

package/dist/react/poc-mcp-ui-official/create-poc-resource.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module poc-mcp-ui-official/create-poc-resource
+ *
+ * PROOF OF CONCEPT — NOT wired into the package's public API (not re-exported from
+ * `src/react/index.ts`), and NOT a replacement for the hand-rolled MCP-UI stack
+ * (`McpUiSurfaceCard.tsx`, `useMcpUiHost`, `create-mcp-ui-tool-caller.ts`), which this file does
+ * not touch.
+ *
+ * Validates that the REAL, official `@mcp-ui/server` package (not this repo's own reimplementation
+ * of the MCP-UI resource shape) can build a `UIResource` end to end, per the owner's decision to
+ * evaluate replacing the hand-rolled client with the upstream package. See
+ * `poc-mcp-ui-official/__tests__/poc-mcp-ui-official.test.tsx` for the assertions this module
+ * exists to feed, and `ADS-memory/` (Tovu side) / this session's final report for the CJS/ESM
+ * interop finding that shaped how this is imported (ESM only — `@mcp-ui/client`'s CJS build is
+ * broken in 7.1.1; `require('@mcp-ui/client')` throws / returns an empty object depending on Node
+ * version. `@mcp-ui/server`'s CJS build works fine in this same version, but this module still
+ * uses the ESM entry point for consistency with the client half of this POC).
+ */
+import { type UIResource } from '@mcp-ui/server';
+/** The one concrete example this POC builds: a simple static HTML card. */
+export declare const POC_CARD_URI = "ui://jini-poc/mcp-ui-official-card";
+export declare const POC_CARD_HTML: string;
+/**
+ * Builds the one UIResource this POC round-trips: server creates it, the test then feeds its
+ * `resource.text` straight to the client's `AppRenderer` as pre-fetched `html` (see the test —
+ * `AppRenderer`'s `html` prop skips MCP resource-fetching entirely, which is the right shape for a
+ * standalone POC with no live MCP server behind it).
+ */
+export declare function createPocUiResource(): UIResource;
+//# sourceMappingURL=create-poc-resource.d.ts.map

package/dist/react/poc-mcp-ui-official/create-poc-resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-poc-resource.d.ts","sourceRoot":"","sources":["../../../src/react/poc-mcp-ui-official/create-poc-resource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEnE,2EAA2E;AAC3E,eAAO,MAAM,YAAY,uCAAuC,CAAC;AAEjE,eAAO,MAAM,aAAa,QAQd,CAAC;AAEb;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,UAAU,CAMhD"}

package/dist/react/poc-mcp-ui-official/create-poc-resource.js

@@ -0,0 +1,44 @@
+/**
+ * @module poc-mcp-ui-official/create-poc-resource
+ *
+ * PROOF OF CONCEPT — NOT wired into the package's public API (not re-exported from
+ * `src/react/index.ts`), and NOT a replacement for the hand-rolled MCP-UI stack
+ * (`McpUiSurfaceCard.tsx`, `useMcpUiHost`, `create-mcp-ui-tool-caller.ts`), which this file does
+ * not touch.
+ *
+ * Validates that the REAL, official `@mcp-ui/server` package (not this repo's own reimplementation
+ * of the MCP-UI resource shape) can build a `UIResource` end to end, per the owner's decision to
+ * evaluate replacing the hand-rolled client with the upstream package. See
+ * `poc-mcp-ui-official/__tests__/poc-mcp-ui-official.test.tsx` for the assertions this module
+ * exists to feed, and `ADS-memory/` (Tovu side) / this session's final report for the CJS/ESM
+ * interop finding that shaped how this is imported (ESM only — `@mcp-ui/client`'s CJS build is
+ * broken in 7.1.1; `require('@mcp-ui/client')` throws / returns an empty object depending on Node
+ * version. `@mcp-ui/server`'s CJS build works fine in this same version, but this module still
+ * uses the ESM entry point for consistency with the client half of this POC).
+ */
+import { createUIResource } from '@mcp-ui/server';
+/** The one concrete example this POC builds: a simple static HTML card. */
+export const POC_CARD_URI = 'ui://jini-poc/mcp-ui-official-card';
+export const POC_CARD_HTML = [
+    '<!doctype html>',
+    '<html>',
+    '  <body style="font-family: sans-serif; margin: 0; padding: 16px;">',
+    '    <h1 data-testid="poc-card-heading">Hello from @mcp-ui/server</h1>',
+    '    <p>This card was built by the REAL, official createUIResource(), not the hand-rolled one.</p>',
+    '  </body>',
+    '</html>',
+].join('\n');
+/**
+ * Builds the one UIResource this POC round-trips: server creates it, the test then feeds its
+ * `resource.text` straight to the client's `AppRenderer` as pre-fetched `html` (see the test —
+ * `AppRenderer`'s `html` prop skips MCP resource-fetching entirely, which is the right shape for a
+ * standalone POC with no live MCP server behind it).
+ */
+export function createPocUiResource() {
+    return createUIResource({
+        uri: POC_CARD_URI,
+        content: { type: 'rawHtml', htmlString: POC_CARD_HTML },
+        encoding: 'text',
+    });
+}
+//# sourceMappingURL=create-poc-resource.js.map

package/dist/react/poc-mcp-ui-official/create-poc-resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-poc-resource.js","sourceRoot":"","sources":["../../../src/react/poc-mcp-ui-official/create-poc-resource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,gBAAgB,EAAmB,MAAM,gBAAgB,CAAC;AAEnE,2EAA2E;AAC3E,MAAM,CAAC,MAAM,YAAY,GAAG,oCAAoC,CAAC;AAEjE,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,iBAAiB;IACjB,QAAQ;IACR,qEAAqE;IACrE,uEAAuE;IACvE,mGAAmG;IACnG,WAAW;IACX,SAAS;CACV,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO,gBAAgB,CAAC;QACtB,GAAG,EAAE,YAAY;QACjB,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE;QACvD,QAAQ,EAAE,MAAM;KACjB,CAAC,CAAC;AACL,CAAC"}