@jini-ai/chat 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.6.1 — 2026-10-13
+
+- Owned renderer registries: `createToolRendererRegistry` / `createExtEventRendererRegistry`, optional `JiniChatProvider` props `toolRendererRegistry` / `extEventRendererRegistry`, and `registerMcpUiSurfaceRenderer({ registry })`. The global register/get/clear functions keep working against a compatibility default. A stale unregister handle no longer removes a replacement registered with the same callback.
+
 ## 0.6.0 — 2026-10-13
 
 - Remove Recharts peer/dev dependencies. Legacy chart wire components now use the neutral UI host with a styled table fallback; require the extracted UI ^0.5.0 so older built-in Recharts imports cannot leak into a clean consumer.

package/dist/react/components/JiniChatProvider.d.ts

@@ -1,8 +1,8 @@
 /**
  * @module JiniChatProvider
  *
- * Wires transport, project, analytics, i18n, and the artifact-renderer
- * registry into context — exactly the `JiniChatProviderProps` shape from
+ * Wires transport, project, analytics, i18n, and the artifact/tool/extension renderer
+ * registries into context — exactly the `JiniChatProviderProps` shape from
  * `ADS-memory/reports/jini-port/recon/r4b-webui-design.md` §2. This is the ONE file in
  * this package's presentational layer allowed to bind concrete
  * adapters/slots to context (mirrors the OD slice discipline's
@@ -10,7 +10,7 @@
  * boundary lint item 3 — the composition-root analogue for a package
  * instead of a feature slice).
  *
- * `slots`/`onFeedback`/`toolRegistry` are threaded through unchanged for a
+ * `slots`/`onFeedback` are threaded through unchanged for a
  * consuming host to read via `useJiniChatSlots()`/`useOnFeedback()` — this
  * package's own components (`<Composer>`, `<MessageRow>`, ...) take the
  * slots they need directly as props rather than reading them from context
@@ -22,6 +22,8 @@ import { type ReactNode } from 'react';
 import type { ChatTransport, OnFeedback } from '../../core/index.js';
 import type { AnalyticsAdapter, AttachmentTraySlot, ComposerSlots, FilePreviewSlot, I18nAdapter, ModelAgentPickerSlot, AnnotationAdapter, ProjectContextValue } from '../slots.js';
 import type { RendererRegistry } from '../artifact-types.js';
+import type { ToolRendererRegistry } from '../tool-renderer-registry.js';
+import type { ExtEventRendererRegistry } from '../ext-event-renderer-registry.js';
 export interface JiniChatSlots {
     modelPicker?: ModelAgentPickerSlot;
     composer?: ComposerSlots;
@@ -35,11 +37,14 @@ export interface JiniChatProviderProps {
     analytics?: AnalyticsAdapter;
     i18n?: I18nAdapter;
     artifactRegistry?: RendererRegistry;
+    /** Optional owned state; omitted bindings inherit the nearest provider or global default. */
+    toolRendererRegistry?: ToolRendererRegistry;
+    extEventRendererRegistry?: ExtEventRendererRegistry;
     slots?: JiniChatSlots;
     onFeedback?: OnFeedback;
     children: ReactNode;
 }
-export declare function JiniChatProvider({ transport, project, analytics, i18n, artifactRegistry, slots, onFeedback, children }: JiniChatProviderProps): import("react").JSX.Element;
+export declare function JiniChatProvider({ transport, project, analytics, i18n, artifactRegistry, toolRendererRegistry, extEventRendererRegistry, slots, onFeedback, children }: JiniChatProviderProps): import("react").JSX.Element;
 export declare function useJiniChatSlots(): JiniChatSlots;
 export declare function useOnFeedback(): OnFeedback | undefined;
 //# sourceMappingURL=JiniChatProvider.d.ts.map

package/dist/react/components/JiniChatProvider.js

@@ -2,8 +2,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * @module JiniChatProvider
  *
- * Wires transport, project, analytics, i18n, and the artifact-renderer
- * registry into context — exactly the `JiniChatProviderProps` shape from
+ * Wires transport, project, analytics, i18n, and the artifact/tool/extension renderer
+ * registries into context — exactly the `JiniChatProviderProps` shape from
  * `ADS-memory/reports/jini-port/recon/r4b-webui-design.md` §2. This is the ONE file in
  * this package's presentational layer allowed to bind concrete
  * adapters/slots to context (mirrors the OD slice discipline's
@@ -11,7 +11,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * boundary lint item 3 — the composition-root analogue for a package
  * instead of a feature slice).
  *
- * `slots`/`onFeedback`/`toolRegistry` are threaded through unchanged for a
+ * `slots`/`onFeedback` are threaded through unchanged for a
  * consuming host to read via `useJiniChatSlots()`/`useOnFeedback()` — this
  * package's own components (`<Composer>`, `<MessageRow>`, ...) take the
  * slots they need directly as props rather than reading them from context
@@ -20,11 +20,15 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * without re-threading props through every layer.
  */
 import { createContext, useContext } from 'react';
-import { AnalyticsContext, ArtifactRegistryContext, ChatTransportContext, I18nContext, ProjectContext } from '../hooks/context.js';
+import { AnalyticsContext, ArtifactRegistryContext, ToolRendererRegistryContext, ExtEventRendererRegistryContext, ChatTransportContext, I18nContext, ProjectContext } from '../hooks/context.js';
 const JiniChatSlotsContext = createContext({});
 const OnFeedbackContext = createContext(undefined);
-export function JiniChatProvider({ transport, project, analytics, i18n, artifactRegistry, slots, onFeedback, children }) {
+export function JiniChatProvider({ transport, project, analytics, i18n, artifactRegistry, toolRendererRegistry, extEventRendererRegistry, slots, onFeedback, children }) {
     let tree = (_jsx(ChatTransportContext.Provider, { value: transport, children: _jsx(JiniChatSlotsContext.Provider, { value: slots ?? {}, children: _jsx(OnFeedbackContext.Provider, { value: onFeedback, children: children }) }) }));
+    if (toolRendererRegistry)
+        tree = _jsx(ToolRendererRegistryContext.Provider, { value: toolRendererRegistry, children: tree });
+    if (extEventRendererRegistry)
+        tree = _jsx(ExtEventRendererRegistryContext.Provider, { value: extEventRendererRegistry, children: tree });
     if (artifactRegistry)
         tree = _jsx(ArtifactRegistryContext.Provider, { value: artifactRegistry, children: tree });
     if (project)

package/dist/react/components/McpUiSurfaceCard.d.ts

@@ -1,5 +1,5 @@
 import { type McpUiToolCallHandler } from '@jini-ai/ui/mcp-ui';
-import { type ExtEventRenderProps } from '../ext-event-renderer-registry.js';
+import { type ExtEventRendererRegistry, type ExtEventRenderProps } from '../ext-event-renderer-registry.js';
 import { type SurfaceExpiryClock } from '../hooks/useSurfaceExpiry.js';
 /** The `kind: 'ext'` event name this renderer claims. */
 export declare const MCP_UI_EXT_EVENT_NAME = "mcp-ui";
@@ -55,6 +55,7 @@ export declare function mcpUiSurfaceSlotKey({ data }: {
  * @param options.maxHeight - See {@link McpUiSurfaceCardProps.maxHeight}. A host with a fixed-width
  * pane (a docked sidebar rather than a full-width transcript) should set this once here instead of
  * accepting the library's full-width-oriented 720px default.
+ * @param options.registry - Owned registry bound to JiniChatProvider; omitted for the global default.
  * @returns An unregister handle, so a test or a hot reload can dispose cleanly.
  */
 export declare function registerMcpUiSurfaceRenderer(options: {
@@ -63,5 +64,7 @@ export declare function registerMcpUiSurfaceRenderer(options: {
     onOpenLink?: (url: string) => void;
     name?: string;
     maxHeight?: number;
+    /** Register in owned state when supplied; otherwise preserve the global API. */
+    registry?: ExtEventRendererRegistry;
 }): () => void;
 //# sourceMappingURL=McpUiSurfaceCard.d.ts.map

package/dist/react/components/McpUiSurfaceCard.js

@@ -4,8 +4,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  *
  * Renders MCP-UI Views inline in a chat transcript, fed by a message's `kind: 'ext', name: 'mcp-ui'`
  * events — the same extensibility seam `A2uiSurfaceCard.tsx` uses, and registered the same way: a
- * host calls {@link registerMcpUiSurfaceRenderer} once at module scope and every `ChatPane` that
- * surfaces a matching event renders through it thereafter.
+ * host calls {@link registerMcpUiSurfaceRenderer} with its owned registry (or the compatibility
+ * default) and matching events in that registry's chat tree render through it.
  *
  * Each event's `data` is expected to be an MCP `EmbeddedResource` carrying UI — exactly the object a
  * tool result's `content` array holds, unwrapped. One shape, deliberately: accepting several
@@ -63,7 +63,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { Fragment, useMemo } from 'react';
 import { McpUiHost, parseUIResource, readActionPlan, readExpiresAt, readPreferredFrameSize, } from '@jini-ai/ui/mcp-ui';
-import { registerExtEventRenderer } from '../ext-event-renderer-registry.js';
+import { defaultExtEventRendererRegistry } from '../ext-event-renderer-registry.js';
 import { useT } from '../hooks/context.js';
 import { useSurfaceExpiry } from '../hooks/useSurfaceExpiry.js';
 import { closedSurfaceLabel, reportDeliveredAnswer } from './mcp-ui-surface-state.js';
@@ -181,9 +181,10 @@ export function mcpUiSurfaceSlotKey({ data }) {
  * @param options.maxHeight - See {@link McpUiSurfaceCardProps.maxHeight}. A host with a fixed-width
  * pane (a docked sidebar rather than a full-width transcript) should set this once here instead of
  * accepting the library's full-width-oriented 720px default.
+ * @param options.registry - Owned registry bound to JiniChatProvider; omitted for the global default.
  * @returns An unregister handle, so a test or a hot reload can dispose cleanly.
  */
 export function registerMcpUiSurfaceRenderer(options) {
-    return registerExtEventRenderer({ name: options.name ?? MCP_UI_EXT_EVENT_NAME, renderer: (props) => (_jsx(McpUiSurfaceCard, { ...props, sandboxProxyUrl: options.sandboxProxyUrl, ...(options.onToolCall === undefined ? {} : { onToolCall: options.onToolCall }), ...(options.onOpenLink === undefined ? {} : { onOpenLink: options.onOpenLink }), ...(options.maxHeight === undefined ? {} : { maxHeight: options.maxHeight }) })) }, { slotKey: mcpUiSurfaceSlotKey });
+    return (options.registry ?? defaultExtEventRendererRegistry).register({ name: options.name ?? MCP_UI_EXT_EVENT_NAME, renderer: (props) => (_jsx(McpUiSurfaceCard, { ...props, sandboxProxyUrl: options.sandboxProxyUrl, ...(options.onToolCall === undefined ? {} : { onToolCall: options.onToolCall }), ...(options.onOpenLink === undefined ? {} : { onOpenLink: options.onOpenLink }), ...(options.maxHeight === undefined ? {} : { maxHeight: options.maxHeight }) })) }, { slotKey: mcpUiSurfaceSlotKey });
 }
 //# sourceMappingURL=McpUiSurfaceCard.js.map

package/dist/react/components/MessageRow.js

@@ -59,8 +59,7 @@ import { useCopyToClipboard } from '../hooks/useCopyToClipboard.js';
 import { useRunActivity } from '../hooks/useRunActivity.js';
 import { useAnsweredCards } from '../hooks/useAnsweredCards.js';
 import { interleaveMessageBlocks } from '../message-blocks.js';
-import { useT } from '../hooks/context.js';
-import { extEventSlot, getExtEventRenderer } from '../ext-event-renderer-registry.js';
+import { useT, useExtEventRendererRegistry } from '../hooks/context.js';
 import { ExtEventErrorBoundary } from './ExtEventErrorBoundary.js';
 import { AttachmentPreviewModal } from './AttachmentPreviewModal.js';
 import { SentAttachmentButton } from './SentAttachment.js';
@@ -116,7 +115,7 @@ function UsageSummary({ usage, showTotal }) {
         return null;
     return (_jsxs("div", { className: "jini-message-usage", title: title, role: "note", "aria-label": ariaLabel, children: [_jsx("span", { className: "jini-message-usage-dot", "aria-hidden": true, children: "\u25CF" }), t('Done'), " \u00B7 ", text] }));
 }
-function messageBlocks({ visibleContent, message, rows }, { toolCallDisplay = 'show', includeThinking = false } = {}) {
+function messageBlocks({ visibleContent, message, rows, registry }, { toolCallDisplay = 'show', includeThinking = false } = {}) {
     // Interleaving is skipped outright when an artifact was stripped. `stripArtifact` operates on the
     // whole string and trims, so the surviving text no longer lines up with the per-run offsets the
     // event walk produces, and an artifact block could legitimately span a tool call. Rather than
@@ -124,7 +123,7 @@ function messageBlocks({ visibleContent, message, rows }, { toolCallDisplay = 's
     // messages are dominated by the artifact panel anyway, so the ordering matters least there.
     if (visibleContent !== message.content)
         return null;
-    const blocks = interleaveMessageBlocks({ events: message.events, content: message.content, rows }, { slotOf: (ev) => extEventSlot({ name: ev.name, data: ev.data }), includeThinking });
+    const blocks = interleaveMessageBlocks({ events: message.events, content: message.content, rows }, { slotOf: (ev) => registry.slot({ name: ev.name, data: ev.data }), includeThinking });
     return blocks ? applyToolCallDisplay({ blocks, mode: toolCallDisplay }) : null;
 }
 /** The model's reasoning, folded under a "Thinking" summary so it never crowds the answer. */
@@ -164,10 +163,11 @@ function CopyMessageButton({ text, label }) {
  */
 export const MessageRow = memo(function MessageRow({ message, usageSummary, showUsageTotal = true, showUsageLine = true, toolCallDisplay = 'show', showThinking = false, runStreaming = false, runSucceeded = false, questionFormInteractive = false, questionFormSubmittedAnswers, onQuestionFormSubmit, projectFileNames, onRequestOpenFile, renderAttachment, }) {
     const t = useT();
+    const registry = useExtEventRendererRegistry();
     const messageUsage = useMessageUsage({ message, ...(usageSummary === undefined ? {} : { summary: usageSummary }) });
     const timeline = useToolTimeline({ events: message.events }, { runStreaming, runSucceeded });
-    const extGroups = useExtEventGroups({ events: message.events }, { slotOf: (name, data) => extEventSlot({ name, data }) });
-    const answeredCards = useAnsweredCards({ slotOf: extEventSlot });
+    const extGroups = useExtEventGroups({ events: message.events }, { slotOf: (name, data) => registry.slot({ name, data }) });
+    const answeredCards = useAnsweredCards({ slotOf: registry.slot });
     // Which attachment chip (if any) this row's preview modal is open for. Row-local, not
     // module-level: two attachments in the same message can never be "open" at once, but two
     // different messages opening their own attachments independently is fine and expected.
@@ -178,7 +178,7 @@ export const MessageRow = memo(function MessageRow({ message, usageSummary, show
     const terminalNotice = terminalMessageNotice({ message }, {});
     const visibleContent = stripArtifact({ content: message.content });
     const segments = splitOnQuestionForms({ input: visibleContent });
-    const blocks = messageBlocks({ visibleContent, message, rows: timeline.rows }, { toolCallDisplay, includeThinking: showThinking });
+    const blocks = messageBlocks({ visibleContent, message, rows: timeline.rows, registry }, { toolCallDisplay, includeThinking: showThinking });
     const pending = isPendingWithNoContent(message, visibleContent, timeline.rows.length);
     const runInProgress = isRunInProgress(message.runStatus);
     const awaitingAnswer = messageAwaitingAnswer({ runStreaming, runInProgress, events: message.events }, { isAnsweredCard: answeredCards.isAnsweredCard });
@@ -191,7 +191,7 @@ export const MessageRow = memo(function MessageRow({ message, usageSummary, show
         : _jsx("div", { className: "jini-message-tools", children: rows.map(renderToolCard) }, key));
     const flatToolRows = toolRowsForDisplay({ rows: timeline.rows, mode: toolCallDisplay });
     const renderExtGroup = (group) => {
-        const renderer = getExtEventRenderer({ name: group.name });
+        const renderer = registry.get({ name: group.name });
         if (!renderer)
             return null;
         const node = renderer({

package/dist/react/components/ToolCard.js

@@ -22,8 +22,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  */
 import { useId, useState } from 'react';
 import { describeCollapsedToolCall, describeToolCallDetail, formatToolOutputForDisplay, isDelegatedWrapperToolName, isTodoWriteToolName, parseTodoWriteInput, toRenderProps } from '../../core/index.js';
-import { useT } from '../hooks/context.js';
-import { getToolRenderer } from '../tool-renderer-registry.js';
+import { useT, useToolRendererRegistry } from '../hooks/context.js';
 import { Icon } from './Icon.js';
 import { TodoCard } from './TodoCard.js';
 /** A Jini registry tool id: dotted, lowercase, snake_case segments — `page.fill`, `daemon.db.vacuum`, `chat.send_message`. Never matches an agent-vendor tool name (`Bash`, `Write`, `mcp__jini__execute_delegated_tool`), which is the point — this is how a canonical delegated-tool event is told apart from everything else. */
@@ -31,10 +30,11 @@ const JINI_TOOL_ID_PATTERN = /^[a-z][a-z_]*(\.[a-z][a-z_]*)+$/;
 const SEARCH_TOOLS_NAMES = new Set(['search_tools', 'mcp__jini__search_tools']);
 const DESCRIBE_TOOL_NAMES = new Set(['describe_tool', 'mcp__jini__describe_tool']);
 export function ToolCard({ use, result, runStreaming, runSucceeded, projectFileNames, onRequestOpenFile }) {
+    const registry = useToolRendererRegistry();
     const name = use.name;
     const isStreaming = runStreaming ?? false;
     const isSucceeded = runSucceeded ?? false;
-    const content = renderToolCardBody(name, use, result, isStreaming, isSucceeded, { projectFileNames, onRequestOpenFile });
+    const content = renderToolCardBody(name, use, result, isStreaming, isSucceeded, { projectFileNames, onRequestOpenFile }, registry);
     if (content === null)
         return null;
     // Tagged once here, at the single dispatch point every branch below funnels through, rather than
@@ -44,8 +44,8 @@ export function ToolCard({ use, result, runStreaming, runSucceeded, projectFileN
     // ambiguous the way a repeated literal handle would be.
     return (_jsx("div", { "data-agent-element": `tool-call-${use.id}`, "data-agent-role": "region", "data-agent-label": `A ${humanizeToolId(name)} tool call the AI made`, children: content }));
 }
-function renderToolCardBody(name, use, result, isStreaming, isSucceeded, fileCtx) {
-    const custom = getToolRenderer({ name: name });
+function renderToolCardBody(name, use, result, isStreaming, isSucceeded, fileCtx, registry) {
+    const custom = registry.get({ name });
     if (custom) {
         try {
             const node = custom(toRenderProps({ use: use, result: result, runStreaming: isStreaming }, { runSucceeded: isSucceeded }));

package/dist/react/ext-event-renderer-registry.d.ts

@@ -88,26 +88,41 @@ export interface ExtEventRendererOptions {
     /** See {@link ExtEventSlotKey}. Omit for one shared slot per `name`. */
     slotKey?: ExtEventSlotKey;
 }
-/**
- * Register a renderer for an ext-event `name`. Returns an unregister handle so tests / hot-reloads
- * can dispose cleanly. Re-registering the same name overwrites — last writer wins.
+/** Owned renderer and slot-key state for one chat tree. */
+export interface ExtEventRendererRegistry {
+    register(required: {
+        name: string;
+        renderer: ExtEventRenderer;
+    }, options?: ExtEventRendererOptions): () => void;
+    get(required: {
+        name: string;
+    }): ExtEventRenderer | undefined;
+    slot(required: {
+        name: string;
+        data: unknown;
+    }): string;
+    clear(): void;
+}
+/** Create independent extension renderer state, including each protocol's slot grouping.
+ * @returns A keyed registry with identity-safe unregister handles.
+ * @example const extensions = createExtEventRendererRegistry({}); extensions.register({ name: 'card', renderer });
  */
-export declare function registerExtEventRenderer({ name, renderer }: {
+export declare function createExtEventRendererRegistry(_required?: Record<string, never>): ExtEventRendererRegistry;
+/** Compatibility default for hosts that have not supplied owned state. */
+export declare const defaultExtEventRendererRegistry: ExtEventRendererRegistry;
+/** Register against the compatibility default; see the owned registry's registration contract. */
+export declare function registerExtEventRenderer(required: {
     name: string;
     renderer: ExtEventRenderer;
 }, options?: ExtEventRendererOptions): () => void;
-export declare function getExtEventRenderer({ name }: {
+export declare function getExtEventRenderer(required: {
     name: string;
 }): ExtEventRenderer | undefined;
-/**
- * The render slot an ext event belongs to: its `name`, or `name:key` when the name's renderer was
- * registered with a {@link ExtEventSlotKey} that recognizes this event. A throwing key function
- * falls back to the shared slot rather than taking the whole message down.
- */
-export declare function extEventSlot({ name, data }: {
+/** Resolve a slot using the compatibility default's registered slot key. */
+export declare function extEventSlot(required: {
     name: string;
     data: unknown;
 }): string;
-/** Visible mainly for tests. */
+/** Visible mainly for tests using the compatibility default. */
 export declare function clearExtEventRenderers(): void;
 //# sourceMappingURL=ext-event-renderer-registry.d.ts.map

package/dist/react/ext-event-renderer-registry.js

@@ -1,39 +1,59 @@
-const renderers = new Map();
-/**
- * Register a renderer for an ext-event `name`. Returns an unregister handle so tests / hot-reloads
- * can dispose cleanly. Re-registering the same name overwrites — last writer wins.
+/** Create independent extension renderer state, including each protocol's slot grouping.
+ * @returns A keyed registry with identity-safe unregister handles.
+ * @example const extensions = createExtEventRendererRegistry({}); extensions.register({ name: 'card', renderer });
  */
-export function registerExtEventRenderer({ name, renderer }, options = {}) {
-    const entry = { renderer, slotKey: options.slotKey };
-    renderers.set(name, entry);
-    return () => {
-        if (renderers.get(name) === entry)
-            renderers.delete(name);
-    };
-}
-export function getExtEventRenderer({ name }) {
-    return renderers.get(name)?.renderer;
-}
-/**
- * The render slot an ext event belongs to: its `name`, or `name:key` when the name's renderer was
- * registered with a {@link ExtEventSlotKey} that recognizes this event. A throwing key function
- * falls back to the shared slot rather than taking the whole message down.
- */
-export function extEventSlot({ name, data }) {
-    const slotKey = renderers.get(name)?.slotKey;
-    if (!slotKey)
-        return name;
-    let key;
-    try {
-        key = slotKey({ data });
+export function createExtEventRendererRegistry(_required = {}) {
+    const renderers = new Map();
+    /**
+     * Register a renderer for an ext-event `name`. Returns an unregister handle so tests / hot-reloads
+     * can dispose cleanly. Re-registering the same name overwrites — last writer wins.
+     */
+    function register({ name, renderer }, options = {}) {
+        const entry = { renderer, slotKey: options.slotKey };
+        renderers.set(name, entry);
+        return () => {
+            if (renderers.get(name) === entry)
+                renderers.delete(name);
+        };
     }
-    catch {
-        key = undefined;
+    function get({ name }) {
+        return renderers.get(name)?.renderer;
     }
-    return key === undefined || key === '' ? name : `${name}:${key}`;
+    /**
+     * The render slot an ext event belongs to: its `name`, or `name:key` when the name's renderer was
+     * registered with a {@link ExtEventSlotKey} that recognizes this event. A throwing key function
+     * falls back to the shared slot rather than taking the whole message down.
+     */
+    function slot({ name, data }) {
+        const slotKey = renderers.get(name)?.slotKey;
+        if (!slotKey)
+            return name;
+        let key;
+        try {
+            key = slotKey({ data });
+        }
+        catch {
+            key = undefined;
+        }
+        return key === undefined || key === '' ? name : `${name}:${key}`;
+    }
+    /** Visible mainly for tests. */
+    function clear() { renderers.clear(); }
+    return { register, get, slot, clear };
+}
+/** Compatibility default for hosts that have not supplied owned state. */
+export const defaultExtEventRendererRegistry = createExtEventRendererRegistry({});
+/** Register against the compatibility default; see the owned registry's registration contract. */
+export function registerExtEventRenderer(required, options = {}) {
+    return defaultExtEventRendererRegistry.register(required, options);
+}
+export function getExtEventRenderer(required) {
+    return defaultExtEventRendererRegistry.get(required);
 }
-/** Visible mainly for tests. */
-export function clearExtEventRenderers() {
-    renderers.clear();
+/** Resolve a slot using the compatibility default's registered slot key. */
+export function extEventSlot(required) {
+    return defaultExtEventRendererRegistry.slot(required);
 }
+/** Visible mainly for tests using the compatibility default. */
+export function clearExtEventRenderers() { defaultExtEventRendererRegistry.clear(); }
 //# sourceMappingURL=ext-event-renderer-registry.js.map

package/dist/react/hooks/context.d.ts

@@ -1,10 +1,14 @@
 import type { AnalyticsAdapter, I18nAdapter, ProjectContextValue } from '../slots.js';
 import type { ChatTransport } from '../../core/index.js';
 import type { RendererRegistry } from '../artifact-types.js';
+import { type ToolRendererRegistry } from '../tool-renderer-registry.js';
+import { type ExtEventRendererRegistry } from '../ext-event-renderer-registry.js';
 export declare const I18nContext: import("react").Context<I18nAdapter>;
 export declare const AnalyticsContext: import("react").Context<AnalyticsAdapter>;
 export declare const ProjectContext: import("react").Context<ProjectContextValue | undefined>;
 export declare const ChatTransportContext: import("react").Context<ChatTransport | undefined>;
+export declare const ToolRendererRegistryContext: import("react").Context<ToolRendererRegistry>;
+export declare const ExtEventRendererRegistryContext: import("react").Context<ExtEventRendererRegistry>;
 export declare const ArtifactRegistryContext: import("react").Context<RendererRegistry | undefined>;
 /** Convenience for call sites that only need the translator function. */
 export declare function useT(): I18nAdapter['t'];
@@ -15,4 +19,8 @@ export declare function useProjectContext(): ProjectContextValue | undefined;
 /** Throws when read outside `<JiniChatProvider>` — unlike the other contexts, hooks that need a transport (`useConversation`/`useRunStream`) have no sensible no-op fallback. */
 export declare function useChatTransport(): ChatTransport;
 export declare function useArtifactRegistry(): RendererRegistry | undefined;
+/** Read the nearest tool binding, or the compatibility default outside an owned provider. */
+export declare function useToolRendererRegistry(): ToolRendererRegistry;
+/** Renderer lookup and grouping must read the same provider binding. */
+export declare function useExtEventRendererRegistry(): ExtEventRendererRegistry;
 //# sourceMappingURL=context.d.ts.map

package/dist/react/hooks/context.js

@@ -15,6 +15,8 @@
  * allowed dependency per `ADS-memory/reports/jini-port/recon/r4b-webui-design.md` §1).
  */
 import { createContext, useContext } from 'react';
+import { defaultToolRendererRegistry } from '../tool-renderer-registry.js';
+import { defaultExtEventRendererRegistry } from '../ext-event-renderer-registry.js';
 const PASSTHROUGH_I18N = {
     t: (key, vars) => interpolate(key, vars),
     locale: 'en',
@@ -32,6 +34,8 @@ export const I18nContext = createContext(PASSTHROUGH_I18N);
 export const AnalyticsContext = createContext(NOOP_ANALYTICS);
 export const ProjectContext = createContext(undefined);
 export const ChatTransportContext = createContext(undefined);
+export const ToolRendererRegistryContext = createContext(defaultToolRendererRegistry);
+export const ExtEventRendererRegistryContext = createContext(defaultExtEventRendererRegistry);
 export const ArtifactRegistryContext = createContext(undefined);
 /** Convenience for call sites that only need the translator function. */
 export function useT() {
@@ -57,4 +61,8 @@ export function useChatTransport() {
 export function useArtifactRegistry() {
     return useContext(ArtifactRegistryContext);
 }
+/** Read the nearest tool binding, or the compatibility default outside an owned provider. */
+export function useToolRendererRegistry() { return useContext(ToolRendererRegistryContext); }
+/** Renderer lookup and grouping must read the same provider binding. */
+export function useExtEventRendererRegistry() { return useContext(ExtEventRendererRegistryContext); }
 //# sourceMappingURL=context.js.map

package/dist/react/index.d.ts

@@ -7,10 +7,10 @@ export type { ChatTransport, FeedbackChange, OnFeedback, ReattachRunOptions, Run
 export { RendererRegistry, } from './artifact-types.js';
 export type { ArtifactFile, ArtifactRenderContext, ArtifactRenderMatch, ArtifactRenderer, } from './artifact-types.js';
 export type { AgentOption, AgentSelection, AnalyticsAdapter, AnnotationAdapter, AttachmentTraySlot, ComposerDiscoveryArgument, ComposerDiscoveryGroup, ComposerDiscoveryItem, ComposerDiscoveryOutcome, ComposerDiscoverySelection, ComposerPlusItem, ComposerSlots, FilePreviewSlot, I18nAdapter, MentionResult, MentionSource, ModelAgentPickerSlot, ProjectContextValue, } from './slots.js';
-export { clearToolRenderers, getToolRenderer, registerToolRenderer, } from './tool-renderer-registry.js';
-export type { ToolRenderer, } from './tool-renderer-registry.js';
-export { clearExtEventRenderers, extEventSlot, getExtEventRenderer, registerExtEventRenderer, } from './ext-event-renderer-registry.js';
-export type { ExtEventRenderProps, ExtEventRenderer, ExtEventRendererOptions, ExtEventSlotKey, } from './ext-event-renderer-registry.js';
+export { createToolRendererRegistry, clearToolRenderers, getToolRenderer, registerToolRenderer, } from './tool-renderer-registry.js';
+export type { ToolRendererRegistry, ToolRenderer, } from './tool-renderer-registry.js';
+export { createExtEventRendererRegistry, clearExtEventRenderers, extEventSlot, getExtEventRenderer, registerExtEventRenderer, } from './ext-event-renderer-registry.js';
+export type { ExtEventRendererRegistry, ExtEventRenderProps, ExtEventRenderer, ExtEventRendererOptions, ExtEventSlotKey, } from './ext-event-renderer-registry.js';
 /**
  * @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,

package/dist/react/index.js

@@ -1,6 +1,6 @@
 export { RendererRegistry, } from './artifact-types.js';
-export { clearToolRenderers, getToolRenderer, registerToolRenderer, } from './tool-renderer-registry.js';
-export { clearExtEventRenderers, extEventSlot, getExtEventRenderer, registerExtEventRenderer, } from './ext-event-renderer-registry.js';
+export { createToolRendererRegistry, clearToolRenderers, getToolRenderer, registerToolRenderer, } from './tool-renderer-registry.js';
+export { createExtEventRendererRegistry, clearExtEventRenderers, extEventSlot, 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

package/dist/react/tool-renderer-registry.d.ts

@@ -28,19 +28,36 @@ import type { ToolRenderProps } from '../core/index.js';
  * step (a built-in family card, then the generic fallback).
  */
 export type ToolRenderer = (props: ToolRenderProps) => ReactNode;
+/** Owned lookup and registration state for one chat tree. */
+export interface ToolRendererRegistry {
+    register(required: {
+        name: string;
+        renderer: ToolRenderer;
+    }): () => void;
+    get(required: {
+        name: string;
+    }): ToolRenderer | undefined;
+    clear(required: Record<string, never>): void;
+}
+/** Create independent tool renderer state; registrations never leak to another tree.
+ * @returns A keyed registry with identity-safe unregister handles.
+ * @example const tools = createToolRendererRegistry({}); tools.register({ name: 'Read', renderer });
+ */
+export declare function createToolRendererRegistry(_required?: Record<string, never>): ToolRendererRegistry;
+/** Compatibility default for hosts that have not supplied owned state. */
+export declare const defaultToolRendererRegistry: ToolRendererRegistry;
 /**
- * Register a renderer for a tool name. Returns an unregister handle so
- * tests / hot-reloads can dispose cleanly. Names are matched case-sensitively
- * against `tool_use.name`. Re-registering the same name overwrites — last
- * writer wins.
+ * Register a renderer for a tool name in the compatibility default. Returns an unregister handle so
+ * tests / hot-reloads can dispose cleanly. Names are matched case-sensitively against
+ * `tool_use.name`. Re-registering the same name overwrites — last writer wins.
  */
-export declare function registerToolRenderer({ name, renderer }: {
+export declare function registerToolRenderer(required: {
     name: string;
     renderer: ToolRenderer;
 }): () => void;
-export declare function getToolRenderer({ name }: {
+export declare function getToolRenderer(required: {
     name: string;
 }): ToolRenderer | undefined;
-/** Visible mainly for tests. */
-export declare function clearToolRenderers(_requiredArgs: Record<string, never>): void;
+/** Visible mainly for tests using the compatibility default. */
+export declare function clearToolRenderers(required: Record<string, never>): void;
 //# sourceMappingURL=tool-renderer-registry.d.ts.map

package/dist/react/tool-renderer-registry.js

@@ -1,22 +1,37 @@
-const renderers = new Map();
-/**
- * Register a renderer for a tool name. Returns an unregister handle so
- * tests / hot-reloads can dispose cleanly. Names are matched case-sensitively
- * against `tool_use.name`. Re-registering the same name overwrites — last
- * writer wins.
+/** Create independent tool renderer state; registrations never leak to another tree.
+ * @returns A keyed registry with identity-safe unregister handles.
+ * @example const tools = createToolRendererRegistry({}); tools.register({ name: 'Read', renderer });
  */
-export function registerToolRenderer({ name, renderer }) {
-    renderers.set(name, renderer);
-    return () => {
-        if (renderers.get(name) === renderer)
-            renderers.delete(name);
+export function createToolRendererRegistry(_required = {}) {
+    const renderers = new Map();
+    return {
+        // Names are case-sensitive; last writer wins. Compare the registration entry rather than
+        // the callback: re-registering the same callback still invalidates its old cleanup handle.
+        register({ name, renderer }) {
+            const entry = { renderer };
+            renderers.set(name, entry);
+            return () => { if (renderers.get(name) === entry)
+                renderers.delete(name); };
+        },
+        get({ name }) { return renderers.get(name)?.renderer; },
+        clear(_required) { renderers.clear(); },
     };
 }
-export function getToolRenderer({ name }) {
-    return renderers.get(name);
+/** Compatibility default for hosts that have not supplied owned state. */
+export const defaultToolRendererRegistry = createToolRendererRegistry({});
+/**
+ * Register a renderer for a tool name in the compatibility default. Returns an unregister handle so
+ * tests / hot-reloads can dispose cleanly. Names are matched case-sensitively against
+ * `tool_use.name`. Re-registering the same name overwrites — last writer wins.
+ */
+export function registerToolRenderer(required) {
+    return defaultToolRendererRegistry.register(required);
+}
+export function getToolRenderer(required) {
+    return defaultToolRendererRegistry.get(required);
 }
-/** Visible mainly for tests. */
-export function clearToolRenderers(_requiredArgs) {
-    renderers.clear();
+/** Visible mainly for tests using the compatibility default. */
+export function clearToolRenderers(required) {
+    defaultToolRendererRegistry.clear(required);
 }
 //# sourceMappingURL=tool-renderer-registry.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/chat",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Jini's chat/artifact frontend, consolidated into one package with two subpaths: framework-free chat vocabulary and pure parsers in `/core`, headless hooks + presentational components + slots in `/react`. Import only the layer you need.",
   "license": "Apache-2.0",
   "repository": {
@@ -196,7 +196,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/core": "^0.4.4"
+    "@jini-ai/core": "^0.4.5"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",
@@ -304,11 +304,11 @@
     "@ag-ui/core": "0.0.58",
     "@jini-ai/db": "0.3.4",
     "@jini-ai/agent-runtime": "0.4.8",
-    "@jini-ai/core": "^0.4.4",
-    "@jini-ai/protocol": "^0.4.4",
-    "@jini-ai/ui": "^0.5.0",
+    "@jini-ai/core": "^0.4.5",
     "@jini-ai/diagnostics": "^0.5.2",
-    "@jini-ai/agentic": "^0.4.4"
+    "@jini-ai/ui": "^0.5.1",
+    "@jini-ai/agentic": "^0.4.4",
+    "@jini-ai/protocol": "^0.4.4"
   },
   "typesVersions": {
     "*": {