@datalayer/agent-runtimes 1.5.43 → 1.5.45

package/lib/hooks/useChat.js

@@ -10,8 +10,11 @@
  */
 import { useCallback, useMemo } from 'react';
 import { useChatStore } from '../stores';
-import { createUserMessage, createAssistantMessage, generateMessageId, } from '../types/messages';
-import { sanitizeAssistantContent } from '../utils';
+import { createUserMessage, generateMessageId } from '../types/messages';
+import { isToolCallMessage } from '../utils';
+import { BROWSER_LIMITS, emptyConversation, reduceConversation, withPrompt, } from '../portable/conversation';
+import { conversationEventsOf, snapshotOfMessages, } from '../portable/adapterEvents';
+import { conversationDrawer, emptyChatLayer, } from '../chat/base/conversationItems';
 /**
  * Main hook for chat functionality
  *
@@ -56,13 +59,17 @@ export function useChat() {
     const clearMessages = useChatStore(state => state.clearMessages);
     const setLoading = useChatStore(state => state.setLoading);
     const setError = useChatStore(state => state.setError);
+    const setMessages = useChatStore(state => state.setMessages);
     const startStreaming = useChatStore(state => state.startStreaming);
-    const appendToStream = useChatStore(state => state.appendToStream);
     const stopStreaming = useChatStore(state => state.stopStreaming);
     const setSuggestions = useChatStore(state => state.setSuggestions);
     const getTools = useChatStore(state => state.getTools);
     /**
-     * Send a user message and get AI response
+     * Send a user message and get the AI's response. The conversation is
+     * `reduceConversation`'s (MOBILE M-030), as in ChatBase and on the phone:
+     * every adapter event read by `conversationEventsOf`, an inference
+     * provider's deltas as AG-UI text events, and the store's messages drawn
+     * from it.
      */
     const sendMessage = useCallback(async (content, options) => {
         // Check if we have a way to send messages
@@ -70,102 +77,95 @@ export function useChat() {
             setError(new Error('No inference provider or protocol adapter configured.'));
             return;
         }
-        // Create and add user message
         const userMessage = createUserMessage(content);
-        addMessage(userMessage);
-        // Clear error and set loading
+        const draw = conversationDrawer(words => words);
+        let conversation = withPrompt(reduceConversation(emptyConversation(BROWSER_LIMITS), snapshotOfMessages(messages)), userMessage.id, content);
+        const show = (next) => {
+            conversation = next;
+            setMessages(draw(conversation, emptyChatLayer()).filter((item) => !isToolCallMessage(item)));
+        };
+        const reduce = (events) => {
+            if (events.length) {
+                show(events.reduce((kept, event) => reduceConversation(kept, event), conversation));
+            }
+        };
+        /** An adapter's event, as the conversation reads it; its failure is the chat's error. */
+        const read = (event) => {
+            if (event.type === 'error') {
+                if (event.error) {
+                    setError(event.error);
+                }
+                return;
+            }
+            try {
+                reduce(conversationEventsOf(event, conversation));
+            }
+            catch (failure) {
+                setError(failure instanceof Error ? failure : new Error(String(failure)));
+            }
+        };
+        show(conversation);
         setError(null);
         setLoading(true);
+        startStreaming(generateMessageId());
         try {
-            // Get registered tools
             const tools = getTools();
-            // Merge options
             const requestOptions = {
                 ...options,
                 tools: tools.length > 0 ? tools : undefined,
             };
-            // Get all messages for context
+            // Every message so far, for context.
             const allMessages = [...messages, userMessage];
-            // Create placeholder for assistant message
-            const assistantMessageId = generateMessageId();
-            const assistantMessage = createAssistantMessage('');
-            assistantMessage.id = assistantMessageId;
-            addMessage(assistantMessage);
-            // Stream the response
-            startStreaming(assistantMessageId);
-            // Use protocol adapter if available (for ag-ui, a2a, acp)
-            // Otherwise fall back to inference provider (for vercel-ai, OpenAI-compatible)
+            // A protocol adapter (ag-ui, a2a, acp) when there is one; else the
+            // inference provider (vercel-ai, OpenAI-compatible).
             if (protocolAdapter) {
-                // Track pending tool calls for this run
+                // The calls this run asks the page's tools for, run once it ends.
                 const pendingToolCalls = new Map();
-                let currentAssistantContent = '';
-                // Subscribe to adapter events
                 const unsubscribe = protocolAdapter.subscribe(event => {
-                    switch (event.type) {
-                        case 'message':
-                            // AG-UI sends incremental messages with accumulating content
-                            if (event.message) {
-                                const rawContent = typeof event.message.content === 'string'
-                                    ? event.message.content
-                                    : '';
-                                currentAssistantContent =
-                                    sanitizeAssistantContent(rawContent);
-                                // Update the assistant message with the current content
-                                updateMessage(assistantMessageId, {
-                                    content: currentAssistantContent,
-                                    toolCalls: event.message.toolCalls,
-                                });
-                            }
-                            break;
-                        case 'tool-call':
-                            // Track tool call for execution after stream completes
-                            if (event.toolCall) {
-                                console.log('[useChat] Tool call received:', event.toolCall.toolCallId, event.toolCall.toolName);
-                                pendingToolCalls.set(event.toolCall.toolCallId, {
-                                    toolName: event.toolCall.toolName,
-                                    args: event.toolCall.args,
-                                });
-                            }
-                            break;
-                        case 'error':
-                            if (event.error) {
-                                setError(event.error);
-                            }
-                            break;
+                    if (event.type === 'tool-call' && event.toolCall) {
+                        pendingToolCalls.set(event.toolCall.toolCallId, {
+                            toolName: event.toolCall.toolName,
+                            args: event.toolCall.args,
+                        });
                     }
+                    read(event);
                 });
                 try {
-                    // Send the initial message
                     await protocolAdapter.sendMessage(userMessage, {
                         tools: requestOptions.tools,
                         messages: allMessages,
                     });
-                    // After stream completes, execute any pending tool calls
                     if (pendingToolCalls.size > 0 && toolExecutor) {
-                        console.log('[useChat] Executing', pendingToolCalls.size, 'tool calls');
-                        // Execute tool calls and collect results
                         const toolResults = [];
                         for (const [toolCallId, { toolName, args }] of pendingToolCalls) {
-                            console.log('[useChat] Executing tool:', toolName, 'with args:', args);
                             const result = await toolExecutor.execute({
                                 toolCallId,
                                 toolName,
                                 args,
                             });
-                            console.log('[useChat] Tool result:', result);
                             toolResults.push({
                                 toolCallId,
                                 toolName,
                                 result: result.result,
                                 isError: !result.success,
                             });
+                            // The call answered, in the conversation.
+                            reduce(conversationEventsOf({
+                                type: 'tool-result',
+                                toolResult: {
+                                    toolCallId,
+                                    success: result.success,
+                                    result: result.result,
+                                    ...(result.success ? {} : { error: result.error }),
+                                },
+                            }, conversation));
                         }
-                        // Build messages array with tool results for continuation
-                        // Include the assistant message with tool calls
+                        // The run continued with the results: the assistant's calls,
+                        // then one `tool` message per result (AG-UI).
                         const assistantWithToolCalls = {
-                            id: assistantMessageId,
+                            id: generateMessageId(),
                             role: 'assistant',
-                            content: currentAssistantContent,
+                            content: '',
                             createdAt: new Date(),
                             toolCalls: Array.from(pendingToolCalls.entries()).map(([toolCallId, { toolName, args }]) => ({
                                 type: 'tool-call',
@@ -175,7 +175,6 @@ export function useChat() {
                                 status: 'completed',
                             })),
                         };
-                        // Create tool result messages
                         const toolResultMessages = toolResults.map(tr => ({
                             id: generateMessageId(),
                             role: 'tool',
@@ -187,48 +186,14 @@ export function useChat() {
                                 isError: tr.isError,
                             },
                         }));
-                        // Update stored messages
-                        updateMessage(assistantMessageId, assistantWithToolCalls);
-                        toolResultMessages.forEach(msg => addMessage(msg));
-                        // Create new assistant message for the continuation
-                        const continuationAssistantId = generateMessageId();
-                        const continuationMessage = createAssistantMessage('');
-                        continuationMessage.id = continuationAssistantId;
-                        addMessage(continuationMessage);
-                        startStreaming(continuationAssistantId);
-                        // Subscribe to continuation events
-                        const unsubscribeContinuation = protocolAdapter.subscribe(event => {
-                            if (event.type === 'message' && event.message) {
-                                const rawContent = typeof event.message.content === 'string'
-                                    ? event.message.content
-                                    : '';
-                                const content = sanitizeAssistantContent(rawContent);
-                                updateMessage(continuationAssistantId, {
-                                    content,
-                                    toolCalls: event.message.toolCalls,
-                                });
-                            }
-                            else if (event.type === 'error' && event.error) {
-                                setError(event.error);
-                            }
-                        });
-                        try {
-                            // Build the full message history for continuation
-                            const continuationMessages = [
+                        await protocolAdapter.sendMessage(toolResultMessages[toolResultMessages.length - 1], {
+                            tools: requestOptions.tools,
+                            messages: [
                                 ...allMessages,
                                 assistantWithToolCalls,
                                 ...toolResultMessages,
-                            ];
-                            // Send continuation request with tool results
-                            // AG-UI expects tool results as messages with role: "tool"
-                            await protocolAdapter.sendMessage(toolResultMessages[toolResultMessages.length - 1], {
-                                tools: requestOptions.tools,
-                                messages: continuationMessages,
-                            });
-                        }
-                        finally {
-                            unsubscribeContinuation();
-                        }
+                            ],
+                        });
                     }
                 }
                 finally {
@@ -236,47 +201,50 @@ export function useChat() {
                 }
             }
             else if (inferenceProvider) {
+                const answerId = generateMessageId();
+                reduce([
+                    { type: 'RUN_STARTED' },
+                    {
+                        type: 'TEXT_MESSAGE_START',
+                        messageId: answerId,
+                        role: 'assistant',
+                    },
+                ]);
                 const response = await inferenceProvider.streamMessage(allMessages, requestOptions, event => {
-                    switch (event.type) {
-                        case 'content-delta':
-                            if (event.delta?.delta.content) {
-                                appendToStream(assistantMessageId, event.delta.delta.content);
-                            }
-                            break;
-                        case 'tool-call-start':
-                            // Handle tool call UI update
-                            if (event.toolCall) {
-                                // Tool calls are handled by the tool executor
-                                console.log('[useChat] Tool call started:', event.toolCall);
-                            }
-                            break;
-                        case 'error':
-                            if (event.error) {
-                                setError(event.error);
-                            }
-                            break;
+                    if (event.type === 'content-delta' &&
+                        event.delta?.delta.content) {
+                        reduce([
+                            {
+                                type: 'TEXT_MESSAGE_CONTENT',
+                                messageId: answerId,
+                                delta: event.delta.delta.content,
+                            },
+                        ]);
+                    }
+                    else if (event.type === 'error' && event.error) {
+                        setError(event.error);
                     }
                 });
-                // Update final message with complete content and tool calls
-                const finalAssistantContent = typeof response.message.content === 'string'
-                    ? sanitizeAssistantContent(response.message.content)
-                    : response.message.content;
-                updateMessage(assistantMessageId, {
-                    content: finalAssistantContent,
-                    toolCalls: response.message.toolCalls,
-                });
-                // Handle tool calls if present
-                if (response.message.toolCalls &&
-                    response.message.toolCalls.length > 0) {
-                    // Tool calls are executed by the tool executor if configured
-                    if (toolExecutor) {
-                        for (const toolCall of response.message.toolCalls) {
-                            await toolExecutor.execute({
-                                toolCallId: toolCall.toolCallId,
-                                toolName: toolCall.toolName,
-                                args: toolCall.args,
-                            });
-                        }
+                // The answer as the provider gave it whole, then the run's end.
+                const said = conversationEventsOf({
+                    type: 'message',
+                    message: {
+                        id: answerId,
+                        role: 'assistant',
+                        content: typeof response.message.content === 'string'
+                            ? response.message.content
+                            : '',
+                    },
+                }, conversation);
+                reduce([...said, { type: 'RUN_FINISHED' }]);
+                // The page's tools run the calls it asked for.
+                if (toolExecutor && response.message.toolCalls?.length) {
+                    for (const toolCall of response.message.toolCalls) {
+                        await toolExecutor.execute({
+                            toolCallId: toolCall.toolCallId,
+                            toolName: toolCall.toolName,
+                            args: toolCall.args,
+                        });
                     }
                 }
             }
@@ -293,12 +261,10 @@ export function useChat() {
         protocolAdapter,
         toolExecutor,
         messages,
-        addMessage,
-        updateMessage,
+        setMessages,
         setLoading,
         setError,
         startStreaming,
-        appendToStream,
         stopStreaming,
         getTools,
     ]);

package/lib/portable/activity.d.ts

@@ -0,0 +1,78 @@
+export type RecordKind = 'session'
+/** A run began: in progress until it answers (R-15). Not a step. */
+ | 'run' | 'tool_call' | 'decision' | 'check' | 'approval' | 'output' | 'feedback'
+/** A turn of a conversation: what was asked, what it answered (V-16). */
+ | 'turn'
+/** What it did, step by step (P-16); a harness's session, turn and plan events (SHIELD §6.4). */
+ | 'step'
+/** What one of its channels was sent, or why not: `{channel, event, delivery, detail}` (R-37). */
+ | 'notification';
+/** One entry of an application's record. */
+export type RecordEntry = {
+    uid: string;
+    appUid: string;
+    sessionUid: string;
+    deploymentUid: string;
+    version: number;
+    kind: RecordKind;
+    summary: string;
+    payload: Record<string, unknown>;
+    createdAt: string;
+    /** `test` for a session its tests ran (the Evals engine's); empty for real use. */
+    purpose: string;
+};
+/** An entry as ai-agents answers with it. */
+export declare function entryOf(raw: Record<string, unknown>): RecordEntry;
+/** How the run an entry ends ended: `answered`, `stopped`, `gone`; `''` for any other entry. */
+export declare function runEndOf(entry: RecordEntry): string;
+/** An entry in words: its summary, or how its run ended when its words are not kept. */
+export declare function entrySaid(entry: RecordEntry): string;
+/** A session in a sentence: how many calls, what stopped it, how it ended. */
+export declare function sessionSentence(entries: readonly RecordEntry[]): string;
+/** A run its schedule plans, as the scheduler says (R-15). */
+export type ScheduledRun = {
+    deploymentUid: string;
+    appUid: string;
+    version: number;
+    /** Which of its triggers, by position in its Appspec. */
+    position: number;
+    cron: string;
+    description: string;
+    /** When it runs next; empty when the scheduler does not say. */
+    nextAt: string;
+};
+/** What an application, or all of a person's, is doing (R-15): real use only, its tests read apart. */
+export type AppActivity = {
+    /** Sessions whose latest run has not answered yet, newest first: their run's start. */
+    inProgress: RecordEntry[];
+    /** Its live deployments' next runs, soonest first. */
+    scheduled: ScheduledRun[];
+    /** Why its schedules could not be read; empty when they were. */
+    scheduledProblem: string;
+    /** Its other sessions, newest first: their opening entries. */
+    completed: RecordEntry[];
+    /** The offset of the next page of completed sessions; `null` after the last. */
+    nextOffset: number | null;
+};
+/** `/apps/activity`'s answer, read. */
+export declare function activityOf(body: Record<string, unknown>): AppActivity;
+/** Pages as one: in progress and scheduled from the first, completed from all, the last page's next offset. */
+export declare function mergeActivityPages(pages: readonly AppActivity[]): AppActivity;
+/** What Activity says, on every client (checked against the vocabulary). */
+export declare const ACTIVITY_WORDS: {
+    readonly inProgress: "In progress";
+    readonly scheduled: "Scheduled";
+    readonly completed: "Completed";
+    readonly working: "Working since";
+    readonly next: "next";
+    readonly wakes: "It also starts on its own when something happens:";
+    readonly nothing: "Nothing yet.";
+};
+/** What happens that starts it on its own, in words (LOOP W-03): its event triggers. */
+export declare const wakesOn: (triggers: ReadonlyArray<{
+    type: string;
+    event?: string;
+    description?: string;
+}> | undefined) => string[];
+/** A scheduled run in words: what it does, and on which version. */
+export declare const scheduledSays: (run: ScheduledRun) => string;

package/lib/portable/activity.js

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * What an application is doing (LOOP R-15), as ai-agents answers
+ * `/api/ai-agents/v1/apps/activity`, and its record's entries
+ * (`/apps/sessions`, `/apps/records`): read and said the same by the Studio
+ * and Datalayer Mobile (MOBILE M-015b). Pure: each client fetches with its own
+ * authentication and hands the body here.
+ *
+ * @module portable/activity
+ */
+import { RUN_END_WORDS } from './records';
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+const records = (value) => Array.isArray(value) ? value.filter(isRecord) : [];
+const said = (value) => typeof value === 'string' ? value : value == null ? '' : String(value);
+/** An entry as ai-agents answers with it. */
+export function entryOf(raw) {
+    return {
+        uid: said(raw.uid),
+        appUid: said(raw.app_uid),
+        sessionUid: said(raw.session_uid),
+        deploymentUid: said(raw.deployment_uid),
+        version: Number(raw.version) || 0,
+        kind: (said(raw.kind) || 'output'),
+        summary: said(raw.summary),
+        payload: isRecord(raw.payload) ? raw.payload : {},
+        createdAt: said(raw.created_at),
+        purpose: said(raw.purpose),
+    };
+}
+/** How the run an entry ends ended: `answered`, `stopped`, `gone`; `''` for any other entry. */
+export function runEndOf(entry) {
+    const status = entry.kind === 'output' ? entry.payload.status : undefined;
+    return typeof status === 'string' && status in RUN_END_WORDS ? status : '';
+}
+/** An entry in words: its summary, or how its run ended when its words are not kept. */
+export function entrySaid(entry) {
+    return entry.summary || RUN_END_WORDS[runEndOf(entry)] || '';
+}
+const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
+/** A session in a sentence: how many calls, what stopped it, how it ended. */
+export function sessionSentence(entries) {
+    const calls = entries.filter(entry => entry.kind === 'tool_call').length;
+    const checks = entries.filter(entry => entry.kind === 'check');
+    const ends = entries.map(runEndOf).filter(Boolean);
+    const answers = ends.filter(end => end === 'answered').length;
+    const parts = [];
+    parts.push(calls === 0 ? 'No tool called' : plural(calls, 'tool call'));
+    if (checks.length) {
+        parts.push(`${plural(checks.length, 'step')} a check did not let pass`);
+    }
+    const unsent = entries.filter(entry => entry.kind === 'notification' && entry.payload.delivery !== 'sent');
+    if (unsent.length) {
+        parts.push(`${plural(unsent.length, 'notification')} not sent`);
+    }
+    if (ends[ends.length - 1] === 'stopped') {
+        parts.push('stopped');
+    }
+    else if (answers) {
+        parts.push(plural(answers, 'answer'));
+    }
+    return `${parts.join(', ')}.`;
+}
+/** `/apps/activity`'s answer, read. */
+export function activityOf(body) {
+    return {
+        inProgress: records(body.in_progress).map(entryOf),
+        scheduled: records(body.scheduled).map(raw => ({
+            deploymentUid: said(raw.deployment_uid),
+            appUid: said(raw.app_uid),
+            version: Number(raw.version) || 0,
+            position: Number(raw.position) || 0,
+            cron: said(raw.cron),
+            description: said(raw.description),
+            nextAt: said(raw.next_at),
+        })),
+        scheduledProblem: said(body.scheduled_problem),
+        completed: records(body.completed).map(entryOf),
+        nextOffset: typeof body.next_offset === 'number' ? body.next_offset : null,
+    };
+}
+/** Pages as one: in progress and scheduled from the first, completed from all, the last page's next offset. */
+export function mergeActivityPages(pages) {
+    const [first] = pages;
+    if (!first) {
+        return {
+            inProgress: [],
+            scheduled: [],
+            scheduledProblem: '',
+            completed: [],
+            nextOffset: null,
+        };
+    }
+    const seen = new Set();
+    const completed = pages
+        .flatMap(page => page.completed)
+        .filter(entry => {
+        const key = entry.uid || entry.sessionUid;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+    return {
+        ...first,
+        completed,
+        nextOffset: pages[pages.length - 1].nextOffset,
+    };
+}
+/** What Activity says, on every client (checked against the vocabulary). */
+export const ACTIVITY_WORDS = {
+    inProgress: 'In progress',
+    scheduled: 'Scheduled',
+    completed: 'Completed',
+    working: 'Working since',
+    next: 'next',
+    wakes: 'It also starts on its own when something happens:',
+    nothing: 'Nothing yet.',
+};
+/** What happens that starts it on its own, in words (LOOP W-03): its event triggers. */
+export const wakesOn = (triggers) => (triggers ?? [])
+    .filter(trigger => trigger.type === 'event' && (trigger.description || trigger.event))
+    .map(trigger => trigger.description ||
+    `When ${String(trigger.event).replace(/_/g, ' ')}`);
+/** A scheduled run in words: what it does, and on which version. */
+export const scheduledSays = (run) => `${run.description || 'Its schedule'} (${run.cron}) · version ${run.version}`;

package/lib/portable/fixtures.d.ts

@@ -18,3 +18,10 @@ export declare function shieldDisplayFixtures(): {
     terminal: Record<string, unknown>;
 };
 export declare function conversationFixture(): ConversationState;
+/**
+ * `GET /api/ai-agents/v1/apps/activity`'s answer for one application: a
+ * session in progress, a scheduled run, a completed one ended by Stop, and a
+ * next page — what the Studio's Activity and the phone's read alike (MOBILE
+ * M-015b).
+ */
+export declare function activityFixture(): Record<string, unknown>;

package/lib/portable/fixtures.js

@@ -118,3 +118,53 @@ export function conversationFixture() {
         dropped: 3,
     };
 }
+/**
+ * `GET /api/ai-agents/v1/apps/activity`'s answer for one application: a
+ * session in progress, a scheduled run, a completed one ended by Stop, and a
+ * next page — what the Studio's Activity and the phone's read alike (MOBILE
+ * M-015b).
+ */
+export function activityFixture() {
+    return {
+        success: true,
+        in_progress: [
+            {
+                uid: 'e-run',
+                app_uid: 'app-1',
+                session_uid: 's-2',
+                deployment_uid: 'd-1',
+                version: 3,
+                kind: 'run',
+                summary: 'Triage the inbox',
+                payload: {},
+                created_at: '2026-10-16T08:00:00Z',
+            },
+        ],
+        scheduled: [
+            {
+                deployment_uid: 'd-1',
+                app_uid: 'app-1',
+                version: 3,
+                position: 0,
+                cron: '0 8 * * 1-5',
+                description: 'Every weekday morning',
+                next_at: '2026-10-17T08:00:00Z',
+            },
+        ],
+        scheduled_problem: '',
+        completed: [
+            {
+                uid: 'e-out',
+                app_uid: 'app-1',
+                session_uid: 's-1',
+                deployment_uid: 'd-1',
+                version: 3,
+                kind: 'output',
+                summary: '',
+                payload: { status: 'stopped' },
+                created_at: '2026-10-15T08:00:00Z',
+            },
+        ],
+        next_offset: 20,
+    };
+}

package/lib/portable/index.d.ts

@@ -16,7 +16,7 @@ export { BROWSER_LIMITS, CUT_MARK, DEVICE_LIMITS, DIAGNOSTIC_LIMIT, emptyConvers
 export { conversationEventsOf, sanitizeAssistantContent, snapshotOfMessages, type AdapterEvent, type SaidMessage, } from './adapterEvents';
 export { PRESENCE_LINES, presenceOfConversation, presenceState, presenceToolOf, type PresenceState, type PresenceTool, } from './presence';
 export { ANSWER_BELOW, ANSWER_COMPLETE, composerOf, droppedWords, ENDED_WORDS, messageLabel, OPENING_WORDS, presenceLine, showsQuestion, stepLine, TOOL_STATUS_WORDS, toolLabel, type ComposerProps, type ComposerState, type ConversationViewProps, type ErrorItem, type ErrorRowProps, type MessageItem, type MessageRowProps, type PresenceLineProps, type ProtocolDisplayProps, type QuestionCardProps, type StepItem, type StepRowProps, type ToolItem, type ToolRowProps, type TurnEndItem, type TurnEndRowProps, } from './views';
-export { conversationFixture } from './fixtures';
+export { activityFixture, conversationFixture } from './fixtures';
 export { DISPLAY_META_KEY, displayLine, displayOfToolResult, PAP_CONFIRM_TYPE, PAP_HANDOFF_TOOL, PAP_OUTCOME_TYPE, PAP_REPLIES_TYPE, PAP_SIGN_IN_TYPE, protocolDisplayOf, replyAuthor, type ActionClass, type ProtocolDisplay, DIFF_LINES_LIMIT, SHIELD_DIFF_TYPE, SHIELD_TERMINAL_TYPE, languageOf, unifiedDiffLines, unifiedDiffText, type DiffLine, } from './displays';
 export { shieldDisplayFixtures } from './fixtures';
 export { isPapSignInTool, PAP_SIGN_IN_WORDS, readPapSignIn, safeSignInUrl, type PapSignInWaiting, } from './signIn';
@@ -24,5 +24,8 @@ export { DIRECT_MAX, DIRECT_WORDS, directAnswerOf, directAuthor, directClient, o
 export { SIGN_IN_POLL_MS, SIGN_IN_STATUS_PATH, signInStandsOf, signInStatusClient, type SignInStands, } from './signInStatus';
 export { emptyFields, fieldProblems, MAX_VALUE_LENGTH, PROTECTED_INPUT_WORDS, protectedInputClient, protectedRequestOf, ProtectedRequestGone, sentWords, submitBody, submitWords, ticketComplete, ticketOfPage, type ProtectedField, type ProtectedRequest, } from './protectedInput';
 export { failureOf, otlpMetricsOf, RunMeter, type RunMeasure, type StreamFailure, } from './runMeasures';
+export { ACTIVITY_WORDS, activityOf, entryOf, entrySaid, mergeActivityPages, runEndOf, scheduledSays, sessionSentence, wakesOn, type AppActivity, type RecordEntry, type RecordKind, type ScheduledRun, } from './activity';
+export { deploymentEventLine, deploymentEventOf, notDeletedOf, resetBody, resetCountsOf, resetLines, stateChangeBody, stoppedWorkLine, stoppedWorkOf, type DeploymentEvent, type DeploymentEventKind, type DeploymentState, type ResetCounts, type StoppedWork, } from './lifecycle';
+export { agentRuntimesOf, agentSummaryOfRuntime, CREATING_STATUSES, isAgentRuntime, isCreatingAgent, runtimeOf, type AgentRuntime, type AgentSummaryData, } from './runtimes';
 export { agentRunClient, agentRuntimesUrlOf, appSessionsClient, RuntimeRefusal, type AgentRunClient, type AgentTurn, type AppSessionsClient, type RuntimeClientOptions, type SessionStart, type StreamOptions, } from './sessions';
 export type { ChatMessage } from '../types/messages';