@datalayer/agent-runtimes 1.5.21 → 1.5.22

package/lib/portable/agui.js

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** What the page says when a run's stream closes before the run said how it ended. */
+export const RUN_CUT_SHORT = 'The run stopped before it finished, without an answer or an error: send it again.';
+/**
+ * The name of `reactor.ui` (Reactor's `AGUI_NAME`): its ops come over the
+ * conversation's ui socket, never a run stream (REACTOR_UI RU-W). Held here
+ * so that a reader of a run needs no Reactor module; a test holds it to
+ * Reactor's.
+ */
+export const REACTOR_UI_NAME = 'reactor.ui';
+/** What the page says when a `reactor.ui` op comes on a run stream. */
+export const UI_ON_RUN = 'A reactor.ui op came on the run stream: it comes over the ui socket (REACTOR_UI RU-W).';
+/** What is said when the `fetch` given cannot read a response as it streams. */
+export const NOT_STREAMING = 'This fetch does not stream a response: give one whose response body has getReader (expo/fetch on a phone).';
+/** Whether an event ends a run: the run said how it ended. */
+export const endsRun = (event) => event.type === 'RUN_FINISHED' || event.type === 'RUN_ERROR';
+/**
+ * The `text/event-stream` of a run, read as it arrives: text in, one AG-UI
+ * event out per frame. A frame is its `data:` lines up to a blank line; a
+ * frame whose data is not JSON is handed to `malformed`, never guessed at.
+ */
+export class AgUiFrames {
+    malformed;
+    buffer = '';
+    data = [];
+    constructor(malformed = () => { }) {
+        this.malformed = malformed;
+    }
+    /** The events the text completes. */
+    push(text) {
+        this.buffer += text;
+        const lines = this.buffer.split(/\r?\n/);
+        this.buffer = lines.pop() ?? '';
+        const events = [];
+        for (const line of lines) {
+            this.line(line, events);
+        }
+        return events;
+    }
+    /** The events left when the stream closes: a last frame without its blank line. */
+    end() {
+        const events = [];
+        if (this.buffer) {
+            this.line(this.buffer, events);
+            this.buffer = '';
+        }
+        this.dispatch(events);
+        return events;
+    }
+    line(line, events) {
+        if (line === '') {
+            this.dispatch(events);
+            return;
+        }
+        if (line.startsWith('data:')) {
+            const value = line.slice('data:'.length);
+            this.data.push(value.startsWith(' ') ? value.slice(1) : value);
+        }
+        // `event:`, `id:`, `retry:` and comments name nothing AG-UI reads.
+    }
+    dispatch(events) {
+        if (!this.data.length) {
+            return;
+        }
+        const data = this.data.join('\n');
+        this.data = [];
+        let parsed;
+        try {
+            parsed = JSON.parse(data);
+        }
+        catch {
+            this.malformed(data);
+            return;
+        }
+        if (parsed &&
+            typeof parsed === 'object' &&
+            typeof parsed.type === 'string') {
+            events.push(parsed);
+        }
+        else {
+            this.malformed(data);
+        }
+    }
+}
+/** Every event a complete stream's text holds: a stream already read whole. */
+export function eventsOfStream(text) {
+    const frames = new AgUiFrames();
+    return [...frames.push(text), ...frames.end()];
+}
+/** A text decoder that keeps a character split between two chunks whole. */
+function decoderOf() {
+    if (typeof TextDecoder === 'undefined') {
+        throw new Error('This JavaScript runtime has no TextDecoder to read a run stream with.');
+    }
+    const decoder = new TextDecoder();
+    return chunk => typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
+}
+/**
+ * Read a run's stream to its end, each event handed to `onEvent` as it
+ * arrives. Throws `RUN_CUT_SHORT` when the stream closes before the run said
+ * how it ended, and `NOT_STREAMING` for a response that cannot be read as it
+ * streams. An abort ends the reading with the caller's `AbortError`.
+ */
+export async function readRunStream(response, onEvent, malformed) {
+    const body = response.body;
+    if (!body || typeof body.getReader !== 'function') {
+        throw new Error(NOT_STREAMING);
+    }
+    const reader = body.getReader();
+    const decode = decoderOf();
+    const frames = new AgUiFrames(malformed);
+    let ended = false;
+    const handle = (events) => {
+        for (const event of events) {
+            if (endsRun(event)) {
+                ended = true;
+            }
+            onEvent(event);
+        }
+    };
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            if (value !== undefined) {
+                handle(frames.push(decode(value)));
+            }
+        }
+        handle(frames.end());
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (!ended) {
+        throw new Error(RUN_CUT_SHORT);
+    }
+}
+/**
+ * A tool result's content, read as the chat reads it: JSON when it is JSON,
+ * and failed when the execution result says so (`execution_ok: false`, a
+ * `code_error`, or an `error` without `success`).
+ */
+export function toolResultOf(content) {
+    let result = content;
+    if (typeof result === 'string') {
+        try {
+            result = JSON.parse(result);
+        }
+        catch {
+            // Words, kept as they are.
+        }
+    }
+    const said = result && typeof result === 'object'
+        ? result
+        : undefined;
+    const failed = said?.execution_ok === false ||
+        said?.code_error != null ||
+        (said?.error != null && !said?.success);
+    if (!failed) {
+        return { result, success: true };
+    }
+    const codeError = said?.code_error;
+    const error = (typeof said?.execution_error === 'string' && said.execution_error) ||
+        (typeof said?.error === 'string' && said.error) ||
+        (codeError
+            ? `${codeError.name || 'Error'}: ${codeError.value || ''}`
+            : undefined);
+    return { result, success: false, error };
+}

package/lib/portable/conversation.d.ts

@@ -0,0 +1,124 @@
+/**
+ * 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.
+ *
+ * It reads the stream as the web 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`).
+ *
+ * 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.
+ *
+ * @module portable/conversation
+ */
+import { type AgUiEvent } from './agui';
+/** How many rows a conversation keeps: its newest. */
+export declare const ITEM_LIMIT = 400;
+/** How many characters of an answer are kept. */
+export declare const MESSAGE_TEXT_LIMIT = 100000;
+/** How many characters of a tool's arguments, and of its result, are kept. */
+export declare const TOOL_TEXT_LIMIT = 4000;
+/** How many events it does not draw are kept, by type and name. */
+export declare const DIAGNOSTIC_LIMIT = 50;
+/** What is said after a text cut at its limit. */
+export declare const CUT_MARK = "\u2026 (cut: too long to keep on this device)";
+/** How a turn ended without words of its own: `RUN_END_WORDS`'s. */
+export type TurnEnd = 'answered' | 'stopped' | 'gone';
+/** One row of a conversation. */
+export type ConversationItem = {
+    kind: 'message';
+    id: string;
+    role: 'user' | 'assistant';
+    text: string;
+    /** Its words are still arriving. */
+    streaming: boolean;
+} | {
+    kind: 'tool';
+    id: string;
+    name: string;
+    /** Its arguments as they streamed: JSON, cut at its limit. */
+    args: string;
+    status: 'running' | 'complete' | 'error';
+    /** Its result in words, cut at its limit. */
+    result: string;
+    error: string;
+} | {
+    kind: 'step';
+    id: string;
+    name: string;
+    status: 'running' | 'complete';
+} | {
+    kind: 'end';
+    id: string;
+    end: TurnEnd;
+    words: string;
+} | {
+    kind: 'error';
+    id: string;
+    text: string;
+};
+/** What an application asks the person (`loop.ask`): its kind and what answers it. */
+export type ConversationQuestion = {
+    kind: 'text' | 'choice' | 'form' | 'file';
+    prompt: string;
+    /** A choice's options. */
+    options: string[];
+    /** A form's JSON Schema. */
+    schema: Record<string, unknown> | null;
+    /** A file's kinds. */
+    accept: string[];
+};
+/** A conversation, as the stream and the person built it. */
+export type ConversationState = {
+    items: ConversationItem[];
+    /** A turn is streaming. */
+    running: boolean;
+    /** The session as `loop.session` said it last, or `null` (an agent's run). */
+    session: Record<string, unknown> | null;
+    /** What the application waits for an answer to, or `null`. */
+    asking: ConversationQuestion | null;
+    /** How many of its oldest rows were not kept. */
+    dropped: number;
+    /** The events it does not draw, by type and name only. */
+    diagnostics: {
+        type: string;
+        name: string;
+    }[];
+    /** How many rows the turn streaming added: whether it said anything. */
+    turnRows: number;
+};
+/** A conversation with nothing in it yet. */
+export declare const emptyConversation: () => ConversationState;
+/** The question an application asks, as `RUN_FINISHED`'s `result.asking` or a session says it. */
+export declare function questionOf(raw: unknown): ConversationQuestion | null;
+/** The person's prompt, added before it is sent: its own row. */
+export declare function withPrompt(state: ConversationState, id: string, words: string): ConversationState;
+/**
+ * The turn ended without the stream saying so: the person stopped it
+ * (`stopped`), or its client went before the answer (`gone`). What streamed
+ * stops streaming; a turn that said nothing is said by how it ended.
+ */
+export declare function withTurnEnded(state: ConversationState, end: Exclude<TurnEnd, 'answered'>): ConversationState;
+/** A failure said in the conversation (a refusal, a stream cut short): the turn stops with it. */
+export declare function withError(state: ConversationState, words: string): ConversationState;
+/** A conversation with one more event of its stream. */
+export declare function reduceConversation(state: ConversationState, event: AgUiEvent): ConversationState;
+/** The question in words with what answers it, for a screen reader or a row. */
+export declare function questionWords(question: ConversationQuestion): string;
+/** The fields a form question asks, in order, with their titles: what a native form draws. */
+export declare function formFieldsOf(schema: Record<string, unknown> | null): {
+    name: string;
+    title: string;
+    type: string;
+    options: string[];
+    required: boolean;
+}[];

package/lib/portable/conversation.js

@@ -0,0 +1,357 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * 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.
+ *
+ * It reads the stream as the web 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`).
+ *
+ * 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.
+ *
+ * @module portable/conversation
+ */
+import { REACTOR_UI_NAME, toolResultOf, UI_ON_RUN, } from './agui';
+import { RUN_END_WORDS } from './records';
+import { messagesOfThread } from './thread';
+/** How many rows a conversation keeps: its newest. */
+export const ITEM_LIMIT = 400;
+/** How many characters of an answer are kept. */
+export const MESSAGE_TEXT_LIMIT = 100_000;
+/** How many characters of a tool's arguments, and of its result, are kept. */
+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;
+/** 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,
+});
+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. */
+const appended = (kept, delta, limit) => {
+    if (kept.endsWith(CUT_MARK)) {
+        return kept;
+    }
+    return cut(kept + delta, limit);
+};
+/** A result in words. */
+function said(result) {
+    if (result === undefined || result === null) {
+        return '';
+    }
+    return typeof result === 'string' ? result : JSON.stringify(result);
+}
+/** The question an application asks, as `RUN_FINISHED`'s `result.asking` or a session says it. */
+export function questionOf(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    const asked = raw;
+    const kind = asked.kind;
+    if (kind !== 'text' &&
+        kind !== 'choice' &&
+        kind !== 'form' &&
+        kind !== 'file') {
+        throw new Error(`The application asks something no client knows: ${String(kind)}.`);
+    }
+    const strings = (value) => Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string')
+        : [];
+    const schema = asked.schema;
+    return {
+        kind,
+        prompt: text(asked.prompt),
+        options: strings(asked.options),
+        schema: schema && typeof schema === 'object' && !Array.isArray(schema)
+            ? schema
+            : null,
+        accept: strings(asked.accept),
+    };
+}
+function withItems(state, items, added = 0) {
+    const over = items.length - ITEM_LIMIT;
+    return {
+        ...state,
+        items: over > 0 ? items.slice(over) : items,
+        dropped: state.dropped + Math.max(0, over),
+        turnRows: state.turnRows + added,
+    };
+}
+function changed(state, id, change) {
+    const at = state.items.findIndex(item => item.id === id);
+    if (at < 0) {
+        return null;
+    }
+    const items = state.items.slice();
+    items[at] = change(items[at]);
+    return { ...state, items };
+}
+function noted(state, event) {
+    const entry = {
+        type: event.type,
+        name: text(event.name) || text(event.activityType),
+    };
+    return {
+        ...state,
+        diagnostics: [...state.diagnostics, entry].slice(-DIAGNOSTIC_LIMIT),
+    };
+}
+let rowCount = 0;
+const rowId = (prefix) => `${prefix}-${Date.now().toString(36)}-${(rowCount += 1)}`;
+/** The person's prompt, added before it is sent: its own row. */
+export function withPrompt(state, id, words) {
+    return withItems({ ...state, asking: null }, [
+        ...state.items,
+        { kind: 'message', id, role: 'user', text: words, streaming: false },
+    ]);
+}
+/**
+ * The turn ended without the stream saying so: the person stopped it
+ * (`stopped`), or its client went before the answer (`gone`). What streamed
+ * stops streaming; a turn that said nothing is said by how it ended.
+ */
+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.kind === 'step' && item.status === 'running'
+                ? { ...item, status: 'complete' }
+                : item);
+    const ended = { ...state, items, running: false };
+    return withItems(ended, [
+        ...items,
+        { kind: 'end', id: rowId('end'), end, words: RUN_END_WORDS[end] },
+    ]);
+}
+/** A failure said in the conversation (a refusal, a stream cut short): the turn stops with it. */
+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.kind === 'step' && item.status === 'running'
+                ? { ...item, status: 'complete' }
+                : item);
+    return withItems({ ...state, running: false }, [
+        ...items,
+        { kind: 'error', id: rowId('error'), text: words },
+    ]);
+}
+/** A conversation with one more event of its stream. */
+export function reduceConversation(state, event) {
+    switch (event.type) {
+        case 'RUN_STARTED':
+            return { ...state, running: true, asking: null, turnRows: 0 };
+        case 'TEXT_MESSAGE_START': {
+            const id = text(event.messageId) || rowId('message');
+            if (state.items.some(item => item.id === id)) {
+                return state;
+            }
+            const role = event.role === 'user' ? 'user' : 'assistant';
+            return withItems(state, [
+                ...state.items,
+                { kind: 'message', id, role, text: '', streaming: true },
+            ], 1);
+        }
+        case 'TEXT_MESSAGE_CONTENT':
+        case 'TEXT_MESSAGE_CHUNK': {
+            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);
+            if (grown) {
+                return grown;
+            }
+            return withItems(state, [
+                ...state.items,
+                {
+                    kind: 'message',
+                    id: id || rowId('message'),
+                    role: event.role === 'user' ? 'user' : 'assistant',
+                    text: cut(delta, MESSAGE_TEXT_LIMIT),
+                    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 'TOOL_CALL_START': {
+            const id = text(event.toolCallId) || rowId('tool');
+            if (state.items.some(item => item.id === id)) {
+                return state;
+            }
+            return withItems(state, [
+                ...state.items,
+                {
+                    kind: 'tool',
+                    id,
+                    name: text(event.toolCallName) || text(event.name),
+                    args: '',
+                    status: 'running',
+                    result: '',
+                    error: '',
+                },
+            ], 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),
+                }
+                : item) ?? state);
+        case 'TOOL_CALL_END':
+            return state;
+        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(result.result), TOOL_TEXT_LIMIT),
+                    error: result.error ?? '',
+                }
+                : item) ?? noted(state, event));
+        }
+        case 'STEP_STARTED': {
+            const name = text(event.stepName) || text(event.name);
+            return withItems(state, [
+                ...state.items,
+                { kind: 'step', id: rowId('step'), name, status: 'running' },
+            ], 1);
+        }
+        case 'STEP_FINISHED': {
+            const name = text(event.stepName) || text(event.name);
+            const at = state.items
+                .map((item, index) => ({ item, index }))
+                .reverse()
+                .find(({ item }) => item.kind === 'step' &&
+                item.name === name &&
+                item.status === 'running');
+            if (!at) {
+                return noted(state, event);
+            }
+            const items = state.items.slice();
+            items[at.index] = {
+                ...at.item,
+                status: 'complete',
+            };
+            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,
+            })), 
+            // The conversation said again is what this turn says (a resume):
+            // never also said as a wordless answer.
+            1);
+        }
+        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') {
+                const session = event.value;
+                return {
+                    ...state,
+                    session,
+                    asking: questionOf(session.asking) ?? state.asking,
+                };
+            }
+            return noted(state, event);
+        }
+        case 'ACTIVITY_SNAPSHOT':
+        case 'ACTIVITY_DELTA':
+            if (event.activityType === REACTOR_UI_NAME) {
+                return withError(state, UI_ON_RUN);
+            }
+            return noted(state, event);
+        case 'RUN_FINISHED': {
+            const result = event.result && typeof event.result === 'object'
+                ? event.result
+                : {};
+            const asking = questionOf(result.asking);
+            const items = state.items.map(item => item.kind === 'message' && item.streaming
+                ? { ...item, streaming: false }
+                : item);
+            const finished = { ...state, items, running: false, asking };
+            if (asking || state.turnRows > 0) {
+                return finished;
+            }
+            // Answered without a word: said by how it ended (RUN_END_WORDS).
+            return withItems(finished, [
+                ...items,
+                {
+                    kind: 'end',
+                    id: rowId('end'),
+                    end: 'answered',
+                    words: RUN_END_WORDS.answered,
+                },
+            ]);
+        }
+        case 'RUN_ERROR':
+            return withError(state, text(event.message) || 'Run failed');
+        default:
+            return noted(state, event);
+    }
+}
+/** The question in words with what answers it, for a screen reader or a row. */
+export function questionWords(question) {
+    switch (question.kind) {
+        case 'choice':
+            return `${question.prompt} (${question.options.join(' or ')})`;
+        case 'file':
+            return `${question.prompt} (a file: ${question.accept.join(', ') || 'any file'})`;
+        default:
+            return question.prompt;
+    }
+}
+/** The fields a form question asks, in order, with their titles: what a native form draws. */
+export function formFieldsOf(schema) {
+    const properties = schema?.properties && typeof schema.properties === 'object'
+        ? schema.properties
+        : {};
+    const required = Array.isArray(schema?.required)
+        ? schema?.required
+        : [];
+    return Object.entries(properties).map(([name, field]) => ({
+        name,
+        title: text(field?.title) || name,
+        type: text(field?.type) || 'string',
+        options: Array.isArray(field?.enum) ? field.enum.map(String) : [],
+        required: required.includes(name),
+    }));
+}

package/lib/portable/index.d.ts

@@ -1,11 +1,16 @@
 /**
  * What any JavaScript runtime can import from Agent Runtimes: no React, DOM,
- * Jupyter or Node built-in. Re-exports only; the mobile app reaches Agent
- * Runtimes through this entry alone.
+ * Jupyter, Reactor or Node module. Every module it reaches at run time lives
+ * in this folder (a test holds it to that), so that Datalayer Mobile's Metro
+ * graph takes `lib/portable/*` and nothing else of Agent Runtimes.
  *
  * @module portable
  */
-export { messageOfApproval, normalizeApproval, whyAsked, type ApprovalArgs, type ApprovalRecord, type MessageAsked, } from '../utils/approvals';
-export { AGUIAdapter, type AGUIAdapterConfig } from '../protocols/AGUIAdapter';
-export { createActivityMessage, createAssistantMessage, createUserMessage, generateMessageId, type ChatMessage, type ChatMessageDelta, type ChatMessageInput, type ChatThread, type ContentPart, type MessageRole, type ToolCallStatus, } from '../types/messages';
-export type { ProtocolAdapterConfig, ProtocolConnectionState, ProtocolEvent, ProtocolEventHandler, } from '../types/protocol';
+export { messageOfApproval, normalizeApproval, whyAsked, type ApprovalArgs, type ApprovalRecord, type MessageAsked, } from './approvals';
+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 { agentRunClient, agentRuntimesUrlOf, appSessionsClient, RuntimeRefusal, type AgentRunClient, type AgentTurn, type AppSessionsClient, type RuntimeClientOptions, type SessionStart, type StreamOptions, } from './sessions';
+export type { ChatMessage } from '../types/messages';