@loopingai/core 0.1.0

package/dist/a2a/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/a2a/context.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,UAAU,EACV,qBAAqB,EACtB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,+BAA+B,EAIhC,MAAM,oBAAoB,CAAC;AAG5B;;;;;;GAMG;AAEH;;;;;GAKG;AACH,MAAM,WAAW;IACc;IAA7B,YAA6B,QAAyB;QAAzB,aAAQ,GAAR,QAAQ,CAAiB;IAAG,CAAC;IAE1D,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,QAAQ;QACV,yEAAyE;QACzE,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,EAAE,CAAC;IACjC,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAAgB,EAChB,QAAyB;IAEzB,MAAM,OAAO,GAAmB,EAAE,CAAC;IACnC,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,OAAO,CAAC,OAAO;QAAE,OAAO,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;IAEnE,OAAO,+BAA+B,CAAC;QACrC,UAAU,EAAE,UAAU,CAAC,qBAAqB,CAC1C,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,IAAI,SAAS,CACxD;QACD,IAAI,EAAE,IAAI,WAAW,CAAC,QAAQ,CAAC;QAC/B,OAAO;QACP,gBAAgB,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,IAAI,SAAS;KACvE,CAAC,CAAC;AACL,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,gBAAgB,CAAC,OAA0B;IACzD,MAAM,SAAS,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAC9C,IAAI,CAAC,SAAS,EAAE,MAAM;QAAE,OAAO,EAAE,CAAC;IAClC,OAAO,EAAE,CAAC,qBAAqB,CAAC,EAAE,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAE,CAAC;AAC/E,CAAC"}

package/dist/a2a/executor.d.ts

@@ -0,0 +1,85 @@
+import { type AgentExecutor, type ExecutionEventBus, type RequestContext } from "@a2a-js/sdk/server";
+import type { GatewayIdentity } from "./verify.js";
+import type { AgentResolver } from "./agent-stub.js";
+/**
+ * Derive a deterministic workflow instance id for a turn. Keyed on the gateway's
+ * `messageId` (stable across dispatch retries), so re-creating it is a no-op —
+ * the turn runs exactly once. Sanitized to the id charset.
+ */
+export declare function workflowIdForMessage(messageId: string, prefix?: string): string;
+/**
+ * Everything the executor knows about an accepted turn, handed to the
+ * consumer's {@link TurnStarter}.
+ *
+ * Core stops here deliberately: which workflow runs the turn, what else its
+ * params carry, and which binding it is created on are all the agent's, so core
+ * describes the turn and the agent starts it.
+ */
+export interface AcceptedTurn {
+    /** The gateway's message id — the idempotency key for the whole turn. */
+    messageId: string;
+    taskId: string;
+    contextId: string;
+    /** The caller's message, flattened to text. */
+    text: string;
+    identity: GatewayIdentity;
+    /** Webhook the terminal task is POSTed to. */
+    pushUrl: string;
+    /** Per-task validation token echoed on the callback. */
+    pushToken: string;
+    /** This agent's card-signing JWKS URL — the callback JWT `jku`. */
+    jku: string;
+}
+/**
+ * Start the durable turn. **Must be idempotent**: a dispatch retry calls it
+ * again with the same {@link AcceptedTurn.messageId}, and the conventional
+ * implementation swallows the workflow's "instance already exists" race — see
+ * {@link workflowIdForMessage} and {@link ignoreAlreadyExists}.
+ */
+export type TurnStarter = (turn: AcceptedTurn) => Promise<void>;
+export interface ExecutorConfig {
+    identity: GatewayIdentity;
+    /** This agent's card-signing JWKS URL — the callback JWT `jku`. */
+    jku: string;
+    resolveAgent: AgentResolver;
+    startTurn: TurnStarter;
+}
+/**
+ * Run `create` and swallow the "instance already exists" retry race, so a
+ * {@link TurnStarter} is idempotent in the one way that actually happens.
+ *
+ * ```ts
+ * startTurn: (turn) =>
+ *   ignoreAlreadyExists(() =>
+ *     env.HANDLE_TASK_WORKFLOW.create({
+ *       id: workflowIdForMessage(turn.messageId),
+ *       params: { ...turn }
+ *     })
+ *   )
+ * ```
+ */
+export declare function ignoreAlreadyExists(create: () => Promise<unknown>): Promise<void>;
+/**
+ * A2A executor for the **async accept + notify** contract. On `SendMessage` it
+ * does not block on generation: it records a `submitted` task in the caller's DO
+ * (idempotent on `messageId`), hands the turn to a durable workflow, and
+ * publishes the accepted task immediately as the response. The workflow
+ * generates the reply and POSTs it to the gateway's push-notification webhook
+ * out of band.
+ *
+ * The verified caller identity comes from the config — the outer Worker builds
+ * one executor per verified request. The push config comes from the request
+ * itself: v1.0 hands the executor the whole `SendMessageRequest` via
+ * {@link RequestContext.request}, so nothing has to be threaded around it.
+ */
+export declare class A2AExecutor implements AgentExecutor {
+    private readonly config;
+    constructor(config: ExecutorConfig);
+    execute: (requestContext: RequestContext, eventBus: ExecutionEventBus) => Promise<void>;
+    /**
+     * `CancelTask`: best-effort mark the task canceled in the DO and publish the
+     * canceled task. The in-flight workflow's `notify` step skips a canceled task.
+     */
+    cancelTask: (taskId: string, eventBus: ExecutionEventBus) => Promise<void>;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/a2a/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/a2a/executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGrD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,MAAM,SAAS,GACd,MAAM,CAER;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,eAAe,CAAC;IAC1B,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEhE,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,eAAe,CAAC;IAC1B,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,aAAa,CAAC;IAC5B,SAAS,EAAE,WAAW,CAAC;CACxB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAC7B,OAAO,CAAC,IAAI,CAAC,CASf;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,WAAY,YAAW,aAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,cAAc;IAEnD,OAAO,GACL,gBAAgB,cAAc,EAC9B,UAAU,iBAAiB,KAC1B,OAAO,CAAC,IAAI,CAAC,CA6Cd;IAEF;;;OAGG;IACH,UAAU,GACR,QAAQ,MAAM,EACd,UAAU,iBAAiB,KAC1B,OAAO,CAAC,IAAI,CAAC,CAMd;CACH"}

package/dist/a2a/executor.js

@@ -0,0 +1,107 @@
+import { AgentEvent } from "@a2a-js/sdk/server";
+import { textOf } from "./parts.js";
+/**
+ * Derive a deterministic workflow instance id for a turn. Keyed on the gateway's
+ * `messageId` (stable across dispatch retries), so re-creating it is a no-op —
+ * the turn runs exactly once. Sanitized to the id charset.
+ */
+export function workflowIdForMessage(messageId, prefix = "turn") {
+    return `${prefix}-${messageId.replace(/[^A-Za-z0-9_-]/g, "-")}`;
+}
+/**
+ * Run `create` and swallow the "instance already exists" retry race, so a
+ * {@link TurnStarter} is idempotent in the one way that actually happens.
+ *
+ * ```ts
+ * startTurn: (turn) =>
+ *   ignoreAlreadyExists(() =>
+ *     env.HANDLE_TASK_WORKFLOW.create({
+ *       id: workflowIdForMessage(turn.messageId),
+ *       params: { ...turn }
+ *     })
+ *   )
+ * ```
+ */
+export async function ignoreAlreadyExists(create) {
+    try {
+        await create();
+    }
+    catch (err) {
+        if (err instanceof Error && /already exists|exist/i.test(err.message)) {
+            return;
+        }
+        throw err;
+    }
+}
+/**
+ * A2A executor for the **async accept + notify** contract. On `SendMessage` it
+ * does not block on generation: it records a `submitted` task in the caller's DO
+ * (idempotent on `messageId`), hands the turn to a durable workflow, and
+ * publishes the accepted task immediately as the response. The workflow
+ * generates the reply and POSTs it to the gateway's push-notification webhook
+ * out of band.
+ *
+ * The verified caller identity comes from the config — the outer Worker builds
+ * one executor per verified request. The push config comes from the request
+ * itself: v1.0 hands the executor the whole `SendMessageRequest` via
+ * {@link RequestContext.request}, so nothing has to be threaded around it.
+ */
+export class A2AExecutor {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    execute = async (requestContext, eventBus) => {
+        const pushConfig = requestContext.request.configuration?.taskPushNotificationConfig;
+        // Defensive: the Worker validates url + token before the executor runs, and
+        // must keep doing so — a throw here is turned into a `failed` task by the
+        // request handler, not into the JSON-RPC error the caller needs to see.
+        if (!pushConfig?.url || !pushConfig.token) {
+            throw new Error("taskPushNotificationConfig url and token are required");
+        }
+        const text = textOf(requestContext.userMessage);
+        const messageId = requestContext.userMessage.messageId;
+        const contextId = requestContext.contextId;
+        // `identity.key` is guaranteed non-null: the Worker rejects a keyless
+        // identity (400) before constructing this executor.
+        const stub = this.config.resolveAgent(this.config.identity);
+        // Record (or reuse) the submitted task, then start the durable turn. Both
+        // are idempotent, so a dispatch retry heals a crash between the two.
+        const accepted = await stub.beginTask({
+            messageId,
+            taskId: requestContext.taskId,
+            contextId
+        });
+        // Widened in one explicit step: DO-stub returns come back through
+        // Cloudflare's RPC type mapping, and letting that mapped type flow into a
+        // generic SDK call site instead exceeds TypeScript's instantiation depth on
+        // the v1.0 (proto-generated) model.
+        const task = accepted;
+        await this.config.startTurn({
+            messageId,
+            taskId: accepted.id,
+            contextId,
+            text,
+            identity: this.config.identity,
+            pushUrl: pushConfig.url,
+            pushToken: pushConfig.token,
+            jku: this.config.jku
+        });
+        // The accept ack: a `submitted` task, not a Message. Returned synchronously.
+        eventBus.publish(AgentEvent.task(task));
+        eventBus.finished();
+    };
+    /**
+     * `CancelTask`: best-effort mark the task canceled in the DO and publish the
+     * canceled task. The in-flight workflow's `notify` step skips a canceled task.
+     */
+    cancelTask = async (taskId, eventBus) => {
+        const task = await this.config
+            .resolveAgent(this.config.identity)
+            .cancelTask(taskId);
+        if (task)
+            eventBus.publish(AgentEvent.task(task));
+        eventBus.finished();
+    };
+}
+//# sourceMappingURL=executor.js.map

package/dist/a2a/executor.js.map

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

package/dist/a2a/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@loopingai/core/a2a` — the A2A protocol adapter.
+ *
+ * The zero-trust contract in both directions (verify the gateway with its public
+ * JWKS, prove ourselves with ours), the accept-and-notify task lifecycle, and the
+ * narrowed task types that survive Durable Object RPC. Nothing here knows what an
+ * agent *does* — past {@link A2AExecutor} everything is plain strings.
+ */
+export { IDENTITY_CLAIM, GatewayAuthError, bearerToken, normalizeGatewayOrigins, verifyGatewayToken, type GatewayIdentity, type VerifyOptions } from "./verify.js";
+export { A2A_RPC_PATH, buildBaseCard, signCard, wireCard, parsePrivateJwk, publicCardJwks, type AgentManifest, type BuildCardOptions, type CardSigningConfig, type WireAgentCard } from "./card.js";
+export { NOTIFICATION_TOKEN_HEADER, buildSubmittedTask, buildWorkingTask, buildCompletedTask, buildFailedTask, buildNoReplyCompletedTask, signCallbackJwt, postNotification } from "./notify.js";
+export { taskStateLabel, type PlainArtifact, type PlainMessage, type PlainPart, type PlainStatus, type PlainTask } from "./task.js";
+export { textPart, partsText, textOf, agentTextMessage, inboundText, InboundPartError, MAX_INBOUND_TEXT_BYTES } from "./parts.js";
+export { buildCallContext, extensionHeaders } from "./context.js";
+export { DurableTaskStore } from "./task-store.js";
+export { A2AExecutor, workflowIdForMessage, ignoreAlreadyExists, type AcceptedTurn, type ExecutorConfig, type TurnStarter } from "./executor.js";
+export type { AgentResolver, TaskAgent, TaskListPage, TaskListQuery } from "./agent-stub.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/a2a/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/a2a/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,uBAAuB,EACvB,kBAAkB,EAClB,KAAK,eAAe,EACpB,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,cAAc,EACd,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EACnB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,yBAAyB,EACzB,eAAe,EACf,gBAAgB,EACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,cAAc,EACd,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,SAAS,EACf,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,QAAQ,EACR,SAAS,EACT,MAAM,EACN,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAElE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EACL,WAAW,EACX,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,EACjB,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,aAAa,EACb,SAAS,EACT,YAAY,EACZ,aAAa,EACd,MAAM,iBAAiB,CAAC"}

package/dist/a2a/index.js

@@ -0,0 +1,17 @@
+/**
+ * `@loopingai/core/a2a` — the A2A protocol adapter.
+ *
+ * The zero-trust contract in both directions (verify the gateway with its public
+ * JWKS, prove ourselves with ours), the accept-and-notify task lifecycle, and the
+ * narrowed task types that survive Durable Object RPC. Nothing here knows what an
+ * agent *does* — past {@link A2AExecutor} everything is plain strings.
+ */
+export { IDENTITY_CLAIM, GatewayAuthError, bearerToken, normalizeGatewayOrigins, verifyGatewayToken } from "./verify.js";
+export { A2A_RPC_PATH, buildBaseCard, signCard, wireCard, parsePrivateJwk, publicCardJwks } from "./card.js";
+export { NOTIFICATION_TOKEN_HEADER, buildSubmittedTask, buildWorkingTask, buildCompletedTask, buildFailedTask, buildNoReplyCompletedTask, signCallbackJwt, postNotification } from "./notify.js";
+export { taskStateLabel } from "./task.js";
+export { textPart, partsText, textOf, agentTextMessage, inboundText, InboundPartError, MAX_INBOUND_TEXT_BYTES } from "./parts.js";
+export { buildCallContext, extensionHeaders } from "./context.js";
+export { DurableTaskStore } from "./task-store.js";
+export { A2AExecutor, workflowIdForMessage, ignoreAlreadyExists } from "./executor.js";
+//# sourceMappingURL=index.js.map

package/dist/a2a/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/a2a/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,uBAAuB,EACvB,kBAAkB,EAGnB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,cAAc,EAKf,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,yBAAyB,EACzB,eAAe,EACf,gBAAgB,EACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,cAAc,EAMf,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,QAAQ,EACR,SAAS,EACT,MAAM,EACN,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAElE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EACL,WAAW,EACX,oBAAoB,EACpB,mBAAmB,EAIpB,MAAM,eAAe,CAAC"}

package/dist/a2a/notify.d.ts

@@ -0,0 +1,75 @@
+import { type JWK } from "jose";
+import { type Task } from "@a2a-js/sdk";
+import type { PlainTask } from "./task.js";
+/**
+ * Header carrying the per-task validation `token` the gateway set in the
+ * `taskPushNotificationConfig`. Echoed verbatim so the gateway can correlate the
+ * callback to its pending task row. Must match looping-gateway's
+ * `NOTIFICATION_TOKEN_HEADER` (`src/a2a/notifications/remote.ts`).
+ */
+export declare const NOTIFICATION_TOKEN_HEADER = "x-a2a-notification-token";
+/**
+ * The `submitted` Task we return synchronously to accept a turn (A2A §7.2). The
+ * gateway only requires a non-empty `id`; the actual reply follows later via the
+ * callback.
+ */
+export declare function buildSubmittedTask(taskId: string, contextId: string): PlainTask;
+/**
+ * The terminal `completed` Task for a turn the agent deliberately did not answer
+ * (it called the `no_reply` tool — see the agent loop). Same
+ * shape as {@link buildSubmittedTask}: **no `status.message` at all**.
+ *
+ * The callback is still POSTed. The gateway's pending row has to resolve — we
+ * simply hand it nothing to post to Slack. There is no `messageId` because there
+ * is no message, so unlike {@link buildCompletedTask} nothing needs a stable id
+ * for the gateway to dedupe on: a `notify`-step retry re-delivers no content and
+ * is idempotent by construction.
+ */
+export declare function buildNoReplyCompletedTask(taskId: string, contextId: string): PlainTask;
+/**
+ * A non-terminal `working` Task snapshot carrying an intermediate content message.
+ * Streamed live from the DO as the tool loop emits content before the final reply.
+ * `messageId` is derived from `${taskId}:${stepIndex}` — stable across re-runs (see
+ * {@link agentTextMessage}) so the gateway dedupes correctly on workflow replay.
+ */
+export declare function buildWorkingTask(taskId: string, contextId: string, text: string, stepIndex: number): PlainTask;
+/**
+ * The terminal `completed` Task POSTed to the gateway callback. The `messageId` is
+ * deterministic (`${taskId}:final`, not a fresh UUID) because this is built in the
+ * workflow body, which re-runs on replay: a random id would change on a notify-step
+ * retry and the gateway would dedupe the final message as a new one and double-post.
+ */
+export declare function buildCompletedTask(taskId: string, contextId: string, reply: string): PlainTask;
+/**
+ * The terminal `failed` Task POSTed to the gateway callback — an unexpected,
+ * non-transient failure aborted the turn.
+ *
+ * A2A v1.0 gives a task no structured error (`TaskStatus` is only
+ * `{state, message, timestamp}`), so the state *is* the failure signal and `text`
+ * is the only place to explain. Keep that text user-safe: the gateway renders it
+ * to a human, under its own "⚠️ *Agent …* (failed):" prefix.
+ *
+ * Shares the `${taskId}:final` messageId with {@link buildCompletedTask} by
+ * design: a Task terminates exactly once and the two states are mutually
+ * exclusive, so only one of them is ever built and posted — and a notify retry
+ * re-posts that same one under the same dedupe key.
+ */
+export declare function buildFailedTask(taskId: string, contextId: string, text: string): PlainTask;
+/**
+ * Sign the callback JWT the gateway verifies against our pinned card key. The
+ * protected header mirrors the card signature (`kid`+`jku`); `aud` must equal the
+ * exact webhook URL the gateway handed us in the `taskPushNotificationConfig`.
+ */
+export declare function signCallbackJwt(privateJwk: JWK & {
+    kid: string;
+}, opts: {
+    jku: string;
+    aud: string;
+}): Promise<string>;
+/**
+ * POST a Task snapshot to the gateway's push-notification webhook, wrapped in the
+ * v1.0 `StreamResponse` envelope. Returns the raw `Response` so the caller (the
+ * workflow's `notify` step) can decide whether a non-2xx warrants a retry.
+ */
+export declare function postNotification(url: string, token: string, jwt: string, task: Task): Promise<Response>;
+//# sourceMappingURL=notify.d.ts.map

package/dist/a2a/notify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notify.d.ts","sourceRoot":"","sources":["../../src/a2a/notify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,EAAa,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAGnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAqB3C;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,6BAA6B,CAAC;AAqCpE;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,SAAS,CAEX;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,SAAS,CAEX;AAwBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,SAAS,CAQX;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,SAAS,CAQX;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GACX,SAAS,CAQX;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,GAAG,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,EACjC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACjC,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,QAAQ,CAAC,CAanB"}

package/dist/a2a/notify.js

@@ -0,0 +1,161 @@
+import { SignJWT } from "jose";
+import { TaskState } from "@a2a-js/sdk";
+import { V1PushNotificationSerializer } from "@a2a-js/sdk/server";
+import { agentTextMessage } from "./parts.js";
+/**
+ * Outbound push-notification (accept + notify) helpers — the "notify" half of the
+ * async A2A contract. The gateway dispatches `SendMessage` with a
+ * `taskPushNotificationConfig` (webhook `url` + validation `token`), we accept
+ * immediately with a `submitted` Task, and later POST the terminal Task back to
+ * that webhook. This module builds the Task shapes and signs + sends that
+ * callback.
+ *
+ * The callback is authenticated exactly like the AgentCard: a short-lived EdDSA
+ * JWT signed by `A2A_SIGNING_KEY`, whose protected header `kid`+`jku` must equal
+ * the card's signing `kid`+`jku` (see {@link file://./card.ts} `signCard`) — the
+ * gateway pinned those at registration (Trust-On-First-Use) and verifies the
+ * callback token against that same public JWKS. No shared secret crosses the
+ * boundary; only our public key is ever used to verify.
+ */
+/** JWS algorithm — must match the card + gateway (`EdDSA`). */
+const ALG = "EdDSA";
+/**
+ * Header carrying the per-task validation `token` the gateway set in the
+ * `taskPushNotificationConfig`. Echoed verbatim so the gateway can correlate the
+ * callback to its pending task row. Must match looping-gateway's
+ * `NOTIFICATION_TOKEN_HEADER` (`src/a2a/notifications/remote.ts`).
+ */
+export const NOTIFICATION_TOKEN_HEADER = "x-a2a-notification-token";
+/**
+ * Callback-JWT lifetime. The gateway enforces `maxTokenAge: 10m` with a 60s clock
+ * tolerance, so keep this comfortably under that.
+ */
+const CALLBACK_TOKEN_TTL = "5m";
+/**
+ * The SDK's canonical v1.0 push-notification body encoder: the `StreamResponse`
+ * envelope as protobuf-JSON, with content type `application/a2a+json`. v1.0
+ * moved push notifications onto the same envelope the streaming transports use
+ * (v0.3 POSTed a bare `Task`), so the encoding is the SDK's rather than ours —
+ * the gateway decodes it with `StreamResponse.fromJSON`.
+ */
+const PUSH_SERIALIZER = new V1PushNotificationSerializer();
+/** A Task snapshot in `state` carrying no message — nothing to say, only a state change. */
+function buildBareTask(taskId, contextId, state) {
+    return {
+        id: taskId,
+        contextId,
+        status: {
+            state,
+            message: undefined,
+            timestamp: new Date().toISOString()
+        },
+        artifacts: [],
+        history: [],
+        metadata: undefined
+    };
+}
+/**
+ * The `submitted` Task we return synchronously to accept a turn (A2A §7.2). The
+ * gateway only requires a non-empty `id`; the actual reply follows later via the
+ * callback.
+ */
+export function buildSubmittedTask(taskId, contextId) {
+    return buildBareTask(taskId, contextId, TaskState.TASK_STATE_SUBMITTED);
+}
+/**
+ * The terminal `completed` Task for a turn the agent deliberately did not answer
+ * (it called the `no_reply` tool — see the agent loop). Same
+ * shape as {@link buildSubmittedTask}: **no `status.message` at all**.
+ *
+ * The callback is still POSTed. The gateway's pending row has to resolve — we
+ * simply hand it nothing to post to Slack. There is no `messageId` because there
+ * is no message, so unlike {@link buildCompletedTask} nothing needs a stable id
+ * for the gateway to dedupe on: a `notify`-step retry re-delivers no content and
+ * is idempotent by construction.
+ */
+export function buildNoReplyCompletedTask(taskId, contextId) {
+    return buildBareTask(taskId, contextId, TaskState.TASK_STATE_COMPLETED);
+}
+/**
+ * A Task snapshot POSTed to the gateway callback in a given `state`, carrying one
+ * `agent` message. The gateway reads the reply from `status.message.parts`, so
+ * the text lives there.
+ */
+function buildTaskUpdate(taskId, contextId, state, text, messageId) {
+    const task = buildBareTask(taskId, contextId, state);
+    task.status.message = agentTextMessage({
+        messageId,
+        text,
+        contextId,
+        taskId
+    });
+    return task;
+}
+/**
+ * A non-terminal `working` Task snapshot carrying an intermediate content message.
+ * Streamed live from the DO as the tool loop emits content before the final reply.
+ * `messageId` is derived from `${taskId}:${stepIndex}` — stable across re-runs (see
+ * {@link agentTextMessage}) so the gateway dedupes correctly on workflow replay.
+ */
+export function buildWorkingTask(taskId, contextId, text, stepIndex) {
+    return buildTaskUpdate(taskId, contextId, TaskState.TASK_STATE_WORKING, text, `${taskId}:${stepIndex}`);
+}
+/**
+ * The terminal `completed` Task POSTed to the gateway callback. The `messageId` is
+ * deterministic (`${taskId}:final`, not a fresh UUID) because this is built in the
+ * workflow body, which re-runs on replay: a random id would change on a notify-step
+ * retry and the gateway would dedupe the final message as a new one and double-post.
+ */
+export function buildCompletedTask(taskId, contextId, reply) {
+    return buildTaskUpdate(taskId, contextId, TaskState.TASK_STATE_COMPLETED, reply, `${taskId}:final`);
+}
+/**
+ * The terminal `failed` Task POSTed to the gateway callback — an unexpected,
+ * non-transient failure aborted the turn.
+ *
+ * A2A v1.0 gives a task no structured error (`TaskStatus` is only
+ * `{state, message, timestamp}`), so the state *is* the failure signal and `text`
+ * is the only place to explain. Keep that text user-safe: the gateway renders it
+ * to a human, under its own "⚠️ *Agent …* (failed):" prefix.
+ *
+ * Shares the `${taskId}:final` messageId with {@link buildCompletedTask} by
+ * design: a Task terminates exactly once and the two states are mutually
+ * exclusive, so only one of them is ever built and posted — and a notify retry
+ * re-posts that same one under the same dedupe key.
+ */
+export function buildFailedTask(taskId, contextId, text) {
+    return buildTaskUpdate(taskId, contextId, TaskState.TASK_STATE_FAILED, text, `${taskId}:final`);
+}
+/**
+ * Sign the callback JWT the gateway verifies against our pinned card key. The
+ * protected header mirrors the card signature (`kid`+`jku`); `aud` must equal the
+ * exact webhook URL the gateway handed us in the `taskPushNotificationConfig`.
+ */
+export async function signCallbackJwt(privateJwk, opts) {
+    return new SignJWT({})
+        .setProtectedHeader({ alg: ALG, kid: privateJwk.kid, jku: opts.jku })
+        .setAudience(opts.aud)
+        .setIssuedAt()
+        .setExpirationTime(CALLBACK_TOKEN_TTL)
+        .sign(privateJwk);
+}
+/**
+ * POST a Task snapshot to the gateway's push-notification webhook, wrapped in the
+ * v1.0 `StreamResponse` envelope. Returns the raw `Response` so the caller (the
+ * workflow's `notify` step) can decide whether a non-2xx warrants a retry.
+ */
+export async function postNotification(url, token, jwt, task) {
+    const { body, contentType } = PUSH_SERIALIZER.serialize({
+        payload: { $case: "task", value: task }
+    });
+    return fetch(url, {
+        method: "POST",
+        headers: {
+            "content-type": contentType,
+            authorization: `Bearer ${jwt}`,
+            [NOTIFICATION_TOKEN_HEADER]: token
+        },
+        body
+    });
+}
+//# sourceMappingURL=notify.js.map

package/dist/a2a/notify.js.map

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

package/dist/a2a/parts.d.ts

@@ -0,0 +1,46 @@
+import { type Message, type Part } from "@a2a-js/sdk";
+import type { PlainMessage, PlainPart } from "./task.js";
+/**
+ * A `text` part carrying `text`. Typed as the narrowed {@link PlainPart} (which
+ * widens to `Part` for free) so a message built here can cross the DO RPC
+ * boundary — see {@link file://./task.ts}.
+ */
+export declare function textPart(text: string): PlainPart;
+/** Concatenate the text of every `text` part, trimming surrounding whitespace. */
+export declare function partsText(parts: Part[] | undefined): string;
+/** The plain-text content of an inbound A2A message (what the caller said). */
+export declare function textOf(message: Message): string;
+/**
+ * Bounds the inbound user text carried in a durable Workflow payload (UTF-8).
+ * Workflow params have a platform size limit, and a caller's message is the one
+ * unbounded thing that goes into them.
+ */
+export declare const MAX_INBOUND_TEXT_BYTES: number;
+/** Invalid inbound content that must not cross the A2A-to-workflow boundary. */
+export declare class InboundPartError extends Error {
+    constructor(message: string);
+}
+/**
+ * Extract and validate the user-turn text. Rejects a message with no usable
+ * text, and enforces a single UTF-8 size bound *before* the text enters a
+ * workflow payload — past that point the failure is a workflow that will not
+ * start, with no request left to answer on.
+ *
+ * File and data parts are deliberately out of scope: only text crosses into the
+ * agent runtime.
+ */
+export declare function inboundText(message: Message): string;
+/**
+ * An `agent`-role message carrying one text part, with the proto-required
+ * fields this agent never sets filled in. `messageId` is the gateway's dedupe
+ * key, so callers pass a **stable** id (never a fresh random per attempt) — a
+ * callback the workflow/DO re-runs must reuse the same id or the gateway
+ * treats the replay as a new message and double-posts.
+ */
+export declare function agentTextMessage(input: {
+    messageId: string;
+    text: string;
+    contextId: string;
+    taskId: string;
+}): PlainMessage;
+//# sourceMappingURL=parts.d.ts.map

package/dist/a2a/parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parts.d.ts","sourceRoot":"","sources":["../../src/a2a/parts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAmBzD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAOhD;AAED,kFAAkF;AAClF,wBAAgB,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,SAAS,GAAG,MAAM,CAM3D;AAED,+EAA+E;AAC/E,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAE/C;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,QAAa,CAAC;AAIjD,gFAAgF;AAChF,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CASpD;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,YAAY,CAWf"}

package/dist/a2a/parts.js

@@ -0,0 +1,95 @@
+import { Role } from "@a2a-js/sdk";
+/**
+ * Constructors and readers for A2A v1.0 message content — the one place the
+ * adapter reaches into the `@a2a-js/sdk` message shape. Everything past
+ * {@link file://./executor.ts A2AExecutor} works in plain strings, so the agent
+ * runtime never sees an A2A type.
+ *
+ * The v1.0 data model is generated from the protobuf schema, so the wire types
+ * are "all fields present": a `Part` carries a `content` oneof discriminated by
+ * `$case` (plus `filename`/`mediaType`) instead of v0.3's `kind`, and a
+ * `Message` carries empty strings and empty arrays rather than omitted
+ * optionals. Hand-writing those literals at every call site is noisy and easy to
+ * get subtly wrong, so every part/message this agent emits is built here.
+ */
+/** Media type stamped on the text parts this agent emits. */
+const TEXT_MEDIA_TYPE = "text/plain";
+/**
+ * A `text` part carrying `text`. Typed as the narrowed {@link PlainPart} (which
+ * widens to `Part` for free) so a message built here can cross the DO RPC
+ * boundary — see {@link file://./task.ts}.
+ */
+export function textPart(text) {
+    return {
+        content: { $case: "text", value: text },
+        metadata: undefined,
+        filename: "",
+        mediaType: TEXT_MEDIA_TYPE
+    };
+}
+/** Concatenate the text of every `text` part, trimming surrounding whitespace. */
+export function partsText(parts) {
+    let out = "";
+    for (const part of parts ?? []) {
+        if (part.content?.$case === "text")
+            out += part.content.value;
+    }
+    return out.trim();
+}
+/** The plain-text content of an inbound A2A message (what the caller said). */
+export function textOf(message) {
+    return partsText(message.parts);
+}
+/**
+ * Bounds the inbound user text carried in a durable Workflow payload (UTF-8).
+ * Workflow params have a platform size limit, and a caller's message is the one
+ * unbounded thing that goes into them.
+ */
+export const MAX_INBOUND_TEXT_BYTES = 256 * 1024;
+const encoder = new TextEncoder();
+/** Invalid inbound content that must not cross the A2A-to-workflow boundary. */
+export class InboundPartError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InboundPartError";
+    }
+}
+/**
+ * Extract and validate the user-turn text. Rejects a message with no usable
+ * text, and enforces a single UTF-8 size bound *before* the text enters a
+ * workflow payload — past that point the failure is a workflow that will not
+ * start, with no request left to answer on.
+ *
+ * File and data parts are deliberately out of scope: only text crosses into the
+ * agent runtime.
+ */
+export function inboundText(message) {
+    const text = textOf(message);
+    if (!text) {
+        throw new InboundPartError("message has no usable text");
+    }
+    if (encoder.encode(text).byteLength > MAX_INBOUND_TEXT_BYTES) {
+        throw new InboundPartError("message text exceeds the size limit");
+    }
+    return text;
+}
+/**
+ * An `agent`-role message carrying one text part, with the proto-required
+ * fields this agent never sets filled in. `messageId` is the gateway's dedupe
+ * key, so callers pass a **stable** id (never a fresh random per attempt) — a
+ * callback the workflow/DO re-runs must reuse the same id or the gateway
+ * treats the replay as a new message and double-posts.
+ */
+export function agentTextMessage(input) {
+    return {
+        messageId: input.messageId,
+        role: Role.ROLE_AGENT,
+        parts: [textPart(input.text)],
+        contextId: input.contextId,
+        taskId: input.taskId,
+        metadata: undefined,
+        extensions: [],
+        referenceTaskIds: []
+    };
+}
+//# sourceMappingURL=parts.js.map