@datalayer/agent-runtimes 1.5.24 → 1.5.26

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.js

@@ -32,6 +32,7 @@ export function conversationFixture() {
                 status: 'complete',
                 result: 'Shipped on Monday.',
                 error: '',
+                display: null,
             },
             {
                 kind: 'tool',
@@ -41,6 +42,7 @@ export function conversationFixture() {
                 status: 'error',
                 result: '',
                 error: 'Refused by its rule.',
+                display: null,
             },
             {
                 kind: 'step',

package/lib/portable/index.d.ts

@@ -13,7 +13,12 @@ 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 QuestionCardProps, type StepItem, type StepRowProps, type ToolItem, type ToolRowProps, type TurnEndItem, type TurnEndRowProps, } from './views';
+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 { 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 { 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

@@ -24,5 +24,14 @@ export { PRESENCE_LINES, presenceOfConversation, presenceState, presenceToolOf,
 // 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';
+// How a sign-in under way stands, asked by the person's own client (MOBILE M-039).
+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';
 // The runtime's routes a native client drives.
 export { agentRunClient, agentRuntimesUrlOf, appSessionsClient, RuntimeRefusal, } from './sessions';

package/lib/portable/protectedInput.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Mediated sign-in (PAP_DATALAYER P-03, MOBILE M-039): a personal agent signs
+ * the person in at a company that asks for what only the person knows — a
+ * name and a password, or a code the company sent them. The person types it
+ * on a page of their own Datalayer client, signed in to Datalayer; it goes
+ * to IAM with the one-use protected ticket the sign-in named
+ * (`/pap/my/protected/{ticket}`), which passes it to the company once. The
+ * agent never sees it. The Studio's `/pap/sign-in` and Datalayer Mobile use
+ * this one module.
+ *
+ * Pure but for the given `fetch`: nothing typed is kept — not in an address,
+ * not in storage, not in an error.
+ *
+ * @module portable/protectedInput
+ */
+/** One thing the company asks the person to type. */
+export type ProtectedField = {
+    name: string;
+    label: string;
+    /** Typed as a password: hidden, never filled in by the browser. */
+    secret: boolean;
+};
+/** What the company asks, of whom, until when. */
+export type ProtectedRequest = {
+    companyName: string;
+    /** The company's own domain: what the person can check. */
+    companyDomain: string;
+    purpose: 'credentials' | 'one_time_code';
+    fields: ProtectedField[];
+    /** Where the company sent its code, when it did. */
+    sentTo: string | null;
+    expiresAt: string;
+};
+/** What IAM keeps of one field, at most. */
+export declare const MAX_VALUE_LENGTH = 1024;
+/** What the page says (checked against the vocabulary). */
+export declare const PROTECTED_INPUT_WORDS: {
+    readonly title: (company: string) => string;
+    readonly intro: (company: string) => string;
+    readonly asks: "Who asks";
+    readonly where: "Where";
+    readonly whereHint: "The company’s address: the part you can check.";
+    readonly sentCode: (company: string, sentTo: string) => string;
+    readonly sentCodeSomewhere: (company: string) => string;
+    readonly code: "Code";
+    readonly signIn: (company: string) => string;
+    readonly sendCode: "Send the code";
+    readonly sending: "Sending…";
+    readonly fillEvery: "Fill in every field.";
+    readonly tooLong: (label: string) => string;
+    readonly done: "Done. Go back to your conversation: the agent continues once it checks.";
+    readonly expires: (at: string) => string;
+    readonly reading: "Reading the request…";
+    readonly gone: "This request is unknown, already answered or expired. Ask your personal agent to start again.";
+    readonly incomplete: "This link is incomplete: it names no request. Start again from your personal agent.";
+    readonly signedOut: "Sign in to Datalayer first.";
+};
+/** Whether a link names a request. */
+export declare const ticketComplete: (ticket: string) => boolean;
+/** Raised when IAM does not know the request (unknown, answered or expired): the page says only that. */
+export declare class ProtectedRequestGone extends Error {
+    constructor();
+}
+/** IAM's answer read whole, or refused with a sentence: no default. */
+export declare function protectedRequestOf(raw: unknown): ProtectedRequest;
+/** The fields still empty, by name: the form is sent only when there is none. */
+export declare const emptyFields: (request: Pick<ProtectedRequest, "fields">, values: Record<string, string>) => string[];
+/** What keeps the form from being sent, in sentences; none when it can be. Never what was typed. */
+export declare function fieldProblems(request: Pick<ProtectedRequest, 'fields'>, values: Record<string, string>): string[];
+/** The words on the one button. */
+export declare const submitWords: (request: Pick<ProtectedRequest, "purpose" | "companyName">) => string;
+/** What the code page says of where the code went. */
+export declare const sentWords: (request: Pick<ProtectedRequest, "companyName" | "sentTo">) => string;
+/**
+ * The body sent: exactly the fields asked, none empty, as typed. A code is
+ * sent without its spaces; a password, exactly as typed.
+ */
+export declare function submitBody(request: Pick<ProtectedRequest, 'fields' | 'purpose'>, values: Record<string, string>): {
+    values: Record<string, string>;
+};
+/** The ticket a mediated sign-in page names (`…?ticket=`), or `''`. */
+export declare function ticketOfPage(open: string): string;
+/** IAM's protected-input routes, with the person's own sign-in. */
+export declare function protectedInputClient({ iamUrl, getAccessToken, fetch: fetcher, }: {
+    iamUrl: string;
+    getAccessToken: () => string | undefined;
+    fetch: typeof fetch;
+}): {
+    /** What the company asks; reading it does not use the request up. */
+    read: (ticket: string) => Promise<ProtectedRequest>;
+    /** What the person typed, sent once to IAM. */
+    send: (ticket: string, request: Pick<ProtectedRequest, "fields" | "purpose">, values: Record<string, string>) => Promise<void>;
+};