@datalayer/agent-runtimes 1.5.23 → 1.5.25

package/lib/portable/direct.js

@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The longest message the gateway takes. */
+export const DIRECT_MAX = 4000;
+/** What a page says around the person's own words. */
+export const DIRECT_WORDS = {
+    notConfigured: 'Datalayer is not configured to send your words to a company here.',
+    signIn: 'Sign in to Datalayer first: only you write in your Direct Conversation.',
+    tooLong: `Write a message of at most ${DIRECT_MAX} characters.`,
+    empty: 'Write something to send.',
+    unread: (company) => `${company}'s answer could not be read.`,
+    write: (company) => `Write to ${company} yourself`,
+    says: (company) => `Your own words to ${company}, sent as yours, not through the application`,
+    writing: (company) => `Writing to ${company} yourself`,
+    how: 'What you write here goes to the company as your own words, never through the application. The company’s answers appear here.',
+    you: 'You',
+    agent: 'Its agent',
+    human: 'One of its people',
+    back: 'Back to the application',
+    closed: (company) => `${company} closed this conversation: write through the application again.`,
+    locked: (company) => `You are writing to ${company} yourself: go back to the application to talk to it.`,
+};
+const root = (url) => url.replace(/\/+$/, '');
+/** The sentence a refusal carries: its `note` (closed, none, another) or its `detail`. */
+async function refusal(response, fallback) {
+    const body = (await response.json().catch(() => ({})));
+    const said = typeof body.note === 'string'
+        ? body.note
+        : typeof body.detail === 'string'
+            ? body.detail
+            : '';
+    return new Error(said || `${fallback} (${response.status})`);
+}
+/** The gateway's answer, read whole or refused. */
+export function directAnswerOf(raw, company) {
+    const data = raw;
+    const replies = data?.replies;
+    if (!data ||
+        typeof data.direct_conversation !== 'string' ||
+        !Array.isArray(replies) ||
+        typeof data.status !== 'string' ||
+        replies.some(reply => !reply ||
+            typeof reply.text !== 'string' ||
+            (reply.from !== 'agent' &&
+                reply.from !== 'human'))) {
+        throw new Error(DIRECT_WORDS.unread(company));
+    }
+    return {
+        directConversation: data.direct_conversation,
+        replies: replies.map(reply => ({
+            text: reply.text,
+            from: reply.from,
+        })),
+        status: data.status,
+        responder: typeof data.responder === 'string' ? data.responder : '',
+        cursor: typeof data.cursor === 'string' ? data.cursor : '',
+        display: data.display ?? null,
+    };
+}
+/** IAM's ticket and the gateway's Direct Conversation routes, as the person. */
+export function directClient({ iamUrl, gatewayUrl, getAccessToken, fetch: fetcher, }) {
+    const bearer = () => {
+        const token = getAccessToken();
+        if (!token) {
+            throw new Error(DIRECT_WORDS.signIn);
+        }
+        return { Authorization: `Bearer ${token}` };
+    };
+    const configured = (...urls) => {
+        if (urls.some(url => !url)) {
+            throw new Error(DIRECT_WORDS.notConfigured);
+        }
+    };
+    /** A one-use ticket for one message, asked of IAM with the person's own sign-in. */
+    const ticket = async (target) => {
+        configured(iamUrl);
+        const response = await fetcher(`${root(iamUrl)}/api/iam/v1/pap/my/direct`, {
+            method: 'POST',
+            headers: { ...bearer(), 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                app_uid: target.appUid,
+                company: target.company,
+                conversation_id: target.conversationId,
+            }),
+        });
+        if (!response.ok) {
+            throw await refusal(response, 'Your words could not be sent');
+        }
+        const body = (await response.json());
+        if (typeof body.ticket !== 'string' || !body.ticket) {
+            throw new Error('Your words could not be sent: no ticket came back.');
+        }
+        return body.ticket;
+    };
+    return {
+        ticket,
+        /**
+         * The person's own words, sent as theirs: a ticket, then the words with
+         * it. Refused in the gateway's sentence, and never retried.
+         */
+        send: async (target, text) => {
+            const words = text.trim();
+            if (!words) {
+                throw new Error(DIRECT_WORDS.empty);
+            }
+            if (words.length > DIRECT_MAX) {
+                throw new Error(DIRECT_WORDS.tooLong);
+            }
+            configured(gatewayUrl);
+            const used = await ticket(target);
+            const response = await fetcher(`${root(gatewayUrl)}/api/mcp/v1/pap/direct`, {
+                method: 'POST',
+                headers: { ...bearer(), 'Content-Type': 'application/json' },
+                body: JSON.stringify({ ticket: used, text: words }),
+            });
+            if (!response.ok) {
+                throw await refusal(response, 'Your words were not sent');
+            }
+            return directAnswerOf(await response.json(), target.company);
+        },
+        /** What the company wrote since `cursor`: read, never sent again. */
+        read: async (target, cursor = '') => {
+            configured(gatewayUrl);
+            const query = new URLSearchParams({
+                app_uid: target.appUid,
+                company: target.company,
+                conversation_id: target.conversationId,
+            });
+            if (cursor) {
+                query.set('cursor', cursor);
+            }
+            const response = await fetcher(`${root(gatewayUrl)}/api/mcp/v1/pap/direct?${query.toString()}`, { headers: bearer() });
+            if (!response.ok) {
+                throw await refusal(response, DIRECT_WORDS.unread(target.company));
+            }
+            return directAnswerOf(await response.json(), target.company);
+        },
+    };
+}
+/** A Direct Conversation opened under the conversation a company answered in. */
+export const openDirect = (target) => ({
+    target,
+    lines: [],
+    cursor: '',
+    closed: false,
+});
+/** The open conversation with what the company answered, and the person's words when they sent some. */
+export function withDirectAnswer(open, answer, mine) {
+    return {
+        target: {
+            ...open.target,
+            conversationId: answer.directConversation || open.target.conversationId,
+        },
+        lines: [
+            ...open.lines,
+            ...(mine !== undefined
+                ? [{ from: 'you', text: mine.trim() }]
+                : []),
+            ...answer.replies.map(reply => ({ from: reply.from, text: reply.text })),
+        ],
+        cursor: answer.cursor || open.cursor,
+        closed: answer.status === 'closed',
+    };
+}
+/** Who wrote a line, said apart: the person, the company's agent, one of its people. */
+export const directAuthor = (line) => line.from === 'you'
+    ? DIRECT_WORDS.you
+    : line.from === 'agent'
+        ? DIRECT_WORDS.agent
+        : DIRECT_WORDS.human;

package/lib/portable/displays.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The protocol displays a run's tool results carry, read strictly for any
+ * renderer (MOBILE M-037, REACTOR_UI RU-1): the page's half of a tool result
+ * — `_meta["reactor.ui/display"]`, as the runtime's AG-UI stream sends it
+ * beside the model's view — decoded into what a card draws.
+ *
+ * - **Sign in at a company** (`…pap.sign-in+json`, and a plain `pap_sign_in`
+ *   or a business's `pact_sign_in` answer): Direct, Device or Mediated, its
+ *   page (`https` only), its code, until when, what it needs.
+ * - **An operation to confirm** (`…pap.confirm+json`): the company's words
+ *   verbatim, its terms, the revision and the one it replaced, what it does
+ *   (a Rules class; `buy` when money moves — a purchase), whether only the
+ *   person may decide. It is answered where approvals are, never here: the
+ *   approval it stands for is named (`approvalId`).
+ * - **What a confirmed operation came to** (`…pap.outcome+json`).
+ * - **What a company answered** (`…pap.replies+json`): each reply with who
+ *   wrote it there (its agent or one of its people), who answers now and
+ *   where the conversation stands — participation.
+ * - **A handoff** (`pap_handoff`'s answer): handed to the company's people,
+ *   or why not.
+ *
+ * Anything else — an unknown type, a known one whose data does not read — is
+ * `unknown`: its type, version and model-safe text, nothing drawn from its
+ * data (diagnosable and safe). Typed decoding fails closed.
+ *
+ * @module portable/displays
+ */
+import { type PapSignInWaiting } from './signIn';
+export declare const PAP_SIGN_IN_TYPE = "application/vnd.datalayer.pap.sign-in+json";
+export declare const PAP_CONFIRM_TYPE = "application/vnd.datalayer.pap.confirm+json";
+export declare const PAP_OUTCOME_TYPE = "application/vnd.datalayer.pap.outcome+json";
+export declare const PAP_REPLIES_TYPE = "application/vnd.datalayer.pap.replies+json";
+/** Where a tool result carries its display for the page. */
+export declare const DISPLAY_META_KEY = "reactor.ui/display";
+/** What confirming an operation does, as an application's Rules class it. */
+export type ActionClass = 'read' | 'write' | 'send' | 'buy' | 'delete' | 'publish';
+export type ProtocolDisplay = ({
+    kind: 'sign-in';
+    id: string;
+} & PapSignInWaiting) | {
+    kind: 'sign-in-refused';
+    id: string;
+    why: string;
+} | {
+    kind: 'confirm';
+    id: string;
+    /** The approval it stands for: answered where approvals are. */
+    approvalId: string;
+    company: string;
+    summary: string;
+    terms: Record<string, unknown>;
+    operationRef: string;
+    revision: number;
+    does: ActionClass | null;
+    signedIn: boolean | null;
+    expiresAt: string;
+    was: {
+        revision: number;
+        terms: Record<string, unknown>;
+    } | null;
+    onlyThePerson: boolean;
+} | {
+    kind: 'outcome';
+    id: string;
+    company: string;
+    summary: string;
+    operationRef: string;
+    revision: number;
+    state: 'in_progress' | 'succeeded' | 'failed' | 'cancelled' | 'expired';
+    result: string;
+    approvedBy: 'user' | 'standing_permission' | null;
+} | {
+    kind: 'replies';
+    id: string;
+    company: string;
+    conversation: string;
+    replies: {
+        sender: 'agent' | 'human';
+        text: string;
+    }[];
+    status: 'working' | 'idle' | 'queued' | 'closed' | null;
+    responder: 'agent' | 'human' | null;
+} | {
+    kind: 'handoff';
+    id: string;
+    handed: boolean;
+    responder: 'agent' | 'human' | null;
+    note: string;
+} | {
+    kind: 'unknown';
+    id: string;
+    type: string;
+    version: number;
+    text: string;
+};
+/** A display's wire (`{type, version, id, text, data}`) decoded, or `unknown` with its text. */
+export declare function protocolDisplayOf(wire: unknown): ProtocolDisplay | null;
+/** `pap_handoff`, as the gateway names it with or without a prefix. */
+export declare const PAP_HANDOFF_TOOL: RegExp;
+/**
+ * The protocol display of a tool's result, or `null` for one that has none:
+ * its embedded display first; else a plain `pap_sign_in`/`pact_sign_in`
+ * answer or a `pap_handoff` answer, read by the tool's name.
+ */
+export declare function displayOfToolResult(toolName: string, result: unknown, id?: string): ProtocolDisplay | null;
+/** What each display says in one line, for a screen reader and a collapsed row. */
+export declare function displayLine(display: ProtocolDisplay): string;
+/** Who wrote a reply, said apart from the person's words and the agent's summaries (PAP-7.8-01). */
+export declare const replyAuthor: (company: string, sender: "agent" | "human") => string;

package/lib/portable/displays.js

@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The protocol displays a run's tool results carry, read strictly for any
+ * renderer (MOBILE M-037, REACTOR_UI RU-1): the page's half of a tool result
+ * — `_meta["reactor.ui/display"]`, as the runtime's AG-UI stream sends it
+ * beside the model's view — decoded into what a card draws.
+ *
+ * - **Sign in at a company** (`…pap.sign-in+json`, and a plain `pap_sign_in`
+ *   or a business's `pact_sign_in` answer): Direct, Device or Mediated, its
+ *   page (`https` only), its code, until when, what it needs.
+ * - **An operation to confirm** (`…pap.confirm+json`): the company's words
+ *   verbatim, its terms, the revision and the one it replaced, what it does
+ *   (a Rules class; `buy` when money moves — a purchase), whether only the
+ *   person may decide. It is answered where approvals are, never here: the
+ *   approval it stands for is named (`approvalId`).
+ * - **What a confirmed operation came to** (`…pap.outcome+json`).
+ * - **What a company answered** (`…pap.replies+json`): each reply with who
+ *   wrote it there (its agent or one of its people), who answers now and
+ *   where the conversation stands — participation.
+ * - **A handoff** (`pap_handoff`'s answer): handed to the company's people,
+ *   or why not.
+ *
+ * Anything else — an unknown type, a known one whose data does not read — is
+ * `unknown`: its type, version and model-safe text, nothing drawn from its
+ * data (diagnosable and safe). Typed decoding fails closed.
+ *
+ * @module portable/displays
+ */
+import { isPapSignInTool, readPapSignIn, } from './signIn';
+export const PAP_SIGN_IN_TYPE = 'application/vnd.datalayer.pap.sign-in+json';
+export const PAP_CONFIRM_TYPE = 'application/vnd.datalayer.pap.confirm+json';
+export const PAP_OUTCOME_TYPE = 'application/vnd.datalayer.pap.outcome+json';
+export const PAP_REPLIES_TYPE = 'application/vnd.datalayer.pap.replies+json';
+/** Where a tool result carries its display for the page. */
+export const DISPLAY_META_KEY = 'reactor.ui/display';
+const record = (value) => value && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : null;
+const text = (value) => typeof value === 'string' ? value : '';
+const words = (value) => text(value).trim();
+const count = (value) => typeof value === 'number' && Number.isInteger(value) && value >= 1
+    ? value
+    : 0;
+const ACTIONS = [
+    'read',
+    'write',
+    'send',
+    'buy',
+    'delete',
+    'publish',
+];
+const OUTCOMES = [
+    'in_progress',
+    'succeeded',
+    'failed',
+    'cancelled',
+    'expired',
+];
+const STATUSES = ['working', 'idle', 'queued', 'closed'];
+const who = (value) => value === 'agent' || value === 'human' ? value : null;
+/** A display's wire (`{type, version, id, text, data}`) decoded, or `unknown` with its text. */
+export function protocolDisplayOf(wire) {
+    const shown = record(wire);
+    if (!shown || !text(shown.type)) {
+        return null;
+    }
+    const id = text(shown.id);
+    const data = record(shown.data) ?? {};
+    const unknown = {
+        kind: 'unknown',
+        id,
+        type: text(shown.type),
+        version: typeof shown.version === 'number' ? shown.version : 0,
+        text: text(shown.text),
+    };
+    switch (shown.type) {
+        case PAP_SIGN_IN_TYPE: {
+            const read = readPapSignIn({ status: 'waiting_for_the_person', ...data });
+            if (!read)
+                return unknown;
+            return 'refused' in read
+                ? { kind: 'sign-in-refused', id, why: read.refused }
+                : { kind: 'sign-in', id, ...read };
+        }
+        case PAP_CONFIRM_TYPE: {
+            const company = words(data.company);
+            const summary = text(data.summary);
+            const operationRef = words(data.operation_ref);
+            const revision = count(data.revision);
+            const terms = record(data.terms);
+            const was = record(data.was);
+            const wasRevision = was ? count(was.revision) : 0;
+            if (!company ||
+                !summary.trim() ||
+                !operationRef ||
+                !revision ||
+                !terms ||
+                !id.endsWith('-confirm')) {
+                return unknown;
+            }
+            if (was && (!wasRevision || wasRevision >= revision)) {
+                return unknown;
+            }
+            const does = data.does === null || data.does === undefined
+                ? null
+                : ACTIONS.find(a => a === data.does);
+            if (does === undefined)
+                return unknown;
+            const session = record(data.session);
+            return {
+                kind: 'confirm',
+                id,
+                approvalId: id.slice(0, -'-confirm'.length),
+                company,
+                summary,
+                terms,
+                operationRef,
+                revision,
+                does,
+                signedIn: session && typeof session.signed_in === 'boolean'
+                    ? session.signed_in
+                    : null,
+                expiresAt: text(data.expires_at),
+                was: was
+                    ? { revision: wasRevision, terms: record(was.terms) ?? {} }
+                    : null,
+                onlyThePerson: data.only_the_person === true,
+            };
+        }
+        case PAP_OUTCOME_TYPE: {
+            const state = OUTCOMES.find(s => s === data.state);
+            const company = words(data.company);
+            const summary = text(data.summary);
+            const result = text(data.result);
+            if (!state ||
+                !company ||
+                !summary.trim() ||
+                !words(data.operation_ref) ||
+                !count(data.revision)) {
+                return unknown;
+            }
+            // Final, it says what it came to in the company's words; in progress, nothing yet.
+            if ((state === 'in_progress') !== !result.trim())
+                return unknown;
+            return {
+                kind: 'outcome',
+                id,
+                company,
+                summary,
+                operationRef: words(data.operation_ref),
+                revision: count(data.revision),
+                state,
+                result,
+                approvedBy: data.approved_by === 'user' ||
+                    data.approved_by === 'standing_permission'
+                    ? data.approved_by
+                    : null,
+            };
+        }
+        case PAP_REPLIES_TYPE: {
+            const company = words(data.company);
+            const conversation = text(data.conversation);
+            const replies = Array.isArray(data.replies)
+                ? data.replies.map(record).map(reply => ({
+                    sender: who(reply?.sender),
+                    text: text(reply?.text),
+                }))
+                : [];
+            if (!company ||
+                !/^[A-Za-z0-9_-]{1,256}$/.test(conversation) ||
+                !replies.length ||
+                replies.some(reply => !reply.sender || !reply.text.trim())) {
+                return unknown;
+            }
+            return {
+                kind: 'replies',
+                id,
+                company,
+                conversation,
+                replies: replies,
+                status: STATUSES.find(s => s === data.status) ?? null,
+                responder: who(data.responder),
+            };
+        }
+        default:
+            return unknown;
+    }
+}
+/** `pap_handoff`, as the gateway names it with or without a prefix. */
+export const PAP_HANDOFF_TOOL = /(^|[_.:\-/])pap_handoff$/;
+/**
+ * The protocol display of a tool's result, or `null` for one that has none:
+ * its embedded display first; else a plain `pap_sign_in`/`pact_sign_in`
+ * answer or a `pap_handoff` answer, read by the tool's name.
+ */
+export function displayOfToolResult(toolName, result, id = '') {
+    const answer = record(result);
+    const embedded = record(answer?._meta)?.[DISPLAY_META_KEY];
+    if (embedded !== undefined) {
+        return protocolDisplayOf(embedded);
+    }
+    if (isPapSignInTool(toolName)) {
+        const read = readPapSignIn(result);
+        if (!read)
+            return null;
+        return 'refused' in read
+            ? { kind: 'sign-in-refused', id, why: read.refused }
+            : { kind: 'sign-in', id, ...read };
+    }
+    if (PAP_HANDOFF_TOOL.test(toolName) && answer) {
+        const status = text(answer.status);
+        if (!status)
+            return null;
+        return {
+            kind: 'handoff',
+            id,
+            handed: status !== 'closed' && status !== 'direct_conversation_open',
+            responder: who(answer.responder),
+            note: text(answer.note),
+        };
+    }
+    return null;
+}
+/** What each display says in one line, for a screen reader and a collapsed row. */
+export function displayLine(display) {
+    switch (display.kind) {
+        case 'sign-in':
+            return display.mode === 'mediated'
+                ? `Sign in through ${display.host}`
+                : `Sign in at ${display.company || display.host}`;
+        case 'sign-in-refused':
+            return display.why;
+        case 'confirm':
+            return `${display.company} asks you to confirm: ${display.summary} (version ${display.revision})`;
+        case 'outcome':
+            return display.state === 'in_progress'
+                ? `Still in progress at ${display.company}: ${display.summary}`
+                : `${OUTCOME_LEADS[display.state]} ${display.company}: ${display.result}`;
+        case 'replies':
+            return `${display.company} answered${display.responder === 'human' ? ': one of its people is answering' : ''}`;
+        case 'handoff':
+            return display.handed
+                ? `Handed to ${display.responder === 'human' ? 'one of the company’s people' : 'the company'}`
+                : display.note || 'Nothing was handed over.';
+        case 'unknown':
+            return display.text || `A display this app cannot draw (${display.type})`;
+    }
+}
+const OUTCOME_LEADS = {
+    succeeded: 'Done at',
+    failed: 'Failed at',
+    cancelled: 'Cancelled at',
+    expired: 'Expired at',
+};
+/** Who wrote a reply, said apart from the person's words and the agent's summaries (PAP-7.8-01). */
+export const replyAuthor = (company, sender) => sender === 'human'
+    ? `${company}, one of its people`
+    : `${company}, its agent`;

package/lib/portable/fixtures.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A conversation with one row of every kind, and a question waiting: the
+ * fixture every renderer of `portable/views` is tested against — the web's
+ * and Datalayer Mobile's (MOBILE §4.2) — so that a change of a row's words or
+ * states is caught once.
+ *
+ * @module portable/fixtures
+ */
+import { type ConversationState } from './conversation';
+/** A fresh copy of the fixture conversation. */
+export declare function conversationFixture(): ConversationState;

package/lib/portable/fixtures.js

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * A conversation with one row of every kind, and a question waiting: the
+ * fixture every renderer of `portable/views` is tested against — the web's
+ * and Datalayer Mobile's (MOBILE §4.2) — so that a change of a row's words or
+ * states is caught once.
+ *
+ * @module portable/fixtures
+ */
+import { emptyConversation } from './conversation';
+import { RUN_END_WORDS } from './records';
+/** A fresh copy of the fixture conversation. */
+export function conversationFixture() {
+    return {
+        ...emptyConversation(),
+        items: [
+            {
+                kind: 'message',
+                id: 'm-1',
+                role: 'user',
+                text: 'Where is order 7?',
+                streaming: false,
+            },
+            {
+                kind: 'tool',
+                id: 't-1',
+                name: 'lookup_order',
+                args: '{"order":7}',
+                status: 'complete',
+                result: 'Shipped on Monday.',
+                error: '',
+                display: null,
+            },
+            {
+                kind: 'tool',
+                id: 't-2',
+                name: 'send_mail',
+                args: '{}',
+                status: 'error',
+                result: '',
+                error: 'Refused by its rule.',
+                display: null,
+            },
+            {
+                kind: 'step',
+                id: 's-1',
+                name: 'Check the carrier',
+                status: 'complete',
+            },
+            {
+                kind: 'message',
+                id: 'm-2',
+                role: 'assistant',
+                text: 'It **shipped** on Monday.',
+                streaming: false,
+            },
+            { kind: 'end', id: 'e-1', end: 'stopped', words: RUN_END_WORDS.stopped },
+            { kind: 'error', id: 'x-1', text: 'The runtime did not answer.' },
+        ],
+        asking: {
+            kind: 'choice',
+            prompt: 'Track it by mail?',
+            options: ['Yes', 'No'],
+            schema: null,
+            accept: [],
+        },
+        dropped: 3,
+    };
+}

package/lib/portable/index.d.ts

@@ -12,5 +12,11 @@ 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';
 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 { 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 { 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, } from './displays';
+export { isPapSignInTool, PAP_SIGN_IN_WORDS, readPapSignIn, safeSignInUrl, type PapSignInWaiting, } from './signIn';
+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 { 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

@@ -19,5 +19,15 @@ 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';
+// 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.
+export { ANSWER_BELOW, ANSWER_COMPLETE, composerOf, droppedWords, ENDED_WORDS, messageLabel, OPENING_WORDS, presenceLine, showsQuestion, stepLine, TOOL_STATUS_WORDS, toolLabel, } from './views';
+export { conversationFixture } from './fixtures';
+// The protocol displays a run's tool results carry (MOBILE M-037).
+export { DISPLAY_META_KEY, displayLine, displayOfToolResult, PAP_CONFIRM_TYPE, PAP_HANDOFF_TOOL, PAP_OUTCOME_TYPE, PAP_REPLIES_TYPE, PAP_SIGN_IN_TYPE, protocolDisplayOf, replyAuthor, } from './displays';
+export { isPapSignInTool, PAP_SIGN_IN_WORDS, readPapSignIn, safeSignInUrl, } from './signIn';
+// A Direct Conversation the person types in themselves (PAP_DATALAYER P-08, MOBILE M-038).
+export { DIRECT_MAX, DIRECT_WORDS, directAnswerOf, directAuthor, directClient, openDirect, withDirectAnswer, } from './direct';
 // The runtime's routes a native client drives.
 export { agentRunClient, agentRuntimesUrlOf, appSessionsClient, RuntimeRefusal, } from './sessions';