glirastes 0.4.0 → 0.5.1

package/dist/cjs/react/ui.d.ts

@@ -1,21 +1,12 @@
+import { type PayloadContract } from '../browser/client-actions.js';
+import { type NavigationBridgeOptions } from '../browser/navigation.js';
+import { UiActionBus, type UiActionHandler } from '../browser/ui-action-bus.js';
 import type { ActionIdRegistry } from '../types.js';
-export interface UiAction {
-    type: string;
-    actionId?: string;
-    [key: string]: unknown;
-}
-export type UiActionHandler = (action: UiAction) => void | Promise<void>;
+export { getDefaultUiActionBus, UiActionBus, type UiAction, type UiActionHandler, } from '../browser/ui-action-bus.js';
 export interface AiClientActionEventDetail {
     actionId: string;
     payload?: Record<string, unknown>;
 }
-export declare class UiActionBus {
-    private handlersByType;
-    private handlersById;
-    subscribeByType(type: string, handler: UiActionHandler): () => void;
-    subscribeById(actionId: string, handler: UiActionHandler): () => void;
-    dispatch(action: UiAction): Promise<void>;
-}
 export declare function useAiClientActionByType(bus: UiActionBus, actionType: string, handler: UiActionHandler): void;
 export declare function useAiClientActionById(bus: UiActionBus, actionId: string, handler: UiActionHandler): void;
 /**
@@ -35,16 +26,26 @@ export declare function dispatchAiClientAction(detail: AiClientActionEventDetail
 export declare function dispatchAiClientActions(details: AiClientActionEventDetail | AiClientActionEventDetail[]): void;
 /**
  * Hook to register a handler for a specific AI client action ID.
- * The handler is tracked in a global registry for dev-mode validation.
+ * The literal id and the optional contract (third argument, e.g. a Zod
+ * object) are what `glirastes tools refresh` turns into the tool
+ * `ui.<actionId>`; the contract types and validates the payload. Generated
+ * actions arrive on the default UiActionBus; `dispatchAiClientAction`
+ * window events keep working for existing callers.
  *
  * @example
  * ```tsx
  * useAiClientAction('task-details.open', (payload) => {
- *   openTaskDetails(payload?.taskId as string);
- * });
+ *   openTaskDetails(payload.taskId);
+ * }, z.object({ taskId: z.string() }));
  * ```
  */
-export declare function useAiClientAction(actionId: string, handler: (payload?: Record<string, unknown>) => void): void;
+export declare function useAiClientAction<T = Record<string, unknown>>(actionId: string, handler: (payload: T) => void | Promise<void>, contract?: PayloadContract<T>): void;
+/**
+ * Executes the generated `ui.navigate` and `ui.filter.<view>` tools with the
+ * app's router, e.g. `useGlirastesNavigationBridge({ push: router.push })`
+ * with Next.js `useRouter()`. Always the latest `push` is used.
+ */
+export declare function useGlirastesNavigationBridge(options: NavigationBridgeOptions): void;
 /**
  * Returns all currently registered handler actionIds.
  */

package/dist/cjs/react/ui.js

@@ -1,57 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UiActionBus = void 0;
+exports.UiActionBus = exports.getDefaultUiActionBus = void 0;
 exports.useAiClientActionByType = useAiClientActionByType;
 exports.useAiClientActionById = useAiClientActionById;
 exports.setActionIdRegistry = setActionIdRegistry;
 exports.dispatchAiClientAction = dispatchAiClientAction;
 exports.dispatchAiClientActions = dispatchAiClientActions;
 exports.useAiClientAction = useAiClientAction;
+exports.useGlirastesNavigationBridge = useGlirastesNavigationBridge;
 exports.getRegisteredHandlers = getRegisteredHandlers;
 exports.getMissingHandlers = getMissingHandlers;
 exports.getActionIdInfo = getActionIdInfo;
 exports.useAiMissingHandlerWarning = useAiMissingHandlerWarning;
 const react_1 = require("react");
+const client_actions_js_1 = require("../browser/client-actions.js");
+const navigation_js_1 = require("../browser/navigation.js");
+const ui_action_bus_js_1 = require("../browser/ui-action-bus.js");
 // ============================================================================
-// UiActionBus (class-based, framework-agnostic)
+// Types and the framework-neutral bus (glirastes/browser)
 // ============================================================================
-function addHandler(map, key, handler) {
-    const handlers = map.get(key) ?? new Set();
-    handlers.add(handler);
-    map.set(key, handlers);
-    return () => {
-        const current = map.get(key);
-        if (!current)
-            return;
-        current.delete(handler);
-        if (current.size === 0)
-            map.delete(key);
-    };
-}
-class UiActionBus {
-    handlersByType = new Map();
-    handlersById = new Map();
-    subscribeByType(type, handler) {
-        return addHandler(this.handlersByType, type, handler);
-    }
-    subscribeById(actionId, handler) {
-        return addHandler(this.handlersById, actionId, handler);
-    }
-    async dispatch(action) {
-        const typeHandlers = this.handlersByType.get(action.type);
-        const idHandlers = action.actionId
-            ? this.handlersById.get(action.actionId)
-            : undefined;
-        const allHandlers = new Set([
-            ...(typeHandlers ? Array.from(typeHandlers) : []),
-            ...(idHandlers ? Array.from(idHandlers) : []),
-        ]);
-        for (const handler of allHandlers) {
-            await handler(action);
-        }
-    }
-}
-exports.UiActionBus = UiActionBus;
+var ui_action_bus_js_2 = require("../browser/ui-action-bus.js");
+Object.defineProperty(exports, "getDefaultUiActionBus", { enumerable: true, get: function () { return ui_action_bus_js_2.getDefaultUiActionBus; } });
+Object.defineProperty(exports, "UiActionBus", { enumerable: true, get: function () { return ui_action_bus_js_2.UiActionBus; } });
 // ============================================================================
 // UiActionBus Hooks
 // ============================================================================
@@ -97,18 +67,24 @@ function dispatchAiClientActions(details) {
 }
 /**
  * Hook to register a handler for a specific AI client action ID.
- * The handler is tracked in a global registry for dev-mode validation.
+ * The literal id and the optional contract (third argument, e.g. a Zod
+ * object) are what `glirastes tools refresh` turns into the tool
+ * `ui.<actionId>`; the contract types and validates the payload. Generated
+ * actions arrive on the default UiActionBus; `dispatchAiClientAction`
+ * window events keep working for existing callers.
  *
  * @example
  * ```tsx
  * useAiClientAction('task-details.open', (payload) => {
- *   openTaskDetails(payload?.taskId as string);
- * });
+ *   openTaskDetails(payload.taskId);
+ * }, z.object({ taskId: z.string() }));
  * ```
  */
-function useAiClientAction(actionId, handler) {
+function useAiClientAction(actionId, handler, contract) {
     const handlerRef = (0, react_1.useRef)(handler);
     handlerRef.current = handler;
+    const contractRef = (0, react_1.useRef)(contract);
+    contractRef.current = contract;
     const stableHandler = (0, react_1.useCallback)((payload) => handlerRef.current(payload), []);
     (0, react_1.useEffect)(() => {
         registeredHandlers.add(actionId);
@@ -117,15 +93,44 @@ function useAiClientAction(actionId, handler) {
                 .detail;
             if (!detail || detail.actionId !== actionId)
                 return;
-            stableHandler(detail.payload);
+            const validator = contractRef.current;
+            if (!validator) {
+                void stableHandler(detail.payload);
+                return;
+            }
+            const parsed = validator.safeParse(detail.payload ?? {});
+            if (!parsed.success) {
+                console.warn('[glirastes] A UI action payload did not match its contract');
+                return;
+            }
+            void stableHandler(parsed.data);
         };
         window.addEventListener(AI_CLIENT_ACTION_EVENT, handleEvent);
+        const unsubscribe = (0, client_actions_js_1.registerAiClientAction)(actionId, (payload) => stableHandler(payload), {
+            safeParse: (value) => contractRef.current?.safeParse(value)
+                ?? { success: true, data: value },
+        }, { bus: (0, ui_action_bus_js_1.getDefaultUiActionBus)() });
         return () => {
             window.removeEventListener(AI_CLIENT_ACTION_EVENT, handleEvent);
+            unsubscribe();
             registeredHandlers.delete(actionId);
         };
     }, [actionId, stableHandler]);
 }
+/**
+ * Executes the generated `ui.navigate` and `ui.filter.<view>` tools with the
+ * app's router, e.g. `useGlirastesNavigationBridge({ push: router.push })`
+ * with Next.js `useRouter()`. Always the latest `push` is used.
+ */
+function useGlirastesNavigationBridge(options) {
+    const pushRef = (0, react_1.useRef)(options.push);
+    pushRef.current = options.push;
+    const bus = options.bus;
+    (0, react_1.useEffect)(() => (0, navigation_js_1.registerNavigationBridge)({
+        push: (href) => pushRef.current(href),
+        ...(bus ? { bus } : {}),
+    }), [bus]);
+}
 // ============================================================================
 // Handler Registry Inspection (for dev-mode validation)
 // ============================================================================
@@ -175,7 +180,7 @@ function useAiMissingHandlerWarning(options = {}) {
             const missing = getMissingHandlers();
             if (missing.length === 0)
                 return;
-            console.warn(`[glirastes] ${missing.length} AI action handler(s) missing:`, missing);
+            console.warn(`[glirastes] ${missing.length} AI action handler(s) missing`);
             console.warn('[glirastes] Register handlers with useAiClientAction() or mark as @ai-ignore');
         }, delay);
         return () => clearTimeout(timer);

package/dist/cjs/react/unstyled.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Appended to the first compound of every rule in `styles.css`. It matches
+ * nothing at or inside a root that carries `data-unstyled`, so `unstyled`
+ * on `AiChatProvider` turns all shipped styles off without changing their
+ * specificity anywhere else.
+ */
+export declare const UNSTYLED_GUARD = ":where(:not([data-unstyled], [data-unstyled] *))";

package/dist/cjs/react/unstyled.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNSTYLED_GUARD = void 0;
+/**
+ * Appended to the first compound of every rule in `styles.css`. It matches
+ * nothing at or inside a root that carries `data-unstyled`, so `unstyled`
+ * on `AiChatProvider` turns all shipped styles off without changing their
+ * specificity anywhere else.
+ */
+exports.UNSTYLED_GUARD = ':where(:not([data-unstyled], [data-unstyled] *))';

package/dist/cjs/react/utils/activity.d.ts

@@ -0,0 +1,16 @@
+import { type PlanItem } from '../../contracts/plan.js';
+export type ActivityStepStatus = 'running' | 'done' | 'error' | 'waiting';
+export interface ActivityStep {
+    id: string;
+    toolName: string;
+    status: ActivityStepStatus;
+    /** Tool output message or error text, when the display mode allows it. */
+    detail?: string;
+}
+/**
+ * App tool calls of a message in the order they ran. `allowDetail` decides
+ * per tool whether its output message or error text may be shown.
+ */
+export declare function readActivitySteps(parts: ReadonlyArray<unknown>, allowDetail: (toolName: string) => boolean): ActivityStep[];
+/** Items of the last `update_plan` call in a message, or null without one. */
+export declare function readLatestPlan(parts: ReadonlyArray<unknown>): PlanItem[] | null;

package/dist/cjs/react/utils/activity.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readActivitySteps = readActivitySteps;
+exports.readLatestPlan = readLatestPlan;
+const clarification_js_1 = require("../../contracts/clarification.js");
+const plan_js_1 = require("../../contracts/plan.js");
+/** SDK built-ins render elsewhere (plan, clarification card, suggestions). */
+const BUILTIN_TOOL_NAMES = new Set([
+    'find_tools',
+    'suggest_followups',
+    clarification_js_1.CLARIFICATION_TOOL_NAME,
+    plan_js_1.PLAN_TOOL_NAME,
+]);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Tool name of an AI SDK 5.x/6.x tool part (`tool-{name}` or `dynamic-tool`). */
+function toolPartName(part) {
+    const type = typeof part.type === 'string' ? part.type : '';
+    if (type === 'dynamic-tool')
+        return typeof part.toolName === 'string' ? part.toolName : null;
+    if (!type.startsWith('tool-') || type === 'tool-result' || type === 'tool-call')
+        return null;
+    return type.slice('tool-'.length);
+}
+function stepStatus(state) {
+    switch (state) {
+        case 'output-available':
+            return 'done';
+        case 'output-error':
+        case 'output-denied':
+            return 'error';
+        case 'approval-requested':
+        case 'approval-responded':
+            return 'waiting';
+        default:
+            return 'running';
+    }
+}
+/**
+ * App tool calls of a message in the order they ran. `allowDetail` decides
+ * per tool whether its output message or error text may be shown.
+ */
+function readActivitySteps(parts, allowDetail) {
+    const steps = [];
+    parts.forEach((part, index) => {
+        if (!isRecord(part))
+            return;
+        const toolName = toolPartName(part);
+        if (!toolName || BUILTIN_TOOL_NAMES.has(toolName))
+            return;
+        const status = stepStatus(part.state);
+        const step = {
+            id: typeof part.toolCallId === 'string' ? part.toolCallId : `part-${index}`,
+            toolName,
+            status,
+        };
+        if (allowDetail(toolName)) {
+            const detail = status === 'error'
+                ? part.errorText
+                : status === 'done' && isRecord(part.output) ? part.output.message : undefined;
+            if (typeof detail === 'string' && detail.trim())
+                step.detail = detail.trim();
+        }
+        steps.push(step);
+    });
+    return steps;
+}
+/** Items of the last `update_plan` call in a message, or null without one. */
+function readLatestPlan(parts) {
+    for (let index = parts.length - 1; index >= 0; index--) {
+        const part = parts[index];
+        if (isRecord(part) && toolPartName(part) === plan_js_1.PLAN_TOOL_NAME) {
+            const items = (0, plan_js_1.readPlanItems)(part.input);
+            if (items)
+                return items;
+        }
+    }
+    return null;
+}

package/dist/cjs/react/utils/clarification.d.ts

@@ -0,0 +1,31 @@
+import { type ClarificationRequest } from '../../contracts/clarification.js';
+export interface ClarificationPart {
+    readonly toolCallId: string;
+    readonly request: ClarificationRequest;
+    /** True once the tool output exists; only then can the user answer. */
+    readonly ready: boolean;
+}
+/** Reads an `ask_clarification` tool part from AI SDK 5/6 UI messages. */
+export declare function readClarificationPart(part: unknown): ClarificationPart | undefined;
+/** The clarification the latest assistant message is waiting on, if any. */
+export declare function findOpenClarification(messages: ReadonlyArray<{
+    role: string;
+    parts: ReadonlyArray<unknown>;
+}>): ClarificationPart | undefined;
+/** True once a user message carries the answer marker for this clarification. */
+export declare function isClarificationAnswered(messages: ReadonlyArray<{
+    role: string;
+    parts: ReadonlyArray<unknown>;
+}>, toolCallId: string): boolean;
+/**
+ * The user message that answers a clarification: the marked answer that
+ * resumes the original request. When the ids cannot be carried by the marker
+ * (a provider id over 200 characters or with unusual characters) it falls back
+ * to the plain visible answer, so answering never throws and never leaves the
+ * user with a card that did nothing; the model still sees the answer.
+ */
+export declare function clarificationAnswerMessage(input: {
+    toolCallId: string;
+    answer: string;
+    optionId?: string;
+}): string;

package/dist/cjs/react/utils/clarification.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readClarificationPart = readClarificationPart;
+exports.findOpenClarification = findOpenClarification;
+exports.isClarificationAnswered = isClarificationAnswered;
+exports.clarificationAnswerMessage = clarificationAnswerMessage;
+const clarification_js_1 = require("../../contracts/clarification.js");
+const TARGETS = new Set(clarification_js_1.CLARIFICATION_TARGETS);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function readOptions(value) {
+    if (!Array.isArray(value))
+        return [];
+    const seen = new Set();
+    const options = [];
+    for (const candidate of value.slice(0, clarification_js_1.CLARIFICATION_MAX_OPTIONS)) {
+        if (!isRecord(candidate))
+            continue;
+        const { id, label, description } = candidate;
+        if (typeof id !== 'string' || !clarification_js_1.CLARIFICATION_OPTION_ID_PATTERN.test(id))
+            continue;
+        if (typeof label !== 'string' || !label.trim() || seen.has(id))
+            continue;
+        seen.add(id);
+        options.push({
+            id,
+            label: label.trim().slice(0, clarification_js_1.CLARIFICATION_MAX_LABEL_LENGTH),
+            ...(typeof description === 'string' && description.trim()
+                ? { description: description.trim().slice(0, clarification_js_1.CLARIFICATION_MAX_DESCRIPTION_LENGTH) }
+                : {}),
+        });
+    }
+    return options;
+}
+function readRequest(value) {
+    if (!isRecord(value) || typeof value.question !== 'string' || !value.question.trim()) {
+        return undefined;
+    }
+    const options = readOptions(value.options);
+    const allowFreeText = value.allowFreeText !== false || options.length === 0;
+    const target = typeof value.target === 'string' && TARGETS.has(value.target)
+        ? value.target
+        : 'other';
+    return {
+        question: value.question.trim().slice(0, clarification_js_1.CLARIFICATION_MAX_QUESTION_LENGTH),
+        target,
+        options,
+        allowFreeText,
+    };
+}
+/** Reads an `ask_clarification` tool part from AI SDK 5/6 UI messages. */
+function readClarificationPart(part) {
+    if (!isRecord(part) || typeof part.toolCallId !== 'string')
+        return undefined;
+    const isClarification = part.type === `tool-${clarification_js_1.CLARIFICATION_TOOL_NAME}`
+        || (part.type === 'dynamic-tool' && part.toolName === clarification_js_1.CLARIFICATION_TOOL_NAME);
+    if (!isClarification)
+        return undefined;
+    const fromOutput = isRecord(part.output) ? readRequest(part.output.clarification) : undefined;
+    const request = fromOutput ?? readRequest(part.input);
+    if (!request)
+        return undefined;
+    return {
+        toolCallId: part.toolCallId,
+        request,
+        ready: part.state === 'output-available',
+    };
+}
+/** The clarification the latest assistant message is waiting on, if any. */
+function findOpenClarification(messages) {
+    const latest = messages[messages.length - 1];
+    if (!latest || latest.role !== 'assistant')
+        return undefined;
+    for (let index = latest.parts.length - 1; index >= 0; index -= 1) {
+        const clarification = readClarificationPart(latest.parts[index]);
+        if (clarification?.ready)
+            return clarification;
+    }
+    return undefined;
+}
+/** True once a user message carries the answer marker for this clarification. */
+function isClarificationAnswered(messages, toolCallId) {
+    return messages.some((message) => (message.role === 'user'
+        && message.parts.some((part) => (isRecord(part)
+            && part.type === 'text'
+            && typeof part.text === 'string'
+            && (0, clarification_js_1.parseClarificationAnswer)(part.text)?.reference.toolCallId === toolCallId))));
+}
+/**
+ * The user message that answers a clarification: the marked answer that
+ * resumes the original request. When the ids cannot be carried by the marker
+ * (a provider id over 200 characters or with unusual characters) it falls back
+ * to the plain visible answer, so answering never throws and never leaves the
+ * user with a card that did nothing; the model still sees the answer.
+ */
+function clarificationAnswerMessage(input) {
+    try {
+        return (0, clarification_js_1.formatClarificationAnswer)(input);
+    }
+    catch {
+        return input.answer.trim().slice(0, clarification_js_1.CLARIFICATION_MAX_ANSWER_LENGTH);
+    }
+}

package/dist/cjs/react/utils/create-approval-description.d.ts

@@ -14,6 +14,12 @@ export interface ApprovalDescriptionConfig {
     valueTranslations?: Record<string, Record<string, string>>;
     /** Field names to always hide (e.g. internal IDs). UUIDs are hidden automatically. */
     hiddenFields?: string[] | Set<string>;
+    /**
+     * Id fields whose record name is shown under the given label, when the
+     * conversation's tool results already reported that name. Works for hidden
+     * fields too, since the name replaces the id. Example: `{ taskId: 'Task' }`
+     */
+    nameLabels?: Record<string, string>;
     /** Map tool names to human-readable action labels */
     toolLabels?: Record<string, string>;
     /** Locale for date formatting (default: `'en-US'`) */

package/dist/cjs/react/utils/create-approval-description.js

@@ -58,7 +58,7 @@ function formatDateValue(strValue, locale) {
  * ```
  */
 function createApprovalDescriptionGenerator(config = {}) {
-    const { fieldLabels = {}, valueTranslations = {}, hiddenFields: rawHiddenFields, toolLabels = {}, dateLocale = 'en-US', defaultConfirmText, defaultDescription = 'Confirm action?', } = config;
+    const { fieldLabels = {}, valueTranslations = {}, hiddenFields: rawHiddenFields, nameLabels = {}, toolLabels = {}, dateLocale = 'en-US', defaultConfirmText, defaultDescription = 'Confirm action?', } = config;
     const hiddenFields = rawHiddenFields instanceof Set
         ? rawHiddenFields
         : new Set(rawHiddenFields ?? []);
@@ -76,6 +76,25 @@ function createApprovalDescriptionGenerator(config = {}) {
             return formatDateValue(strValue, dateLocale);
         return capitalize(strValue);
     }
+    /** The known names behind the id fields, as `[label, names]` pairs. */
+    function collectNames(obj, names) {
+        const result = [];
+        for (const [key, value] of Object.entries(obj)) {
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                result.push(...collectNames(value, names));
+                continue;
+            }
+            const label = nameLabels[key];
+            if (!label)
+                continue;
+            const known = (Array.isArray(value) ? value : [value])
+                .map((id) => (typeof id === 'string' ? names.get(id.toLowerCase()) : undefined))
+                .filter((name) => !!name);
+            if (known.length > 0)
+                result.push([label, known.join(', ')]);
+        }
+        return result;
+    }
     function collectDetails(obj) {
         const result = [];
         for (const [key, value] of Object.entries(obj)) {
@@ -90,24 +109,39 @@ function createApprovalDescriptionGenerator(config = {}) {
                 continue;
             }
             const label = fieldLabels[key] || key;
-            let displayValue;
             if (Array.isArray(value)) {
                 const filtered = value.filter((v) => !UUID_REGEX.test(String(v)));
                 if (filtered.length === 0)
                     continue;
-                displayValue = filtered.map((v) => formatValue(key, v)).join(', ');
+                const items = filtered.map((v) => formatValue(key, v));
+                result.push({ line: `${label}: ${items.join(', ')}`, items });
             }
             else {
-                displayValue = formatValue(key, value);
+                result.push({ line: `${label}: ${formatValue(key, value)}` });
             }
-            result.push(`${label}: ${displayValue}`);
         }
         return result;
     }
-    return (toolName, approvalId, args) => {
+    return (toolName, approvalId, args, context) => {
         const details = [];
+        const detailItems = [];
         if (args && typeof args === 'object') {
-            details.push(...collectDetails(args));
+            const stated = collectDetails(args);
+            // What the call states comes first: a grouped card shows the first line.
+            for (const entry of stated) {
+                details.push(entry.line);
+                detailItems.push(entry.items);
+            }
+            if (context?.names?.size) {
+                // A name the arguments already state is not repeated; a differing
+                // one stays visible next to it.
+                for (const [label, name] of collectNames(args, context.names)) {
+                    if (!stated.some((entry) => entry.line.endsWith(`: ${name}`))) {
+                        details.push(`${label}: ${name}`);
+                        detailItems.push(undefined);
+                    }
+                }
+            }
         }
         return {
             id: approvalId,
@@ -116,6 +150,7 @@ function createApprovalDescriptionGenerator(config = {}) {
             messageId: '',
             description: toolLabels[toolName] || defaultDescription,
             details,
+            ...(detailItems.some(Boolean) ? { detailItems } : {}),
             ...(defaultConfirmText ? { confirmText: defaultConfirmText } : {}),
         };
     };

package/dist/cjs/react/utils/create-tool-result-handler.d.ts

@@ -6,7 +6,7 @@ interface SafeParseable {
     } | {
         success: false;
         error: {
-            issues: unknown[];
+            issues: ReadonlyArray<unknown>;
         };
     };
 }

package/dist/cjs/react/utils/create-tool-result-handler.js

@@ -79,7 +79,7 @@ function createToolResultHandler(config) {
                 if (uiActionSchema) {
                     const parsed = uiActionSchema.safeParse(candidate);
                     if (!parsed.success) {
-                        console.warn('[AI Chat] Invalid uiAction dropped:', parsed.error.issues);
+                        console.warn('[AI Chat] Invalid uiAction dropped');
                         continue;
                     }
                     uiAction = parsed.data;

package/dist/cjs/react/utils/entity-names.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The display names of the records the tools of this conversation returned,
+ * by record id. Only finished tool results count, never what the model put
+ * into a call, so a name found here is one the app itself reported.
+ */
+export declare function collectEntityNames(messages: ReadonlyArray<unknown>): Map<string, string>;

package/dist/cjs/react/utils/entity-names.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectEntityNames = collectEntityNames;
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const NAME_KEYS = ['title', 'name', 'displayName', 'label'];
+const MAX_DEPTH = 6;
+const MAX_NODES = 5000;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * The display names of the records the tools of this conversation returned,
+ * by record id. Only finished tool results count, never what the model put
+ * into a call, so a name found here is one the app itself reported.
+ */
+function collectEntityNames(messages) {
+    const names = new Map();
+    let budget = MAX_NODES;
+    const walk = (value, depth) => {
+        if (depth > MAX_DEPTH || budget <= 0)
+            return;
+        budget -= 1;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                walk(item, depth + 1);
+            return;
+        }
+        if (!isRecord(value))
+            return;
+        if (typeof value.id === 'string' && UUID_REGEX.test(value.id)) {
+            for (const key of NAME_KEYS) {
+                const name = value[key];
+                if (typeof name === 'string' && name.trim()) {
+                    names.set(value.id.toLowerCase(), name);
+                    break;
+                }
+            }
+        }
+        for (const child of Object.values(value)) {
+            if (typeof child === 'object' && child !== null)
+                walk(child, depth + 1);
+        }
+    };
+    for (const message of messages) {
+        if (!isRecord(message) || !Array.isArray(message.parts))
+            continue;
+        for (const part of message.parts) {
+            if (isRecord(part)
+                && typeof part.type === 'string'
+                && part.type.startsWith('tool-')
+                && part.state === 'output-available') {
+                walk(part.output, 0);
+            }
+        }
+    }
+    return names;
+}

package/dist/cjs/react/utils/followup-suggestions.d.ts

@@ -0,0 +1,11 @@
+export interface ExtractedFollowupSuggestions {
+    text: string;
+    suggestions: string[];
+}
+/**
+ * Extract a strictly delimited, trailing Markdown follow-up list.
+ *
+ * This is a presentation fallback for models that write suggestions instead
+ * of calling `suggest_followups`. Unmatched text is returned unchanged.
+ */
+export declare function extractTrailingFollowupSuggestions(text: string, limit?: number): ExtractedFollowupSuggestions;