@object-ui/app-shell 6.2.3 → 7.1.0

package/dist/hooks/useChatConversation.js

@@ -8,7 +8,55 @@
  * (404/403).
  */
 import { useCallback, useEffect, useRef, useState } from 'react';
+/**
+ * Rebuild the MINIMAL `{ status:'drafted', … }` envelope that
+ * `mapMessages.detectDraftResult` re-parses, from the already-derived
+ * `DraftReview`. Inverse of the detector: we keep only the fields it reads, so
+ * the draft "Review N changes / Publish" card and the ADR-0038 verification
+ * chip survive without re-storing the (potentially large) blueprint JSON.
+ * `failed` is materialized to the right length because the detector counts
+ * `failed.length`.
+ */
+function draftReviewToCachedResult(dr) {
+    return {
+        status: 'drafted',
+        drafted: dr.items,
+        ...(dr.summary ? { summary: dr.summary } : {}),
+        ...(dr.packageId ? { packageId: dr.packageId } : {}),
+        ...(dr.autoPublishable ? { autoPublishable: true } : {}),
+        ...(dr.failedCount ? { failed: Array.from({ length: dr.failedCount }, () => null) } : {}),
+        ...(dr.materialized ? { materialized: true } : {}),
+        ...(dr.verification ? { verification: dr.verification } : {}),
+        ...(dr.issues && dr.issues.length ? { issues: dr.issues } : {}),
+        ...(dr.nextSteps && dr.nextSteps.length ? { nextSteps: dr.nextSteps } : {}),
+    };
+}
+/**
+ * Rebuild the MINIMAL `{ status:'blueprint_proposed', … }` envelope that
+ * `mapMessages.detectProposedPlan` re-parses, from the already-derived
+ * `ProposedPlan`. Object `fields` are materialized to the right length because
+ * the detector reads `fields.length` as the per-object field count — the field
+ * definitions themselves are dropped (the lean win).
+ */
+function proposedPlanToCachedResult(pp) {
+    return {
+        status: 'blueprint_proposed',
+        ...(pp.summary ? { summary: pp.summary } : {}),
+        counts: pp.counts,
+        questions: pp.questions,
+        ...(pp.targetApp ? { targetApp: pp.targetApp } : {}),
+        blueprint: {
+            objects: pp.objects.map((o) => ({
+                name: o.name,
+                ...(o.label ? { label: o.label } : {}),
+                fields: Array.from({ length: o.fieldCount }, () => null),
+            })),
+            assumptions: pp.assumptions,
+        },
+    };
+}
 const CACHE_PREFIX = 'objectstack:ai-chat-conversation-id';
+const MESSAGE_CACHE_PREFIX = 'objectstack:ai-chat-messages';
 function cacheKey(userId, scope) {
     return scope ? `${CACHE_PREFIX}:${userId}:${scope}` : `${CACHE_PREFIX}:${userId}`;
 }
@@ -31,46 +79,258 @@ function writeCache(key, value) {
         /* ignore — private mode, quota, etc. */
     }
 }
-function contentToText(content) {
-    if (typeof content === 'string')
-        return content;
+function messageCacheKey(conversationId) {
+    return `${MESSAGE_CACHE_PREFIX}:${conversationId}`;
+}
+function readMessageCache(conversationId) {
+    try {
+        const raw = localStorage.getItem(messageCacheKey(conversationId));
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((msg) => {
+            return (Boolean(msg) &&
+                typeof msg === 'object' &&
+                typeof msg.id === 'string' &&
+                (msg.role === 'user' ||
+                    msg.role === 'assistant' ||
+                    msg.role === 'system') &&
+                Array.isArray(msg.parts));
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export function writeConversationMessagesCache(conversationId, messages) {
+    if (!conversationId)
+        return;
+    try {
+        if (messages.length === 0) {
+            localStorage.removeItem(messageCacheKey(conversationId));
+            return;
+        }
+        localStorage.setItem(messageCacheKey(conversationId), JSON.stringify(messages));
+    }
+    catch {
+        /* ignore — private mode, quota, etc. */
+    }
+}
+export function sanitizeChatMessagesForCache(messages) {
+    return messages
+        .map((message) => {
+        const parts = [];
+        if (message.content) {
+            parts.push({ type: 'text', text: message.content });
+        }
+        if (message.role === 'assistant') {
+            for (const tool of message.toolInvocations ?? []) {
+                // Re-serialize the draft/plan affordance into a compact tool `output`.
+                // Without it, a cache-fallback reload (server returns no messages →
+                // `readMessageCache`) drops the draft "Review N changes / Publish"
+                // card, the ADR-0038 verification chip, and the "Proposed plan" card,
+                // because `mapMessages.detect*` read the result `output` that the
+                // earlier cache shape never kept. `output` (not a custom part field)
+                // is used because the AI SDK preserves it through `useChat` init,
+                // exactly as the server-backed tool-result merge relies on.
+                const cachedOutput = tool.draftReview
+                    ? draftReviewToCachedResult(tool.draftReview)
+                    : tool.proposedPlan
+                        ? proposedPlanToCachedResult(tool.proposedPlan)
+                        : undefined;
+                parts.push({
+                    type: `tool-${tool.toolName}`,
+                    toolCallId: tool.toolCallId,
+                    toolName: tool.toolName,
+                    state: tool.state ?? (tool.errorText ? 'output-error' : 'output-available'),
+                    ...(tool.errorText ? { errorText: tool.errorText } : {}),
+                    ...(cachedOutput !== undefined ? { output: cachedOutput } : {}),
+                });
+            }
+        }
+        if (parts.length === 0)
+            return undefined;
+        return {
+            id: message.id,
+            role: message.role,
+            parts,
+        };
+    })
+        .filter((message) => Boolean(message));
+}
+function contentToParts(content) {
+    if (typeof content === 'string') {
+        return content ? [{ type: 'text', text: content }] : [];
+    }
     if (Array.isArray(content)) {
         return content
             .map((part) => {
-            if (typeof part === 'string')
+            if (typeof part === 'string') {
+                return part ? { type: 'text', text: part } : undefined;
+            }
+            if (part &&
+                typeof part === 'object' &&
+                'type' in part &&
+                typeof part.type === 'string') {
                 return part;
+            }
             if (part &&
                 typeof part === 'object' &&
                 'text' in part &&
                 typeof part.text === 'string') {
-                return part.text;
+                return { type: 'text', text: part.text };
             }
-            return '';
+            return undefined;
         })
-            .join('');
+            .filter((part) => Boolean(part));
+    }
+    if (content &&
+        typeof content === 'object' &&
+        'parts' in content &&
+        Array.isArray(content.parts)) {
+        return contentToParts(content.parts);
+    }
+    return [];
+}
+/**
+ * Merge a `tool`-role message's tool-result outputs back onto the assistant
+ * tool-call parts that requested them. The server persists conversations in
+ * ModelMessage format, where a tool CALL (assistant message) and its RESULT (a
+ * separate `tool` row) live in different messages. The chat UI needs the output
+ * ON the call part so `detectDraftResult` can rebuild the publish/preview
+ * affordances after a reload — otherwise the result, and the whole `tool` row
+ * (which the UI never renders directly), is dropped and the build card + publish
+ * button vanish on refresh.
+ */
+function mergeToolResultsInto(content, byCallId) {
+    for (const part of contentToParts(content)) {
+        const callId = typeof part.toolCallId === 'string' ? part.toolCallId : undefined;
+        if (!callId)
+            continue;
+        const target = byCallId.get(callId);
+        if (!target)
+            continue;
+        const output = part.output ?? part.result;
+        if (output === undefined)
+            continue;
+        target.output = output;
+        const errorText = part.errorText;
+        const isError = Boolean(part.isError) || typeof errorText === 'string';
+        target.state = isError ? 'output-error' : 'output-available';
+        if (typeof errorText === 'string')
+            target.errorText = errorText;
     }
-    return '';
 }
-function toUIMessages(rows) {
+export function toUIMessages(rows) {
     if (!rows)
         return [];
     const out = [];
+    // Index assistant tool-call parts by id so a later `tool`-role result row can
+    // merge its output onto the matching call (see mergeToolResultsInto).
+    const toolPartByCallId = new Map();
     rows.forEach((row, idx) => {
         const role = row.role;
+        if (role === 'tool') {
+            mergeToolResultsInto(row.content, toolPartByCallId);
+            return;
+        }
         if (role !== 'user' && role !== 'assistant' && role !== 'system')
             return;
-        const text = contentToText(row.content);
-        if (!text)
+        const parts = contentToParts(row.content);
+        if (parts.length === 0)
             return;
+        if (role === 'assistant') {
+            for (const part of parts) {
+                // ModelMessage format persists an assistant tool CALL as the literal
+                // `type:'tool-call'` with the real tool in `toolName`. Left as-is, the
+                // chat humanizes the step title to "Call" (and downstream toolName
+                // extraction yields "call"). Remap to the AI SDK UI part type
+                // `tool-<toolName>` so the step reads "Apply blueprint" / "Propose
+                // blueprint" after a clean server-backed reload; the result-merge below
+                // and `detect*` are unaffected (they key off toolCallId / output).
+                if (part.type === 'tool-call' && typeof part.toolName === 'string' && part.toolName) {
+                    part.type = `tool-${part.toolName}`;
+                }
+                const callId = typeof part.toolCallId === 'string' ? part.toolCallId : undefined;
+                if (callId && (part.type === 'tool-call' || part.type.startsWith('tool-'))) {
+                    toolPartByCallId.set(callId, part);
+                }
+            }
+        }
         out.push({
             id: row.id ?? `msg-${idx}`,
             role,
-            parts: [{ type: 'text', text }],
+            parts,
         });
     });
     return out;
 }
-async function fetchConversation(apiBase, id) {
+function safeParseArray(value) {
+    if (typeof value !== 'string' || !value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Reconstruct the ModelMessage-shaped `content` that {@link toUIMessages}
+ * expects from the FLAT columns the public share endpoint returns raw.
+ *
+ * The authenticated path gets this reconstruction server-side
+ * (`ObjqlConversationService.toMessage`): an assistant turn's tool CALLS live
+ * in the separate `tool_calls` column, and a `tool` row's RESULTS are a
+ * JSON-stringified array in `content`. The share endpoint skips that step and
+ * dumps the rows verbatim — so the shared transcript previously rendered the
+ * raw `{"type":"tool-result",…}` envelope as text instead of a card. Mirroring
+ * `toMessage` here lets the share page reuse the exact same hydrate → render
+ * pipeline as the live chat. Keep this in lockstep with `toMessage`.
+ */
+export function aiMessageRowsToServerMessages(rows) {
+    if (!rows)
+        return [];
+    return rows.map((row) => {
+        const id = row.id;
+        const text = typeof row.content === 'string' ? row.content : '';
+        if (row.role === 'assistant') {
+            const toolCalls = safeParseArray(row.tool_calls);
+            if (toolCalls && toolCalls.length > 0) {
+                const content = [];
+                if (text)
+                    content.push({ type: 'text', text });
+                content.push(...toolCalls);
+                return { id, role: 'assistant', content };
+            }
+            return { id, role: 'assistant', content: text };
+        }
+        if (row.role === 'tool') {
+            const results = safeParseArray(row.content);
+            if (results && results.length > 0 && results[0]?.type === 'tool-result') {
+                return { id, role: 'tool', content: results };
+            }
+            // Back-compat: pre-array tool rows persisted a plain string.
+            return {
+                id,
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: row.tool_call_id ?? '',
+                        toolName: 'unknown',
+                        output: { type: 'text', value: text },
+                    },
+                ],
+            };
+        }
+        return { id, role: row.role, content: text };
+    });
+}
+export async function fetchConversation(apiBase, id) {
     const res = await fetch(`${apiBase}/conversations/${encodeURIComponent(id)}`, {
         credentials: 'include',
     });
@@ -100,15 +360,18 @@ async function deleteConversation(apiBase, id) {
     });
 }
 export function useChatConversation(options) {
-    const { userId, scope, apiBase, activeId } = options;
+    const { userId, scope, apiBase, activeId, forceNew } = options;
     const [conversationId, setConversationId] = useState(undefined);
     const [initialMessages, setInitialMessages] = useState([]);
     const [isLoading, setIsLoading] = useState(Boolean(userId));
     const mountedRef = useRef(true);
-    // Tracks "we have already resolved a no-activeId conversation for this user".
-    // Prevents creating duplicate conversations when sibling state (e.g. the
-    // page's selected agent / `scope`) transitions during the same /ai visit.
+    // Tracks the (user, scope) we have already resolved a no-activeId
+    // conversation for. Keyed by SCOPE as well as user so a deliberate agent
+    // switch (the `/ai/:agent` launcher changes `scope`) re-resolves under the
+    // new agent's cache instead of clinging to the previous agent's conversation,
+    // while a no-op re-render under the same scope still short-circuits.
     const resolvedForUserRef = useRef(undefined);
+    const resolvedScopeRef = useRef(undefined);
     useEffect(() => {
         mountedRef.current = true;
         return () => {
@@ -121,15 +384,31 @@ export function useChatConversation(options) {
             setInitialMessages([]);
             setIsLoading(false);
             resolvedForUserRef.current = undefined;
+            resolvedScopeRef.current = undefined;
             return;
         }
-        // Already resolved a conversation for this user during the no-activeId
-        // window — don't re-create just because `scope` or another dep changed.
-        if (!activeId && resolvedForUserRef.current === userId && conversationId) {
+        // Already resolved a conversation for this (user, scope) during the
+        // no-activeId window — don't re-create just because an unrelated dep
+        // changed. A `forceNew` intent or a scope (agent) change overrides it.
+        const scopeChanged = resolvedScopeRef.current !== scope;
+        if (!activeId &&
+            !forceNew &&
+            !scopeChanged &&
+            resolvedForUserRef.current === userId &&
+            conversationId) {
             return;
         }
         let cancelled = false;
         const key = cacheKey(userId, scope);
+        // Drop the previous id NOW, before the async resolve, for both an explicit
+        // new-conversation intent AND an agent switch: the host page mirrors
+        // `conversationId` into the URL the moment `activeId` is empty, so a stale
+        // id left in state would be written onto the new agent's URL (`/ai/:agent`)
+        // and then resumed as that agent's conversation.
+        if (!activeId && (forceNew || (scopeChanged && resolvedForUserRef.current === userId))) {
+            setConversationId(undefined);
+            setInitialMessages([]);
+        }
         setIsLoading(true);
         (async () => {
             try {
@@ -140,14 +419,17 @@ export function useChatConversation(options) {
                     if (existing) {
                         writeCache(key, existing.id);
                         setConversationId(existing.id);
-                        setInitialMessages(toUIMessages(existing.messages));
+                        const messages = toUIMessages(existing.messages);
+                        setInitialMessages(messages.length > 0 ? messages : readMessageCache(existing.id));
                         resolvedForUserRef.current = userId;
+                        resolvedScopeRef.current = scope;
                         return;
                     }
                     // Requested id is gone — fall through to create a fresh one.
                     writeCache(key, undefined);
+                    writeConversationMessagesCache(activeId, []);
                 }
-                else {
+                else if (!forceNew) {
                     const cached = readCache(key);
                     if (cached) {
                         const existing = await fetchConversation(apiBase, cached);
@@ -155,11 +437,14 @@ export function useChatConversation(options) {
                             return;
                         if (existing) {
                             setConversationId(existing.id);
-                            setInitialMessages(toUIMessages(existing.messages));
+                            const messages = toUIMessages(existing.messages);
+                            setInitialMessages(messages.length > 0 ? messages : readMessageCache(existing.id));
                             resolvedForUserRef.current = userId;
+                            resolvedScopeRef.current = scope;
                             return;
                         }
                         writeCache(key, undefined);
+                        writeConversationMessagesCache(cached, []);
                     }
                 }
                 const fresh = await createConversation(apiBase);
@@ -169,6 +454,7 @@ export function useChatConversation(options) {
                 setConversationId(fresh.id);
                 setInitialMessages(toUIMessages(fresh.messages));
                 resolvedForUserRef.current = userId;
+                resolvedScopeRef.current = scope;
             }
             catch {
                 if (!cancelled) {
@@ -188,7 +474,7 @@ export function useChatConversation(options) {
         // short-circuit guard, which is governed by the ref. Including it would
         // re-run the effect after we successfully resolved an id.
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [userId, scope, apiBase, activeId]);
+    }, [userId, scope, apiBase, activeId, forceNew]);
     const reset = useCallback(async () => {
         if (!userId)
             return;
@@ -197,9 +483,11 @@ export function useChatConversation(options) {
         try {
             if (conversationId)
                 await deleteConversation(apiBase, conversationId);
+            writeConversationMessagesCache(conversationId, []);
             writeCache(key, undefined);
             const fresh = await createConversation(apiBase);
             writeCache(key, fresh.id);
+            writeConversationMessagesCache(fresh.id, []);
             if (!mountedRef.current)
                 return;
             setConversationId(fresh.id);
@@ -216,5 +504,8 @@ export function useChatConversation(options) {
                 setIsLoading(false);
         }
     }, [conversationId, userId, scope, apiBase]);
-    return { conversationId, initialMessages, isLoading, reset };
+    // `resolvedScopeRef` is updated in lockstep with every `setConversationId`
+    // (same async tick), so at render time it always describes the scope the
+    // current `conversationId` was resolved under.
+    return { conversationId, conversationScope: resolvedScopeRef.current, initialMessages, isLoading, reset };
 }

package/dist/hooks/useConsoleActionRuntime.d.ts

@@ -0,0 +1,70 @@
+/**
+ * useConsoleActionRuntime — the reusable console "action runtime".
+ *
+ * ObjectView historically owned all the wiring needed to make schema-driven
+ * `action:button`s actually *do* something: confirm/param/result dialogs, an
+ * authenticated API caller, flow + server-action handlers, SPA navigation, and
+ * the paused screen-flow runner. SDUI pages (PageView) render the same
+ * `action:button` widgets but lacked that runtime, so their actions could not
+ * collect params, call authenticated APIs, show result dialogs, refresh, or
+ * navigate (#1605).
+ *
+ * This hook extracts that generic wiring so BOTH ObjectView and PageView can
+ * mount it. It owns the dialog state and handlers, and returns:
+ *   - `actionProviderProps` — spread onto `<ActionProvider>`;
+ *   - `dialogs` — the confirm/param/result/flow dialogs to render inside it;
+ *   - the individual handlers (e.g. `confirmHandler`, `toastHandler`) so a
+ *     caller like ObjectView can also feed them into `useObjectActions`.
+ *
+ * `objectName` is optional: pages run global (or action-scoped) actions, while
+ * ObjectView passes its current object so object-scoped actions resolve their
+ * target + param defaults.
+ */
+import React from 'react';
+import { createAuthenticatedFetch } from '@object-ui/auth';
+import type { ActionContext, ActionDef, ActionResult, ConfirmationHandler, NavigationHandler, ParamCollectionHandler, ResultDialogHandler, ToastHandler } from '@object-ui/core';
+export interface ConsoleActionRuntimeOptions {
+    /** Adapter for generic CRUD / execute calls. */
+    dataSource: any;
+    /** All object definitions — used to resolve param defaults from row/object. */
+    objects?: any[];
+    /** Current object name (ObjectView). Omit for pages running global actions. */
+    objectName?: string;
+    /** Invoked after a successful action that requests a refresh (`refreshAfter`
+     *  !== false) — bump a refresh key to re-fetch embedded data. */
+    onRefresh?: () => void;
+}
+export interface ConsoleActionRuntime {
+    confirmHandler: ConfirmationHandler;
+    toastHandler: ToastHandler;
+    navigateHandler: NavigationHandler;
+    paramCollectionHandler: ParamCollectionHandler;
+    resultDialogHandler: ResultDialogHandler;
+    apiHandler: (action: ActionDef) => Promise<ActionResult>;
+    flowHandler: (action: ActionDef, context?: ActionContext) => Promise<ActionResult>;
+    serverActionHandler: (action: ActionDef, context?: ActionContext) => Promise<ActionResult>;
+    /** Authenticated fetch wrapper (Bearer + tenant + cookies). */
+    authFetch: ReturnType<typeof createAuthenticatedFetch>;
+    /** Props to spread onto `<ActionProvider>`. */
+    actionProviderProps: {
+        context: Record<string, any>;
+        onConfirm: ConfirmationHandler;
+        onToast: ToastHandler;
+        onNavigate: NavigationHandler;
+        onParamCollection: ParamCollectionHandler;
+        onResultDialog: ResultDialogHandler;
+        handlers: Record<string, (action: ActionDef) => Promise<ActionResult>>;
+    };
+    /** Confirm / param / result / paused-flow dialogs — render inside the provider. */
+    dialogs: React.ReactNode;
+}
+export declare function useConsoleActionRuntime(opts: ConsoleActionRuntimeOptions): ConsoleActionRuntime;
+/**
+ * ConsoleActionRuntimeProvider — convenience wrapper for callers (e.g. PageView)
+ * that only need to wrap a subtree in the console action runtime. ObjectView
+ * uses {@link useConsoleActionRuntime} directly because it also feeds the
+ * handlers into `useObjectActions`.
+ */
+export declare function ConsoleActionRuntimeProvider({ children, ...opts }: ConsoleActionRuntimeOptions & {
+    children: React.ReactNode;
+}): React.JSX.Element;