@datalayer/agent-runtimes 1.5.26 → 1.5.28

package/lib/portable/conversation.js

@@ -3,24 +3,35 @@
  * Distributed under the terms of the Modified BSD License.
  */
 /**
- * A conversation as a run stream builds it, for a client that draws it
- * natively (Datalayer Mobile): one pure reducer over the AG-UI events of an
- * application's session or an agent's run, and the person's own actions.
+ * A conversation as a run stream builds it, for every client that draws one:
+ * the web chat (`ChatBase`) and Datalayer Mobile. One pure reducer over the
+ * AG-UI events of an application's session or an agent's run, the events
+ * every other protocol adapter is normalised into (`portable/adapterEvents`),
+ * and the person's own actions.
  *
- * It reads the stream as the web chat reads it — `TEXT_MESSAGE_*` into one
+ * It reads the stream as the chat reads it — `TEXT_MESSAGE_*` into one
  * message streamed in place, `TOOL_CALL_*` into a collapsed row whose result
  * is read by `toolResultOf`, `STEP_*` into a step row, a `MESSAGES_SNAPSHOT`
- * through `messagesOfThread`, a `reactor.ui` op on the run refused — and adds
- * what a session says besides: `loop.session`, the question its application
- * asks (`RUN_FINISHED` with `result.asking`, LOOP `loop.ask`), and a turn
- * that ended without words said by how it ended (`answered`, `stopped`,
- * `gone`).
+ * (its tool calls and their results too) through `messagesOfThread`, a
+ * `reactor.ui` op on the run refused — and adds what a session says besides:
+ * `loop.session`, the question its application asks (`RUN_FINISHED` with
+ * `result.asking`, LOOP `loop.ask`), and a turn that ended without words said
+ * by how it ended (`answered`, `stopped`, `gone`).
+ *
+ * An adapter that tells a message or a tool call whole rather than by its
+ * deltas — A2A, Vercel AI, ACP, the in-page agent, and the web's AG-UI
+ * adapter, which accumulates — says it with three events of this reducer's
+ * own, never AG-UI's: `MESSAGE_SAID` (a message's words so far),
+ * `TOOL_CALL_SAID` (a call's arguments as an object) and `TOOL_CALL_DONE`
+ * (its result as a value). They are refused when malformed.
  *
  * Bounded: a long tool run cannot grow it without end. Each tool's arguments
- * and result keep their first `TOOL_TEXT_LIMIT` characters, an answer its
- * first `MESSAGE_TEXT_LIMIT`, the conversation its last `ITEM_LIMIT` rows
- * (`dropped` counts the rest), and an event it does not draw is kept only as
- * its type and name, the last `DIAGNOSTIC_LIMIT` of them — never its payload.
+ * and result keep their first `limits.toolText` characters (their values only
+ * when kept whole), an answer its first `limits.messageText`, the
+ * conversation its last `limits.items` rows (`dropped` counts the rest), and
+ * an event it does not draw is kept only as its type and name, the last
+ * `limits.diagnostics` of them — never its payload. A phone keeps
+ * `DEVICE_LIMITS`, a browser `BROWSER_LIMITS`.
  *
  * @module portable/conversation
  */
@@ -28,26 +39,48 @@ import { REACTOR_UI_NAME, toolResultOf, UI_ON_RUN, } from './agui';
 import { displayOfToolResult } from './displays';
 import { RUN_END_WORDS } from './records';
 import { messagesOfThread } from './thread';
-/** How many rows a conversation keeps: its newest. */
+/** How many rows a conversation on a phone keeps: its newest. */
 export const ITEM_LIMIT = 400;
-/** How many characters of an answer are kept. */
+/** How many characters of an answer a phone keeps. */
 export const MESSAGE_TEXT_LIMIT = 100_000;
-/** How many characters of a tool's arguments, and of its result, are kept. */
+/** How many characters of a tool's arguments, and of its result, a phone keeps. */
 export const TOOL_TEXT_LIMIT = 4_000;
 /** How many events it does not draw are kept, by type and name. */
 export const DIAGNOSTIC_LIMIT = 50;
+/** A phone's bounds (Datalayer Mobile). */
+export const DEVICE_LIMITS = {
+    items: ITEM_LIMIT,
+    messageText: MESSAGE_TEXT_LIMIT,
+    toolText: TOOL_TEXT_LIMIT,
+    diagnostics: DIAGNOSTIC_LIMIT,
+};
+/** A browser's bounds (the web chat): a long working session, still bounded. */
+export const BROWSER_LIMITS = {
+    items: 5_000,
+    messageText: 1_000_000,
+    toolText: 1_000_000,
+    diagnostics: DIAGNOSTIC_LIMIT,
+};
 /** What is said after a text cut at its limit. */
 export const CUT_MARK = '… (cut: too long to keep on this device)';
-/** A conversation with nothing in it yet. */
-export const emptyConversation = () => ({
-    items: [],
-    running: false,
-    session: null,
-    asking: null,
-    dropped: 0,
-    diagnostics: [],
-    turnRows: 0,
-});
+/** A conversation with nothing in it yet, kept within `limits` (a phone's by default). */
+export const emptyConversation = (limits = DEVICE_LIMITS) => {
+    for (const [name, bound] of Object.entries(limits)) {
+        if (!Number.isInteger(bound) || bound < 1) {
+            throw new Error(`A conversation's ${name} bound is ${String(bound)}: give a whole number of at least 1.`);
+        }
+    }
+    return {
+        items: [],
+        running: false,
+        session: null,
+        asking: null,
+        dropped: 0,
+        diagnostics: [],
+        turnRows: 0,
+        limits,
+    };
+};
 const text = (value) => typeof value === 'string' ? value : '';
 const cut = (value, limit) => value.length > limit ? `${value.slice(0, limit)}${CUT_MARK}` : value;
 /** Text appended to what is kept, never past its limit. */
@@ -57,12 +90,10 @@ const appended = (kept, delta, limit) => {
     }
     return cut(kept + delta, limit);
 };
+const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
 /** A result as the model read it: the page's `_meta` (its display) is the card's, not words. */
 function withoutMeta(result) {
-    if (result &&
-        typeof result === 'object' &&
-        !Array.isArray(result) &&
-        '_meta' in result) {
+    if (isRecord(result) && '_meta' in result) {
         const { _meta: _page, ...view } = result;
         return view;
     }
@@ -96,14 +127,12 @@ export function questionOf(raw) {
         kind,
         prompt: text(asked.prompt),
         options: strings(asked.options),
-        schema: schema && typeof schema === 'object' && !Array.isArray(schema)
-            ? schema
-            : null,
+        schema: isRecord(schema) ? schema : null,
         accept: strings(asked.accept),
     };
 }
 function withItems(state, items, added = 0) {
-    const over = items.length - ITEM_LIMIT;
+    const over = items.length - state.limits.items;
     return {
         ...state,
         items: over > 0 ? items.slice(over) : items,
@@ -127,11 +156,151 @@ function noted(state, event) {
     };
     return {
         ...state,
-        diagnostics: [...state.diagnostics, entry].slice(-DIAGNOSTIC_LIMIT),
+        diagnostics: [...state.diagnostics, entry].slice(-state.limits.diagnostics),
     };
 }
 let rowCount = 0;
 const rowId = (prefix) => `${prefix}-${Date.now().toString(36)}-${(rowCount += 1)}`;
+/** A tool call just begun: running, nothing said of it yet. */
+function toolRow(id, name) {
+    return {
+        kind: 'tool',
+        id,
+        name,
+        args: '',
+        input: null,
+        status: 'running',
+        awaiting: null,
+        result: '',
+        value: undefined,
+        error: '',
+        executionError: '',
+        codeError: null,
+        exitCode: null,
+        display: null,
+    };
+}
+/** Its arguments kept: their words cut at the limit, the object only when kept whole. */
+function withInput(item, input, limit) {
+    const words = JSON.stringify(input);
+    const whole = words.length <= limit;
+    return { ...item, args: cut(words, limit), input: whole ? input : null };
+}
+/** A human-in-the-loop call: its arguments are steps the person confirms. */
+const asksThePerson = (input) => !!input && Array.isArray(input.steps);
+/**
+ * A tool call with its result: failed when the protocol, its sandbox, its
+ * code or its exit code says so; still running when it waits on an approval
+ * (`pending_approval`) or on the person (its steps). A result read from a
+ * conversation's past is its outcome only: nothing waits there any more.
+ */
+function withResult(item, result, limit, past = false) {
+    const given = result.result;
+    const words = said(withoutMeta(given));
+    const record = isRecord(given) ? given : null;
+    const executionError = typeof record?.execution_error === 'string' ? record.execution_error : '';
+    const raised = isRecord(record?.code_error) ? record.code_error : null;
+    const codeError = raised
+        ? {
+            name: text(raised.name) || 'Error',
+            value: text(raised.value) || 'Unknown error',
+            traceback: cut(text(raised.traceback), limit),
+        }
+        : null;
+    const exitCode = record && typeof record.exit_code === 'number' ? record.exit_code : null;
+    const failed = !result.success ||
+        executionError !== '' ||
+        codeError !== null ||
+        (exitCode !== null && exitCode !== 0) ||
+        record?.execution_ok === false;
+    const awaiting = failed || past
+        ? null
+        : record?.pending_approval === true
+            ? 'approval'
+            : asksThePerson(item.input)
+                ? 'person'
+                : null;
+    return {
+        ...item,
+        status: failed ? 'error' : awaiting ? 'running' : 'complete',
+        awaiting,
+        result: cut(words, limit),
+        value: words.length <= limit ? given : undefined,
+        error: result.error ?? '',
+        executionError: cut(executionError, limit),
+        codeError,
+        exitCode,
+        display: displayOfToolResult(item.name, given, item.id),
+    };
+}
+/** The rows a conversation said again holds: its messages, and its tool calls with their results. */
+function rowsOfSnapshot(messages, limits, unread) {
+    if (!Array.isArray(messages)) {
+        throw new Error('A messages snapshot carries no list of messages.');
+    }
+    const rows = [];
+    const tools = new Map();
+    for (const message of messages) {
+        for (const drawn of messagesOfThread([message])) {
+            rows.push({
+                kind: 'message',
+                id: drawn.id,
+                role: drawn.role === 'user' ? 'user' : 'assistant',
+                text: cut(typeof drawn.content === 'string' ? drawn.content : '', limits.messageText),
+                streaming: false,
+            });
+        }
+        if (!isRecord(message)) {
+            continue;
+        }
+        if (message.role === 'assistant' && message.toolCalls !== undefined) {
+            if (!Array.isArray(message.toolCalls)) {
+                throw new Error(`Message ${String(message.id)}'s tool calls are not a list.`);
+            }
+            for (const call of message.toolCalls) {
+                const fn = isRecord(call) ? call.function : undefined;
+                if (!isRecord(call) || typeof call.id !== 'string' || !isRecord(fn)) {
+                    throw new Error(`Message ${String(message.id)} holds a tool call without its id and function.`);
+                }
+                const argsWords = text(fn.arguments);
+                let input = null;
+                if (argsWords && argsWords.length <= limits.toolText) {
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(argsWords);
+                    }
+                    catch {
+                        parsed = undefined;
+                    }
+                    if (!isRecord(parsed)) {
+                        throw new Error(`Tool call ${call.id}'s arguments are not a JSON object.`);
+                    }
+                    input = parsed;
+                }
+                tools.set(call.id, rows.length);
+                rows.push({
+                    ...toolRow(call.id, text(fn.name)),
+                    args: cut(argsWords, limits.toolText),
+                    input: argsWords ? input : {},
+                    // Said again from the past: it ended, as its result says.
+                    status: 'complete',
+                });
+            }
+        }
+        if (message.role === 'tool') {
+            const id = text(message.toolCallId);
+            const at = tools.get(id);
+            if (at === undefined) {
+                // A result whose call the snapshot does not carry (a client that
+                // reads words only): kept as the unread events are, by name.
+                unread.push(id || 'no call');
+                continue;
+            }
+            rows[at] = withResult(rows[at], toolResultOf(message.content), limits.toolText, true);
+        }
+    }
+    return rows;
+}
 /** The person's prompt, added before it is sent: its own row. */
 export function withPrompt(state, id, words) {
     return withItems({ ...state, asking: null }, [
@@ -139,6 +308,14 @@ export function withPrompt(state, id, words) {
         { kind: 'message', id, role: 'user', text: words, streaming: false },
     ]);
 }
+/**
+ * The conversation without some of its rows: those the person removed (a
+ * turn taken away), or a message its application took back.
+ */
+export function withoutItems(state, ids) {
+    const drop = new Set(ids);
+    return { ...state, items: state.items.filter(item => !drop.has(item.id)) };
+}
 /**
  * The turn ended without the stream saying so: the person stopped it
  * (`stopped`), or its client went before the answer (`gone`). What streamed
@@ -148,7 +325,12 @@ export function withTurnEnded(state, end) {
     const items = state.items.map(item => item.kind === 'message' && item.streaming
         ? { ...item, streaming: false }
         : item.kind === 'tool' && item.status === 'running'
-            ? { ...item, status: 'error', error: RUN_END_WORDS[end] }
+            ? {
+                ...item,
+                status: 'error',
+                awaiting: null,
+                error: RUN_END_WORDS[end],
+            }
             : item.kind === 'step' && item.status === 'running'
                 ? { ...item, status: 'complete' }
                 : item);
@@ -163,7 +345,7 @@ export function withError(state, words) {
     const items = state.items.map(item => item.kind === 'message' && item.streaming
         ? { ...item, streaming: false }
         : item.kind === 'tool' && item.status === 'running'
-            ? { ...item, status: 'error' }
+            ? { ...item, status: 'error', awaiting: null }
             : item.kind === 'step' && item.status === 'running'
                 ? { ...item, status: 'complete' }
                 : item);
@@ -172,8 +354,17 @@ export function withError(state, words) {
         { kind: 'error', id: rowId('error'), text: words },
     ]);
 }
+/** The string field an event must carry, or a refusal that names it. */
+function required(event, field) {
+    const value = event[field];
+    if (typeof value !== 'string' || !value) {
+        throw new Error(`${event.type} carries no ${field}.`);
+    }
+    return value;
+}
 /** A conversation with one more event of its stream. */
 export function reduceConversation(state, event) {
+    const { limits } = state;
     switch (event.type) {
         case 'RUN_STARTED':
             return { ...state, running: true, asking: null, turnRows: 0 };
@@ -193,7 +384,7 @@ export function reduceConversation(state, event) {
             const delta = text(event.delta);
             const id = text(event.messageId);
             const grown = changed(state, id, item => item.kind === 'message'
-                ? { ...item, text: appended(item.text, delta, MESSAGE_TEXT_LIMIT) }
+                ? { ...item, text: appended(item.text, delta, limits.messageText) }
                 : item);
             if (grown) {
                 return grown;
@@ -204,13 +395,37 @@ export function reduceConversation(state, event) {
                     kind: 'message',
                     id: id || rowId('message'),
                     role: event.role === 'user' ? 'user' : 'assistant',
-                    text: cut(delta, MESSAGE_TEXT_LIMIT),
+                    text: cut(delta, limits.messageText),
                     streaming: event.type === 'TEXT_MESSAGE_CONTENT',
                 },
             ], 1);
         }
         case 'TEXT_MESSAGE_END':
             return (changed(state, text(event.messageId), item => item.kind === 'message' ? { ...item, streaming: false } : item) ?? state);
+        case 'MESSAGE_SAID': {
+            // A message told whole so far, by an adapter that accumulates it.
+            const id = required(event, 'messageId');
+            if (typeof event.text !== 'string') {
+                throw new Error(`MESSAGE_SAID of ${id} carries no text.`);
+            }
+            if (event.role !== 'user' && event.role !== 'assistant') {
+                throw new Error(`MESSAGE_SAID of ${id} is said by ${String(event.role)}: only the person or the assistant speaks here.`);
+            }
+            const role = event.role;
+            const words = cut(event.text, limits.messageText);
+            const streaming = role === 'assistant' && event.streaming !== false;
+            const at = state.items.findIndex(item => item.id === id);
+            if (at >= 0) {
+                const kept = state.items[at];
+                if (kept.kind !== 'message') {
+                    throw new Error(`MESSAGE_SAID of ${id} names a ${kept.kind} row.`);
+                }
+                const items = state.items.slice();
+                items[at] = { ...kept, text: words, streaming };
+                return { ...state, items };
+            }
+            return withItems(state, [...state.items, { kind: 'message', id, role, text: words, streaming }], 1);
+        }
         case 'TOOL_CALL_START': {
             const id = text(event.toolCallId) || rowId('tool');
             if (state.items.some(item => item.id === id)) {
@@ -218,37 +433,88 @@ export function reduceConversation(state, event) {
             }
             return withItems(state, [
                 ...state.items,
-                {
-                    kind: 'tool',
-                    id,
-                    name: text(event.toolCallName) || text(event.name),
-                    args: '',
-                    status: 'running',
-                    result: '',
-                    error: '',
-                    display: null,
-                },
+                toolRow(id, text(event.toolCallName) || text(event.name)),
             ], 1);
         }
         case 'TOOL_CALL_ARGS':
             return (changed(state, text(event.toolCallId), item => item.kind === 'tool'
                 ? {
                     ...item,
-                    args: appended(item.args, text(event.delta), TOOL_TEXT_LIMIT),
+                    args: appended(item.args, text(event.delta), limits.toolText),
                 }
                 : item) ?? state);
         case 'TOOL_CALL_END':
-            return state;
+            // Its arguments are whole: read them, unless they were cut.
+            return (changed(state, text(event.toolCallId), item => {
+                if (item.kind !== 'tool' || item.args.endsWith(CUT_MARK)) {
+                    return item;
+                }
+                if (!item.args) {
+                    return { ...item, input: {} };
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse(item.args);
+                }
+                catch {
+                    parsed = undefined;
+                }
+                if (!isRecord(parsed)) {
+                    return {
+                        ...item,
+                        status: 'error',
+                        awaiting: null,
+                        error: 'Its arguments are not a JSON object.',
+                    };
+                }
+                return { ...item, input: parsed };
+            }) ?? state);
+        case 'TOOL_CALL_SAID': {
+            // A call's arguments told whole, by an adapter that parsed them.
+            const id = required(event, 'toolCallId');
+            const name = required(event, 'toolCallName');
+            if (!isRecord(event.args)) {
+                throw new Error(`TOOL_CALL_SAID of ${id} carries arguments that are not an object.`);
+            }
+            const args = event.args;
+            const at = state.items.findIndex(item => item.id === id);
+            if (at < 0) {
+                return withItems(state, [...state.items, withInput(toolRow(id, name), args, limits.toolText)], 1);
+            }
+            const kept = state.items[at];
+            if (kept.kind !== 'tool') {
+                throw new Error(`TOOL_CALL_SAID of ${id} names a ${kept.kind} row.`);
+            }
+            const items = state.items.slice();
+            items[at] = withInput(kept, { ...(kept.input ?? {}), ...args }, limits.toolText);
+            return { ...state, items };
+        }
         case 'TOOL_CALL_RESULT': {
             const result = toolResultOf(event.content);
             return (changed(state, text(event.toolCallId), item => item.kind === 'tool'
-                ? {
-                    ...item,
-                    status: result.success ? 'complete' : 'error',
-                    result: cut(said(withoutMeta(result.result)), TOOL_TEXT_LIMIT),
-                    error: result.error ?? '',
-                    display: displayOfToolResult(item.name, result.result, item.id),
-                }
+                ? withResult(item, result, limits.toolText)
+                : item) ?? noted(state, event));
+        }
+        case 'TOOL_CALL_DONE': {
+            // A call's result as a value, by an adapter (or the page) that has it;
+            // `answered` when it is the person's answer.
+            const id = required(event, 'toolCallId');
+            if (typeof event.success !== 'boolean') {
+                throw new Error(`TOOL_CALL_DONE of ${id} does not say whether it succeeded.`);
+            }
+            if (event.error !== undefined && typeof event.error !== 'string') {
+                throw new Error(`TOOL_CALL_DONE of ${id} says its error in no words.`);
+            }
+            const result = {
+                result: event.result,
+                success: event.success,
+                ...(event.error !== undefined ? { error: event.error } : {}),
+            };
+            return (changed(state, id, item => item.kind === 'tool'
+                ? withResult(item, result, limits.toolText, 
+                // The person's own answer (an approval decided, steps
+                // confirmed): nothing waits after it.
+                event.answered === true)
                 : item) ?? noted(state, event));
         }
         case 'STEP_STARTED': {
@@ -277,27 +543,19 @@ export function reduceConversation(state, event) {
             return { ...state, items };
         }
         case 'MESSAGES_SNAPSHOT': {
-            const messages = messagesOfThread(event.messages);
-            return withItems({ ...state, dropped: 0 }, messages.map(message => ({
-                kind: 'message',
-                id: message.id,
-                role: message.role === 'user'
-                    ? 'user'
-                    : 'assistant',
-                text: cut(typeof message.content === 'string' ? message.content : '', MESSAGE_TEXT_LIMIT),
-                streaming: false,
-            })), 
+            const unread = [];
+            const rows = rowsOfSnapshot(event.messages, limits, unread);
+            const restored = withItems({ ...state, dropped: 0 }, rows, 
             // The conversation said again is what this turn says (a resume):
             // never also said as a wordless answer.
             1);
+            return unread.reduce((kept, id) => noted(kept, { type: 'TOOL_CALL_RESULT', name: `${id} (no call)` }), restored);
         }
         case 'CUSTOM': {
             if (event.name === REACTOR_UI_NAME) {
                 return withError(state, UI_ON_RUN);
             }
-            if (event.name === 'loop.session' &&
-                event.value &&
-                typeof event.value === 'object') {
+            if (event.name === 'loop.session' && isRecord(event.value)) {
                 const session = event.value;
                 return {
                     ...state,
@@ -314,9 +572,7 @@ export function reduceConversation(state, event) {
             }
             return noted(state, event);
         case 'RUN_FINISHED': {
-            const result = event.result && typeof event.result === 'object'
-                ? event.result
-                : {};
+            const result = isRecord(event.result) ? event.result : {};
             const asking = questionOf(result.asking);
             const items = state.items.map(item => item.kind === 'message' && item.streaming
                 ? { ...item, streaming: false }

package/lib/portable/fixtures.js

@@ -29,9 +29,15 @@ export function conversationFixture() {
                 id: 't-1',
                 name: 'lookup_order',
                 args: '{"order":7}',
+                input: { order: 7 },
                 status: 'complete',
+                awaiting: null,
                 result: 'Shipped on Monday.',
+                value: 'Shipped on Monday.',
                 error: '',
+                executionError: '',
+                codeError: null,
+                exitCode: null,
                 display: null,
             },
             {
@@ -39,9 +45,15 @@ export function conversationFixture() {
                 id: 't-2',
                 name: 'send_mail',
                 args: '{}',
+                input: {},
                 status: 'error',
+                awaiting: null,
                 result: '',
+                value: undefined,
                 error: 'Refused by its rule.',
+                executionError: '',
+                codeError: null,
+                exitCode: null,
                 display: null,
             },
             {

package/lib/portable/index.d.ts

@@ -7,11 +7,13 @@
  * @module portable
  */
 export { messageOfApproval, normalizeApproval, whyAsked, type ApprovalArgs, type ApprovalRecord, type MessageAsked, } from './approvals';
+export { actionOf, APPROVAL_CARD_WORDS, approvalCardOf, argumentsShown, type ApprovalCard, type ApprovalCardProps, type ApprovalCardSource, } from './approvalCard';
 export { AgUiFrames, endsRun, eventsOfStream, NOT_STREAMING, REACTOR_UI_NAME, readRunStream, RUN_CUT_SHORT, toolResultOf, UI_ON_RUN, type AgUiEvent, type ToolResultSaid, } from './agui';
 export { AG_UI_NOT_ALLOWED, AG_UI_NOT_ON_RUNTIME, agUiRefusal, refusalBody, refusalDetail, } from './agUiRefusal';
 export { ASKED_FOR_TAG, askedOf, RUN_END_WORDS } from './records';
 export { messagesOfThread, openThread, snapshotOfStream, THREAD_WORDS, } from './thread';
-export { CUT_MARK, DIAGNOSTIC_LIMIT, emptyConversation, formFieldsOf, ITEM_LIMIT, MESSAGE_TEXT_LIMIT, questionOf, questionWords, reduceConversation, TOOL_TEXT_LIMIT, withError, withPrompt, withTurnEnded, type ConversationItem, type ConversationQuestion, type ConversationState, type TurnEnd, } from './conversation';
+export { BROWSER_LIMITS, CUT_MARK, DEVICE_LIMITS, DIAGNOSTIC_LIMIT, emptyConversation, formFieldsOf, ITEM_LIMIT, MESSAGE_TEXT_LIMIT, questionOf, questionWords, reduceConversation, TOOL_TEXT_LIMIT, withError, withoutItems, withPrompt, withTurnEnded, type ConversationItem, type ConversationLimits, type ConversationQuestion, type ConversationState, type ToolAwaiting, type ToolCodeError, type TurnEnd, } from './conversation';
+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';
@@ -20,5 +22,6 @@ export { isPapSignInTool, PAP_SIGN_IN_WORDS, readPapSignIn, safeSignInUrl, type
 export { DIRECT_MAX, DIRECT_WORDS, directAnswerOf, directAuthor, directClient, openDirect, withDirectAnswer, type DirectAnswer, type DirectClient, type DirectClientOptions, type DirectLine, type DirectOpen, type DirectReply, type DirectTarget, } from './direct';
 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 { agentRunClient, agentRuntimesUrlOf, appSessionsClient, RuntimeRefusal, type AgentRunClient, type AgentTurn, type AppSessionsClient, type RuntimeClientOptions, type SessionStart, type StreamOptions, } from './sessions';
 export type { ChatMessage } from '../types/messages';

package/lib/portable/index.js

@@ -11,6 +11,8 @@
  * @module portable
  */
 export { messageOfApproval, normalizeApproval, whyAsked, } from './approvals';
+// An approval as every card says it (MOBILE M-016).
+export { actionOf, APPROVAL_CARD_WORDS, approvalCardOf, argumentsShown, } from './approvalCard';
 // A run's stream, read as every client reads it.
 export { AgUiFrames, endsRun, eventsOfStream, NOT_STREAMING, REACTOR_UI_NAME, readRunStream, RUN_CUT_SHORT, toolResultOf, UI_ON_RUN, } from './agui';
 export { AG_UI_NOT_ALLOWED, AG_UI_NOT_ON_RUNTIME, agUiRefusal, refusalBody, refusalDetail, } from './agUiRefusal';
@@ -18,7 +20,9 @@ export { AG_UI_NOT_ALLOWED, AG_UI_NOT_ON_RUNTIME, agUiRefusal, refusalBody, refu
 export { ASKED_FOR_TAG, askedOf, RUN_END_WORDS } from './records';
 export { messagesOfThread, openThread, snapshotOfStream, THREAD_WORDS, } from './thread';
 // A conversation as its stream builds it, for a native client.
-export { CUT_MARK, DIAGNOSTIC_LIMIT, emptyConversation, formFieldsOf, ITEM_LIMIT, MESSAGE_TEXT_LIMIT, questionOf, questionWords, reduceConversation, TOOL_TEXT_LIMIT, withError, withPrompt, withTurnEnded, } from './conversation';
+export { BROWSER_LIMITS, CUT_MARK, DEVICE_LIMITS, DIAGNOSTIC_LIMIT, emptyConversation, formFieldsOf, ITEM_LIMIT, MESSAGE_TEXT_LIMIT, questionOf, questionWords, reduceConversation, TOOL_TEXT_LIMIT, withError, withoutItems, withPrompt, withTurnEnded, } from './conversation';
+// What every protocol adapter says, as the conversation reads it (M-030).
+export { conversationEventsOf, sanitizeAssistantContent, snapshotOfMessages, } from './adapterEvents';
 // What an application is doing, in the words beside its face (LOOP T-08).
 export { PRESENCE_LINES, presenceOfConversation, presenceState, presenceToolOf, } from './presence';
 // One contract for every renderer of a conversation's components.
@@ -33,5 +37,7 @@ export { DIRECT_MAX, DIRECT_WORDS, directAnswerOf, directAuthor, directClient, o
 export { SIGN_IN_POLL_MS, SIGN_IN_STATUS_PATH, signInStandsOf, signInStatusClient, } from './signInStatus';
 // What a company asks the person to type in a mediated sign-in, sent with its one-use ticket (MOBILE M-039).
 export { emptyFields, fieldProblems, MAX_VALUE_LENGTH, PROTECTED_INPUT_WORDS, protectedInputClient, protectedRequestOf, ProtectedRequestGone, sentWords, submitBody, submitWords, ticketComplete, ticketOfPage, } from './protectedInput';
+// How a streamed turn went, measured without its words (MOBILE M-036).
+export { failureOf, otlpMetricsOf, RunMeter, } from './runMeasures';
 // The runtime's routes a native client drives.
 export { agentRunClient, agentRuntimesUrlOf, appSessionsClient, RuntimeRefusal, } from './sessions';

package/lib/portable/presence.js

@@ -62,7 +62,10 @@ export function presenceOfConversation(state, paused = false) {
     for (let index = state.items.length - 1; index >= 0; index -= 1) {
         const item = state.items[index];
         if (item.kind === 'tool') {
-            tool = { open: item.status === 'running', pendingApproval: false };
+            tool = {
+                open: item.status === 'running',
+                pendingApproval: item.awaiting === 'approval',
+            };
             break;
         }
     }