@aeolus-fleet/gateway 0.29.2 → 0.31.0

package/dist/adapters/trpc/router.d.ts

@@ -11,6 +11,11 @@ import type { IsServed } from '../../core/installation/served.js';
 import type { SetFleetEnabled } from '../../core/installation/set-fleet-enabled.js';
 import type { AuthenticateActor } from '../../core/actors/authenticate-actor.js';
 import type { ReadOutsideParties, SetOutsideParties } from '../../core/outside-parties/set-outside-parties.js';
+import type { AddClientParty } from '../../core/parties/add-client-party.js';
+import type { ListReachedShips } from '../../core/a2a-in/list-reached-ships.js';
+import type { AddA2aClient } from '../../core/parties/add-a2a-client.js';
+import type { AddA2aAgent } from '../../core/parties/add-a2a-agent.js';
+import type { MarkA2aAgent } from '../../core/a2a-out/mark-a2a-agent.js';
 import type { ApproveParty } from '../../core/parties/approve-party.js';
 import type { CrewParty } from '../../core/parties/crew-party.js';
 import type { ListOwnerChoices } from '../../core/parties/list-owner-choices.js';
@@ -21,6 +26,7 @@ import type { MarkTool } from '../../core/mcp-out/mark-tool.js';
 import type { StateParty } from '../../core/mcp-out/state-party.js';
 import type { CheckServer } from '../../core/parties/check-server.js';
 import type { ReadPartyTools } from '../../core/parties/read-party-tools.js';
+import type { SwitchTool } from '../../core/parties/switch-tool.js';
 import type { RegisterClient } from '../../core/oauth/register-client.js';
 import type { DecideRequest } from '../../core/requests/decide-request.js';
 import type { ListMine } from '../../core/requests/list-mine.js';
@@ -29,7 +35,15 @@ import type { EndSignIns } from '../../core/sign-in/end-sign-ins.js';
 import type { AnswerDelivery } from '../../core/people/answer-delivery.js';
 import type { DoneDelivery } from '../../core/people/done-delivery.js';
 import type { OpenDelivery } from '../../core/people/open-delivery.js';
+import type { ChangeOwnMic } from '../../core/meetings/change-own-mic.js';
+import type { ReadMeeting } from '../../core/meetings/read-meeting.js';
+import type { SendMessage } from '../../core/people/send-message.js';
 import type { ReadInbox } from '../../core/people/read-inbox.js';
+import type { ReadWakeChannels } from '../../core/people/read-wake-channels.js';
+import type { FocusPage } from '../../core/people/focus-page.js';
+import type { TurnOffWebPush } from '../../core/people/turn-off-web-push.js';
+import type { TurnOnWebPush } from '../../core/people/turn-on-web-push.js';
+import type { TurnEmailChannel } from '../../core/people/turn-email-channel.js';
 import type { ReadAuthorization } from '../../core/oauth/read-authorization.js';
 import type { WatchWaiting } from '../../core/requests/watch-waiting.js';
 /** The header the web app's waiting page sends its browser's secret in (web/lib/gateway-api/gateway-api.ts names the same). */
@@ -66,6 +80,7 @@ export interface Context {
     readConnection: ReadConnection;
     connect: Connect;
     approveParty: ApproveParty;
+    addClientParty: AddClientParty;
     crewParty: CrewParty;
     listParties: ListParties;
     listOwnerChoices: ListOwnerChoices;
@@ -75,8 +90,16 @@ export interface Context {
     readParty: ReadParty;
     checkServer: CheckServer;
     readPartyTools: ReadPartyTools;
+    addA2aClient: AddA2aClient;
+    addA2aAgent: AddA2aAgent;
+    markA2aAgent: MarkA2aAgent;
+    /** The ships an A2A client reaches now, by alias (decision 0060). */
+    listReachedShips: ListReachedShips;
+    /** The address of an alias's public card, under the gateway's public URL. */
+    cardAddressOf: (alias: string) => string;
     stateParty: StateParty;
     markTool: MarkTool;
+    switchTool: SwitchTool;
     registerClient: RegisterClient;
     /** An MCP client's authorization request, as the gateway reads it before it signs the person in. */
     readAuthorization?: ReadAuthorization;
@@ -93,6 +116,14 @@ export interface Context {
         openDelivery: OpenDelivery;
         answerDelivery: AnswerDelivery;
         doneDelivery: DoneDelivery;
+        readWakeChannels: ReadWakeChannels;
+        turnEmailChannel: TurnEmailChannel;
+        turnOnWebPush: TurnOnWebPush;
+        turnOffWebPush: TurnOffWebPush;
+        focusPage: FocusPage;
+        sendMessage: SendMessage;
+        readMeeting: ReadMeeting;
+        changeOwnMic: ChangeOwnMic;
     };
     readOutsideParties: ReadOutsideParties;
     setOutsideParties: SetOutsideParties;
@@ -217,7 +248,7 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
             output: ({
                 kind: "mcpServer";
                 url: string;
-                credentialKind: "bearer" | "clientCredentials";
+                credentialKind: "none" | "bearer" | "clientCredentials";
                 concurrencyLimit: number;
                 proxyShipName: string | null;
                 ownerShipId: string | null;
@@ -236,6 +267,28 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
                 name: string;
                 state: "awaitingCrew" | "crewed" | "commissioning";
                 proxyShipId: string | null;
+            } | {
+                kind: "a2aClient";
+                proxyShipName: string | null;
+                ownerShipId: string | null;
+                ownerName: string | null;
+                scopes: string[] | null;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                cardUrl: string;
+                credentialKind: "none" | "bearer" | "clientCredentials";
+                concurrencyLimit: number;
+                isRepeatable: boolean;
+                kind: "a2aAgent";
+                proxyShipName: string | null;
+                ownerShipId: string | null;
+                ownerName: string | null;
+                scopes: string[] | null;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
             })[];
             meta: object;
         }>;
@@ -256,7 +309,7 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
             output: {
                 kind: "mcpServer";
                 url: string;
-                credentialKind: "bearer" | "clientCredentials";
+                credentialKind: "none" | "bearer" | "clientCredentials";
                 concurrencyLimit: number;
                 proxyShipName: string | null;
                 ownerShipId: string | null;
@@ -275,10 +328,32 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
                 name: string;
                 state: "awaitingCrew" | "crewed" | "commissioning";
                 proxyShipId: string | null;
+            } | {
+                kind: "a2aClient";
+                proxyShipName: string | null;
+                ownerShipId: string | null;
+                ownerName: string | null;
+                scopes: string[] | null;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                cardUrl: string;
+                credentialKind: "none" | "bearer" | "clientCredentials";
+                concurrencyLimit: number;
+                isRepeatable: boolean;
+                kind: "a2aAgent";
+                proxyShipName: string | null;
+                ownerShipId: string | null;
+                ownerName: string | null;
+                scopes: string[] | null;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
             };
             meta: object;
         }>;
-        /** An outside MCP server's tools, as the server lists them now, asked with the credential the gateway keeps. Any actor reads them. */
+        /** An outside MCP server's tools, as the server lists them now, asked with the credential the gateway keeps, each with its switch. Any actor reads them. */
         tools: import("@trpc/server").TRPCQueryProcedure<{
             input: {
                 name: string;
@@ -286,6 +361,9 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
             output: {
                 tools: {
                     name: string;
+                    isReadOnly: boolean;
+                    isOn: boolean;
+                    isNew: boolean;
                     description?: string | undefined;
                 }[];
             };
@@ -301,6 +379,8 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
             input: {
                 url: string;
                 credential: {
+                    kind: "none";
+                } | {
                     kind: "bearer";
                     token: string;
                 } | {
@@ -314,6 +394,7 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
             output: {
                 tools: {
                     name: string;
+                    isReadOnly: boolean;
                     description?: string | undefined;
                 }[];
             };
@@ -331,6 +412,8 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
                 name: string;
                 url: string;
                 credential: {
+                    kind: "none";
+                } | {
                     kind: "bearer";
                     token: string;
                 } | {
@@ -342,11 +425,15 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
                 };
                 ownerShipId: unknown;
                 concurrencyLimit?: number | undefined;
+                tools?: {
+                    name: string;
+                    isOn: boolean;
+                }[] | undefined;
             };
             output: {
                 kind: "mcpServer";
                 url: string;
-                credentialKind: "bearer" | "clientCredentials";
+                credentialKind: "none" | "bearer" | "clientCredentials";
                 concurrencyLimit: number;
                 name: string;
                 state: "awaitingCrew" | "crewed" | "commissioning";
@@ -357,6 +444,199 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
                 name: string;
                 state: "awaitingCrew" | "crewed" | "commissioning";
                 proxyShipId: string | null;
+            } | {
+                kind: "a2aClient";
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                cardUrl: string;
+                credentialKind: "none" | "bearer" | "clientCredentials";
+                concurrencyLimit: number;
+                isRepeatable: boolean;
+                kind: "a2aAgent";
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            };
+            meta: object;
+        }>;
+        /**
+         * An actor holding gateway:approve adds a client party with no human at
+         * the authorize step, such as a vendor agent (vendor platforms V4): its
+         * name, its owner (a person ship) and its scopes, only ones it holds. Its
+         * client id and secret are answered once, the secret when its proxy ship
+         * is crewed; a party left awaiting crew gets it from parties.crew. A
+         * repeat with the same request id picks up where the last one stopped.
+         */
+        addClient: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                requestId: string;
+                name: string;
+                ownerShipId: unknown;
+                scopes: string[];
+            };
+            output: {
+                party: {
+                    kind: "mcpServer";
+                    url: string;
+                    credentialKind: "none" | "bearer" | "clientCredentials";
+                    concurrencyLimit: number;
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                } | {
+                    kind: "mcpClient";
+                    clientId: string;
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                } | {
+                    kind: "a2aClient";
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                } | {
+                    cardUrl: string;
+                    credentialKind: "none" | "bearer" | "clientCredentials";
+                    concurrencyLimit: number;
+                    isRepeatable: boolean;
+                    kind: "a2aAgent";
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                };
+                clientId: string;
+                clientSecret: string | null;
+            };
+            meta: object;
+        }>;
+        /**
+         * An actor holding gateway:approve adds an outside A2A client (decision
+         * 0060): the gateway commissions and crews its proxy ship with the owner
+         * and scopes chosen, and answers its bearer, shown only here. A repeat
+         * with the same request id commissions nothing again and answers a new
+         * bearer in place of the first.
+         */
+        addA2aClient: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                requestId: string;
+                name: string;
+                ownerShipId: unknown;
+                scopes: string[];
+            };
+            output: {
+                party: {
+                    kind: "mcpServer";
+                    url: string;
+                    credentialKind: "none" | "bearer" | "clientCredentials";
+                    concurrencyLimit: number;
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                } | {
+                    kind: "mcpClient";
+                    clientId: string;
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                } | {
+                    kind: "a2aClient";
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                } | {
+                    cardUrl: string;
+                    credentialKind: "none" | "bearer" | "clientCredentials";
+                    concurrencyLimit: number;
+                    isRepeatable: boolean;
+                    kind: "a2aAgent";
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                };
+                bearer: string;
+            };
+            meta: object;
+        }>;
+        /**
+         * An actor holding gateway:approve adds an outside A2A agent by its card
+         * address (slice 5): the gateway reads the card first, then commissions
+         * and crews its proxy ship with the owner and scopes chosen, and keeps the
+         * credential in its vault. A repeat with the same request id picks up
+         * where the last one stopped.
+         */
+        addA2aAgent: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                requestId: string;
+                name: string;
+                cardUrl: string;
+                credential: {
+                    kind: "none";
+                } | {
+                    kind: "bearer";
+                    token: string;
+                } | {
+                    kind: "clientCredentials";
+                    clientId: string;
+                    clientSecret: string;
+                    issuer: string;
+                    scope?: string | undefined;
+                };
+                ownerShipId: unknown;
+                scopes: string[];
+                concurrencyLimit?: number | undefined;
+            };
+            output: {
+                kind: "mcpServer";
+                url: string;
+                credentialKind: "none" | "bearer" | "clientCredentials";
+                concurrencyLimit: number;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                kind: "mcpClient";
+                clientId: string;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                kind: "a2aClient";
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                cardUrl: string;
+                credentialKind: "none" | "bearer" | "clientCredentials";
+                concurrencyLimit: number;
+                isRepeatable: boolean;
+                kind: "a2aAgent";
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            };
+            meta: object;
+        }>;
+        /** An actor holding gateway:approve marks an outside A2A agent not repeatable, or repeatable again (A9): kept, then stated at once. */
+        markA2aAgent: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                isRepeatable: boolean;
+            };
+            output: {
+                isRepeatable: boolean;
+                statementRefusal: string | null;
+            };
+            meta: object;
+        }>;
+        /** The card address of each ship an A2A client's proxy ship reaches now (decision 0060), for its owner to hand over. Any actor reads them. */
+        cardAddresses: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                name: string;
+            };
+            output: {
+                addresses: string[];
             };
             meta: object;
         }>;
@@ -393,16 +673,21 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
             output: Record<string, never>;
             meta: object;
         }>;
-        /** argo hands over a new secret, from a new starting prompt in the console, for a proxy ship that awaits crew. */
+        /**
+         * argo hands over a new secret, from a new starting prompt in the console,
+         * for a proxy ship that awaits crew, its crew released or never taken. A
+         * client party that signs in by client credentials is answered its new
+         * client secret, this once (vendor platforms V8).
+         */
         crew: import("@trpc/server").TRPCMutationProcedure<{
             input: {
                 name: string;
                 secret: string;
             };
-            output: {
+            output: ({
                 kind: "mcpServer";
                 url: string;
-                credentialKind: "bearer" | "clientCredentials";
+                credentialKind: "none" | "bearer" | "clientCredentials";
                 concurrencyLimit: number;
                 name: string;
                 state: "awaitingCrew" | "crewed" | "commissioning";
@@ -413,6 +698,22 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
                 name: string;
                 state: "awaitingCrew" | "crewed" | "commissioning";
                 proxyShipId: string | null;
+            } | {
+                kind: "a2aClient";
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                cardUrl: string;
+                credentialKind: "none" | "bearer" | "clientCredentials";
+                concurrencyLimit: number;
+                isRepeatable: boolean;
+                kind: "a2aAgent";
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            }) & {
+                clientSecret: string | null;
             };
             meta: object;
         }>;
@@ -426,6 +727,20 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
             };
             meta: object;
         }>;
+        /** An actor holding gateway:approve switches one tool of an outside MCP server on or off for the party (aeolus-fleet#1151): kept, then stated at once. */
+        switchTool: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                tool: string;
+                isOn: boolean;
+            };
+            output: {
+                tool: string;
+                isOn: boolean;
+                statementRefusal: string | null;
+            };
+            meta: object;
+        }>;
         /** argo marks a party's tool repeatable, or takes the mark off (interop 5.2): kept, then stated at once. */
         markTool: import("@trpc/server").TRPCMutationProcedure<{
             input: {
@@ -477,6 +792,125 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
             output: import("../../core/people/opened-of.js").Dealt;
             meta: object;
         }>;
+        /** The channels that wake them when something waits for their person ship, each offered or not and on or not (wake a person, W8). */
+        wakeChannels: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                email: {
+                    readonly isOffered: boolean;
+                    readonly isOn: boolean;
+                };
+                webPush: {
+                    publicKey: string | null;
+                    browsers: {
+                        addedAt: string;
+                        endpoint: string;
+                        browser: string;
+                        isGone: boolean;
+                    }[];
+                };
+            };
+            meta: object;
+        }>;
+        /** Turns email on or off, to be woken when something waits for their person ship. */
+        turnEmail: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                isOn: boolean;
+            };
+            output: void;
+            meta: object;
+        }>;
+        /** Turns web push on for the browser that sent its subscription; its wakes name the fleet as the person's shared sign-in states it. */
+        turnOnWebPush: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                endpoint: string;
+                keys: {
+                    p256dh: string;
+                    auth: string;
+                };
+                browser: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+        /** Removes a browser the person turned web push on in. */
+        turnOffWebPush: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                endpoint: string;
+            };
+            output: void;
+            meta: object;
+        }>;
+        /**
+         * Held open by a page of the person while it is in focus (wake a person,
+         * W6): what arrives is handed through the page, and no wake goes out. It
+         * tells once that it holds; it ends when the page lets go or loses its
+         * connection.
+         */
+        focus: import("@trpc/server").TRPCSubscriptionProcedure<{
+            input: void;
+            output: AsyncIterable<{
+                isInFocus: boolean;
+            }, void, any>;
+            meta: object;
+        }>;
+        /** A meeting they take part in, with a page of its contributions, newest first, and where they stand on its mic (decision 0061). */
+        meeting: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                meetingId: unknown;
+                cursor?: unknown;
+            };
+            output: {
+                openedAt: string;
+                endedAt: string | null;
+                mic: {
+                    requests: {
+                        ship: import("../../core/meetings/ports.js").MeetingShip;
+                        requestedAt: string;
+                    }[];
+                    holder: import("../../core/meetings/ports.js").MeetingShip | null;
+                    pattern: import("../../core/meetings/ports.js").MicPattern;
+                };
+                contributions: {
+                    items: {
+                        sentAt: string;
+                        messageId: import("@aeolus-fleet/common").MessageId;
+                        sender: import("../../core/meetings/ports.js").MeetingShip;
+                        contentType: string;
+                        payload: string;
+                    }[];
+                    nextCursor: `msg_${string}` | null;
+                };
+                yourMic: import("../../core/meetings/mic-standing.js").MicStanding;
+                meetingId: import("@aeolus-fleet/common").MeetingId;
+                title: string | null;
+                owner: import("../../core/meetings/ports.js").MeetingShip;
+                moderator: import("../../core/meetings/ports.js").MeetingShip;
+                participants: readonly import("../../core/meetings/ports.js").MeetingParticipant[];
+            };
+            meta: object;
+        }>;
+        /** Contributes to a meeting, once under the page's key; the fleet takes it while they hold the mic or moderate. */
+        contribute: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                meetingId: unknown;
+                payload: string;
+                idempotencyKey: string;
+            };
+            output: {
+                messageId: import("@aeolus-fleet/common").MessageId;
+            };
+            meta: object;
+        }>;
+        /** Their own mic call: request it, withdraw the request, or release the mic they hold. */
+        mic: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                meetingId: unknown;
+                change: "request" | "withdraw" | "release";
+            };
+            output: {};
+            meta: object;
+        }>;
     }>>;
     requests: import("@trpc/server").TRPCBuiltRouter<{
         ctx: Context;
@@ -519,7 +953,8 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
             meta: object;
         }>;
         /**
-         * Each change to the actor's fleet's requests, carrying nothing of it:
+         * Each change to the actor's fleet's requests, and to its person ship's
+         * inbox when it is a person's (wake a person, #1014), carrying nothing of it:
          * the page that follows reads itself again as its own caller, so it is
          * never sent what its actor may not see. Changes heard while the last
          * was not yet taken come as one.
@@ -580,6 +1015,8 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
                     };
                     server?: {
                         credential: {
+                            kind: "none";
+                        } | {
                             kind: "bearer";
                             token: string;
                         } | {
@@ -598,7 +1035,7 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
                 party: {
                     kind: "mcpServer";
                     url: string;
-                    credentialKind: "bearer" | "clientCredentials";
+                    credentialKind: "none" | "bearer" | "clientCredentials";
                     concurrencyLimit: number;
                     name: string;
                     state: "awaitingCrew" | "crewed" | "commissioning";
@@ -609,6 +1046,20 @@ export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
                     name: string;
                     state: "awaitingCrew" | "crewed" | "commissioning";
                     proxyShipId: string | null;
+                } | {
+                    kind: "a2aClient";
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                } | {
+                    cardUrl: string;
+                    credentialKind: "none" | "bearer" | "clientCredentials";
+                    concurrencyLimit: number;
+                    isRepeatable: boolean;
+                    kind: "a2aAgent";
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
                 } | null;
             };
             meta: object;