@datalayer/agent-runtimes 1.3.111 → 1.3.112

package/lib/apps/apps/appspec.js

@@ -272,6 +272,7 @@ function parsePap(data) {
             scopes: texts(company.scopes),
             extensions: texts(company.extensions),
             personalAgents: oneOf(company.personal_agents, ['any', 'registered'], 'any'),
+            registeredAgents: texts(company.registered_agents),
             operations: records(company.operations).map(operation => ({
                 action: text(operation.action),
                 tool: text(operation.tool),
@@ -304,6 +305,7 @@ function dumpPap(pap) {
         .list('scopes', pap.company.scopes)
         .list('extensions', pap.company.extensions)
         .value('personal_agents', pap.company.personalAgents, 'any')
+        .list('registered_agents', pap.company.registeredAgents)
         .list('operations', pap.company.operations.map(operation => new Writer()
         .text('action', operation.action, '\u0000')
         .text('tool', operation.tool, '\u0000')

package/lib/apps/apps/checks.js

@@ -771,12 +771,16 @@ export function documentShapeProblems(document) {
     ]) {
         text(d[key], key);
     }
-    // A drawing is named as it is in the profile's sets, `AstronautIcon`.
-    for (const key of ['avatar', 'banner']) {
-        const name = typeof d[key] === 'string' ? d[key].trim() : '';
-        if (name && !/^[A-Z][A-Za-z0-9]{0,63}$/.test(name)) {
-            at(key, 'is named as its drawing is, `AstronautIcon`');
-        }
+    // An avatar is kept as a person's is (core's avatarChoice): `emoji:<emoji>`
+    // or `@datalayer/icons-react:<Name>Icon`; a banner by its drawing's name.
+    const avatar = typeof d.avatar === 'string' ? d.avatar.trim() : '';
+    if (avatar &&
+        !/^(emoji:[^\sA-Za-z0-9]{1,32}|@datalayer\/icons-react:[A-Z][A-Za-z0-9]{0,62}Icon)$/u.test(avatar)) {
+        at('avatar', 'is `emoji:<emoji>` or `@datalayer/icons-react:<Name>Icon`, as `emoji:👀`');
+    }
+    const banner = typeof d.banner === 'string' ? d.banner.trim() : '';
+    if (banner && !/^[A-Z][A-Za-z0-9]{0,63}$/.test(banner)) {
+        at('banner', 'is named as its drawing is, `SvgTutorialsHero`');
     }
     for (const key of [
         'skills',

package/lib/examples/PapSignInDisplayExample.d.ts

@@ -0,0 +1,4 @@
+/** The PAP sign-in card drawn from a tool result's display, as a Reactor workspace plugin. */
+import React from 'react';
+declare const PapSignInDisplayExample: React.FC;
+export default PapSignInDisplayExample;

package/lib/examples/PapSignInDisplayExample.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** The PAP sign-in card drawn from a tool result's display, as a Reactor workspace plugin. */
+import { useMemo } from 'react';
+import { Box, setupPrimerPortals } from '@datalayer/primer-addons';
+import { LoopEmbed } from '../apps';
+import { definePapExamplePlugin } from '../apps/plugins/pap-example';
+import { ThemedProvider } from './utils/themedProvider';
+setupPrimerPortals();
+const PapSignInDisplayPlugin = definePapExamplePlugin({
+    key: 'sign-in-display',
+    title: 'PAP Sign-In Display',
+    description: 'A sign-in tool’s PapSignIn display: the model reads its model view, the page draws the card.',
+    load: () => import('./pap/PapSignInDisplayView'),
+});
+const PapSignInDisplayExample = () => {
+    const plugins = useMemo(() => [PapSignInDisplayPlugin], []);
+    return (_jsx(ThemedProvider, { children: _jsx(Box, { height: "100vh", minHeight: 0, children: _jsx(LoopEmbed, { target: "browser", agentId: "loop-shell", defaultEditor: "none", showHeader: true, plugins: plugins }) }) }));
+};
+export default PapSignInDisplayExample;

package/lib/examples/example-selector.js

@@ -144,6 +144,7 @@ export const EXAMPLE_ENTRIES = [
     makeEntry('PapConversationStreamingExample', () => import('./PapConversationStreamingExample'), 'Replay a PAP conversation over SSE: display-only text deltas, complete events, and a Last-Event-ID resume.'),
     makeEntry('PapConversationControlExample', () => import('./PapConversationControlExample'), 'Replay conversation control: a Direct Conversation, a handoff to a person, and closing.'),
     makeEntry('PapOperationsExample', () => import('./PapOperationsExample'), 'Replay PAP Operations v1: exact approval of one revision, terms changed, at-most-once confirmation, and cancellation.'),
+    makeEntry('PapSignInDisplayExample', () => import('./PapSignInDisplayExample'), 'The sign-in card as a display: a PapSignIn tool result drawn with resolveToolResult and ReactorDisplay, its link and code never in the model view.'),
     makeEntry('AgentNotificationsExample', () => import('./AgentNotificationsExample'), 'Notifications and event routing example.'),
     makeEntry('AgentOutputsExample', () => import('./AgentOutputsExample'), 'Structured outputs and rendering patterns.'),
     makeEntry('AgentParametersExample', () => import('./AgentParametersExample'), 'Launch-time parameterized agent creation with JSON schema.'),

package/lib/examples/index.d.ts

@@ -40,6 +40,7 @@ export { default as PapMediatedSignInExample } from './PapMediatedSignInExample'
 export { default as PapConversationStreamingExample } from './PapConversationStreamingExample';
 export { default as PapConversationControlExample } from './PapConversationControlExample';
 export { default as PapOperationsExample } from './PapOperationsExample';
+export { default as PapSignInDisplayExample } from './PapSignInDisplayExample';
 export { default as ScenesExample } from './ScenesExample';
 export { default as AgentEvalsExample } from './AgentEvalsExample';
 export { default as AgentGuardrailsExample } from './AgentGuardrailsExample';

package/lib/examples/index.js

@@ -46,6 +46,7 @@ export { default as PapMediatedSignInExample } from './PapMediatedSignInExample'
 export { default as PapConversationStreamingExample } from './PapConversationStreamingExample';
 export { default as PapConversationControlExample } from './PapConversationControlExample';
 export { default as PapOperationsExample } from './PapOperationsExample';
+export { default as PapSignInDisplayExample } from './PapSignInDisplayExample';
 export { default as ScenesExample } from './ScenesExample';
 export { default as AgentEvalsExample } from './AgentEvalsExample';
 export { default as AgentGuardrailsExample } from './AgentGuardrailsExample';

package/lib/examples/main.js

@@ -96,6 +96,8 @@ const ANONYMOUS_EXAMPLES = new Set([
     'PapConversationStreamingExample',
     'PapConversationControlExample',
     'PapOperationsExample',
+    // The sign-in card drawn from a tool result's display: fixtures, no runtime.
+    'PapSignInDisplayExample',
     // The floating assistant: the character, its balloon and its motions need
     // no runtime; a conversation does, and says so when there is none.
     'AssistantExample',

package/lib/examples/pap/PapSignInDisplayView.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The sign-in card as a display (REACTOR_UI RU-1), drawn as the chat draws it.
+ *
+ * A tool that starts a sign-in answers with a `PapSignIn` display
+ * (`application/vnd.datalayer.pap.sign-in+json`). Agent Runtimes gives the
+ * model the display's model view — no page to open, no code — and sends the
+ * page the same result with the whole display in `_meta["reactor.ui/display"]`
+ * (`agent_runtimes/transports/agui_displays.py`). The page finds it with
+ * `resolveToolResult` and draws it with `ReactorDisplay`, which picks the
+ * renderer the `pap-sign-in` plugin contributes. A plain `pap_sign_in` result,
+ * with no display, is found through the plugin's tool binding instead.
+ */
+import React from 'react';
+declare const PapSignInDisplayView: React.FC;
+export default PapSignInDisplayView;

package/lib/examples/pap/PapSignInDisplayView.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The sign-in card as a display (REACTOR_UI RU-1), drawn as the chat draws it.
+ *
+ * A tool that starts a sign-in answers with a `PapSignIn` display
+ * (`application/vnd.datalayer.pap.sign-in+json`). Agent Runtimes gives the
+ * model the display's model view — no page to open, no code — and sends the
+ * page the same result with the whole display in `_meta["reactor.ui/display"]`
+ * (`agent_runtimes/transports/agui_displays.py`). The page finds it with
+ * `resolveToolResult` and draws it with `ReactorDisplay`, which picks the
+ * renderer the `pap-sign-in` plugin contributes. A plain `pap_sign_in` result,
+ * with no display, is found through the plugin's tool binding instead.
+ */
+import { useMemo, useState } from 'react';
+import { Box } from '@datalayer/primer-addons';
+import { Heading, Label, SegmentedControl, Text } from '@primer/react';
+import { useReactorPlatform } from '@datalayer/reactor/react';
+import { DISPLAY_META_KEY, resolveToolResult } from '@datalayer/reactor/ui';
+import { ReactorDisplay } from '@datalayer/reactor/ui/react';
+import { PapExamplePage, PapResult } from './PapExamplePage';
+import { PAP_SIGN_IN_CASES, modelRead } from './papSignInCases';
+const PapSignInDisplayView = () => {
+    const platform = useReactorPlatform();
+    const [index, setIndex] = useState(0);
+    const chosen = PAP_SIGN_IN_CASES[index];
+    const display = useMemo(() => resolveToolResult(platform, {
+        toolName: chosen.toolName,
+        result: chosen.result,
+        toolCallId: `call-${chosen.id}`,
+    }), [platform, chosen]);
+    const meta = chosen.result._meta;
+    const embedded = meta !== undefined && DISPLAY_META_KEY in meta;
+    const fallback = (_jsx(Text, { sx: { color: 'fg.muted' }, children: "No renderer claimed this result." }));
+    const context = {
+        toolCallId: `call-${chosen.id}`,
+        toolName: chosen.toolName,
+        name: chosen.toolName,
+        args: {},
+        result: chosen.result,
+        status: 'complete',
+        defaultUI: fallback,
+    };
+    return (_jsxs(PapExamplePage, { eyebrow: "Reactor UI display", title: "PAP Sign-In Display", description: "A sign-in tool answers with a PapSignIn display. The model reads its model view; the page receives the whole display beside it and draws the Sign in at a company card with resolveToolResult and ReactorDisplay.", children: [_jsx(SegmentedControl, { "aria-label": "Sign-in result", onChange: setIndex, sx: { alignSelf: 'flex-start' }, children: PAP_SIGN_IN_CASES.map((item, at) => (_jsx(SegmentedControl.Button, { selected: at === index, children: item.label }, item.id))) }), _jsx(Text, { sx: { color: 'fg.muted' }, children: chosen.explanation }), _jsxs(Box, { display: "grid", gridTemplateColumns: ['1fr', null, '1fr 1fr'], gap: 3, alignItems: "start", children: [_jsx(PapResult, { title: "What the model read", value: modelRead(chosen.result) }), _jsxs(Box, { border: "1px solid", borderColor: "border.default", borderRadius: 2, bg: "canvas.default", p: 3, "data-pap-sign-in-page": chosen.id, children: [_jsxs(Box, { display: "flex", alignItems: "center", gap: 2, mb: 2, children: [_jsx(Heading, { as: "h2", sx: { fontSize: 2 }, children: "What the page drew" }), _jsx(Label, { variant: embedded ? 'success' : 'attention', children: embedded ? 'embedded display' : 'tool binding' })] }), display ? (_jsx(ReactorDisplay, { display: display, context: context, fallback: fallback })) : (fallback)] })] })] }));
+};
+export default PapSignInDisplayView;

package/lib/examples/pap/PapTraceView.d.ts

@@ -3,9 +3,8 @@
  *
  * The traces are generated from the PAP Python SDK's demo worlds by
  * `examples/personal-agent-protocol/traces/generate.py`: real keys, proofs
- * and HTTP between the parties, recorded and redacted. The TypeScript SDK
- * does not implement these features yet, so this view calls no SDK function:
- * it shows what the user sees, what each party holds, and the sequence of
+ * and HTTP between the parties, recorded and redacted. This view calls no
+ * SDK function: it shows what the user sees, what each party holds, and the sequence of
  * exchanges between them, all synchronized on one step.
  */
 import React from 'react';

package/lib/examples/pap/PapTraceView.js

@@ -8,9 +8,8 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  *
  * The traces are generated from the PAP Python SDK's demo worlds by
  * `examples/personal-agent-protocol/traces/generate.py`: real keys, proofs
- * and HTTP between the parties, recorded and redacted. The TypeScript SDK
- * does not implement these features yet, so this view calls no SDK function:
- * it shows what the user sees, what each party holds, and the sequence of
+ * and HTTP between the parties, recorded and redacted. This view calls no
+ * SDK function: it shows what the user sees, what each party holds, and the sequence of
  * exchanges between them, all synchronized on one step.
  */
 import { useEffect, useMemo, useRef, useState } from 'react';
@@ -191,7 +190,7 @@ export const PapTraceView = ({ trace, eyebrow = 'PAP · Replayed trace', }) => {
     const go = (next) => setStepIndex(Math.max(0, Math.min(trace.steps.length - 1, next)));
     const active = new Set(step.sequence.flatMap(item => [item.from, item.to]));
     const observers = trace.parties.slice(1);
-    return (_jsxs(PapExamplePage, { eyebrow: eyebrow, title: trace.title, description: `${trace.description} Replayed from a trace the PAP Python SDK's demo world generated (${trace.generator}); every token, code, proof and assertion is a placeholder. These features need the PAP release after 0.3.3.`, maxWidth: 1240, children: [_jsx(Box, { display: "flex", gap: 2, flexWrap: "wrap", p: 3, bg: "canvas.default", border: "1px solid", borderColor: "border.default", borderRadius: 2, children: trace.parties.map(party => (_jsxs(Box, { display: "flex", gap: 2, alignItems: "center", mr: 3, children: [_jsx(Avatar, { party: party, tone: toneOf(trace.parties, party.id) }), _jsxs(Box, { children: [_jsx(Text, { as: "div", sx: { fontWeight: 700, fontSize: 1 }, children: party.name }), _jsx(Text, { as: "div", sx: { fontSize: 0, color: 'fg.muted' }, children: party.role })] })] }, party.id))) }), _jsxs(Box, { display: "flex", gap: 2, alignItems: "center", children: [_jsx(IconButton, { icon: ChevronLeftIcon, "aria-label": "Previous step", disabled: stepIndex === 0, onClick: () => go(stepIndex - 1) }), _jsx(Box, { display: "flex", gap: 2, overflow: "auto", flex: 1, "aria-label": "Trace steps", children: trace.steps.map((candidate, index) => (_jsxs(Button, { variant: index === stepIndex ? 'primary' : 'default', onClick: () => go(index), sx: { flexShrink: 0 }, children: [index + 1, ". ", candidate.title] }, candidate.title))) }), _jsx(IconButton, { icon: ChevronRightIcon, "aria-label": "Next step", disabled: stepIndex === trace.steps.length - 1, onClick: () => go(stepIndex + 1) })] }), _jsxs(Box, { display: "grid", sx: {
+    return (_jsxs(PapExamplePage, { eyebrow: eyebrow, title: trace.title, description: `${trace.description} Replayed from a trace the PAP Python SDK's demo world generated (${trace.generator}); every token, code, proof and assertion is a placeholder.`, maxWidth: 1240, children: [_jsx(Box, { display: "flex", gap: 2, flexWrap: "wrap", p: 3, bg: "canvas.default", border: "1px solid", borderColor: "border.default", borderRadius: 2, children: trace.parties.map(party => (_jsxs(Box, { display: "flex", gap: 2, alignItems: "center", mr: 3, children: [_jsx(Avatar, { party: party, tone: toneOf(trace.parties, party.id) }), _jsxs(Box, { children: [_jsx(Text, { as: "div", sx: { fontWeight: 700, fontSize: 1 }, children: party.name }), _jsx(Text, { as: "div", sx: { fontSize: 0, color: 'fg.muted' }, children: party.role })] })] }, party.id))) }), _jsxs(Box, { display: "flex", gap: 2, alignItems: "center", children: [_jsx(IconButton, { icon: ChevronLeftIcon, "aria-label": "Previous step", disabled: stepIndex === 0, onClick: () => go(stepIndex - 1) }), _jsx(Box, { display: "flex", gap: 2, overflow: "auto", flex: 1, "aria-label": "Trace steps", children: trace.steps.map((candidate, index) => (_jsxs(Button, { variant: index === stepIndex ? 'primary' : 'default', onClick: () => go(index), sx: { flexShrink: 0 }, children: [index + 1, ". ", candidate.title] }, candidate.title))) }), _jsx(IconButton, { icon: ChevronRightIcon, "aria-label": "Next step", disabled: stepIndex === trace.steps.length - 1, onClick: () => go(stepIndex + 1) })] }), _jsxs(Box, { display: "grid", sx: {
                     gridTemplateColumns: ['1fr', '1fr', 'minmax(300px, 0.7fr) 1.5fr'],
                 }, gap: 4, alignItems: "start", children: [_jsx(Phone, { trace: trace, stepIndex: stepIndex }), _jsxs(Box, { display: "flex", flexDirection: "column", gap: 3, minWidth: 0, children: [_jsxs(Box, { p: 3, bg: "canvas.default", border: "1px solid", borderColor: "border.default", borderRadius: 2, children: [_jsxs(Text, { as: "div", sx: { fontSize: 0, color: 'fg.muted' }, children: ["Step ", stepIndex + 1, " of ", trace.steps.length, " \u00B7 ", step.channel] }), _jsx(Heading, { as: "h2", sx: { mt: 1, fontSize: 3 }, children: step.title }), _jsx(Text, { as: "p", sx: { mt: 2, mb: 0, color: 'fg.muted' }, children: step.summary })] }), _jsx(Sequence, { trace: trace, step: step }), _jsx(Box, { display: "grid", sx: {
                                     gridTemplateColumns: [

package/lib/examples/pap/papSignInCases.d.ts

@@ -0,0 +1,12 @@
+export type PapSignInCase = {
+    id: string;
+    label: string;
+    toolName: string;
+    /** What the page receives for the tool call. */
+    result: Record<string, unknown>;
+    explanation: string;
+};
+/** The results a page receives for a sign-in, as Agent Runtimes sends them. */
+export declare const PAP_SIGN_IN_CASES: PapSignInCase[];
+/** What the model read: the result without the page's `_meta`. */
+export declare function modelRead(result: Record<string, unknown>): unknown;

package/lib/examples/pap/papSignInCases.js

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The results a page receives for a sign-in (REACTOR_UI RU-1), as Agent
+ * Runtimes sends them: a display's model view with the whole display beside
+ * it in `_meta`, or a plain `pap_sign_in` answer. Fictional company, no
+ * credential.
+ */
+import { DISPLAY_META_KEY } from '@datalayer/reactor/ui';
+import { PAP_SIGN_IN_TYPE } from '../../apps/plugins/pap-sign-in';
+const EXPIRES_AT = '2026-10-12T12:15:00+00:00';
+const DEVICE_PAGE = 'https://manzanita.example/device?user_code=WDJB-MJHT';
+const DEVICE_CODE = 'WDJB-MJHT';
+/** The results a page receives for a sign-in, as Agent Runtimes sends them. */
+export const PAP_SIGN_IN_CASES = [
+    {
+        id: 'device',
+        label: 'Device sign-in',
+        toolName: 'pap_manzanita_example_pap_sign_in',
+        explanation: 'The model view the model read, with the whole display beside it in _meta: the page gets the link and the code, the model got neither.',
+        result: {
+            type: PAP_SIGN_IN_TYPE,
+            text: 'Sign in at manzanita.example: open its sign-in page, shown here, and enter the code shown with it.',
+            data: { mode: 'device', expires_at: EXPIRES_AT, sent_to: null },
+            _meta: {
+                [DISPLAY_META_KEY]: {
+                    type: PAP_SIGN_IN_TYPE,
+                    version: 1,
+                    id: 'sign-in-device',
+                    text: 'Sign in at manzanita.example: open its sign-in page, shown here, and enter the code shown with it.',
+                    data: {
+                        mode: 'device',
+                        open: DEVICE_PAGE,
+                        code: DEVICE_CODE,
+                        expires_at: EXPIRES_AT,
+                        sent_to: null,
+                    },
+                    actions: [],
+                },
+            },
+        },
+    },
+    {
+        id: 'direct',
+        label: 'Direct sign-in',
+        toolName: 'pap_manzanita_example_pap_sign_in',
+        explanation: 'A Direct Sign-In: the company’s own page, then back. No code; the page alone gets the link.',
+        result: {
+            type: PAP_SIGN_IN_TYPE,
+            text: 'Sign in at manzanita.example: open its sign-in page, shown here, sign in there, and come back.',
+            data: { mode: 'direct', expires_at: EXPIRES_AT, sent_to: null },
+            _meta: {
+                [DISPLAY_META_KEY]: {
+                    type: PAP_SIGN_IN_TYPE,
+                    version: 1,
+                    id: 'sign-in-direct',
+                    text: 'Sign in at manzanita.example: open its sign-in page, shown here, sign in there, and come back.',
+                    data: {
+                        mode: 'direct',
+                        open: 'https://manzanita.example/authorize?request_uri=urn%3Aexample',
+                        expires_at: EXPIRES_AT,
+                        sent_to: null,
+                    },
+                    actions: [],
+                },
+            },
+        },
+    },
+    {
+        id: 'plain',
+        label: 'Plain result',
+        toolName: 'pap_sign_in',
+        explanation: 'A pap_sign_in answer that carries no display: the plugin’s tool binding claims the tool by its name, and the card reads the answer itself.',
+        result: {
+            status: 'waiting_for_the_person',
+            mode: 'device',
+            open: DEVICE_PAGE,
+            code: DEVICE_CODE,
+            expires_at: EXPIRES_AT,
+        },
+    },
+];
+/** What the model read: the result without the page's `_meta`. */
+export function modelRead(result) {
+    return Object.fromEntries(Object.entries(result).filter(([key]) => key !== '_meta'));
+}

package/lib/protocols/a2a/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * A2A as a Reactor Plugin (AGENT_PROTOCOLS PR-02): Agent Card extensions
+ * read, published from what is contributed, and negotiated.
+ *
+ * Each A2A extension this runtime implements is a Contribution Point of the
+ * plugin, `a2a.extension.<name>`: `orchestration` and `face` (Datalayer's,
+ * defaults `datalayer`), and `other` for any extension by its URI (no
+ * default, every contribution used). The twin of `agent_runtimes.protocols.a2a`.
+ *
+ * @module protocols/a2a
+ */
+import { type ReactorPlatformView } from '@datalayer/reactor';
+export declare const A2A_PLUGIN = "agent-runtimes.protocols.a2a";
+export declare const ORCHESTRATION_URI = "https://datalayer.ai/extensions/orchestration/v1";
+export declare const FACE_URI = "https://datalayer.ai/extensions/face/v1";
+/** One extension an Agent Card advertises. */
+export interface CardExtension {
+    uri: string;
+    description?: string;
+    required?: boolean;
+    params?: Record<string, unknown>;
+}
+/** What an extension may read to say its params on one agent's card. */
+export interface CardContext {
+    agentId: string;
+    apiPrefix?: string;
+    face?: Record<string, string>;
+}
+/** One A2A extension this runtime implements. */
+export interface A2AExtension {
+    uri: string;
+    description: string;
+    required: boolean;
+    /** Its params on this card; `undefined` when it is not published there. */
+    params(context: CardContext): Record<string, unknown> | undefined;
+}
+export declare const A2AOrchestrationExtensions: import("@datalayer/reactor").ContributionPoint<A2AExtension>;
+export declare const A2AFaceExtensions: import("@datalayer/reactor").ContributionPoint<A2AExtension>;
+export declare const A2AOtherExtensions: import("@datalayer/reactor").ContributionPoint<A2AExtension>;
+export declare const A2APlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;
+/** Every extension a card advertises, in its order. */
+export declare function extensionsOf(card: unknown): CardExtension[];
+export declare function findExtension(card: unknown, uri: string): CardExtension | undefined;
+/** The extensions a card requires that the caller does not support. */
+export declare function unsupportedRequired(card: unknown, supported: Iterable<string>): string[];
+/** What one agent's card publishes: what is contributed, then what it declares. */
+export declare function cardExtensions(reactor: ReactorPlatformView, context: CardContext, declared?: CardExtension[]): CardExtension[];
+/**
+ * The extensions a client activates with an agent: those of its card that
+ * are implemented here. Throws when the card requires one that is not.
+ */
+export declare function negotiateExtensions(card: unknown, reactor: ReactorPlatformView): string[];

package/lib/protocols/a2a/index.js

@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * A2A as a Reactor Plugin (AGENT_PROTOCOLS PR-02): Agent Card extensions
+ * read, published from what is contributed, and negotiated.
+ *
+ * Each A2A extension this runtime implements is a Contribution Point of the
+ * plugin, `a2a.extension.<name>`: `orchestration` and `face` (Datalayer's,
+ * defaults `datalayer`), and `other` for any extension by its URI (no
+ * default, every contribution used). The twin of `agent_runtimes.protocols.a2a`.
+ *
+ * @module protocols/a2a
+ */
+import { contribution, defineContributionPoint, definePlugin, } from '@datalayer/reactor';
+import { DEFAULT_ORDER, ProtocolDescriptions } from '../core';
+export const A2A_PLUGIN = 'agent-runtimes.protocols.a2a';
+export const ORCHESTRATION_URI = 'https://datalayer.ai/extensions/orchestration/v1';
+export const FACE_URI = 'https://datalayer.ai/extensions/face/v1';
+export const A2AOrchestrationExtensions = defineContributionPoint('a2a.extension.orchestration');
+export const A2AFaceExtensions = defineContributionPoint('a2a.extension.face');
+export const A2AOtherExtensions = defineContributionPoint('a2a.extension.other');
+const EXTENSION_POINTS = [
+    A2AOrchestrationExtensions,
+    A2AFaceExtensions,
+    A2AOtherExtensions,
+];
+const orchestration = {
+    uri: ORCHESTRATION_URI,
+    description: 'Pause at a checkpoint and resume from it; steer a task while it works.',
+    required: false,
+    params: context => ({
+        pause: `${context.apiPrefix ?? ''}/a2a/pause`,
+        steer: `${context.apiPrefix ?? ''}/a2a/steer`,
+    }),
+};
+const face = {
+    uri: FACE_URI,
+    description: 'Its face: an emoji, and an avatar when it has one.',
+    required: false,
+    params: context => (context.face ? { ...context.face } : undefined),
+};
+export const A2APlugin = definePlugin({
+    name: A2A_PLUGIN,
+    version: '1.0.0',
+    description: 'Agent2Agent 1.0: the extensions an agent card publishes and a client negotiates.',
+    contributionPoints: EXTENSION_POINTS,
+    contributes: [
+        contribution(ProtocolDescriptions, {
+            id: 'a2a',
+            name: 'Agent2Agent',
+            layer: 'transport',
+            version: '1.0',
+            roles: ['client', 'server'],
+            status: 'implemented',
+            specification: 'https://a2a-protocol.org/latest/specification/',
+            plugin: A2A_PLUGIN,
+            points: EXTENSION_POINTS.map(point => point.id),
+        }, { id: 'a2a', order: DEFAULT_ORDER }),
+        contribution(A2AOrchestrationExtensions, orchestration, {
+            id: 'datalayer',
+            order: DEFAULT_ORDER,
+        }),
+        contribution(A2AFaceExtensions, face, {
+            id: 'datalayer',
+            order: DEFAULT_ORDER,
+        }),
+    ],
+});
+function assertUri(uri) {
+    if (typeof uri !== 'string' || !/^[a-z][a-z0-9+.-]*:/i.test(uri)) {
+        throw new Error(`an extension is named by a URI, not ${String(uri)}`);
+    }
+}
+/** Every extension a card advertises, in its order. */
+export function extensionsOf(card) {
+    const raw = card
+        ?.capabilities?.extensions;
+    if (raw === undefined || raw === null) {
+        return [];
+    }
+    if (!Array.isArray(raw)) {
+        throw new Error('capabilities.extensions is a list');
+    }
+    const out = raw.map(entry => {
+        const { uri, description, required, params } = entry;
+        assertUri(uri);
+        return {
+            uri,
+            description: description ?? '',
+            required: Boolean(required),
+            params: params ?? {},
+        };
+    });
+    if (new Set(out.map(e => e.uri)).size !== out.length) {
+        throw new Error('the card advertises an extension twice');
+    }
+    return out;
+}
+export function findExtension(card, uri) {
+    return extensionsOf(card).find(extension => extension.uri === uri);
+}
+/** The extensions a card requires that the caller does not support. */
+export function unsupportedRequired(card, supported) {
+    const known = new Set(supported);
+    return extensionsOf(card)
+        .filter(extension => extension.required && !known.has(extension.uri))
+        .map(extension => extension.uri);
+}
+function providers(reactor) {
+    const out = [];
+    for (const point of EXTENSION_POINTS) {
+        const contributions = reactor.getContributions(point);
+        if (point === A2AOtherExtensions) {
+            out.push(...contributions.map(c => c.value));
+        }
+        else if (contributions.length) {
+            if (contributions[1] &&
+                contributions[1].order === contributions[0].order) {
+                throw new Error(`two implementations of ${point.id} at the same order`);
+            }
+            out.push(contributions[0].value);
+        }
+    }
+    return out;
+}
+/** What one agent's card publishes: what is contributed, then what it declares. */
+export function cardExtensions(reactor, context, declared = []) {
+    const out = [];
+    for (const provider of providers(reactor)) {
+        const params = provider.params(context);
+        if (params !== undefined) {
+            out.push({
+                uri: provider.uri,
+                description: provider.description,
+                required: provider.required,
+                params,
+            });
+        }
+    }
+    for (const extension of declared) {
+        assertUri(extension.uri);
+        if (out.some(e => e.uri === extension.uri)) {
+            throw new Error(`extension ${extension.uri} is published twice`);
+        }
+        out.push(extension);
+    }
+    return out;
+}
+/**
+ * The extensions a client activates with an agent: those of its card that
+ * are implemented here. Throws when the card requires one that is not.
+ */
+export function negotiateExtensions(card, reactor) {
+    const implemented = new Set(providers(reactor).map(provider => provider.uri));
+    const missing = unsupportedRequired(card, implemented);
+    if (missing.length) {
+        throw new Error(`the agent requires extensions not implemented here: ${missing.join(', ')}`);
+    }
+    return extensionsOf(card)
+        .map(extension => extension.uri)
+        .filter(uri => implemented.has(uri));
+}

package/lib/protocols/agentProtocols.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The `agent-protocols` Reactor Extension: the protocol plugins, delivered
+ * together. An Extension only groups plugins for delivery; it has no
+ * lifecycle and contributes nothing (AGENT_PROTOCOLS §3.1).
+ *
+ * @module protocols/agentProtocols
+ */
+import { type PlatformInput, type ReactorPlatform } from '@datalayer/reactor';
+export declare const AGENT_PROTOCOLS_EXTENSION = "agent-protocols";
+export declare const AgentProtocolsExtension: import("@datalayer/reactor").ReactorExtension;
+/**
+ * A started Reactor with the `agent-protocols` Extension, then the host's
+ * plugins: their lower-order contributions replace the protocols' defaults.
+ */
+export declare function buildProtocolsReactor(plugins?: PlatformInput[]): ReactorPlatform;

package/lib/protocols/agentProtocols.js

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The `agent-protocols` Reactor Extension: the protocol plugins, delivered
+ * together. An Extension only groups plugins for delivery; it has no
+ * lifecycle and contributes nothing (AGENT_PROTOCOLS §3.1).
+ *
+ * @module protocols/agentProtocols
+ */
+import { buildReactorFromPlugins, defineExtension, } from '@datalayer/reactor';
+import { A2APlugin } from './a2a';
+import { AgenticCommercePlugin } from './agentic-commerce';
+import { ProtocolsCorePlugin } from './core';
+import { McpPlugin } from './mcp';
+import { PactPlugin } from './pact';
+import { UcpPlugin } from './ucp';
+import { WebBotAuthPlugin } from './web-bot-auth';
+export const AGENT_PROTOCOLS_EXTENSION = 'agent-protocols';
+export const AgentProtocolsExtension = defineExtension({
+    name: AGENT_PROTOCOLS_EXTENSION,
+    version: '1.0.0',
+    displayName: 'Agent protocols',
+    description: 'MCP, A2A, Web Bot Auth, UCP, the Agentic Commerce Protocol and PACT, each a plugin; their extensions its contribution points.',
+    plugins: [
+        ProtocolsCorePlugin,
+        McpPlugin,
+        A2APlugin,
+        WebBotAuthPlugin,
+        UcpPlugin,
+        AgenticCommercePlugin,
+        PactPlugin,
+    ],
+});
+/**
+ * A started Reactor with the `agent-protocols` Extension, then the host's
+ * plugins: their lower-order contributions replace the protocols' defaults.
+ */
+export function buildProtocolsReactor(plugins = []) {
+    const reactor = buildReactorFromPlugins([
+        AgentProtocolsExtension,
+        ...plugins,
+    ]);
+    reactor.start();
+    return reactor;
+}