@datalayer/agent-runtimes 1.3.85 → 1.3.87

package/lib/components/teams/A2ATeamGraph.d.ts

@@ -1,16 +1,26 @@
 /**
- * A team of two over A2A, as a graph (React Flow): each member is its
- * character (`AssistantStage`), with its name and where it runs under it, and
- * one edge links the entry to the peer.
+ * A team over A2A, as a graph (React Flow): each member is its character
+ * (`AssistantStage`), with its name and where it runs under it, and an edge
+ * links the entry to each peer it asks — one peer (`peer`, a team of two)
+ * or several (`peers`, a team of N; LOOP A-08). The edges are the team's
+ * `talks_to` (`links`): a peer that talks to another peer has its edge
+ * drawn too, still, since the page runs the entry's asks only.
  *
- * The edge is still until a message travels on it. While the entry asks, it
+ * An edge is still until a message travels on it. While the entry asks, it
  * flows from the entry to the peer; while the peer answers, from the peer to
- * the entry ({@link A2ATeamFlow}, from the `A2APeerEvent` phases). A reader
- * who asks for no motion sees the same thing without the movement: the arrow
- * at the end the message goes to, and the word for it on the edge.
+ * the entry ({@link A2ATeamFlow}, from the `A2APeerEvent` phases; one flow
+ * per peer, `flows`). A reader who asks for no motion sees the same thing
+ * without the movement: the arrow at the end the message goes to, and the
+ * word for it on the edge.
+ *
+ * The members stand where the layout puts them: the entry on the left and
+ * the peers to its right, one under another — or where a scene's stage
+ * directions say (`positions`, fractions of the box; LOOP A-13): the
+ * distinct `x` values are the columns, left to right, the distinct `y`
+ * values the rows, top to bottom.
  *
  * A member's connections — the MCP servers it reaches, Odoo for Accounting —
- * hang under it, each a node half a member's size with the server's mark
+ * stand to its right, each a node half a member's size with the server's mark
  * (`SpecMark`), linked to it by an edge of its own. That edge is still until
  * the member calls one of the connection's tools: then it flows toward the
  * connection for as long as the call runs ({@link A2ATeamCall}), with the
@@ -49,7 +59,7 @@ export type A2ATeamGraphMember = {
     onToggle?: () => void;
     /** It was sent away, or called back. */
     onAway?: (away: boolean) => void;
-    /** The MCP servers it reaches, drawn under it (`teamConnectionsOf`). */
+    /** The MCP servers it reaches, drawn to its right (`teamConnectionsOf`). */
     connections?: A2ATeamConnection[];
     /**
      * How its balloon shows what it says (LOOP T-23): only what it says or
@@ -108,17 +118,43 @@ export type A2ATeamGraphMember = {
     /** Its balloon's display was chosen in its menu: the page may keep it. */
     onBalloonDisplayChange?: (display: BalloonDisplay) => void;
 };
+/** Who talks to whom over A2A: an edge of the graph. */
+export type A2ATeamGraphLink = {
+    from: string;
+    to: string;
+};
+/** Where a member stands: fractions of the box, as a scene's stage says. */
+export type A2ATeamGraphPosition = {
+    x: number;
+    y: number;
+};
 export type A2ATeamGraphProps = {
     /** The member that asks: drawn on the left. */
     entry: A2ATeamGraphMember;
-    /** The member asked over A2A: drawn on the right. */
-    peer: A2ATeamGraphMember;
-    /** Which way the link carries a message now. */
-    flow: A2ATeamFlow;
-    /** Whether the peer is reached: the edge is drawn faint until it is. */
-    connected: boolean;
-    /** What the edge says at rest: `A2A · <the peer's skill>`. */
+    /** The member asked over A2A: drawn on the right. A team of two. */
+    peer?: A2ATeamGraphMember;
+    /** The members asked over A2A, a team of N: after `peer` when both are given. */
+    peers?: readonly A2ATeamGraphMember[];
+    /** Which way the link to `peer` carries a message now. */
+    flow?: A2ATeamFlow;
+    /** Which way each peer's link carries a message now, by the peer's id. */
+    flows?: Record<string, A2ATeamFlow>;
+    /**
+     * Whether the peers are reached: an edge is drawn faint until its peer
+     * is. One answer for all, or one per peer id.
+     */
+    connected: boolean | Record<string, boolean>;
+    /** What an edge says at rest: `A2A · <the peer's skill>`. */
     label?: string;
+    /** What each peer's edge says at rest, by the peer's id; `label` unsaid. */
+    labels?: Record<string, string>;
+    /**
+     * The edges: the team's `talks_to` over A2A. Unsaid, the entry to each
+     * peer. An edge between two peers is drawn still.
+     */
+    links?: readonly A2ATeamGraphLink[];
+    /** Where each member stands, by its id (a scene's `stage.positions`). */
+    positions?: Record<string, A2ATeamGraphPosition>;
     /** The character's size, in pixels at full scale. */
     size?: number;
     /** The tool calls running now, to the members' connections (`useA2ATeam`). */
@@ -130,6 +166,36 @@ export type A2ATeamGraphProps = {
      */
     balloonRoom?: number;
 };
+/**
+ * The handles an edge leaves and reaches a member by, named: the middle of
+ * its character on each side, chosen by where the other member stands.
+ */
+export declare const MEMBER_HANDLES: {
+    readonly inLeft: "in-left";
+    readonly outRight: "out-right";
+    readonly inTop: "in-top";
+    readonly outBottom: "out-bottom";
+    readonly inRight: "in-right";
+    readonly outLeft: "out-left";
+    readonly inBottom: "in-bottom";
+    readonly outTop: "out-top";
+    readonly connections: "connections";
+};
+/**
+ * The handles for an edge from one place to another: rightward across,
+ * leftward across, or down or up when the other member is mostly below or
+ * above.
+ */
+export declare function handlesBetween(from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}): {
+    sourceHandle: string;
+    targetHandle: string;
+};
 /** How far a member was moved from its place, in the graph's coordinates. */
 export type MemberOffset = {
     dx: number;
@@ -152,6 +218,17 @@ export declare function connectionLabel(connection: Pick<A2ATeamConnection, 'lab
 export declare function connectionDetails(connection: Pick<A2ATeamConnection, 'name' | 'tools'>, member: string | undefined, calling?: string): string;
 /** The words on the edge for a flow. */
 export declare function flowWords(flow: A2ATeamFlow, entry: string, peer: string): string;
+/**
+ * An arrowhead at the end a message goes to — the target's when `forward`,
+ * the source's otherwise — pointing along the edge.
+ */
+export declare function arrowPath(source: {
+    x: number;
+    y: number;
+}, target: {
+    x: number;
+    y: number;
+}, forward: boolean): string;
 type CallData = {
     /** The tool being called, in words (`list invoices`); empty while none is. */
     calling: string;
@@ -160,8 +237,26 @@ type CallData = {
 export declare const CallEdge: import("react").NamedExoticComponent<EdgeProps<Edge<CallData>>>;
 /** What a member's call says, on its edge and to a screen reader. */
 export declare function callWords(member: string, connection: A2ATeamConnection, tool: string): string;
-/** The viewport that shows the graph's width whole in a box `width` wide, never larger than drawn. */
-export declare function teamViewport(width: number): Viewport;
-/** Draw a team of two over A2A, the link moving with what travels on it. */
-export declare function A2ATeamGraph({ entry, peer, flow, connected, label, size, calls, balloonRoom, }: A2ATeamGraphProps): JSX.Element;
+/** The viewport that shows a graph `drawn` wide whole in a box `width` wide, never larger than drawn. */
+export declare function teamViewport(width: number, drawn?: number): Viewport;
+/** Where a member is laid out: its column and row, from the positions or the default. */
+export type MemberPlace = {
+    column: number;
+    row: number;
+};
+/**
+ * Where each member stands, as columns and rows: from the positions given
+ * (the distinct `x` values are the columns left to right, the distinct `y`
+ * values the rows top to bottom), or the entry in the first column and the
+ * peers one under another in the second.
+ */
+export declare function placeMembers(entryId: string, peerIds: readonly string[], positions?: Record<string, A2ATeamGraphPosition>): {
+    places: Record<string, MemberPlace>;
+    columns: number;
+    rows: number;
+};
+/** The one flow the graph reports for all its edges: asking before answering before still. */
+export declare function flowOfAll(flows: readonly A2ATeamFlow[]): A2ATeamFlow;
+/** Draw a team over A2A, each link moving with what travels on it. */
+export declare function A2ATeamGraph({ entry, peer, peers: more, flow, flows, connected, label, labels, links, positions, size, calls, balloonRoom, }: A2ATeamGraphProps): JSX.Element;
 export default A2ATeamGraph;