@datalayer/agent-runtimes 1.5.24 → 1.5.26

package/lib/portable/protectedInput.js

@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** What IAM keeps of one field, at most. */
+export const MAX_VALUE_LENGTH = 1024;
+/** What the page says (checked against the vocabulary). */
+export const PROTECTED_INPUT_WORDS = {
+    title: (company) => `Sign in at ${company}`,
+    intro: (company) => `Your personal agent is signing you in at ${company}, which asks for what only you know. Type it here: Datalayer passes it to ${company} once, and your agent never sees it.`,
+    asks: 'Who asks',
+    where: 'Where',
+    whereHint: 'The company’s address: the part you can check.',
+    sentCode: (company, sentTo) => `${company} sent a code to ${sentTo}.`,
+    sentCodeSomewhere: (company) => `${company} sent you a code.`,
+    code: 'Code',
+    signIn: (company) => `Sign in at ${company}`,
+    sendCode: 'Send the code',
+    sending: 'Sending…',
+    fillEvery: 'Fill in every field.',
+    tooLong: (label) => `${label} is longer than ${MAX_VALUE_LENGTH} characters.`,
+    done: 'Done. Go back to your conversation: the agent continues once it checks.',
+    expires: (at) => `This request ends at ${new Date(at).toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' })}.`,
+    reading: 'Reading the request…',
+    gone: 'This request is unknown, already answered or expired. Ask your personal agent to start again.',
+    incomplete: 'This link is incomplete: it names no request. Start again from your personal agent.',
+    signedOut: 'Sign in to Datalayer first.',
+};
+const TICKET = /^[A-Za-z0-9_-]{8,256}$/;
+const FIELD_NAME = /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/;
+/** Whether a link names a request. */
+export const ticketComplete = (ticket) => TICKET.test(ticket.trim());
+/** Raised when IAM does not know the request (unknown, answered or expired): the page says only that. */
+export class ProtectedRequestGone extends Error {
+    constructor() {
+        super(PROTECTED_INPUT_WORDS.gone);
+        this.name = 'ProtectedRequestGone';
+    }
+}
+/** IAM's answer read whole, or refused with a sentence: no default. */
+export function protectedRequestOf(raw) {
+    const refused = () => new Error('The request could not be read.');
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw refused();
+    }
+    const data = raw;
+    if (typeof data.company_name !== 'string' ||
+        typeof data.company_domain !== 'string' ||
+        !data.company_domain ||
+        (data.purpose !== 'credentials' && data.purpose !== 'one_time_code') ||
+        !Array.isArray(data.fields) ||
+        data.fields.length === 0 ||
+        data.fields.length > 10 ||
+        typeof data.expires_at !== 'string' ||
+        !(data.sent_to === null ||
+            data.sent_to === undefined ||
+            typeof data.sent_to === 'string')) {
+        throw refused();
+    }
+    const names = new Set();
+    const fields = data.fields.map(item => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            throw refused();
+        }
+        const entry = item;
+        if (typeof entry.name !== 'string' ||
+            !FIELD_NAME.test(entry.name) ||
+            names.has(entry.name) ||
+            typeof entry.label !== 'string' ||
+            typeof entry.secret !== 'boolean') {
+            throw refused();
+        }
+        names.add(entry.name);
+        return {
+            name: entry.name,
+            label: entry.label || entry.name,
+            secret: entry.secret,
+        };
+    });
+    if (data.purpose === 'one_time_code' && fields.length !== 1) {
+        throw refused();
+    }
+    return {
+        companyName: data.company_name || data.company_domain,
+        companyDomain: data.company_domain,
+        purpose: data.purpose,
+        fields,
+        sentTo: typeof data.sent_to === 'string' && data.sent_to ? data.sent_to : null,
+        expiresAt: data.expires_at,
+    };
+}
+/** The fields still empty, by name: the form is sent only when there is none. */
+export const emptyFields = (request, values) => request.fields
+    .filter(field => !(values[field.name] ?? '').trim())
+    .map(field => field.name);
+/** What keeps the form from being sent, in sentences; none when it can be. Never what was typed. */
+export function fieldProblems(request, values) {
+    const problems = [];
+    if (emptyFields(request, values).length) {
+        problems.push(PROTECTED_INPUT_WORDS.fillEvery);
+    }
+    for (const field of request.fields) {
+        if ((values[field.name] ?? '').length > MAX_VALUE_LENGTH) {
+            problems.push(PROTECTED_INPUT_WORDS.tooLong(field.label));
+        }
+    }
+    return problems;
+}
+/** The words on the one button. */
+export const submitWords = (request) => request.purpose === 'one_time_code'
+    ? PROTECTED_INPUT_WORDS.sendCode
+    : PROTECTED_INPUT_WORDS.signIn(request.companyName);
+/** What the code page says of where the code went. */
+export const sentWords = (request) => request.sentTo
+    ? PROTECTED_INPUT_WORDS.sentCode(request.companyName, request.sentTo)
+    : PROTECTED_INPUT_WORDS.sentCodeSomewhere(request.companyName);
+/**
+ * The body sent: exactly the fields asked, none empty, as typed. A code is
+ * sent without its spaces; a password, exactly as typed.
+ */
+export function submitBody(request, values) {
+    const problems = fieldProblems(request, values);
+    if (problems.length) {
+        throw new Error(problems.join(' '));
+    }
+    const sent = {};
+    for (const field of request.fields) {
+        const typed = values[field.name];
+        sent[field.name] =
+            request.purpose === 'one_time_code' ? typed.replace(/\s+/g, '') : typed;
+    }
+    return { values: sent };
+}
+/** The ticket a mediated sign-in page names (`…?ticket=`), or `''`. */
+export function ticketOfPage(open) {
+    try {
+        const ticket = new URL(open).searchParams.get('ticket') ?? '';
+        return ticketComplete(ticket) ? ticket.trim() : '';
+    }
+    catch {
+        return '';
+    }
+}
+/** IAM's protected-input routes, with the person's own sign-in. */
+export function protectedInputClient({ iamUrl, getAccessToken, fetch: fetcher, }) {
+    const address = (ticket) => {
+        if (!iamUrl) {
+            throw new Error('Datalayer’s sign-in service is not configured.');
+        }
+        return `${iamUrl.replace(/\/+$/, '')}/api/iam/v1/pap/my/protected/${encodeURIComponent(ticket.trim())}`;
+    };
+    const headers = () => {
+        const token = getAccessToken();
+        return {
+            'Content-Type': 'application/json',
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        };
+    };
+    /** IAM's refusal in its own sentence; never what was typed. */
+    const answered = async (response, what) => {
+        const body = (await response.json().catch(() => ({})));
+        if (response.status === 404) {
+            throw new ProtectedRequestGone();
+        }
+        if (!response.ok) {
+            throw new Error(`${what}: ${typeof body.detail === 'string' ? body.detail : response.status}`);
+        }
+        return body;
+    };
+    return {
+        /** What the company asks; reading it does not use the request up. */
+        read: async (ticket) => protectedRequestOf(await answered(await fetcher(address(ticket), { headers: headers() }), 'The request could not be read')),
+        /** What the person typed, sent once to IAM. */
+        send: async (ticket, request, values) => {
+            const body = submitBody(request, values);
+            const answer = await answered(await fetcher(address(ticket), {
+                method: 'POST',
+                headers: headers(),
+                body: JSON.stringify(body),
+            }), 'It was not sent');
+            if (answer.kept !== true) {
+                throw new Error('It was not sent: the answer does not say it was kept.');
+            }
+        },
+    };
+}

package/lib/portable/signIn.d.ts

@@ -0,0 +1,96 @@
+/**
+ * What the gateway's `pap_sign_in` tool answers, read and checked
+ * (AGENT_PROTOCOLS PI-56, PAP_DATALAYER P-03): the person signs in at a
+ * company themselves — on the company's page (`direct`), by entering a
+ * code there (`device`), or by typing what the company asks on Datalayer's
+ * own page (`mediated`), never in the conversation. The chat shows the link,
+ * the code and until when; the agent never sees what the person types. A
+ * business over PACT answers its `pact_sign_in` the same way (a `device`
+ * sign-in at the business).
+ *
+ * Pure: no React. A test reaches it without a chat around it.
+ *
+ * Kept in `portable/` (MOBILE M-037): Datalayer Mobile reads the same
+ * sign-in with the same checks; the web plugin re-exports it.
+ *
+ * @module portable/signIn
+ */
+/** A sign-in waiting for the person, as the card shows it. */
+export type PapSignInWaiting = {
+    mode: 'direct' | 'device' | 'mediated';
+    /** The company's page — Datalayer's own, for `mediated` — `https` only. */
+    open: string;
+    /** The page's domain, read from its address: what the person can trust. */
+    host: string;
+    /**
+     * The company's domain, when the gateway names it: for a bound `direct`
+     * sign-in the page opened is Datalayer's start link (PAP_DATALAYER P-04),
+     * which sends the person on to the company and takes them back only from it.
+     */
+    company?: string;
+    /** The code to enter, for `device`. */
+    code?: string;
+    /** Where the company sent a code, for `mediated`, when it did. */
+    sentTo?: string;
+    /** Until when, ISO 8601. */
+    expiresAt?: string;
+    /**
+     * What the company said it needs (its `authorization` event's scope,
+     * PAP_DATALAYER P-02): what the person is asked to allow there.
+     */
+    needs?: string[];
+};
+/** What the card says. */
+export declare const PAP_SIGN_IN_WORDS: {
+    readonly title: (host: string) => string;
+    readonly direct: "Open the company’s page through Datalayer, sign in there, and this conversation goes on once you are back.";
+    readonly device: "Open the company’s page and enter this code there.";
+    /** `mediated`: the page is Datalayer's, which names the company and asks what it asks. */
+    readonly mediatedTitle: (host: string) => string;
+    readonly mediated: "Open this page: it names the company and asks what the company needs. Type it there, never in this conversation.";
+    readonly sentTo: (to: string) => string;
+    readonly needs: (scopes: string[]) => string;
+    readonly open: (host: string) => string;
+    readonly code: "Your code";
+    readonly copy: "Copy the code";
+    readonly copied: "Copied";
+    readonly until: (at: string) => string;
+    readonly checkAgain: "I have signed in: check again";
+    readonly tellMe: "Tell me when you are done.";
+    readonly checkMessage: (host: string) => string;
+    readonly refused: "This sign-in link cannot be opened safely, so it is not shown.";
+    readonly qr: (host: string) => string;
+    /** Once the person's browser came back from the company (P-04), said under the card. */
+    readonly returned: {
+        readonly signed_in: (company: string) => string;
+        readonly denied: (company: string) => string;
+        readonly refused: (company: string) => string;
+    };
+};
+/**
+ * Where Datalayer's `/pap/signed-in` page says a Direct Sign-In came back
+ * (PAP_DATALAYER P-04): the card waiting for that company hears it in the
+ * person's tab, so the conversation goes on there.
+ */
+export declare const PAP_SIGN_IN_CHANNEL = "datalayer-pap-sign-in";
+/** How a Direct Sign-In came back. */
+export type PapSignInReturn = keyof typeof PAP_SIGN_IN_WORDS.returned;
+/** What a message on the channel says of this company's sign-in, or `null`: another company's, or not one. */
+export declare function signInReturnOf(message: unknown, company: string): PapSignInReturn | null;
+/**
+ * `pap_sign_in` — or a business's `pact_sign_in` (PI-56) — as the gateway
+ * names it with or without a prefix.
+ */
+export declare const PAP_SIGN_IN_TOOL: RegExp;
+/** Whether a tool is `pap_sign_in` or `pact_sign_in`, as the gateway names it with or without a prefix. */
+export declare const isPapSignInTool: (name: string) => boolean;
+/** The page's address, `https` only; `null` for anything else. */
+export declare function safeSignInUrl(open: unknown): URL | null;
+/**
+ * The sign-in waiting for the person, or why it is not shown: `null` for a
+ * result that is not one (another status: the chat's default row says it),
+ * `{ refused }` for a link that is not `https`.
+ */
+export declare function readPapSignIn(result: unknown): PapSignInWaiting | {
+    refused: string;
+} | null;

package/lib/portable/signIn.js

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** What the card says. */
+export const PAP_SIGN_IN_WORDS = {
+    title: (host) => `Sign in at ${host}`,
+    direct: 'Open the company’s page through Datalayer, sign in there, and this conversation goes on once you are back.',
+    device: 'Open the company’s page and enter this code there.',
+    /** `mediated`: the page is Datalayer's, which names the company and asks what it asks. */
+    mediatedTitle: (host) => `Sign in through ${host}`,
+    mediated: 'Open this page: it names the company and asks what the company needs. Type it there, never in this conversation.',
+    sentTo: (to) => `The company sent a code to ${to}.`,
+    needs: (scopes) => `It needs: ${scopes.join(', ')}.`,
+    open: (host) => `Open ${host}`,
+    code: 'Your code',
+    copy: 'Copy the code',
+    copied: 'Copied',
+    until: (at) => `Until ${new Date(at).toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' })}.`,
+    checkAgain: 'I have signed in: check again',
+    tellMe: 'Tell me when you are done.',
+    checkMessage: (host) => `I have signed in at ${host}. Please check again.`,
+    refused: 'This sign-in link cannot be opened safely, so it is not shown.',
+    qr: (host) => `A code to scan to open ${host} on your phone`,
+    /** Once the person's browser came back from the company (P-04), said under the card. */
+    returned: {
+        signed_in: (company) => `Signed in at ${company}: checking again.`,
+        denied: (company) => `You did not sign in at ${company}: ask again when you want to.`,
+        refused: (company) => `That sign-in at ${company} was refused, and nothing was kept: start it again here.`,
+    },
+};
+/**
+ * Where Datalayer's `/pap/signed-in` page says a Direct Sign-In came back
+ * (PAP_DATALAYER P-04): the card waiting for that company hears it in the
+ * person's tab, so the conversation goes on there.
+ */
+export const PAP_SIGN_IN_CHANNEL = 'datalayer-pap-sign-in';
+/** One OAuth scope token (RFC 6749 §3.3). */
+const SCOPE = /^[\x21\x23-\x5B\x5D-\x7E]{1,128}$/;
+const DOMAIN = /^(?=.{1,253}$)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/;
+/** What a message on the channel says of this company's sign-in, or `null`: another company's, or not one. */
+export function signInReturnOf(message, company) {
+    if (!message || typeof message !== 'object' || Array.isArray(message)) {
+        return null;
+    }
+    const said = message;
+    const outcome = said.outcome;
+    return said.company === company &&
+        (outcome === 'signed_in' || outcome === 'denied' || outcome === 'refused')
+        ? outcome
+        : null;
+}
+/**
+ * `pap_sign_in` — or a business's `pact_sign_in` (PI-56) — as the gateway
+ * names it with or without a prefix.
+ */
+export const PAP_SIGN_IN_TOOL = /(^|[_.:\-/])pa(?:p|ct)_sign_in$/;
+/** Whether a tool is `pap_sign_in` or `pact_sign_in`, as the gateway names it with or without a prefix. */
+export const isPapSignInTool = (name) => PAP_SIGN_IN_TOOL.test(name);
+/** An MCP result's own object: its structured content, or the JSON of its text. */
+function unwrapped(result) {
+    let value = result;
+    if (typeof value === 'string') {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const data = value;
+    if (data.structuredContent && typeof data.structuredContent === 'object') {
+        return unwrapped(data.structuredContent);
+    }
+    if (Array.isArray(data.content)) {
+        const text = data.content.find(part => part?.type === 'text' && typeof part.text === 'string');
+        return text ? unwrapped(text.text) : null;
+    }
+    // FastMCP wraps a non-object answer as `{result: …}`.
+    if (data.result && typeof data.result === 'object' && !('status' in data)) {
+        return unwrapped(data.result);
+    }
+    return data;
+}
+/** The page's address, `https` only; `null` for anything else. */
+export function safeSignInUrl(open) {
+    if (typeof open !== 'string') {
+        return null;
+    }
+    try {
+        const url = new URL(open);
+        return url.protocol === 'https:' && url.hostname ? url : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The sign-in waiting for the person, or why it is not shown: `null` for a
+ * result that is not one (another status: the chat's default row says it),
+ * `{ refused }` for a link that is not `https`.
+ */
+export function readPapSignIn(result) {
+    const data = unwrapped(result);
+    if (!data || data.status !== 'waiting_for_the_person') {
+        return null;
+    }
+    if (data.mode !== 'direct' &&
+        data.mode !== 'device' &&
+        data.mode !== 'mediated') {
+        return null;
+    }
+    const url = safeSignInUrl(data.open);
+    if (!url) {
+        return { refused: PAP_SIGN_IN_WORDS.refused };
+    }
+    if (data.mode === 'device' && (typeof data.code !== 'string' || !data.code)) {
+        return null;
+    }
+    // A bound Direct Sign-In opens Datalayer's start link: the card names the company the gateway
+    // names (`PapSignIn.company`); without one, the page's own domain is the company's.
+    const company = typeof data.company === 'string' && DOMAIN.test(data.company)
+        ? data.company
+        : '';
+    // What the company said it needs: scope tokens only, anything else not shown.
+    const needs = Array.isArray(data.needs)
+        ? data.needs.filter((scope) => typeof scope === 'string' && SCOPE.test(scope))
+        : [];
+    return {
+        mode: data.mode,
+        open: url.toString(),
+        host: url.hostname,
+        ...(company ? { company } : {}),
+        ...(typeof data.code === 'string' && data.code ? { code: data.code } : {}),
+        ...(data.mode === 'mediated' &&
+            typeof data.sent_to === 'string' &&
+            data.sent_to
+            ? { sentTo: data.sent_to }
+            : {}),
+        ...(typeof data.expires_at === 'string' && data.expires_at
+            ? { expiresAt: data.expires_at }
+            : {}),
+        ...(needs.length > 0 ? { needs } : {}),
+    };
+}

package/lib/portable/signInStatus.d.ts

@@ -0,0 +1,37 @@
+/**
+ * How a sign-in under way stands, asked by the person's own client (MOBILE
+ * M-039): the gateway's `GET /api/mcp/v1/pap/sign-in?app_uid&company`, with
+ * the person's own sign-in, finishes what can be finished — a Direct return
+ * IAM bound to their browser and the company asked, a Device code the
+ * company confirmed — and says where it stands.
+ *
+ * A continuation is accepted only when it is bound: the answer names the
+ * application and the company the card was for, and a verified issuer. The
+ * client then goes on in the same conversation (its session), once.
+ *
+ * Pure but for the given `fetch`.
+ *
+ * @module portable/signInStatus
+ */
+/** Where the gateway answers how a sign-in stands. */
+export declare const SIGN_IN_STATUS_PATH = "/api/mcp/v1/pap/sign-in";
+/** How often a client asks while a sign-in waits, and never past its expiry. */
+export declare const SIGN_IN_POLL_MS = 5000;
+export type SignInStands = {
+    appUid: string;
+    company: string;
+    issuer: string;
+    status: 'pending' | 'signed_in' | 'refused' | 'denied' | 'not_started' | 'other';
+    reason: string;
+};
+/** The gateway's answer, or `null` when it does not bind to this application and company. */
+export declare function signInStandsOf(raw: unknown, expected: {
+    appUid: string;
+    company: string;
+}): SignInStands | null;
+/** Asks how a sign-in stands; `null` for none under way (404) or an answer that does not bind. */
+export declare function signInStatusClient({ baseUrl, getAccessToken, fetch: fetcher, }: {
+    baseUrl: string;
+    getAccessToken: () => string | undefined;
+    fetch: typeof fetch;
+}): (appUid: string, company: string) => Promise<SignInStands | null>;

package/lib/portable/signInStatus.js

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * How a sign-in under way stands, asked by the person's own client (MOBILE
+ * M-039): the gateway's `GET /api/mcp/v1/pap/sign-in?app_uid&company`, with
+ * the person's own sign-in, finishes what can be finished — a Direct return
+ * IAM bound to their browser and the company asked, a Device code the
+ * company confirmed — and says where it stands.
+ *
+ * A continuation is accepted only when it is bound: the answer names the
+ * application and the company the card was for, and a verified issuer. The
+ * client then goes on in the same conversation (its session), once.
+ *
+ * Pure but for the given `fetch`.
+ *
+ * @module portable/signInStatus
+ */
+/** Where the gateway answers how a sign-in stands. */
+export const SIGN_IN_STATUS_PATH = '/api/mcp/v1/pap/sign-in';
+/** How often a client asks while a sign-in waits, and never past its expiry. */
+export const SIGN_IN_POLL_MS = 5000;
+const STATUSES = [
+    'pending',
+    'signed_in',
+    'refused',
+    'denied',
+    'not_started',
+];
+/** The gateway's answer, or `null` when it does not bind to this application and company. */
+export function signInStandsOf(raw, expected) {
+    const data = raw && typeof raw === 'object' && !Array.isArray(raw)
+        ? raw
+        : null;
+    if (!data ||
+        data.app_uid !== expected.appUid ||
+        typeof data.company !== 'string' ||
+        data.company.toLowerCase() !== expected.company.toLowerCase() ||
+        typeof data.issuer !== 'string' ||
+        !data.issuer.startsWith('https://')) {
+        return null;
+    }
+    return {
+        appUid: expected.appUid,
+        company: data.company,
+        issuer: data.issuer,
+        status: STATUSES.find(status => status === data.status) ?? 'other',
+        reason: typeof data.reason === 'string' ? data.reason : '',
+    };
+}
+/** Asks how a sign-in stands; `null` for none under way (404) or an answer that does not bind. */
+export function signInStatusClient({ baseUrl, getAccessToken, fetch: fetcher, }) {
+    return async (appUid, company) => {
+        const token = getAccessToken();
+        if (!token) {
+            return null;
+        }
+        const query = new URLSearchParams({ app_uid: appUid, company });
+        const response = await fetcher(`${baseUrl.replace(/\/+$/, '')}${SIGN_IN_STATUS_PATH}?${query.toString()}`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: 'application/json',
+            },
+        });
+        if (response.status === 404) {
+            return null;
+        }
+        if (!response.ok) {
+            throw new Error(`How the sign-in at ${company} stands could not be read (${response.status}).`);
+        }
+        return signInStandsOf(await response.json(), { appUid, company });
+    };
+}

package/lib/portable/views.d.ts

@@ -11,6 +11,7 @@
  * @module portable/views
  */
 import type { ConversationItem, ConversationQuestion, ConversationState } from './conversation';
+import type { ProtocolDisplay } from './displays';
 import { type PresenceState } from './presence';
 export type MessageItem = Extract<ConversationItem, {
     kind: 'message';
@@ -58,6 +59,27 @@ export type QuestionCardProps = {
     /** A form, answered by a settings change. */
     onForm: (values: Record<string, unknown>) => void;
 };
+/**
+ * A protocol display under its tool row (MOBILE M-037): what it shows is
+ * `displayLine`'s and the display's own; what the person does goes out
+ * through the host — a sign-in page opened outside the conversation, an
+ * operation answered where approvals are, *I have signed in* said as their
+ * next message. Nothing is answered from the card itself.
+ */
+export type ProtocolDisplayProps = {
+    display: ProtocolDisplay;
+    /** Open a sign-in page, `https` only, outside the conversation. */
+    onOpenSignIn: (url: string) => void;
+    /** Open the approval an operation stands for. */
+    onOpenApproval: (approvalId: string) => void;
+    /** The person says they signed in (`PAP_SIGN_IN_WORDS.checkMessage`). */
+    onSignedIn: (words: string) => void;
+    /**
+     * Open a Direct Conversation under the conversation a company answered in
+     * (`portable/direct`, MOBILE M-038); absent where none can be opened.
+     */
+    onOpenDirect?: (company: string, conversationId: string) => void;
+};
 /** The line beside the application's face. */
 export type PresenceLineProps = {
     state: PresenceState;

package/lib/runtimes/__tests__/fixtures/accounting-agent-card.json

@@ -1,7 +1,7 @@
 {
   "name": "Accounting",
   "description": "Answers requests for financial reports, such as open invoices, aged balances, a trial balance or a customer's ledger, from the Odoo books, which it only reads.",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "supportedInterfaces": [
     {
       "protocolBinding": "JSONRPC",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datalayer/agent-runtimes",
-    "version": "1.5.24",
+    "version": "1.5.26",
     "type": "module",
     "workspaces": [
         ".",