@aeolus-fleet/gateway 0.29.1 → 0.30.0

package/dist/core/a2a-in/task-view.js

@@ -0,0 +1,49 @@
+/**
+ * An A2A task as its client reads it (interop 3.4, decision 0060): the
+ * calls its client made in it, in the order sent, read by the one rule of
+ * the call store. Its state is its latest call's: completed by the answer,
+ * input required by a question, the state an `application/a2a+json` reply
+ * carries, failed at the deadline or when the fleet gave the delivery up,
+ * working once the ship took it, submitted before. Its history is the
+ * client's messages and the ship's replies in the order they came.
+ */
+import { A2A_CONTENT_TYPE, QUESTION_CONTENT_TYPE, answerOf, isOfEssence, repliesBeforeFailure, stateOf, stateSince } from '../mcp-in/client-call.js';
+const isA2a = (reply) => isOfEssence(reply.contentType, A2A_CONTENT_TYPE);
+const isQuestion = (reply) => isOfEssence(reply.contentType, QUESTION_CONTENT_TYPE);
+/**
+ * The status of one call. Failed wins once the call failed; else its answer
+ * completes it; else the latest A2A reply or question drives it; else it is
+ * working or submitted, as the call's own state says.
+ */
+function statusOf(call, now) {
+    const own = stateOf(call, now);
+    const since = stateSince(call, now);
+    if (own.state === 'failed') {
+        return { state: 'failed', since };
+    }
+    const answer = answerOf(call, now);
+    if (answer !== undefined && !isA2a(answer)) {
+        return { state: 'completed', answer, since: answer.receivedAt };
+    }
+    const latest = repliesBeforeFailure(call, now)
+        .filter((reply) => isA2a(reply) || isQuestion(reply))
+        .at(-1);
+    if (latest !== undefined) {
+        return isA2a(latest) ? { state: 'carried', reply: latest, since: latest.receivedAt } : { state: 'inputRequired', question: latest, since: latest.receivedAt };
+    }
+    return own.state === 'submitted' ? { state: 'submitted', since } : { state: 'working', since };
+}
+/** Whether the task ended: completed or failed, so it takes no follow-up and a follow of it ends. */
+export const isTerminal = (view) => view.status.state === 'completed' || view.status.state === 'failed';
+/** What tells one view of a task from the next: its state, since when, and how much history it holds. */
+export const markOf = (view) => `${view.status.state}:${String(view.status.since.getTime())}:${String(view.history.length)}`;
+/** The task as its client reads it now; a task with no call kept yet is submitted since now. */
+export function taskViewOf(task, now) {
+    const latest = task.calls.at(-1);
+    const history = task.calls
+        .flatMap((call) => [{ by: 'client', message: call.task?.message ?? '', at: call.sentAt }, ...call.replies.map((reply) => ({ by: 'ship', reply, at: reply.receivedAt }))])
+        .sort((left, right) => left.at.getTime() - right.at.getTime())
+        .map((entry) => (entry.by === 'client' ? entry : { by: 'ship', reply: entry.reply }));
+    return { taskId: task.taskId, contextId: task.contextId, status: latest === undefined ? { state: 'submitted', since: now } : statusOf(latest, now), history };
+}
+//# sourceMappingURL=task-view.js.map

package/dist/core/a2a-in/task-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-view.js","sourceRoot":"","sources":["../../../src/core/a2a-in/task-view.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,QAAQ,EAAE,WAAW,EAAE,oBAAoB,EAAE,OAAO,EAAE,UAAU,EAAmC,MAAM,0BAA0B,CAAC;AAqBtL,MAAM,KAAK,GAAG,CAAC,KAAgB,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;AACrF,MAAM,UAAU,GAAG,CAAC,KAAgB,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,WAAW,EAAE,qBAAqB,CAAC,CAAC;AAE/F;;;;GAIG;AACH,SAAS,QAAQ,CAAC,IAAgB,EAAE,GAAS;IAC3C,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC/B,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACpC,IAAI,GAAG,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC3B,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IACpC,CAAC;IACD,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACnC,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QAC3C,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC;IAClE,CAAC;IACD,MAAM,MAAM,GAAG,oBAAoB,CAAC,IAAI,EAAE,GAAG,CAAC;SAC3C,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;SACpD,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACV,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC;IAChK,CAAC;IACD,OAAO,GAAG,CAAC,KAAK,KAAK,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;AACjG,CAAC;AAED,qGAAqG;AACrG,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,IAAc,EAAW,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,KAAK,WAAW,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,KAAK,QAAQ,CAAC;AAE3H,yGAAyG;AACzG,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,IAAc,EAAU,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;AAE/I,gGAAgG;AAChG,MAAM,UAAU,UAAU,CAAC,IAAgB,EAAE,GAAS;IACpD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACjC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK;SACvB,OAAO,CAAC,CAAC,IAAI,EAAgC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,IAAI,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,MAAe,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC;SAC/M,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC;SAC7D,GAAG,CAAC,CAAC,KAAK,EAAa,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACnG,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC;AAChK,CAAC"}

package/dist/core/a2a-in/webhook-address.d.ts

@@ -0,0 +1,7 @@
+import type { HostResolver } from './ports.js';
+/**
+ * Where the webhook's host is reached now: an address as the host is itself,
+ * a name at every address it resolves to. It is public only when every one
+ * is; inside when any is not; unresolved when a name resolves to nothing.
+ */
+export declare function reachOf(resolver: HostResolver, url: URL): Promise<'public' | 'inside' | 'unresolved'>;

package/dist/core/a2a-in/webhook-address.js

@@ -0,0 +1,17 @@
+import { isIP } from 'node:net';
+import { isPublicAddress } from './webhook.js';
+/**
+ * Where the webhook's host is reached now: an address as the host is itself,
+ * a name at every address it resolves to. It is public only when every one
+ * is; inside when any is not; unresolved when a name resolves to nothing.
+ */
+export async function reachOf(resolver, url) {
+    // An IPv6 host is written in brackets in a URL.
+    const host = url.hostname.replace(/^\[(.*)\]$/, '$1');
+    const addresses = isIP(host) === 0 ? await resolver.addressesOf(host) : [host];
+    if (addresses.length === 0) {
+        return 'unresolved';
+    }
+    return addresses.every(isPublicAddress) ? 'public' : 'inside';
+}
+//# sourceMappingURL=webhook-address.js.map

package/dist/core/a2a-in/webhook-address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-address.js","sourceRoot":"","sources":["../../../src/core/a2a-in/webhook-address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAGhC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAAC,QAAsB,EAAE,GAAQ;IAC5D,gDAAgD;IAChD,MAAM,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;IACtD,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC/E,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,YAAY,CAAC;IACtB,CAAC;IACD,OAAO,SAAS,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC;AAChE,CAAC"}

package/dist/core/a2a-in/webhook.d.ts

@@ -0,0 +1,6 @@
+import { type DomainError } from '../shared/errors.js';
+import { type Result } from '../shared/result.js';
+/** Whether a webhook may be reached at this address: a public unicast one. */
+export declare function isPublicAddress(address: string): boolean;
+/** A webhook's URL: https, with a host and no credentials in it. */
+export declare function webhookUrlOf(raw: string): Result<URL, DomainError<'WEBHOOK_REFUSED'>>;

package/dist/core/a2a-in/webhook.js

@@ -0,0 +1,80 @@
+/**
+ * An outside A2A client's webhook (slice 4): where the gateway POSTs each
+ * change of its task. The gateway calls it from inside the fleet's network
+ * at a URL the outside chose, so it is an https URL that carries no
+ * credentials, reached only at a public address: never loopback, private,
+ * shared, link-local (cloud metadata), unique-local, site-local,
+ * documentation, multicast or reserved, nor an IPv6 address that carries an
+ * IPv4 one inside (IPv4-mapped, IPv4-compatible, NAT64, 6to4, Teredo).
+ * The address is checked once the host resolves, when the config is set and
+ * again at each push, so a name that resolves to an inside address is
+ * refused like the address itself.
+ */
+import { BlockList, isIP } from 'node:net';
+import { refuse } from '../shared/errors.js';
+import { ok } from '../shared/result.js';
+/** The addresses no webhook is reached at. */
+const INSIDE = new BlockList();
+for (const [network, prefix] of [
+    ['0.0.0.0', 8],
+    ['10.0.0.0', 8],
+    ['100.64.0.0', 10],
+    ['127.0.0.0', 8],
+    ['169.254.0.0', 16],
+    ['172.16.0.0', 12],
+    ['192.0.0.0', 24],
+    ['192.0.2.0', 24],
+    ['192.168.0.0', 16],
+    ['198.18.0.0', 15],
+    ['198.51.100.0', 24],
+    ['203.0.113.0', 24],
+    ['224.0.0.0', 4],
+    ['240.0.0.0', 4],
+]) {
+    INSIDE.addSubnet(network, prefix, 'ipv4');
+}
+for (const [network, prefix] of [
+    // IPv4-compatible (::a.b.c.d), unspecified and loopback.
+    ['::', 96],
+    // NAT64, Teredo and 6to4 carry an IPv4 address inside, which could be any inside one: refused whole, as ::ffff: is.
+    ['64:ff9b::', 96],
+    ['64:ff9b:1::', 48],
+    ['2001::', 32],
+    ['2002::', 16],
+    ['100::', 64],
+    ['2001:db8::', 32],
+    ['fc00::', 7],
+    ['fe80::', 10],
+    ['fec0::', 10],
+    ['ff00::', 8],
+]) {
+    INSIDE.addSubnet(network, prefix, 'ipv6');
+}
+const IPV4 = 4;
+/** Whether a webhook may be reached at this address: a public unicast one. */
+export function isPublicAddress(address) {
+    const version = isIP(address);
+    if (version === 0) {
+        return false;
+    }
+    // An IPv4 address written as IPv6 (::ffff:a.b.c.d) is refused whole: a webhook never needs one, and it could name any inside address.
+    if (version !== IPV4 && /^::ffff:/i.test(address)) {
+        return false;
+    }
+    return !INSIDE.check(address, version === IPV4 ? 'ipv4' : 'ipv6');
+}
+/** A webhook's URL: https, with a host and no credentials in it. */
+export function webhookUrlOf(raw) {
+    if (!URL.canParse(raw)) {
+        return refuse('WEBHOOK_REFUSED', 'The webhook is no URL: name an https URL');
+    }
+    const url = new URL(raw);
+    if (url.protocol !== 'https:' || url.hostname === '') {
+        return refuse('WEBHOOK_REFUSED', 'The webhook must be an https URL');
+    }
+    if (url.username !== '' || url.password !== '') {
+        return refuse('WEBHOOK_REFUSED', 'The webhook URL carries credentials: send them as the config\'s authentication');
+    }
+    return ok(url);
+}
+//# sourceMappingURL=webhook.js.map

package/dist/core/a2a-in/webhook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook.js","sourceRoot":"","sources":["../../../src/core/a2a-in/webhook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAE3C,OAAO,EAAE,MAAM,EAAoB,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,EAAE,EAAe,MAAM,qBAAqB,CAAC;AAEtD,8CAA8C;AAC9C,MAAM,MAAM,GAAG,IAAI,SAAS,EAAE,CAAC;AAC/B,KAAK,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI;IAC9B,CAAC,SAAS,EAAE,CAAC,CAAC;IACd,CAAC,UAAU,EAAE,CAAC,CAAC;IACf,CAAC,YAAY,EAAE,EAAE,CAAC;IAClB,CAAC,WAAW,EAAE,CAAC,CAAC;IAChB,CAAC,aAAa,EAAE,EAAE,CAAC;IACnB,CAAC,YAAY,EAAE,EAAE,CAAC;IAClB,CAAC,WAAW,EAAE,EAAE,CAAC;IACjB,CAAC,WAAW,EAAE,EAAE,CAAC;IACjB,CAAC,aAAa,EAAE,EAAE,CAAC;IACnB,CAAC,YAAY,EAAE,EAAE,CAAC;IAClB,CAAC,cAAc,EAAE,EAAE,CAAC;IACpB,CAAC,aAAa,EAAE,EAAE,CAAC;IACnB,CAAC,WAAW,EAAE,CAAC,CAAC;IAChB,CAAC,WAAW,EAAE,CAAC,CAAC;CACR,EAAE,CAAC;IACX,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC5C,CAAC;AACD,KAAK,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI;IAC9B,yDAAyD;IACzD,CAAC,IAAI,EAAE,EAAE,CAAC;IACV,oHAAoH;IACpH,CAAC,WAAW,EAAE,EAAE,CAAC;IACjB,CAAC,aAAa,EAAE,EAAE,CAAC;IACnB,CAAC,QAAQ,EAAE,EAAE,CAAC;IACd,CAAC,QAAQ,EAAE,EAAE,CAAC;IACd,CAAC,OAAO,EAAE,EAAE,CAAC;IACb,CAAC,YAAY,EAAE,EAAE,CAAC;IAClB,CAAC,QAAQ,EAAE,CAAC,CAAC;IACb,CAAC,QAAQ,EAAE,EAAE,CAAC;IACd,CAAC,QAAQ,EAAE,EAAE,CAAC;IACd,CAAC,QAAQ,EAAE,CAAC,CAAC;CACL,EAAE,CAAC;IACX,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC5C,CAAC;AAED,MAAM,IAAI,GAAG,CAAC,CAAC;AAEf,8EAA8E;AAC9E,MAAM,UAAU,eAAe,CAAC,OAAe;IAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9B,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;QAClB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,sIAAsI;IACtI,IAAI,OAAO,KAAK,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QAClD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AACpE,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,MAAM,CAAC,iBAAiB,EAAE,0CAA0C,CAAC,CAAC;IAC/E,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;IACzB,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,IAAI,GAAG,CAAC,QAAQ,KAAK,EAAE,EAAE,CAAC;QACrD,OAAO,MAAM,CAAC,iBAAiB,EAAE,kCAAkC,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,GAAG,CAAC,QAAQ,KAAK,EAAE,IAAI,GAAG,CAAC,QAAQ,KAAK,EAAE,EAAE,CAAC;QAC/C,OAAO,MAAM,CAAC,iBAAiB,EAAE,gFAAgF,CAAC,CAAC;IACrH,CAAC;IACD,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;AACjB,CAAC"}

package/dist/core/a2a-out/agent-endpoint.d.ts

@@ -0,0 +1,10 @@
+import type { AgentCard, AgentInterface } from './ports.js';
+/** Where the gateway calls an outside A2A agent (slice 6): one of its card's interfaces, and whether the card states streaming. */
+export interface AgentEndpoint {
+    readonly url: string;
+    readonly protocolBinding: string;
+    readonly isStreaming: boolean;
+}
+export declare const isCalledInterface: (each: AgentInterface) => boolean;
+/** The first interface in the card's order that the gateway calls, as the card prefers it; none when it has none. */
+export declare function agentEndpointOf(card: AgentCard): AgentEndpoint | undefined;

package/dist/core/a2a-out/agent-endpoint.js

@@ -0,0 +1,10 @@
+/** The bindings the gateway calls an agent over, at A2A 1.0 (A11). */
+const CALLED_BINDINGS = new Set(['JSONRPC', 'HTTP+JSON']);
+const CALLED_VERSION = /^1\.0(\.\d+)?$/;
+export const isCalledInterface = (each) => CALLED_BINDINGS.has(each.protocolBinding) && CALLED_VERSION.test(each.protocolVersion);
+/** The first interface in the card's order that the gateway calls, as the card prefers it; none when it has none. */
+export function agentEndpointOf(card) {
+    const called = card.supportedInterfaces.find(isCalledInterface);
+    return called === undefined ? undefined : { url: called.url, protocolBinding: called.protocolBinding, isStreaming: card.isStreaming };
+}
+//# sourceMappingURL=agent-endpoint.js.map

package/dist/core/a2a-out/agent-endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-endpoint.js","sourceRoot":"","sources":["../../../src/core/a2a-out/agent-endpoint.ts"],"names":[],"mappings":"AAEA,sEAAsE;AACtE,MAAM,eAAe,GAAwB,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC;AAC/E,MAAM,cAAc,GAAG,gBAAgB,CAAC;AASxC,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,IAAoB,EAAE,EAAE,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;AAElJ,qHAAqH;AACrH,MAAM,UAAU,eAAe,CAAC,IAAe;IAC7C,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IAChE,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,eAAe,EAAE,MAAM,CAAC,eAAe,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC;AACxI,CAAC"}

package/dist/core/a2a-out/agent-event.d.ts

@@ -0,0 +1,41 @@
+import type { AgentPart } from './agent-message.js';
+export type AgentState = 'submitted' | 'working' | 'inputRequired' | 'authRequired' | 'completed' | 'failed' | 'canceled' | 'rejected' | 'unspecified';
+/** A status with the time the agent recorded it, if it said; an artifact, whole or a chunk appended to it; a message. */
+export type AgentEvent = {
+    readonly kind: 'status';
+    readonly state: AgentState;
+    readonly timestamp: string | null;
+    readonly json: string;
+} | {
+    readonly kind: 'artifact';
+    readonly artifactId: string;
+    readonly isAppended: boolean;
+    readonly parts: readonly AgentPart[];
+    readonly json: string;
+} | {
+    readonly kind: 'message';
+    readonly messageId: string;
+    readonly parts: readonly AgentPart[];
+    readonly json: string;
+};
+export declare function endsFollowing(event: AgentEvent): boolean;
+/** Per artifact, the place its next appended chunk takes, as the replies so far leave it. */
+export type ChunkPlaces = Readonly<Record<string, number>>;
+/**
+ * What makes an event of a task one reply, as a follow of one fleet message sees them in turn, and the chunk places after it:
+ * - a status: the message it answers, its state and its time, so a status told again is one reply and the same state on a follow-up is another;
+ * - an artifact: its id and the place of its chunk, so the whole artifact a task read or a new stream starts with is its first chunk again, never its chunks once more;
+ * - a message: its id.
+ */
+export declare function eventIdentityOf(event: AgentEvent, seen: {
+    answering: string;
+    chunkPlaces: ChunkPlaces;
+}): {
+    identity: string;
+    chunkPlaces: ChunkPlaces;
+};
+/** The reply's content type and payload; one too large for a message says so instead. */
+export declare function replyContentOf(event: AgentEvent): {
+    contentType: string;
+    payload: string;
+};

package/dist/core/a2a-out/agent-event.js

@@ -0,0 +1,64 @@
+/**
+ * What an outside A2A agent tells of a task (slice 6): its status, an
+ * artifact, or a message answering with no task, each with the A2A JSON it
+ * came as. Each goes back to the sender as one reply (2a): an artifact or
+ * message of one text part as that text, of one data part as JSON, so a ship
+ * that knows nothing of A2A reads its result; anything else, and every
+ * status, as `application/a2a+json`. Following stops at a terminal or
+ * interrupted state, and at a message answer.
+ */
+import { PAYLOAD_MAX_BYTES, payloadBytes } from '@aeolus-fleet/common';
+import { A2A_CONTENT_TYPE } from '../mcp-in/client-call.js';
+/** The states after which the agent does nothing more without a new message: ended, or waiting for input or authentication. */
+const ENDING_STATES = new Set(['completed', 'failed', 'canceled', 'rejected', 'inputRequired', 'authRequired']);
+export function endsFollowing(event) {
+    switch (event.kind) {
+        case 'status':
+            return ENDING_STATES.has(event.state);
+        case 'message':
+            return true;
+        case 'artifact':
+            return false;
+    }
+}
+/**
+ * What makes an event of a task one reply, as a follow of one fleet message sees them in turn, and the chunk places after it:
+ * - a status: the message it answers, its state and its time, so a status told again is one reply and the same state on a follow-up is another;
+ * - an artifact: its id and the place of its chunk, so the whole artifact a task read or a new stream starts with is its first chunk again, never its chunks once more;
+ * - a message: its id.
+ */
+export function eventIdentityOf(event, seen) {
+    const { answering, chunkPlaces } = seen;
+    switch (event.kind) {
+        case 'status':
+            return { identity: JSON.stringify(['status', answering, event.state, event.timestamp]), chunkPlaces };
+        case 'artifact': {
+            const next = chunkPlaces[event.artifactId] ?? 1;
+            const chunk = event.isAppended ? next : 0;
+            return { identity: JSON.stringify(['artifact', event.artifactId, chunk]), chunkPlaces: { ...chunkPlaces, [event.artifactId]: Math.max(next, chunk + 1) } };
+        }
+        case 'message':
+            return { identity: JSON.stringify(['message', event.messageId]), chunkPlaces };
+    }
+}
+const PLAIN_TEXT = 'text/plain';
+const JSON_TYPE = 'application/json';
+function plainContentOf(event) {
+    const [only, ...more] = event.kind === 'status' ? [] : event.parts;
+    if (only !== undefined && more.length === 0) {
+        if (only.kind === 'text') {
+            return { contentType: only.mediaType, payload: only.text };
+        }
+        if (only.kind === 'data') {
+            return { contentType: JSON_TYPE, payload: JSON.stringify(only.data) };
+        }
+    }
+    return { contentType: A2A_CONTENT_TYPE, payload: event.json };
+}
+/** The reply's content type and payload; one too large for a message says so instead. */
+export function replyContentOf(event) {
+    const content = plainContentOf(event);
+    const bytes = payloadBytes(content.payload);
+    return bytes > PAYLOAD_MAX_BYTES ? { contentType: PLAIN_TEXT, payload: `The agent's ${event.kind} is ${String(bytes)} bytes, over the ${String(PAYLOAD_MAX_BYTES)} a message holds.` } : content;
+}
+//# sourceMappingURL=agent-event.js.map

package/dist/core/a2a-out/agent-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-event.js","sourceRoot":"","sources":["../../../src/core/a2a-out/agent-event.ts"],"names":[],"mappings":"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"}

package/dist/core/a2a-out/agent-message.d.ts

@@ -0,0 +1,36 @@
+import { type DomainError } from '../shared/errors.js';
+import { type Result } from '../shared/result.js';
+/** One part of an A2A message or artifact the gateway reads: text, data, or another kind it carries but does not read. */
+export type AgentPart = {
+    readonly kind: 'text';
+    readonly text: string;
+    readonly mediaType: string;
+} | {
+    readonly kind: 'data';
+    readonly data: unknown;
+    readonly mediaType: string;
+} | {
+    readonly kind: 'other';
+};
+/** The message the gateway sends an outside agent: its parts, or the A2A Message the sender wrote, as JSON. */
+export interface OutboundMessage {
+    readonly messageId: string;
+    /** The task a follow-up continues, none for a new one. */
+    readonly taskId: string | null;
+    readonly contextId: string | null;
+    readonly content: {
+        readonly kind: 'parts';
+        readonly parts: readonly AgentPart[];
+    } | {
+        readonly kind: 'whole';
+        readonly message: Readonly<Record<string, unknown>>;
+    };
+}
+export declare function outboundMessageOf(delivery: {
+    contentType: string;
+    payload: string;
+}, ids: {
+    messageId: string;
+    taskId: string | null;
+    contextId: string | null;
+}): Result<OutboundMessage, DomainError<'NOT_A_MESSAGE'>>;

package/dist/core/a2a-out/agent-message.js

@@ -0,0 +1,36 @@
+/**
+ * A delivery to an outside A2A agent's proxy ship, as the A2A message the
+ * gateway sends the agent (slice 6): A7 the other way, so an A2A client
+ * reading it back gets what the sender wrote. Text travels as one text part
+ * and JSON as one data part, each with the delivery's media type; an
+ * `application/a2a+json` delivery is the A2A Message itself, sent whole with
+ * the gateway's ids put in; any other type travels as one text part.
+ */
+import { A2A_CONTENT_TYPE, essenceOf } from '../mcp-in/client-call.js';
+import { refuse } from '../shared/errors.js';
+import { ok } from '../shared/result.js';
+const isJson = (essence) => essence === 'application/json' || essence.endsWith('+json');
+function parsed(payload) {
+    try {
+        return { isParsed: true, value: JSON.parse(payload) };
+    }
+    catch {
+        return { isParsed: false };
+    }
+}
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export function outboundMessageOf(delivery, ids) {
+    const essence = essenceOf(delivery.contentType);
+    if (essence === A2A_CONTENT_TYPE) {
+        const message = parsed(delivery.payload);
+        return message.isParsed && isObject(message.value)
+            ? ok({ ...ids, content: { kind: 'whole', message: message.value } })
+            : refuse('NOT_A_MESSAGE', `An ${A2A_CONTENT_TYPE} payload is an A2A Message as a JSON object`);
+    }
+    if (isJson(essence)) {
+        const data = parsed(delivery.payload);
+        return data.isParsed ? ok({ ...ids, content: { kind: 'parts', parts: [{ kind: 'data', data: data.value, mediaType: delivery.contentType }] } }) : refuse('NOT_A_MESSAGE', `A ${delivery.contentType} payload is JSON`);
+    }
+    return ok({ ...ids, content: { kind: 'parts', parts: [{ kind: 'text', text: delivery.payload, mediaType: delivery.contentType }] } });
+}
+//# sourceMappingURL=agent-message.js.map

package/dist/core/a2a-out/agent-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-message.js","sourceRoot":"","sources":["../../../src/core/a2a-out/agent-message.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,EAAE,MAAM,EAAoB,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,EAAE,EAAe,MAAM,qBAAqB,CAAC;AActD,MAAM,MAAM,GAAG,CAAC,OAAe,EAAE,EAAE,CAAC,OAAO,KAAK,kBAAkB,IAAI,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;AAEhG,SAAS,MAAM,CAAC,OAAe;IAC7B,IAAI,CAAC;QACH,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC7B,CAAC;AACH,CAAC;AAED,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAoC,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAE5I,MAAM,UAAU,iBAAiB,CAC/B,QAAkD,EAClD,GAA2E;IAE3E,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IAChD,IAAI,OAAO,KAAK,gBAAgB,EAAE,CAAC;QACjC,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACzC,OAAO,OAAO,CAAC,QAAQ,IAAI,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC;YAChD,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;YACpE,CAAC,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,gBAAgB,6CAA6C,CAAC,CAAC;IACnG,CAAC;IACD,IAAI,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACtC,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,EAAE,KAAK,QAAQ,CAAC,WAAW,kBAAkB,CAAC,CAAC;IACzN,CAAC;IACD,OAAO,EAAE,CAAC,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;AACxI,CAAC"}

package/dist/core/a2a-out/agent-statement.d.ts

@@ -0,0 +1,10 @@
+import type { CallTiming, Statement } from '../mcp-out/statement.js';
+import { type DomainError } from '../shared/errors.js';
+import { type Result } from '../shared/result.js';
+import type { AgentCard } from './ports.js';
+export declare function agentStatementOf(input: {
+    partyName: string;
+    card: AgentCard;
+    isRepeatable: boolean;
+    timing: CallTiming;
+}): Result<Statement, DomainError<'CARD_INVALID'>>;

package/dist/core/a2a-out/agent-statement.js

@@ -0,0 +1,45 @@
+/**
+ * An outside A2A agent's proxy ship's statement (slice 5), written from its
+ * public card: each skill is one capability, by its id, with its name,
+ * description and media types, the card's defaults where it names none.
+ * The card's interfaces, schemes and signatures stay in the gateway (NAT
+ * both ways), and a skill has no schema. Every capability is repeatable,
+ * A2A's default, unless the agent is marked not repeatable (A9). A card the
+ * gateway cannot call, or that makes no valid statement, is refused with the
+ * reason.
+ */
+import { STATEMENT_SUMMARY_MAX_LENGTH, statementSchema } from '@aeolus-fleet/common';
+import { refuse } from '../shared/errors.js';
+import { ok } from '../shared/result.js';
+import { agentEndpointOf } from './agent-endpoint.js';
+function capabilityOf(skill, of) {
+    return {
+        name: skill.id,
+        title: skill.name,
+        description: skill.description,
+        inputModes: skill.inputModes.length > 0 ? skill.inputModes : of.card.defaultInputModes,
+        outputModes: skill.outputModes.length > 0 ? skill.outputModes : of.card.defaultOutputModes,
+        waitMs: of.timing.waitMs,
+        deadlineMs: of.timing.deadlineMs,
+        ...(of.isRepeatable ? { repeatable: true } : {}),
+    };
+}
+export function agentStatementOf(input) {
+    const { card } = input;
+    if (agentEndpointOf(card) === undefined) {
+        return refuse('CARD_INVALID', 'The card has no interface the gateway calls: JSONRPC or HTTP+JSON at A2A 1.0');
+    }
+    if (card.skills.length === 0) {
+        return refuse('CARD_INVALID', 'The card has no skill to state');
+    }
+    const statement = {
+        summary: `${input.partyName}, an outside A2A agent reached through the Aeolus gateway: ${card.description}`.slice(0, STATEMENT_SUMMARY_MAX_LENGTH),
+        capabilities: card.skills.map((skill) => capabilityOf(skill, { card, isRepeatable: input.isRepeatable, timing: input.timing })),
+    };
+    const checked = statementSchema.safeParse(statement);
+    if (!checked.success) {
+        return refuse('CARD_INVALID', `The card makes no valid statement: ${checked.error.issues.map((issue) => issue.message).join('; ')}`);
+    }
+    return ok(statement);
+}
+//# sourceMappingURL=agent-statement.js.map

package/dist/core/a2a-out/agent-statement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-statement.js","sourceRoot":"","sources":["../../../src/core/a2a-out/agent-statement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,4BAA4B,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGrF,OAAO,EAAE,MAAM,EAAoB,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,EAAE,EAAe,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtD,SAAS,YAAY,CAAC,KAAiB,EAAE,EAAkE;IACzG,OAAO;QACL,IAAI,EAAE,KAAK,CAAC,EAAE;QACd,KAAK,EAAE,KAAK,CAAC,IAAI;QACjB,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,iBAAiB;QACtF,WAAW,EAAE,KAAK,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,kBAAkB;QAC1F,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM;QACxB,UAAU,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU;QAChC,GAAG,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,IAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC1D,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,KAAwF;IACvH,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC;IACvB,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;QACxC,OAAO,MAAM,CAAC,cAAc,EAAE,8EAA8E,CAAC,CAAC;IAChH,CAAC;IACD,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,MAAM,CAAC,cAAc,EAAE,gCAAgC,CAAC,CAAC;IAClE,CAAC;IACD,MAAM,SAAS,GAAc;QAC3B,OAAO,EAAE,GAAG,KAAK,CAAC,SAAS,8DAA8D,IAAI,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,4BAA4B,CAAC;QAClJ,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;KAChI,CAAC;IACF,MAAM,OAAO,GAAG,eAAe,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IACrD,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;QACrB,OAAO,MAAM,CAAC,cAAc,EAAE,sCAAsC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACvI,CAAC;IACD,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC;AACvB,CAAC"}

package/dist/core/a2a-out/follow-agent-task.d.ts

@@ -0,0 +1,40 @@
+import type { HandOutcome } from '../mcp-out/hand-call.js';
+import type { Sleep } from '../mcp-out/run-party.js';
+import type { A2aAgentParty } from '../parties/party.js';
+import type { Clock } from '../shared/clock.js';
+import type { AgentEndpoint } from './agent-endpoint.js';
+import { type AgentEvent } from './agent-event.js';
+import type { A2aAgents, AgentCall, AgentCalls, AgentKeys, AgentShipCrew, GatewayStatuses } from './ports.js';
+export type FollowAgentTask = (input: {
+    party: A2aAgentParty;
+    endpoint: AgentEndpoint;
+    call: AgentCall;
+    signal: AbortSignal;
+    events?: readonly AgentEvent[];
+}) => Promise<HandOutcome>;
+/** The reason a delivery whose task the agent no longer knows is not handled, as Needs attention shows it. */
+export declare const TASK_GONE = "The agent's task is gone";
+/**
+ * Use case: the gateway follows an outside A2A agent's task, after the agent
+ * took a delivery and the gateway acknowledged it (slice 6, flow 4.2): by
+ * SubscribeToTask when the card states streaming, subscribing again when a
+ * stream ends early, else by GetTask every poll. Each event goes back to the
+ * sender as one reply, under a key derived from the task and the event, so
+ * an event seen again (a poll, a new stream, a restart) is one reply; each
+ * reply is kept as telling of the task, so an answer to it continues the
+ * task. At a terminal or interrupted state the delivery is handled; at the
+ * deadline the gateway replies failed, then handles it; a task the agent no
+ * longer knows is not handled. A reply the fleet does not take is sent again
+ * after a poll. Stopped, it leaves the call followed, for the next start.
+ */
+export declare function createFollowAgentTask(deps: {
+    crew: AgentShipCrew;
+    agents: A2aAgents;
+    calls: AgentCalls;
+    keys: AgentKeys;
+    statuses: GatewayStatuses;
+    clock: Clock;
+    sleep: Sleep;
+    pollMs: number;
+    deadlineMs: number;
+}): FollowAgentTask;

package/dist/core/a2a-out/follow-agent-task.js

@@ -0,0 +1,125 @@
+import { endsFollowing, eventIdentityOf, replyContentOf } from './agent-event.js';
+/** The reason a delivery whose task the agent no longer knows is not handled, as Needs attention shows it. */
+export const TASK_GONE = "The agent's task is gone";
+/** The fleet's code for a key already used for another message: under a key this follow derived, that reply went before. */
+const KEY_REUSED = 'IDEMPOTENCY_KEY_REUSED';
+/** What the failed reply says when the agent refuses reading or streaming its task, before the agent's reason. */
+const FOLLOW_REFUSED = 'The agent refused following its task';
+const AGAIN = { kind: 'again' };
+/**
+ * Use case: the gateway follows an outside A2A agent's task, after the agent
+ * took a delivery and the gateway acknowledged it (slice 6, flow 4.2): by
+ * SubscribeToTask when the card states streaming, subscribing again when a
+ * stream ends early, else by GetTask every poll. Each event goes back to the
+ * sender as one reply, under a key derived from the task and the event, so
+ * an event seen again (a poll, a new stream, a restart) is one reply; each
+ * reply is kept as telling of the task, so an answer to it continues the
+ * task. At a terminal or interrupted state the delivery is handled; at the
+ * deadline the gateway replies failed, then handles it; a task the agent no
+ * longer knows is not handled. A reply the fleet does not take is sent again
+ * after a poll. Stopped, it leaves the call followed, for the next start.
+ */
+export function createFollowAgentTask(deps) {
+    return async ({ party, endpoint, call, signal, events = [] }) => {
+        const { crewToken } = party;
+        if (crewToken === null || call.taskId === null || call.contextId === null) {
+            return AGAIN;
+        }
+        const { taskId, contextId } = call;
+        const caller = { fleetId: party.fleetId, party: party.name };
+        const connection = { endpoint, credential: party.credential };
+        /** The call as kept now: each reply's identity and the chunk places after it are kept with it, so a restart sends none again. */
+        let kept = call;
+        let endedAt;
+        /** Whether an event ended following: set as each event comes, so read through a call. */
+        const hasEnded = () => endedAt !== undefined;
+        /** Whether the gateway stops: read through a call, as a stream ends when it does. */
+        const isStopped = () => signal.aborted;
+        /**
+         * Sends the event as a reply once, tried again after a poll until the fleet takes it, the gateway stops or
+         * the deadline passes: whether it went. A key this follow derived that the fleet holds for another message
+         * went before, as the same event told otherwise (a whole artifact after its chunks): it counts as replied.
+         */
+        const reply = async (event) => {
+            const { identity, chunkPlaces } = eventIdentityOf(event, { answering: call.messageId, chunkPlaces: kept.chunkPlaces });
+            if (kept.replied.includes(identity)) {
+                return true;
+            }
+            const idempotencyKey = deps.keys.replyKeyOf(party.fleetId, { taskId, event: identity });
+            for (;;) {
+                const sent = await deps.crew.send(crewToken, { to: call.senderShipId, inReplyTo: call.messageId, ...replyContentOf(event), idempotencyKey });
+                if (sent.isOk || sent.error.code === KEY_REUSED) {
+                    if (sent.isOk) {
+                        await deps.calls.saveReply(caller, { messageId: sent.value.messageId, taskId, contextId });
+                    }
+                    kept = { ...kept, replied: [...kept.replied, identity], chunkPlaces };
+                    await deps.calls.save(kept);
+                    return true;
+                }
+                if (isStopped() || deps.clock.now().getTime() >= call.deadlineAt.getTime()) {
+                    return false;
+                }
+                await deps.sleep(deps.pollMs, signal);
+            }
+        };
+        const onEvent = async (event) => {
+            if ((await reply(event)) && endsFollowing(event)) {
+                endedAt = event;
+            }
+        };
+        const handled = async () => {
+            if (!(await deps.crew.handled(crewToken, call.deliveryId)).isOk) {
+                return AGAIN;
+            }
+            await deps.calls.save({ ...kept, state: 'done' });
+            return { kind: 'handled' };
+        };
+        const gone = async (reason) => {
+            await deps.calls.save({ ...kept, state: 'done' });
+            await deps.crew.notHandled(crewToken, { deliveryId: call.deliveryId, reason: `${TASK_GONE}: ${reason}` });
+            return { kind: 'notHandled' };
+        };
+        /** Replies the gateway's failed status with why, then handles the delivery. */
+        const failed = async (reason) => {
+            const status = deps.statuses.statusOf({ taskId, contextId, state: 'failed', reason, messageId: deps.keys.replyKeyOf(party.fleetId, { taskId, event: reason }) });
+            return (await reply(status)) ? handled() : AGAIN;
+        };
+        /** GetTask once: each event of the task as it stands replied; how the read ended. */
+        const readTask = async () => {
+            const read = await deps.agents.getTask(connection, taskId);
+            for (const event of read.kind === 'read' ? read.events : []) {
+                await onEvent(event);
+            }
+            return read;
+        };
+        for (const event of events) {
+            await onEvent(event);
+        }
+        while (!hasEnded() && !signal.aborted) {
+            const leftMs = call.deadlineAt.getTime() - deps.clock.now().getTime();
+            if (leftMs <= 0) {
+                return failed(`The agent did not end its task within ${String(deps.deadlineMs)} ms`);
+            }
+            const end = endpoint.isStreaming ? await deps.agents.subscribe(connection, { taskId, timeoutMs: leftMs, signal, onEvent }) : undefined;
+            if (end?.kind === 'gone') {
+                return gone(end.reason);
+            }
+            // A stream that ended with no end of the task may have missed it, and a task that ended refuses a stream: the task is read once.
+            const read = hasEnded() || isStopped() ? undefined : await readTask();
+            if (read?.kind === 'gone') {
+                return gone(read.reason);
+            }
+            if (read?.kind === 'refused') {
+                return failed(`${FOLLOW_REFUSED}: ${read.reason}`);
+            }
+            if (read?.kind === 'read' && !hasEnded() && end?.kind === 'refused') {
+                return failed(`${FOLLOW_REFUSED}: ${end.reason}`);
+            }
+            if (!hasEnded()) {
+                await deps.sleep(deps.pollMs, signal);
+            }
+        }
+        return hasEnded() ? handled() : AGAIN;
+    };
+}
+//# sourceMappingURL=follow-agent-task.js.map