@datalayer/agent-runtimes 1.3.61 → 1.3.63

package/lib/examples/DecksAgent.js

@@ -1,13 +1,15 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box } from '@datalayer/primer-addons';
 import { ThemedProvider } from './utils/themedProvider';
-import { registerDecks } from '@datalayer/decks';
-import { exampleDecks } from '@datalayer/decks/examples';
+import { registerDeckComponents, registerDecks } from '@datalayer/decks';
+import { exampleDeckComponents, exampleDecks } from '@datalayer/decks/examples';
 import { LoopEmbed } from '../loop';
 import { DeckViewPlugin, LoopDecksPlugin } from '../loop/plugins/decks';
 // The package's example decks, so the catalog has something to open and the
 // agent's suggestions point at decks that exist. Once, at module load.
 registerDecks(exampleDecks);
+// And the components their slides name (AgentsHero, LiveAppearance…).
+registerDeckComponents(exampleDeckComponents);
 // Module-level, so the embed builds its reactor once rather than on every
 // render of this component.
 const DECK_PLUGINS = [LoopDecksPlugin, DeckViewPlugin];

package/lib/examples/LoopShellExample.js

@@ -3,8 +3,8 @@ import { useMemo } from 'react';
 import { Box } from '@primer/react';
 import { QueryClientProvider } from '@tanstack/react-query';
 import { useReactor } from '@datalayer/reactor/react';
-import { registerDecks } from '@datalayer/decks';
-import { exampleDecks } from '@datalayer/decks/examples';
+import { registerDeckComponents, registerDecks } from '@datalayer/decks';
+import { exampleDeckComponents, exampleDecks } from '@datalayer/decks/examples';
 import { buildLoopReactor, LoopWorkspace } from '../loop/shell';
 import { DeckViewPlugin, LoopDecksPlugin } from '../loop/plugins/decks';
 import { loopPlugins } from '../loop/presets';
@@ -18,6 +18,8 @@ const FRONT_DOOR = 'jupyter-data-analyst';
 // The package's example decks, so the Decks member has something to open and
 // change before it has made one. Once, at module load.
 registerDecks(exampleDecks);
+// And the components their slides name (AgentsHero, LiveAppearance…).
+registerDeckComponents(exampleDeckComponents);
 export function LoopShellExample({ serverUrl = resolveExampleAgentRuntimesUrl('local'), agentId = FRONT_DOOR, defaultEditor = 'none', inheritTheme = false, }) {
     // Built once: rebuilding would restart every plugin on each render.
     const reactor = useMemo(() => buildLoopReactor([

package/lib/examples/LoopStrategyExample.d.ts

@@ -0,0 +1,12 @@
+import { ServiceManager } from '@jupyterlab/services';
+interface LoopStrategyExampleInnerProps {
+    serviceManager?: ServiceManager.IManager;
+}
+export declare function LoopStrategyExampleInner({ serviceManager, }: LoopStrategyExampleInnerProps): import("react").JSX.Element;
+/**
+ * Main example component with Jupyter provider wrapper.
+ */
+export declare function LoopStrategyExample({ serviceManager, }: {
+    serviceManager?: ServiceManager.IManager;
+}): import("react").JSX.Element;
+export default LoopStrategyExample;

package/lib/examples/{AgentStrategyExample.js → LoopStrategyExample.js}

@@ -4,7 +4,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * Distributed under the terms of the Modified BSD License.
  */
 /**
- * AgentStrategyExample - Define and launch an agent reasoning *strategy*.
+ * LoopStrategyExample - Define and launch an agent reasoning *strategy*.
  *
  * This example demonstrates the control-loop paradigm (observe → think → act →
  * evaluate) instead of one-shot prompting. It is fully driven by the generic
@@ -24,7 +24,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * 1. Start the agent-runtimes server.
  * 2. Select this example from the header dropdown (Agent group).
  *
- * @module examples/AgentStrategyExample
+ * @module examples/LoopStrategyExample
  */
 import { useMemo, useState } from 'react';
 import { Box } from '@datalayer/primer-addons';
@@ -131,7 +131,7 @@ function StrategySummary({ strategy }) {
                         fontWeight: 'bold',
                     }, children: [index + 1, ". ", phase] }, phase))) }), strategy.objective && (_jsxs(Box, { sx: { color: 'fg.muted' }, children: [_jsx("strong", { children: "Objective:" }), " ", strategy.objective] })), strategy.termination && (_jsxs(Box, { sx: { color: 'fg.muted', mt: 1 }, children: [_jsx("strong", { children: "Max iterations:" }), " ", strategy.termination.maxIterations, ' ', "\u00B7 ", _jsx("strong", { children: "On blocked:" }), " ", strategy.termination.onBlocked] }))] }));
 }
-export function AgentStrategyExampleInner({ serviceManager, }) {
+export function LoopStrategyExampleInner({ serviceManager, }) {
     // All available strategies come from the generated strategy catalogue.
     const strategies = useMemo(() => listStrategies(), []);
     const [selectedStrategyId, setSelectedStrategyId] = useState(DEFAULT_STRATEGY);
@@ -141,9 +141,9 @@ export function AgentStrategyExampleInner({ serviceManager, }) {
     // where the strategy turns, and the hook decides that.
     const tools = useNotebookTools(NOTEBOOK_ID);
     const { agentReady, protocol: protocolConfig, chatFrontendTools, error, unavailableReason, createAttempted, } = useExampleJupyterAgent({
-        exampleId: 'AgentStrategyExample',
+        exampleId: 'LoopStrategyExample',
         agentName: DEFAULT_AGENT_ID,
-        description: `Strategy agent (${selectedStrategy.name}) for AgentStrategyExample`,
+        description: `Strategy agent (${selectedStrategy.name}) for LoopStrategyExample`,
         systemPrompt,
         serviceManager,
         frontendTools: tools,
@@ -204,7 +204,7 @@ export function AgentStrategyExampleInner({ serviceManager, }) {
                                         justifyContent: 'space-between',
                                         gap: 3,
                                         flexWrap: 'wrap',
-                                    }, children: [_jsxs(Box, { children: [_jsxs("h1", { style: { margin: 0, fontSize: '1.5rem' }, children: [selectedStrategy.emoji, " Agent Strategy Example"] }), _jsx("p", { style: { margin: '8px 0 0', color: 'var(--fgColor-muted)' }, children: "Define and launch an agent reasoning strategy \u2014 observe, think, act, evaluate \u2014 over a live notebook." })] }), _jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 2 }, title: isStrategySelectorDisabled
+                                    }, children: [_jsxs(Box, { children: [_jsxs("h1", { style: { margin: 0, fontSize: '1.5rem' }, children: [selectedStrategy.emoji, " Loop Strategy Example"] }), _jsx("p", { style: { margin: '8px 0 0', color: 'var(--fgColor-muted)' }, children: "Define and launch an agent reasoning strategy \u2014 observe, think, act, evaluate \u2014 over a live notebook." })] }), _jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 2 }, title: isStrategySelectorDisabled
                                                 ? 'Strategy selector is temporarily disabled while launching the agent'
                                                 : 'Choose a strategy', children: [_jsx(Box, { as: "label", sx: { fontSize: 1, fontWeight: 'bold' }, children: "Strategy" }), _jsx(Box, { as: "select", value: selectedStrategyId, onChange: (e) => setSelectedStrategyId(e.target.value), disabled: isStrategySelectorDisabled, "aria-label": "Strategy specification", sx: {
                                                         px: 2,
@@ -250,7 +250,7 @@ export function AgentStrategyExampleInner({ serviceManager, }) {
 /**
  * Main example component with Jupyter provider wrapper.
  */
-export function AgentStrategyExample({ serviceManager, }) {
-    return (_jsx(ThemedProvider, { children: _jsx(AgentStrategyExampleInner, { serviceManager: serviceManager }) }));
+export function LoopStrategyExample({ serviceManager, }) {
+    return (_jsx(ThemedProvider, { children: _jsx(LoopStrategyExampleInner, { serviceManager: serviceManager }) }));
 }
-export default AgentStrategyExample;
+export default LoopStrategyExample;

package/lib/examples/example-selector.js

@@ -113,7 +113,7 @@ export const EXAMPLE_ENTRIES = [
     // `owns-sandbox-control`: the shell is pinned to the browser sandbox, so
     // the page's selector would offer three targets it cannot move to.
     ['example', 'loop', 'shell', 'prompt', 'editors', 'owns-sandbox-control']),
-    makeEntry('AgentStrategyExample', () => import('./AgentStrategyExample'), 'Define and launch an agent reasoning strategy (a control loop: observe/think/act/evaluate) over a live notebook, driven by generic strategy specs.', ['example', 'agent', 'strategy', 'notebook', 'agentspecs']),
+    makeEntry('LoopStrategyExample', () => import('./LoopStrategyExample'), 'Define and launch an agent reasoning strategy (a control loop: observe/think/act/evaluate) over a live notebook, driven by generic strategy specs.', ['example', 'agent', 'strategy', 'notebook', 'agentspecs']),
     makeEntry('AgentToolApprovalsExample', () => import('./AgentToolApprovalsExample'), 'Tool approval workflows and manual decisions.'),
     makeEntry('AgentMemoryExample', () => import('./AgentMemoryExample'), 'Memory-aware conversation and retrieval example.'),
     makeEntry('AgentSkillsExample', () => import('./AgentSkillsExample'), 'Skills discovery, execution, and monitoring example.'),
@@ -123,6 +123,7 @@ export const EXAMPLE_ENTRIES = [
     makeEntry('AgentMonitoringExample', () => import('./AgentMonitoringExample'), 'Runtime monitoring and live metrics example.'),
     makeEntry('AgentSubagentsExample', () => import('./AgentSubagentsExample'), 'Multi-agent delegation with the in-repo subagents capability.'),
     makeEntry('AgentA2AExample', () => import('./AgentA2AExample'), 'Delegation to separate agents over the A2A protocol, launched locally or on Datalayer runtimes.'),
+    makeEntry('AgentA2ATeamExample', () => import('./AgentA2ATeamExample'), 'Two applications as a team over A2A: Sales in the browser (@a2a-js/sdk) asks Accounting on a runtime (fasta2a, Odoo read only), each an Office Assistant character.'),
     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

@@ -26,11 +26,12 @@ export { default as AgentCompactionExample } from './AgentCompactionExample';
 export { default as AgentCodemodeExample } from './AgentCodemodeExample';
 export { default as AgentCodeSandboxesExample } from './AgentCodeSandboxesExample';
 export { default as AgentDecideExample } from './AgentDecideExample';
+export { default as AgentA2ATeamExample } from './AgentA2ATeamExample';
 export { default as AgentEvalsExample } from './AgentEvalsExample';
 export { default as AgentGuardrailsExample } from './AgentGuardrailsExample';
 export { default as AgentHooksExample } from './AgentHooksExample';
 export { default as AgentInferenceProviderExample } from './AgentInferenceProviderExample';
-export { default as AgentStrategyExample } from './AgentStrategyExample';
+export { default as LoopStrategyExample } from './LoopStrategyExample';
 export { default as AgentToolApprovalsExample } from './AgentToolApprovalsExample';
 export { default as AgentMemoryExample } from './AgentMemoryExample';
 export { default as AgentOtelExample } from './AgentOtelExample';

package/lib/examples/index.js

@@ -32,11 +32,12 @@ export { default as AgentCompactionExample } from './AgentCompactionExample';
 export { default as AgentCodemodeExample } from './AgentCodemodeExample';
 export { default as AgentCodeSandboxesExample } from './AgentCodeSandboxesExample';
 export { default as AgentDecideExample } from './AgentDecideExample';
+export { default as AgentA2ATeamExample } from './AgentA2ATeamExample';
 export { default as AgentEvalsExample } from './AgentEvalsExample';
 export { default as AgentGuardrailsExample } from './AgentGuardrailsExample';
 export { default as AgentHooksExample } from './AgentHooksExample';
 export { default as AgentInferenceProviderExample } from './AgentInferenceProviderExample';
-export { default as AgentStrategyExample } from './AgentStrategyExample';
+export { default as LoopStrategyExample } from './LoopStrategyExample';
 export { default as AgentToolApprovalsExample } from './AgentToolApprovalsExample';
 export { default as AgentMemoryExample } from './AgentMemoryExample';
 export { default as AgentOtelExample } from './AgentOtelExample';

package/lib/examples/main.js

@@ -47,14 +47,14 @@ const DEFAULT_LOCAL_JUPYTER_SERVER_URL = 'http://localhost:8888/api/jupyter-serv
 const DEFAULT_LOCAL_JUPYTER_SERVER_TOKEN = '60c1661cc408f978c309d04157af55c9588ff9557c9380e4fb50785750703da6';
 const DEFAULT_CLOUD_RUNTIME_ENVIRONMENT = 'ai-agents-env';
 const EXAMPLE_GROUP_ORDER = [
-    'Loop',
+    'Apps',
     'A2UI',
     'A2A',
     'AG-UI',
-    'Capabilities',
     'Chat',
     'Document',
     'Notebook',
+    'Capabilities',
     'Cell',
     'CopilotKit',
 ];
@@ -91,11 +91,9 @@ const ANONYMOUS_EXAMPLES = new Set([
 ]);
 const getExampleGroup = (id) => {
     if (id === 'AgentspecsExample' ||
-        id === 'AgentStrategyExample' ||
-        id === 'LoopWorkspaceExample' ||
-        id === 'LoopShellExample' ||
+        id.startsWith('Loop') ||
         id === 'DecksAgent') {
-        return 'Loop';
+        return 'Apps';
     }
     if (id.startsWith('A2Ui'))
         return 'A2UI';
@@ -1072,13 +1070,14 @@ const ExampleAppThemed = ({ selectedExample, isChangingExample, error, ExampleCo
         }
         for (const [groupName, examples] of groups) {
             examples.sort((left, right) => {
-                if (groupName === 'Loop') {
+                if (groupName === 'Apps') {
                     // The shells first, most naked first; then the strategy that drives a
                     // notebook; then the library of specs behind them all.
                     const LOOP_ORDER = [
                         'LoopShellExample',
                         'LoopWorkspaceExample',
-                        'AgentStrategyExample',
+                        'LoopStrategyExample',
+                        'LoopAppComputerExample',
                         'AgentspecsExample',
                     ];
                     const loopOrder = (id) => {

package/lib/examples/utils/clippyJsCharacters.d.ts

@@ -0,0 +1,18 @@
+import type { AssistantCharacterData } from '../../chat/assistant/formats/types';
+import type { GalleryCharacter } from './AssistantGalleryGrid';
+/** The version of `clippyjs` the characters are read from. */
+export declare const CLIPPY_JS_VERSION = "0.1.0";
+/** The characters the package publishes: their names, and their folders. */
+export declare const CLIPPY_JS_CHARACTERS: readonly ["Clippy", "Merlin", "Links", "Rover", "Genie", "Genius", "F1", "Peedy", "Rocky", "Bonzi"];
+export type ClippyJsCharacterName = (typeof CLIPPY_JS_CHARACTERS)[number];
+/** One clippy.js character, fetched and read. */
+export declare function readClippyJsCharacter(name: ClippyJsCharacterName): Promise<AssistantCharacterData>;
+/**
+ * The clippy.js characters as the gallery shows them, fetched once `enabled`
+ * and kept while it stays so; each as soon as it is read.
+ */
+export declare function useClippyJsCharacters(enabled: boolean): {
+    characters: readonly GalleryCharacter[];
+    loading: boolean;
+    problem?: string;
+};

package/lib/examples/utils/clippyJsCharacters.js

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The characters clippy.js publishes — Clippy, Merlin, Links, Rover and the
+ * others — loaded into the floating assistant's gallery from the `clippyjs`
+ * package on jsDelivr, at the reader's request, and read through the same
+ * clippy.js reader a person's files go through.
+ *
+ * Nothing of them is in this repository: clippy.js's licence covers its code
+ * only, and the characters, their names and their drawings are Microsoft's
+ * (§6.9). The page fetches them when asked and keeps them in memory.
+ *
+ * The package ships each character as ES modules: `agent.mjs` exports the
+ * character's data, `map.mjs` its sprite sheet as a data URL. Both are read as
+ * text, never run: the data is rewritten as the `clippy.ready(...)` call the
+ * reader expects. Sounds are left out.
+ *
+ * @module examples/utils/clippyJsCharacters
+ */
+import { useEffect, useState } from 'react';
+import { readClippyCharacter } from '../../chat/assistant/formats/clippy';
+/** The version of `clippyjs` the characters are read from. */
+export const CLIPPY_JS_VERSION = '0.1.0';
+const BASE = `https://cdn.jsdelivr.net/npm/clippyjs@${CLIPPY_JS_VERSION}/dist/agents`;
+/** The characters the package publishes: their names, and their folders. */
+export const CLIPPY_JS_CHARACTERS = [
+    'Clippy',
+    'Merlin',
+    'Links',
+    'Rover',
+    'Genie',
+    'Genius',
+    'F1',
+    'Peedy',
+    'Rocky',
+    'Bonzi',
+];
+async function fetchText(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`${url} answered ${response.status}.`);
+    }
+    return response.text();
+}
+/** The value a module exports by default: `var x = <value>;\nexport …`. */
+function defaultExportText(module, what) {
+    const match = /^var [A-Za-z_$][\w$]* = ([\s\S]*?);\s*export\s*\{/m.exec(module);
+    if (!match) {
+        throw new Error(`${what} does not export its value as clippy.js 0.1 does.`);
+    }
+    return match[1];
+}
+/** One clippy.js character, fetched and read. */
+export async function readClippyJsCharacter(name) {
+    const folder = `${BASE}/${name.toLowerCase()}`;
+    const [agentModule, mapModule] = await Promise.all([
+        fetchText(`${folder}/agent.mjs`),
+        fetchText(`${folder}/map.mjs`),
+    ]);
+    const data = defaultExportText(agentModule, `${name}'s agent.mjs`);
+    const mapUrl = defaultExportText(mapModule, `${name}'s map.mjs`);
+    if (!/^"data:image\/(png|gif|webp|jpeg);base64,[A-Za-z0-9+/=]+"$/.test(mapUrl)) {
+        throw new Error(`${name}'s map.mjs does not hold an image.`);
+    }
+    const mapPng = await (await fetch(mapUrl.slice(1, -1))).blob();
+    return readClippyCharacter({
+        agentJs: `clippy.ready(${JSON.stringify(name)}, ${data});`,
+        mapPng,
+    });
+}
+/**
+ * The clippy.js characters as the gallery shows them, fetched once `enabled`
+ * and kept while it stays so; each as soon as it is read.
+ */
+export function useClippyJsCharacters(enabled) {
+    const [read, setRead] = useState([]);
+    const [pending, setPending] = useState(0);
+    const [problem, setProblem] = useState();
+    useEffect(() => {
+        if (!enabled) {
+            return;
+        }
+        let cancelled = false;
+        const loaded = [];
+        setRead([]);
+        setProblem(undefined);
+        setPending(CLIPPY_JS_CHARACTERS.length);
+        for (const name of CLIPPY_JS_CHARACTERS) {
+            readClippyJsCharacter(name).then(character => {
+                if (cancelled) {
+                    URL.revokeObjectURL(character.sprite);
+                    return;
+                }
+                loaded.push(character);
+                setRead(previous => [
+                    ...previous,
+                    {
+                        id: `clippy-js-${name.toLowerCase()}`,
+                        name: character.name,
+                        character,
+                        from: `clippy.js ${CLIPPY_JS_VERSION}`,
+                    },
+                ].sort((a, b) => CLIPPY_JS_CHARACTERS.indexOf(a.name) -
+                    CLIPPY_JS_CHARACTERS.indexOf(b.name)));
+                setPending(count => count - 1);
+            }, error => {
+                if (cancelled) {
+                    return;
+                }
+                setProblem(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+                setPending(count => count - 1);
+            });
+        }
+        // The object URLs live as long as the characters are shown.
+        return () => {
+            cancelled = true;
+            for (const character of loaded) {
+                URL.revokeObjectURL(character.sprite);
+            }
+        };
+    }, [enabled]);
+    return {
+        characters: enabled ? read : [],
+        loading: enabled && pending > 0,
+        problem: enabled ? problem : undefined,
+    };
+}

package/lib/hooks/useA2A.d.ts

@@ -1,4 +1,40 @@
-import type { AgentCard, Task } from '@a2a-js/sdk';
+/**
+ * The A2A objects this hook reads, as the JSON it receives (the 0.3 wire it
+ * was written against). Not the SDK's types: `@a2a-js/sdk` 1.x types are the
+ * 1.0 protobuf shapes, which `runtimes/browser/a2aPeer` uses with the SDK's
+ * own client.
+ */
+export interface A2AWireTextPart {
+    kind: 'text';
+    text: string;
+}
+export type A2AWirePart = A2AWireTextPart | {
+    kind: string;
+    text?: string;
+};
+export interface A2AWireTask {
+    id: string;
+    contextId: string;
+    status: {
+        state: string;
+        message?: {
+            parts?: A2AWirePart[];
+        };
+    };
+    artifacts?: {
+        parts?: A2AWirePart[];
+    }[];
+}
+export interface A2AWireAgentCard {
+    name: string;
+    description?: string;
+    capabilities?: {
+        streaming?: boolean;
+    };
+    [key: string]: unknown;
+}
+type AgentCard = A2AWireAgentCard;
+type Task = A2AWireTask;
 export interface Message {
     role: 'user' | 'assistant' | 'system';
     content: string;

package/lib/loop/apps/checks.js

@@ -484,7 +484,7 @@ export function documentShapeProblems(document) {
     }
     for (const key of [
         'skills',
-        'tools',
+        'backend_tools',
         'context',
         'contents',
         'notifications',

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

@@ -0,0 +1,60 @@
+{
+  "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",
+  "supportedInterfaces": [
+    {
+      "protocolBinding": "JSONRPC",
+      "url": "http://runtime.test/api/v1/a2a/agents/accounting/",
+      "protocolVersion": "1.0"
+    }
+  ],
+  "skills": [
+    {
+      "id": "accounting",
+      "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.",
+      "tags": ["example", "accounting", "finance", "odoo", "a2a", "team"],
+      "inputModes": ["text/plain"],
+      "outputModes": ["text/plain"],
+      "examples": [
+        "List the customer invoices that are still open, with the total due.",
+        "Give the aged receivables as of today, by customer.",
+        "Give the trial balance for last month."
+      ]
+    }
+  ],
+  "defaultInputModes": ["application/json"],
+  "defaultOutputModes": ["application/json"],
+  "capabilities": {
+    "streaming": true,
+    "pushNotifications": false,
+    "extensions": [
+      {
+        "uri": "https://datalayer.ai/extensions/orchestration/v1",
+        "description": "Pause at a checkpoint and resume from it; steer a task while it works.",
+        "required": false,
+        "params": {
+          "pause": "/api/v1/a2a/pause",
+          "steer": "/api/v1/a2a/steer"
+        }
+      }
+    ]
+  },
+  "securitySchemes": {
+    "datalayer": {
+      "httpAuthSecurityScheme": {
+        "scheme": "Bearer",
+        "bearerFormat": "JWT",
+        "description": "A Datalayer key granted to this route: a token exchanged from a task grant whose task is this application's route on this runtime. The machine itself needs none."
+      }
+    }
+  },
+  "securityRequirements": [
+    {
+      "schemes": {
+        "datalayer": []
+      }
+    }
+  ]
+}

package/lib/runtimes/browser/a2aPeer.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Another application, asked over A2A from an agent whose loop turns in the page.
+ *
+ * A team of applications says who asks whom (agentspecs `teams`, `talks_to`
+ * over `a2a`). The application asked is served on a runtime with fasta2a; the
+ * one that asks may run here, in the browser, and asks with the A2A SDK
+ * (`@a2a-js/sdk` 1.x) itself, with no wrapper of ours between them:
+ *
+ * - {@link connectA2APeer} reads the peer's agent card and makes a client
+ *   from it. The card says where to send a request, what to ask (its skill:
+ *   description, examples, text in, text out) and that a key is needed.
+ * - {@link a2aPeerTool} is the tool the asking agent calls. It takes one
+ *   request in words, as the skill does, streams the task and returns the
+ *   peer's answer in words. Each step is told to {@link A2APeerEvent} as it
+ *   happens, so a page can show the exchange: asked, working, answered.
+ *
+ * The key goes as a bearer token on every request, the card's too. The
+ * runtime hands it to the peer's run, which then reaches the peer's
+ * connections with it and with nothing broader.
+ *
+ * @module runtimes/browser/a2aPeer
+ */
+import { type AgentCard, type AgentSkill, type Message, type Part } from '@a2a-js/sdk';
+import { type Client } from '@a2a-js/sdk/client';
+import { type Tool } from 'ai';
+/** Where an A2A agent's card is, under the address it is served at. */
+export declare const AGENT_CARD_PATH = ".well-known/agent-card.json";
+/** A peer reached over A2A: its client, its card, and the skill it is asked for. */
+export type A2APeer = {
+    client: Client;
+    card: AgentCard;
+    skill: AgentSkill;
+};
+export type ConnectA2APeerOptions = {
+    /** Where the peer is served: `…/api/v1/a2a/agents/<application id>`. */
+    url: string;
+    /** A key granted to the peer's route, sent as a bearer token. */
+    key?: string;
+    /** The fetch to use, for tests and hosts that wrap the network. */
+    fetch?: typeof globalThis.fetch;
+};
+/**
+ * Read a peer's agent card and make a client from it.
+ *
+ * The card's first skill is what the peer is asked for: a peer served from an
+ * application has one, named for it.
+ */
+export declare function connectA2APeer(options: ConnectA2APeerOptions): Promise<A2APeer>;
+/** What happens to one request, as it happens. */
+export type A2APeerEvent = {
+    phase: 'asked';
+    request: string;
+} | {
+    phase: 'working';
+    taskId: string;
+    note?: string;
+} | {
+    phase: 'answered';
+    taskId: string;
+    answer: string;
+} | {
+    phase: 'failed';
+    error: string;
+};
+/** The text of a message's or an artifact's parts. */
+export declare function textOf(parts: Part[] | undefined): string;
+/** A user's message of one text part, as the SDK's 1.x types write it. */
+export declare function textMessage(text: string): Message;
+/**
+ * Ask a peer once, streaming the task, and return its answer.
+ *
+ * The answer is the text of the task's artifact, assembled from its chunks,
+ * or the final status message's when there is no artifact. A task that ends
+ * other than completed is thrown, with what the peer said.
+ */
+export declare function askA2APeer(peer: A2APeer, request: string, options?: {
+    signal?: AbortSignal;
+    onEvent?: (event: A2APeerEvent) => void;
+}): Promise<string>;
+export type A2APeerToolOptions = {
+    peer: A2APeer;
+    /** Told each step of each request, as it happens. */
+    onEvent?: (event: A2APeerEvent) => void;
+};
+/** The tool's description: the peer's skill, and what it may be asked. */
+export declare function peerToolDescription(peer: A2APeer): string;
+/**
+ * The tool an agent asks its peer with: a request in, the peer's answer out.
+ *
+ * A failed request is returned rather than thrown, so the agent can tell the
+ * person what the peer said instead of the whole run failing.
+ */
+export declare function a2aPeerTool(options: A2APeerToolOptions): Tool;